nohup命令：如果你正在运行一个进程，而且你觉得在退出帐户时该进程还不会结束，那么可以使用nohup命令。该命令可以在你退出帐户/关闭终端之后继续运行相应的进程。nohup就是不挂起的意思( n ohang up)。
该命令的一般形式为：nohup
ls xxx 1&out.txt 2&&1
nohup /mnt/Nand3/H2000G &/dev/null&2&&1
对 于& 1 更准确的说应该是文件描述符 1,而1 一般代表的就是STDOUT_FILENO,实际上这个操作就是一个dup2(2)调用.他标准输出到all_result ,然后复制标准输出到文件描述符2(STDERR_FILENO),其后果就是文件描述符1和2指向同一个文件表项,也可以说错误的输出被合并了.其中0
表示键盘输入 1表示屏幕输出 2表示错误输出.把标准出错重定向到标准输出,然后扔到/DEV/NULL下面去。通俗的说，就是把所有标准输出和标准出错都扔到垃圾桶里面。
command &out.file 2&&1 &
command &out.file是将command的输出重定向到out.file文件，即输出内容不打印到屏幕上，而是输出到out.file文件中。 2&&1 是将标准出错重定向到标准输出，这里的标准输出已经重定向到了out.file文件，即将标准出错也输出到out.file文件中。最后一个&
， 是让该命令在后台执行。
试想2&1代表什么，2与&结合代表错误重定向，而1则代表错误重定向到一个文件1，而不代表标准输出；
换成2&&1，&与1结合就代表标准输出了，就变成错误重定向到标准输出.
ls 2&1测试一下，不会报没有2文件的错误，但会输出一个空的文件1；
ls xxx 2&1测试，没有xxx这个文件的错误输出到了1中；
ls xxx 2&&1测试，不会生成1这个文件了，不过错误跑到标准输出了；
ls xxx &out.txt 2&&1, 实际上可换成 ls xxx 1&out.txt 2&&1；重定向符号&默认是1,错误和输出都传到out.txt了。
为何2&&1要写在后面？
command & file 2&&1&
首先是command & file将标准输出重定向到file中， 2&&1 是标准错误拷贝了标准输出的行为，也就是同样被重定向到file中，最终结果就是标准输出和错误都被重定向到file中。&
command 2&&1 &file&
2&&1 标准错误拷贝了标准输出的行为，但此时标准输出还是在终端。&file 后输出才被重定向到file，但标准错误仍然保持在终端。
用strace可以看到：&
1. command & file 2&&1&
这个命令中实现重定向的关键系统调用序列是：&
open(file) == 3&
dup2(3,1)&
dup2(1,2)&
2. command 2&&1 &file&
这个命令中实现重定向的关键系统调用序列是：&
dup2(1,2)&
open(file) == 3&
dup2(3,1)&
为什么要用 /dev/null 2&&1 这样的写法.这条命令的意思是将标准输出和错误输出全部重定向到/dev/null中,也就是将产生的所有信息丢弃.下面我就为大家来说一下,&command
& file 2&file&& 与command
& file 2&&1&有什么不同的地方.
首先~command
& file 2&file&的意思是将命令所产生的标准输出信息,和错误的输出信息送到file 中.command&&
& file 2&file&这样的写法,stdout和stderr都直接送到file中, file会被打开两次,这样stdout和stderr会互相覆盖,这样写相当使用了FD1和FD2两个同时去抢占file 的管道.
&file 2&&1&这条命令就将stdout直接送向file, stderr 继承了FD1管道后,再被送往file,此时,file 只被打开了一次,也只使用了一个管道FD1,它包括了stdout和stderr的内容.
从IO效率上,前一条命令的效率要比后面一条的命令效率要低,所以在编写shell脚本的时候,较多的时候我们会用command
& file 2&&1&这样的写法.
本文已收录于以下专栏：
相关文章推荐
command &/dev/null 2&&1 & 到底什么意思？1.nohupnohup 的用途就是让提交的命令忽略 hangup 信号，那什么叫做hangup信号？这里给出了答案
1. 查看Linux启动的服务
chkconfig --list 查询出所有当前运行的服务
chkconfig --list atd  查询atd服务的当前状态
2.停止所有服务并且...
用途：不挂断地运行命令。
在应用Unix/Linux时，我们一般想让某个程序在后台运行，nohup ./start-mysql.sh &
该命令的一般形式为：nohup command &
在缺省情况...
脚本语言的第一行，目的就是指出，你想要你的这个文件中的代码用什么可执行程序去运行它，就这么简单
#!/usr/bin/python是告诉操作系统执行这个脚本的时候，调用/usr/bin下的pytho...
这几天开始试着学习lucene的一些基础东西，感觉还是比较吃力的，学一些写一点怕自己忘记了~一般要导入的包：lucene-analyzers-3.0.3.jar   分词lucene-core-3.0...
http://blog.csdn.net/zhangdaiscott/article/details/6911640
方法一. mvn assembly 或 mvn package (一个j...
1&/dev/null 2&&1的含义/dev/null 2&&1 解释
http://apps./share/detail/
download ADT link
/android/...
学习了这么多的排序算法，还没有做个总结，呵呵       冒泡排序冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素，使较大的数据下沉，较小的数据上升。...
他的最新文章
讲师：王哲涵
讲师：韦玮
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)雍正登基四个月，手握六十万大军的年羹尧要雍正钦命他为西北抚远大将军。与此同 时，八爷他们也没有闲着，拼命地聚敛钱财，整个江南的税赋被八爷的党徒所掌控着，以 至雍正平定西北叛军竟拿不出银子以做军饷。面对如此艰难的时局，雍正采取忍受之策，将西北抚远大将军交给了年羹尧，同时也将户部和首辅军机大臣的职位交 给了八爷。深谋远虑的雍正暗中却派李卫查八爷党控制的内务府帐目。赌场里，李卫通过赌搏使内务府会计司郎中图拉输得血本无归后，逼迫图拉道出了内 务府里面还有小内府的秘密，并将帐本交给李卫查阅。李卫连夜将帐本送进宫中呈给了雍 正。雍正见到内务府的帐本，方知八爷他们已将内务府掏空了。雍正决意从八爷控制严密 的江南入手，查清八爷党贪污税银的事实。于是派李卫担任苏州织造，在江南八爷的地盘 上钉上一个钉子。
视频集介绍
国家/地区：
视频简介：1.2 数据抽象
时间： 00:00:47
&&&& 阅读：142
&&&& 评论：
&&&& 收藏：0
标签：练习
1.2.1 编写一个Point2D的用例,从命令行接受一个整数N.在单位正方形中生成N个随机点,然后计算两点之间的最近距离. & & & /*查阅Point2D的API*/
public class H1_2_01
public static void main(String[] args)
int N=1000;
Point2D[] arr=new Point2D[N];
for(int i=0;i&N;i++)
arr[i]=new Point2D(Math.random(), Math.random());
double mindis=Double.POSITIVE_INFINITY;
//mindis--store the minimum distance
for(int i=0;i&N-1;i++)
for(int j=i+1;j&N;j++)
double dis=arr[i].distanceTo(arr[j]);
if(mindis&dis)
StdOut.printf("the minimum distance is: %.5f\n",mindis);
1.2.2 编写一个Interval1D的用例,从命令行接受一个整数N.从标准输入中读取N个间隔(每个间隔由一对double值定义)并打印出所有相交的间隔对
public class H1_2_02
public static void main(String[] args)
Interval1D[] arr=new Interval1D[N];
for(int i=0;i&N;i++)
StdOut.println("please input an interval1D.");
double lo=StdIn.readDouble();
double hi=StdIn.readDouble();
while(lo&hi)
//消除不合理的输入
StdOut.println("the input is illegal, please input again.");
lo=StdIn.readDouble();
hi=StdIn.readDouble();
arr[i]=new Interval1D(lo, hi);
for(int i=0;i&N-1;i++)
for(int j=i+1;j&N;j++)
if(arr[i].intersects(arr[j]))
StdOut.printf("the interval %s is intersected to the interval %s\n",arr[i].toString(),arr[j].toString());
1.2.3 编写一个Interval2D的用例,从命令行接受参数N、min和max.生成N个随机的2D间隔,其宽和高均匀的分布在单位正方形中的min和max之间.用StdDraw画出他们并打印出橡胶的间隔对的数量以及包含关系的间隔对数量
public class H1_2_3
public static void main(String[] args)
double min=0.05;
double max=0.1;
int containCnt=0;int intersectCnt=0;
Interval2D[] arr=new Interval2D[N];
Interval1D[] arrx=new Interval1D[N];
Interval1D[] arry=new Interval1D[N];
for(int i=0;i&N;i++)
double x=StdRandom.uniform(0.0,1-max);
arrx[i]=new Interval1D(x, x+StdRandom.uniform(min, max));
double y=StdRandom.uniform(0.0,1-max);
arry[i]=new Interval1D(y, y+StdRandom.uniform(min,max));
arr[i]=new Interval2D(arrx[i], arry[i]);
StdDraw.setPenColor(StdDraw.BOOK_BLUE);
arr[i].draw();
for(int i=0;i&N-1;i++)
for(int j=i+1;j&N;j++)
if(arr[i].intersects(arr[j]))
intersectCnt++;
if(iscontains(arrx[i],arry[i], arrx[j], arry[j]))
containCnt++;
StdOut.printf("the intersect interval2D=%d, the contain interval2D=%d\n", intersectCnt,containCnt);
public static boolean iscontains(Interval1D x1,Interval1D y1,Interval1D x2,Interval1D y2)
//判断是否存在包含关系
if(x1.left()&=x2.left()&&x1.right()&=x2.right()&&y1.left()&=y2.left()&&y1.right()&=y2.right())
return true;
if(x2.left()&=x1.left()&&x2.right()&=x1.right()&&y2.left()&=y1.left()&&y2.right()&=y1.right())
return true;
return false;
注：另一种解决思路是在Interval2D类中添加判断是否存在包含关系的实例函数
1.2.4 主要考察字符串不可变---因此对字符串重新"赋值"其实是指向了新的对象而不是改变原有值
1.2.6 编写一个程序检查两个给定的字符串s和t是否互为回环变位(如果字符串s中的字符循环移动任意位置之后能够得到另一个字符串t,那么s就被称为t的回环变位) & &/*掌握字符串的灵活用法*/
public class H1_2_06
public static void main(String[] args)
StdOut.println(cirRotation("ACTGACG", "TGACGAC"));
public static boolean cirRotation(String s,String t)
String temp=s+s;
//该语句起到很大的简便判断作用
if(temp.indexOf(t)!=-1&&s.length()==t.length())
return true;
return false;
作者网站上给出的答案：Solution:&(s.length() == t.length()) && (s.concat(s).indexOf(t) &= 0)
1.2.9 修改BinarySearch,使用Counter统计在查找中被检查的键的总数并在查找结束后打印该值.
public class H1_2_09
public static void main(String[] args)
Counter cnt=new Counter("count");
int[] arr={1,4,5,6,7,8,9};
Arrays.sort(arr);
int key=9;
rank(key,arr,cnt);
StdOut.println(cnt.toString());
public static int rank(int key,int[] a,Counter cnt)
int hi=a.length-1;
while(lo&=hi)
cnt.increment();
//每次进入循环代表一次检查
int mid=lo+(hi-lo)/2;
if(key&a[mid])
else if(key&a[mid])
return -1;
1.2.10 编写一个类VisualCounter,支持加一和减一操作.它的构造函数接受两个参数N和max,其中N指定了操作的最大次数,max指定了计数器的最大绝对值.作为副作用,用图形显示每次计数器变化后的值.
先根据要求列出"需求"API & & /*明确类所需要的数据,方法等*/
VisualCounter(int N,int max)
increment()
decrement()
public class VisualCounter
private int cnt=0;
private int opN=0;
private int
private int N;
public VisualCounter(int N,int max)
StdDraw.setXscale(0,N);
StdDraw.setYscale(-max-0.1,max+0.1);
StdDraw.setPenColor(StdDraw.BOOK_BLUE);
public void increment()
if(cnt&max&&opN&N)
StdDraw.filledRectangle(opN-0.5, cnt/2.0, 0.9/2, Math.abs(cnt)/2.0); //采用柱状图体现变化后的值
public void decrement()
if(-cnt&max&&opN&N)
StdDraw.filledRectangle(opN-0.5, cnt/2.0, 0.9/2, Math.abs(cnt)/2.0);
public static void main(String[] args)
int N=10;int max=5;
VisualCounter vc=new VisualCounter(N, max);
while(i&N)
if(StdRandom.bernoulli(0.5))
//采用等可能出现进行测试
vc.increment();
vc.decrement();
1.2.11&1.2.12 根据Date的API实现一个SmartDate类型,在日期非法时抛出一个异常,并为SmartDate添加一个方法dayOfTheWeek(),为日期中每周的日返回Monday到Sunday中的适当值.(可以假定时间是21世纪) & & & & /*此题可了解构造函数直接如何调用,闰年的判断,蔡勒公式判断星期以及抛出异常的使用~ 此题重要！*/
Date的API如下
SmartDate(int month,int day,int year)
创建一个日期
SmartDate(String str)
创建一个日期
int month()
int year()
String dayOfTheWeek()
当日为星期几
public class SmartDate
private int
private int
private int
public SmartDate(int y,int m,int d)
if(!isIllegal(y,m,d))
throw new IllegalArgumentException("illegal date!!");
public SmartDate(String date)
String[] fields=date.split("/");
int m=Integer.parseInt(fields[0]);
int d=Integer.parseInt(fields[1]);
int y=Integer.parseInt(fields[2]);
this(y,m,d); ---不可行,必须要写在第一行,因此此处不可用
if(!isIllegal(y,m,d))
throw new IllegalArgumentException("illegal date!!");
public int year()
public int month()
public int day()
public String toString()
return month()+"/"+day()+"/"+year();
//运用蔡勒公式---判断改日的星期
public String dayOfWeek()
int w=(year/100/4-2*(year/100)+year%100+year%100/4+26*(month+1)/10+day-1)%7;
return "Monday";
return "Tuesday";
return "Wednesday";
return "Thursday";
return "Friday";
return "Saturday";
return "Sunday";
//判断是否合法
private boolean isIllegal(int y,int m,int d)
//判断日期是否合法:三方面--年月日
if(y&1||m&1||m&12||d&0||d&31)
return false;
int[] monthOfDay={0,31,-1,31,30,31,30,31,31,30,31,30,31};
if(isLeapYear(y))
monthOfDay[2]=29;
monthOfDay[2]=28;
if(monthOfDay[m]&d)
return false;
return true;
private boolean isLeapYear(int year)
//判断是否为闰年
if(year%100!=0&&year%4==0)
return true;
else if(year%100==0&&year%400==0)
return true;
return false;
public static void main(String[] args)
SmartDate sd=new SmartDate();
StdOut.println(sd.toString()+"
"+sd.dayOfWeek());
1.2.13&1.2.14 用我们对Date的实现作为模板实现Transaction类型 & & & & & /*euqal()重载---一般分为①是否同引用②是否为空③类型是否相同④3同强转⑤内容是否同*/
根据表1.2.6给出的TransactionAPI如下(去掉compareTo)
Transaction(String who, SmartDate when, double amount)
创建一笔交易
Transaction(String transaction)
创建一笔交易
String &who()
Date &when()
double &amount()
String &toString()
对象的字符串表示
boolean &equals(Object that)
该笔交易和that是否相同
public class Transaction
private SmartD
private double
public Transaction(String who,SmartDate when,double amount)
name=who.toString();
date=new SmartDate(when.year(), when.month(), when.day());
public Transaction(String trans)
String[] fields=trans.split("\\s+");
name=fields[0];
date=new SmartDate(fields[1]);
num=Double.parseDouble(fields[2]);
public String who()
public SmartDate when()
public double amount()
public String toString()
return "name:"+name+", date:"+date.toString()+", amount:"+
public boolean equals(Object x)
//判断是否相等
if(this==x)
return true;
if(x==null)
return false;
if(this.getClass()!=x.getClass())
return false;
Transaction that=(Transaction)
return that.date.equals(date)&&that.amount()==num&&that.who()==
public static void main(String[] args)
SmartDate date=new SmartDate();
Transaction tran=new Transaction("Bob",date,1000);
StdOut.println(tran.toString());
1.2.15 文件输入.基于String的split()方法实现In中的静态方法readInts().
public class H1_2_15
public static int[] readInts(String name)
In in=new In(name);
String input=in.readAll();
String[] words=input.split("\\s+");
int[] ints=new int[words.length];
for(int i=0;i&words.i++)
ints[i]=Integer.parseInt(words[i]);
public static void main(String[] args)
int[] ints=readInts("h1_2_15.txt");
for(int a:ints)
StdOut.printf("%d ",a);
1.2.16 有理数.为有理数实现一个不可变数据类型Rational,支持加减乘除操作 & & & /*从中思考如何自己来写出一个API大纲然后实现之*/
Rational(int numerator, int denominator)
Rational &plus(Rational b)
该数与b之和
Rational &minus(Rational b)
该数与b之差
Rational &times(Rational b)
该数与b之积
Ratioanl &divides(Rational b)
该数与b之商
boolean &equals(Rational that)
该数与that相等吗
String &toString()
对象的字符串表示
public class Rational
private long
private long
public Rational(int numerator,int denominator)
if(denominator&0)
//为后续方便,始终将分母变为正数
numerator=-1*
denominator=-1*
long cd=gcd(Math.abs(numerator),Math.abs(denominator));
//化为分数的最简形式
this.numerator=numerator/
this.denominator=denominator/
public long getnumerator()
public long getdenominator()
public Rational plus(Rational b)
long num=b.getnumerator();
long den=b.getdenominator();
long tempnum=num*denominator+numerator*
long tempden=den*
long cd=gcd(Math.abs(tempnum),Math.abs(tempden));
this.numerator=tempnum/
this.denominator=tempden/
return this;
public Rational minus(Rational b)
long num=b.getnumerator();
long den=b.getdenominator();
long tempnum=numerator*den-num*
long tempden=den*
long cd=gcd(Math.abs(tempnum),Math.abs(tempden));
this.numerator=tempnum/
this.denominator=tempden/
return this;
public Rational times(Rational b)
long num=b.getnumerator();
long den=b.getdenominator();
long tempnum=numerator*
long tempden=den*
long cd=gcd(Math.abs(tempnum),Math.abs(tempden));
this.numerator=tempnum/
this.denominator=tempden/
return this;
public Rational divides(Rational b)
long num=b.getnumerator();
long den=b.getdenominator();
long tempnum=numerator*
long tempden=num*
long cd=gcd(Math.abs(tempnum),Math.abs(tempden));
this.numerator=tempnum/
this.denominator=tempden/
return this;
public boolean equals(Rational that)
if(this==that)
return true;
if(that==null)
return false;
return this.numerator==that.getnumerator()&&this.denominator==that.getdenominator();
public String toString()
if(denominator==1)
return numerator+"";
return numerator+"/"+
private long gcd(long x,long y)
long temp=x%y;
return gcd(y,temp);
public static void main(String[] args)
Rational rat1=new Rational(10, 30);
Rational rat2=new Rational(2, 5);
StdOut.printf("plus: %s\n",rat1.plus(rat2).toString());
StdOut.printf("minus: %s\n",rat1.minus(rat2).toString());
//ps:此处rat1已经为+rat2后的值
StdOut.printf("times: %s\n",rat1.times(rat2).toString());
StdOut.printf("divides: %s\n",rat1.divides(rat2).toString());
StdOut.printf("equals?: %s\n",rat1.equals(rat2));
1.2.18 累加器的方差. var()---计算方差, &stddev()---计算标准差 & & &/*回顾1.1.34中内容---此处采用的求均值和方差的方式很好,记忆之*/
public class Accumulator
private double
//m---均值
private double
//s---总和
private int N;
//N---个数
public void addDataValue(double x)
s=s+1.0*(N-1)/N*(x-m)*(x-m);
//见后续推导
m=m+(x-m)/N;
//即(x-m)/N可以理解为将x与m的偏离程度平均分散给N个
public double mean()
public double var()
return s/(N-1);
public double stddev()
return Math.sqrt(this.var());
以上答案中错误和不合理之处希望大家指出O(&_&)O~
注：里面很多来源于《算法》作者给的库
&&国之画&&&& &&&&chrome插件&&
版权所有 京ICP备号-2
迷上了代码！6÷2(1+2)= 1 还是 9 ？ - 知乎58被浏览58005分享邀请回答apina.biz/39808.jpg ，但是不知道哪个型号是比较新的)
TI（计算器）：1 或是 9（这篇似乎是说新版的都变成 1 了： ，但是最后一句话的时态有点怪我也不太懂。另外，我没图不知道它是显示「÷」、「/」还是看型号）
主流编程语言、Sage、Maxima：语法错误
ISO31, ISO/IEC 80000：不知道（有人提到 ISO 标准有这个说明，但是没空去翻也不知道要不要钱)
Fortress（Oracle 做的一个非主流编程语言）：1
台湾教育部、媒体：9
台湾学界：复选
大众：复选，如果只能 1 和 9 选一个 9 比较多 (参考 Facebook 资料)
很多人的解释都只能帮助你记住一个答案，换个计算器就被坑。所以说，把所有可能都记起来还比较实际一点，在大多数人面前就用一个大部分人的答案也没什么关系吧。
就像把哪个国家开车是在哪一边记起来才不会在出国的时候被车撞死。
== 剩下的问题 ==
1. 如果我/我认识的人碰到这个问题，而且只能单选 1 或 9 怎么办？
A: 选 9 ，前提是当事人是想拿到分数而不是伸张正义的情形。因为教育部、媒体、
大众都站这边。当然最好是有明文规定「括号跟÷、/一起出现的题目不能有」，
以免碰到有某种信徒的老师。
2. 如果面试碰到问这个怎么办？
A: 这个问题太难回答。要先设法套出面试官的答案与个性。要打个不撒谎的马屁就
把面试官的答案对应的产品背出来也是一招。另外，目前都没看到到底市场上哪种
计算机的市占率比较高是个可以讨论的问题。
3. 有括号的计算机是不是该把「÷」的键换成「/」？
A: 个人认为这还蛮重要的 但是我不知道这有没有使用方便性的问题
4. 在计算器上「6/2(1+2)」到底应不应该有一个标准？哪个答案好？
A: 我觉得这是个很难的问题，要做一些比较恰当的方便性的调查，Facebook
那个很明显就是让人觉得这是个脑筋急转弯的问答方式得出的答案绝对不会好。
感觉一眼看到是比较重要的。
如果答案是「1」这会帮助使用者少打一些括号(这是我倾向1的主因)，但是这也会让
某些人产生混乱，所以有点难判断。另外，车开在昨边还是右边也没有一个标准，
所以就算没有标准答案也没什么关系吧？
5. 如果我强烈觉得答案是 XX 怎么办？
A: 除了继续讨论以外，你还可以去回报以上列出的产品的错误，有什么
进展你可以继续分享！
6. 我想做这个问题的研究。怎么办？
A: 计算机科学：关键字 - juxposition operator
产品 - 计算器、Fortress、ML 系编程语言、Haskell (其中 Fortress 的规范
很值得一读！)
数学：没听过这种研究，其实这个问题最大的问题在于这个根本不是数学吧？
社会科学：请继续加油
== 计算机科学相关知识 ==
讲一下一个很接近数学的编程语言 — Fortress — 中「空白」运算子（juxtaposition）的优先顺序问题。我不是研究编程语言的只是刚好有去听过这个语言的演讲。
介绍一下 Fortress[1]，这是一个是由发明 Scheme 还有写出 JavaScript、Java 第一版规范的 Guy Steele 跟他在 Sun 的团队（众所周知，被 Oracle 买了）做出来的一个很接近数学的程式语言。这个语言最大的特色是可以用非 ASCII 的符号写程式 比如说：这些算式都是合法的 u · (v × w) 或是 (a + b) ∪ c
算子随便你重载，当然有 2(3+4) 之类的东西。
f(x) = x^2 + sin(x) + cos(2 x) 可以简写成 f(x) = x^2 + sin x + cos 2 x（不能把 2 x 变成 2x）
f(x) = sin(sin(x)) 可以解写成 f(x) = sin sin x （也就是有部份 right-associative!!）
有这种语法： if A ?B = C ?D then ... end（这叫做 chained operator）
内建一个程式码到LaTex 的转换器 不过我不太不晓得涵盖情形怎么样回到原来的问题跟他的变形。Fortress的执行状况如下：6÷2(1+2) = 6/2(1+2) = 6 ÷ 2 (1+2) = 1
6÷2 (1+2)
（语法错误）
6/2 (1+2) = 「6/2
(1+2)」 = 9
（中间有多少空白是一样的结果）
解释一下这些结果。根据 Fortress 规范[2] 16.2，跟这几个式子有关运算符的顺序如下：tight juxtaposition — 没有空白的「空白」运算符（如：2(1+2)）
tight fractions — 没有空白的 '/'
loose juxtaposition — 有空白的「空白」运算符（如：2 (1+2)，sin x，2 3）
（对于为什么「6÷2 (1+2)」是语法错误有兴趣同学的请看规范）
这说明了几件事：真的有「空白」运算符这种东西，只是「空白」运算子根据型态有时候还会是函式调用。
「÷」跟「/」可以不一样
有论点是说「6/2
(1+2)」 跟「6/2(1+2)」应该有一样的结果所以答案应该是 9，但是「6/2
(1+2)」 跟「6/2(1+2)」不一样的结果可以靠把「空白」运算子分成两个达到。
「语法错误」也是一招。
Mathematica 用了另一套 Fortress 用了这一套
所以，这不是一个数学问题，而是设计问题，要什么有什么，而设计问题就是用戶最大，而真正的用戶不包含会现在无聊认真去想「6÷2(1+2)」的人（因为这是一个假问题） 而是那些看着论文上的分式去打计算器的人。「需不需要为了省打一次夸号而引入这套复杂演算法」才是问题所在（因为用戶也可能会忘掉打夸号）。
因此，我才会说需要做方便性调查。标准制定没有方便性调查就会得到次等的结果。
最后，再出一题好了。请问 「2+3 - 4+2」 是多少？
（语法错误）
Fortress的答案是 3. 语法错误，就跟 sin x+y 一样。
（注：原来的两篇文章也是我写的，发表在台湾 BBS PTT 的数学版，搜寻作者 kennyluck。整理了一下，使用简体跟常用说法。）265 条评论分享收藏感谢收起154 条评论分享收藏感谢收起查看更多回答3 个回答被折叠（）}