波兰语反符号

41

您必须评估以反向波兰表示法编写的字符串并输出结果。

程序必须接受输入并返回输出。对于不具有接收输入/输出功能的编程语言，可以采用readLine / print之类的功能。

您不得在程序中使用任何类型的“评估”。

数字和运算符由一个或多个空格分隔。

您必须至少支持+，-，*和/运算符。

您需要为负数和浮点数添加支持（例如，-4与并不相同0 4 -）。

您可以假设输入有效，并遵循上述规则


测试用例

输入：

-4 5 +

输出：

1

输入：

5 2 /

输出：

2.5

输入：

5 2.5 /

输出：

2

输入：

5 1 2 + 4 * 3 - +

输出：

14

输入：

4 2 5 * + 1 3 2 * + /

输出：

2
code-golf  math 
8
遗憾的是，不允许评估，否则GolfScript解决方案为1个字符：~。:-P
— 克里斯·杰斯特·杨
5
这就是为什么它不被允许的原因：-P，StackOverflow上的这个问题使用dc回答了4个字符。
1
@SHiNKiROU：要求您使用哪种语言eval来解析数字？听起来很碎。（据我所知，GolfScript是一种这样的语言。我认为它也已被破坏。）
— 克里斯·杰斯特·杨
3
-4和0 4-怎么不一样？
— 基思·兰德尔
1
我认为如果只是将字符串转换为数字，eval应该可以。例如。在python eval(s)中胜过float(s)
— gnibbler 2011年

Answers:

15

Ruby- 95 77个字符

a=[]
gets.split.each{|b|a<<(b=~/\d/?b.to_f: (j,k=a.pop 2;j.send b,k))}
p a[0]

在stdin上接受输入。

测试代码

[
  "-4 5 +",
  "5 2 /",
  "5 2.5 /",
  "5 1 2 + 4 * 3 - +",
  "4 2 5 * + 1 3 2 * + /",
  "12 8 3 * 6 / - 2 + -20.5 "
].each do |test|
  puts "[#{test}] gives #{`echo '#{test}' | ruby golf-polish.rb`}"
end

给

[-4 5 +] gives 1.0
[5 2 /] gives 2.5
[5 2.5 /] gives 2.0
[5 1 2 + 4 * 3 - +] gives 14.0
[4 2 5 * + 1 3 2 * + /] gives 2.0
[12 8 3 * 6 / - 2 + -20.5 ] gives 10.0

与C版本不同的是，如果输入看起来有多余的数字，它将返回最后一个有效结果。

— 尼莫157
source
1
您可以使用地图代替每个角色来剃除角色
— addison
10

Python-124个字符

s=[1,1]
for i in raw_input().split():b,a=map(float,s[:2]);s[:2]=[[a+b],[a-b],[a*b],[a/b],[i,b,a]]["+-*/".find(i)]
print s[0]

Python-133个字符

s=[1,1]
for i in raw_input().split():b,a=map(float,s[:2]);s={'+':[a+b],'-':[a-b],'*':[a*b],'/':[a/b]}.get(i,[i,b,a])+s[2:]
print s[0]
— ni
source
1
我喜欢堆栈操作。
— 亚历山德鲁（Alexandru）
2
您不能0作为第二个操作数...
— JBernardo 2011年
2
[a/b]应该用替换，b and[a/b]以便您可以将0作为第二个操作数。
— flornquake
10

计划，162个字符

（为清楚起见添加了换行符，所有这些都是可选的。）

(let l((s'()))(let((t(read)))(cond((number? t)(l`(,t,@s)))((assq t
`((+,+)(-,-)(*,*)(/,/)))=>(lambda(a)(l`(,((cadr a)(cadr s)(car s))
,@(cddr s)))))(else(car s)))))

完全格式化（未合并）版本：

(let loop ((stack '()))
  (let ((token (read)))
    (cond ((number? token) (loop `(,token ,@stack)))
          ((assq token `((+ ,+) (- ,-) (* ,*) (/ ,/)))
           => (lambda (ass) (loop `(,((cadr ass) (cadr stack) (car stack))
                                    ,@(cddr stack)))))
          (else (car stack)))))

精选评论

`(,foo ,@bar)与(cons foo bar)（即，（有效†）返回以foo开头的新列表bar）相同，不同之处在于，如果将所有空格压缩出去，它的长度要短一个字符。

因此，您可以阅读迭代子句(loop (cons token stack))，(loop (cons ((cadr ass) (cadr stack) (car stack)) (cddr stack)))如果这样更容易理解。

`((+ ,+) (- ,-) (* ,*) (/ ,/))创建一个符号 +与过程 配对的关联列表+，并与其他运算符配对。因此，这是一个简单的符号查找表（裸露的(read)符号作为符号，这就是为什么不需要进一步处理的原因token）。关联列表具有O（n）查找，因此仅适用于短列表，如此处的情况。:-P

†从技术上讲这不是准确的，但是对于非Lisp程序员来说，这是一个正确的主意。

— 克里斯·杰斯特·杨
source
你能读懂吗？认真吗
1
@ M28：非高尔夫版本，是的。我半定期在Scheme中编程（对于真正的严肃程序）。
— 克里斯·杰斯特·杨
不幸的是，Scheme是一种冗长的语言，众所周知很难很好地打高尔夫球。因此，看到一些Perl提交击败了我，我不会感到惊讶。
— 克里斯·杰斯特·杨
7
我喜欢高尔夫球版的四个笑脸。
— tomsmeding
2
lambda (ass)+1为变量名选择：P
— Downgoat '16
7

c-424个必需字符

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define O(X) g=o();g=o() X g;u(g);break;
char*p=NULL,*b;size_t a,n=0;float g,s[99];float o(){return s[--n];};
void u(float v){s[n++]=v;};int main(){getdelim(&p,&a,EOF,stdin);for(;;){
b=strsep(&p," \n\t");if(3>p-b){if(*b>='0'&&*b<='9')goto n;switch(*b){case 0:
case EOF:printf("%f\n",o());return 0;case'+':O(+)case'-':O(-)case'*':O(*)
case'/':O(/)}}else n:u(atof(b));}}

假设您有一个足够新的libc可以包含getdelim在stdio.h中。该方法很简单，将整个输入读入缓冲区，然后strsep使用进行标记化，并使用长度和初始字符来确定每个类。没有防止输入错误的保护措施。给它加“ +-* / +-...”，它会愉快地从堆栈“下面”的内存中弹出东西，直到出现段故障。所有非运算符都被解释为浮点数，atof如果它们看起来不像数字，则意味着零值。

可读和评论：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *p=NULL,*b;
size_t a,n=0;
float g,s[99];
float o(){        /* pOp */
  //printf("\tpoping '%f'\n",s[n-1]);
  return s[--n];
};
void u(float v){  /* pUsh */
  //printf("\tpushing '%f'\n",v);
  s[n++]=v;
};
int main(){
  getdelim(&p,&a,EOF,stdin); /* get all the input */
  for(;;){
    b=strsep(&p," \n\t"); /* now *b though *(p-1) is a token and p
                 points at the rest of the input */
    if(3>p-b){
      if (*b>='0'&&*b<='9') goto n;
      //printf("Got 1 char token '%c'\n",*b);
      switch (*b) {
      case 0:
      case EOF: printf("%f\n",o()); return 0;
      case '+': g=o(); g=o()+g; u(g); break;
      case '-': g=o(); g=o()-g; u(g); break;
      case '*': g=o(); g=o()*g; u(g); break;
      case '/': g=o(); g=o()/g; u(g); break;
    /* all other cases viciously ignored */
      } 
    } else { n:
      //printf("Got token '%s' (%f)\n",b,atof(b));
      u(atof(b));
    }
  }
}

验证：

 $ gcc -c99 rpn_golf.c 
 $ wc rpn_golf.c
  9  34 433 rpn_golf.c
 $ echo -4 5 + | ./a.out
1.000000
 $ echo 5 2 / | ./a.out
2.500000
 $ echo 5 2.5 / | ./a.out
2.000000

h！要引用其中的任何*内容...

 $ echo "5 1 2 + 4 * 3 - +" | ./a.out
14.000000
 $ echo "4 2 5 * + 1 3 2 * + /" | ./a.out
2.000000

和我自己的测试用例

 $ echo "12 8 3 * 6 / - 2 + -20.5 " | ./a.out
-20.500000
— dmckee
source
您可以通过替换casemakro 来保护某些字符。
— 2011年
7

哈斯克尔（155）

f#(a:b:c)=b`f`a:c
(s:_)![]=print s
s!("+":v)=(+)#s!v
s!("-":v)=(-)#s!v
s!("*":v)=(*)#s!v
s!("/":v)=(/)#s!v
s!(n:v)=(read n:s)!v
main=getLine>>=([]!).words
— 马里纳斯
source
通过将“（s：_）！[] = s”更改为“（s：_）！[] = print s”和“ main = getLine >> = putStrLn.show。（[]！ ）.words“到” main = getLine >> =（[[!!）。words）
— Fors 2013年
然后，使用单行大小写语句进一步删除其他一些字符。
— Fors 2013年
s!(n:v)=case n of{"+"->(+)#s;"-"->(-)#s;"*"->(*)#s;"/"->(/)#s;_->(read n:s)}!v将节省14个字符。
— Fors 2013年
7

MATLAB - 158，147

C=strsplit(input('','s'));D=str2double(C);q=[];for i=1:numel(D),if isnan(D(i)),f=str2func(C{i});q=[f(q(2),q(1)) q(3:end)];else q=[D(i) q];end,end,q

（从用户输入中读取输入，将输出打印出来）。

下面是经过修饰和注释的代码，它几乎实现了所描述的后缀算法（假设表达式有效）：

C = strsplit(input('','s'));         % prompt user for input and split string by spaces
D = str2double(C);                   % convert to numbers, non-numeric are set to NaN
q = [];                              % initialize stack (array)
for i=1:numel(D)                     % for each value
    if isnan(D(i))                   % if it is an operator
        f = str2func(C{i});          % convert op to a function
        q = [f(q(2),q(1)) q(3:end)]; % pop top two values, apply op and push result
    else
        q = [D(i) q];                % else push value on stack
    end
end
q                                    % show result

奖金：

在上面的代码中，我们假定运营商总是二进制（+，-，*，/）。我们可以通过nargin(f)确定操作数/函数所需的参数数量，然后从堆栈中弹出正确数量的值来对其进行概括，如下所示：

f = str2func(C{i});
n = nargin(f);
args = num2cell(q(n:-1:1));
q = [f(args{:}) q(n+1:end)];

这样我们就可以评估表达式，例如：

str = '6 5 1 2 mean_of_three 1 + 4 * +'

其中mean_of_three是具有三个输入的用户定义的函数：

function d = mean_of_three(a,b,c)
    d = (a+b+c)/3;
end
— 安姆罗
source
6

Perl（134）

@a=split/\s/,<>;/\d/?push@s,$_:($x=pop@s,$y=pop@s,push@s,('+'eq$_?$x+$y:'-'eq$_?$y-$x:'*'eq$_?$x*$y:'/'eq$_?$y/$x:0))for@a;print pop@s

下次，我将使用递归正则表达式。

取消高尔夫：

@a = split /\s/, <>;
for (@a) {
    /\d/
  ? (push @s, $_)
  : ( $x = pop @s,
      $y = pop @s,
      push @s , ( '+' eq $_ ? $x + $y
                : '-' eq $_ ? $y - $x
                : '*' eq $_ ? $x * $y
                : '/' eq $_ ? $y / $x
                : 0 )
      )
}
print(pop @s);

我虽然F＃是我唯一的梦想编程语言...

— 明堂
source
我有一个较短的Perl 5实现。
— 支石墓
6

Windows PowerShell中，152 181 192

以可读的形式显示，因为到目前为止只有两行，没有机会将它们分解：

$s=@()
switch -r(-split$input){
  '\+'        {$s[1]+=$s[0]}
  '-'         {$s[1]-=$s[0]}
  '\*'        {$s[1]*=$s[0]}
  '/'         {$s[1]/=$s[0]}
  '-?[\d.]+'  {$s=0,+$_+$s}
  '.'         {$s=$s[1..($s.count)]}}
$s

2010-01-30 11:07（192）–第一次尝试。

2010-01-30 11:09（170）–将函数转换为脚本块可解决范围问题。只是使每个调用长两个字节。

2010-01-30 11:19（188）–没有解决范围问题，测试用例只是掩盖了它。但是，从最终输出中删除了索引，并删除了多余的换行符。并更改为double float。

2010-01-30 11:19（181）–甚至不记得我的建议。转换为数字类型可以在单个字符中完成。

2010-01-30 11:39（152）–通过在中使用正则表达式匹配大大减少了switch。通过访问堆栈以将其弹出，完全解决了先前的范围问题。

— 乔伊
source
5

球拍 131：

(let l((s 0))(define t(read))(cond[(real? t)
(l`(,t,@s))][(memq t'(+ - * /))(l`(,((eval t)(cadr s)
(car s)),@(cddr s)))][0(car s)]))

换行符是可选的。

基于Chris Jester-Young的Scheme解决方案。

— 山姆·托宾·霍斯塔特
source
4

Python，166个字符

import os,operator as o
S=[]
for i in os.read(0,99).split():
 try:S=[float(i)]+S
 except:S=[{'+':o.add,'-':o.sub,'/':o.div,'*':o.mul}[i](S[1],S[0])]+S[2:]
print S[0]
— 基思·兰德尔
source
使用raw_input()代码不会分成多行。
— JPvdMerwe 2011年
然后，您可以尝试：from operator import*并替换o.div为div。
— JPvdMerwe 2011年
4

Python 3，119个字节

s=[]
for x in input().split():
 try:s+=float(x),
 except:o='-*+'.find(x);*s,a,b=s;s+=(a+b*~-o,a*b**o)[o%2],
print(s[0])

输入： 5 1 1 - -7 0 * + - 2 /

输出： 2.5

（您可以在编辑历史记录中找到128个字符的Python 2版本。）

— 地震
source
非常聪明:)我喜欢您不需要/字符串中的内容。
— Daniel Lubarov 2013年
— Erik the Outgolfer
@EriktheOutgolfer ZeroDivisionError在第二个操作数为0时（例如5 0 +）以a中断。
— flornquake
您可以使用该ord(x) - 42方法保存1个字符。
— frederick99
@ frederick99我不知道如何。
— flornquake
3

的JavaScript（157）

此代码假定有以下两个功能：readLine和print

a=readLine().split(/ +/g);s=[];for(i in a){v=a[i];if(isNaN(+v)){f=s.pop();p=s.pop();s.push([p+f,p-f,p*f,p/f]['+-*/'.indexOf(v)])}else{s.push(+v)}}print(s[0])
如果您使用prompt()代替readLine()（可能alert()不是print()匹配prompt()），则更短。
— nyuszika7h 2014年
3

Perl，128个

与其他Perl答案相比，这并不是真正的竞争优势，但它探索了一条不同的（次优）途径。

perl -plE '@_=split" ";$_=$_[$i],/\d||
do{($a,$b)=splice@_,$i-=2,2;$_[$i--]=
"+"eq$_?$a+$b:"-"eq$_?$a-$b:"*"eq$_?
$a*$b:$a/$b;}while++$i<@_'

字符算作简单perl -e ''调用的差异。

— JB
source
2

Python，161个字符：

from operator import*;s=[];i=raw_input().split(' ')
q="*+-/";o=[mul,add,0,sub,0,div]
for c in i:
 if c in q:s=[o[ord(c)-42](*s[1::-1])]+s 
 else:s=[float(c)]+s
print(s[0])
— 托马斯·奥
source
2

PHP，439 265 263 262 244 240个字符

<? $c=fgets(STDIN);$a=array_values(array_filter(explode(" ",$c)));$s[]=0;foreach($a as$b){if(floatval($b)){$s[]=$b;continue;}$d=array_pop($s);$e=array_pop($s);$s[]=$b=="+"?$e+$d:($b=="-"?$e-$d:($b=="*"?$e*$d:($b=="/"?$e/$d:"")));}echo$s[1];

该代码应与stdin一起使用，尽管未经过stdin测试。

已在所有情况下进行了测试，最后一个的输出（和代码）在这里：http :
//codepad.viper-7.com/fGbnv6

Ungolfed，314个 330 326字符

<?php
$c = fgets(STDIN);
$a = array_values(array_filter(explode(" ", $c)));
$s[] = 0;
foreach($a as $b){
    if(floatval($b)){
        $s[] = $b;
        continue;
    }
    $d = array_pop($s);
    $e = array_pop($s);
    $s[] = $b == "+" ? $e + $d : ($b == "-" ? $e - $d : ($b == "*" ? $e * $d : ($b == "/" ? $e / $d :"")));
}
echo $s[1];
— 凯文·布朗
source
从任务描述报价：»编程不具备的功能，以接收输入/输出语言，可以承担类似的readLine /打印功能« - demonstrably PHP。具有功能这样做，因此假设是不正确。
— Joey
更新了它以使用stdin并将其打高尔夫球。
— 凯文·布朗
2

伸缩-157

%{
float b[100],*s=b;
#define O(o) s--;*(s-1)=*(s-1)o*s;
%}
%%
-?[0-9.]+ *s++=strtof(yytext,0);
\+ O(+)
- O(-)
\* O(*)
\/ O(/)
\n printf("%g\n",*--s);
.
%%

如果您不熟悉，请使用 flex rpn.l && gcc -lfl lex.yy.c

— 杰夫·里迪（Geoff Reedy）
source
2

Python 3中，126 132个字符

s=[2,2]
for c in input().split():
    a,b=s[:2]
    try:s[:2]=[[a+b,b-a,a*b,a and b/a]["+-*/".index(c)]]
    except:s=[float(c)]+s
print(s[0])

已经有了更好的解决方案，但是现在我已经编写了它（当然，即使没有阅读以前的提交，即使我不得不承认我的代码看起来好像我已经将它们粘贴复制在一起），我也想共享它，太。

— cemper93
source
b/a应该用替换a and b/a，否则，如果第二个操作数为0（例如4 0 -），则此解决方案将不起作用。
— flornquake
@flornquake为他修复了它。
— mbomb007
2

c99 gcc 235

这对我有用（带有警告）：

#include <stdlib.h>
#define O(x):--d;s[d]=s[d]x s[d+1];break;
float s[99];main(c,v)char**v;{for(int i=1,d=0;i<c;i++)switch(!v[i][1]?*v[i]:' '){case'+'O(+)case'-'O(-)case'*'O(*)case'/'O(/)default:s[++d]=atof(v[i]);}printf("%f\n",s[1]);}

但是，如果您使用mingw32进行编译，则需要通过以下编译来关闭通气（请参阅https://www.cygwin.com/ml/cygwin/1999-11/msg00052.html）：

gcc -std=c99 x.c C:\Applications\mingw32\i686-w64-mingw32\lib\CRT_noglob.o

如果不这样做，则mingw32 CRT会自动将其展开。

是否有人知道如何break;case'*':s[--d]*=s[d+1];变成一个接受字符+作为参数的宏，因为这四种情况都将是O(+)O(-)O(*)O(/)

H:\Desktop>gcc -std=c99 x.c C:\Applications\mingw32\i686-w64-mingw32\lib\CRT_noglob.o
x.c:3:13: warning: return type defaults to 'int'
 float s[99];main(c,v)char**v;{for(int i=1,d=0;i<c;i++)switch(!v[i][1]?*v[i]:' '){case'+'O(+)case'-'O(-)case'*'O(*)case'/'O(/)default:s[++d]=atof(v[i]);}printf("%f\n",s[1]);}
x.c: In function 'main':
x.c:3:13: warning: type of 'c' defaults to 'int'
x.c:3:1: warning: implicit declaration of function 'atof' [-Wimplicit-function-declaration]
 float s[99];main(c,v)char**v;{for(int i=1,d=0;i<c;i++)switch(!v[i][1]?*v[i]:' '){case'+'O(+)case'-'O(-)case'*'O(*)case'/'O(/)default:s[++d]=atof(v[i]);}printf("%f\n",s[1]);}
x.c:3:1: warning: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
x.c:3:153: warning: incompatible implicit declaration of built-in function 'printf'
 float s[99];main(c,v)char**v;{for(int i=1,d=0;i<c;i++)switch(!v[i][1]?*v[i]:' '){case'+'O(+)case'-'O(-)case'*'O(*)case'/'O(/)default:s[++d]=atof(v[i]);}printf("%f\n",s[1]);}
H:\Desktop>a -4 5 +
1.000000
H:\Desktop>a 5 2 /
2.500000
H:\Desktop>a 5 2.5 /
2.000000
H:\Desktop>a 5 1 2 + 4 * 3 - +
14.000000
H:\Desktop>a 4 2 5 * + 1 3 2 * + /
2.000000
— 杰里·耶利米
source
2

C，232 229字节

递归的乐趣。

#include <stdlib.h>
#define b *p>47|*(p+1)>47
char*p;float a(float m){float n=strtof(p,&p);b?n=a(n):0;for(;*++p==32;);m=*p%43?*p%45?*p%42?m/n:m*n:m-n:m+n;return*++p&&b?a(m):m;}main(c,v)char**v;{printf("%f\n",a(strtof(v[1],&p)));}

取消高尔夫：

#include <stdlib.h>

/* Detect if next char in buffer is a number */
#define b *p > 47 | *(p+1) > 47

char*p; /* the buffer */

float a(float m)
{
    float n = strtof(p, &p); /* parse the next number */

    /* if the next thing is another number, recursively evaluate */
    b ? n = a(n) : 0;

    for(;*++p==32;); /* skip spaces */

    /* Perform the arithmetic operation */
    m = *p%'+' ? *p%'-' ? *p%'*' ? m/n : m*n : m-n : m+n;

    /* If there's more stuff, recursively parse that, otherwise return the current computed value */
    return *++p && b ? a(m) : m;
}

int main(int c, char **v)
{
    printf("%f\n", a(strtof(v[1], &p)));
}

测试用例：

$ ./a.out "-4 5 +"
1.000000
$ ./a.out "5 2 /"
2.500000
$ ./a.out "5 2.5 /"
2.000000
$ ./a.out "5 1 2 + 4 * 3 - +"
14.000000
$ ./a.out "4 2 5 * + 1 3 2 * + /"
2.000000
— 科尔·卡梅隆
source
1

PHP-259个字符

$n=explode(" ",$_POST["i"]);$s=array();for($i=0;$i<count($n);$s=$d-->0?array_merge($s,!$p?array($b,$a,$c):array($p)):$s){if($c=$n[$i++]){$d=1;$a=array_pop($s);$b=array_pop($s);$p=$c=="+"?$b+$a:($c=="-"?$b-$a:($c=="*"?$b*$a:($c=="/"?$b/$a:false)));}}echo$s[2];

假设输入POST变量i。

— 奥雷尔·比利
source
2
引用原始说明»对于不具有接收输入/输出功能的编程语言，您可以假定使用readLine / print之类的功能。«PHP具有通过流获取标准输入的方法。
— 凯文·布朗
1

C＃-392个字符

namespace System.Collections.Generic{class P{static void Main(){var i=Console.ReadLine().Split(' ');var k=new Stack<float>();float o;foreach(var s in i)switch (s){case "+":k.Push(k.Pop()+k.Pop());break;case "-":o=k.Pop();k.Push(k.Pop()-o);break;case "*":k.Push(k.Pop()*k.Pop());break;case "/":o=k.Pop();k.Push(k.Pop()/o);break;default:k.Push(float.Parse(s));break;}Console.Write(k.Pop());}}}

但是，如果可以使用参数代替标准输入，我们可以将其简化为

C＃-366个字符

namespace System.Collections.Generic{class P{static void Main(string[] i){var k=new Stack<float>();float o;foreach(var s in i)switch (s){case "+":k.Push(k.Pop()+k.Pop());break;case "-":o=k.Pop();k.Push(k.Pop()-o);break;case "*":k.Push(k.Pop()*k.Pop());break;case "/":o=k.Pop();k.Push(k.Pop()/o);break;default:k.Push(float.Parse(s));break;}Console.Write(k.Pop());}}}
— 狐狸
source
您可以通过一些优化来保存23个字符：1.删除名称空间技巧，明确限定需要它的两种类型。您保存“名称空间”关键字和相应的括号。2.删除string []和i，大小写关键字和标签，switch及其括号之间的空格。3.摆脱浮点数o并简单地使用数学来获得正确的结果（即-k.Pop（）+ k.Pop（）减，1 / k.Pop（）* k.Pop（） 。
— MikeP
1

Scala 412376349335312：

object P extends App{
def p(t:List[String],u:List[Double]):Double={
def a=u drop 2
t match{
case Nil=>u.head
case x::y=>x match{
case"+"=>p(y,u(1)+u(0)::a)
case"-"=>p(y,u(1)-u(0)::a)
case"*"=>p(y,u(1)*u(0)::a)
case"/"=>p(y,u(1)/u(0)::a)
case d=>p(y,d.toDouble::u)}}}
println(p((readLine()split " ").toList,Nil))}
— 用户未知
source
1

Python-206

import sys;i=sys.argv[1].split();s=[];a=s.append;b=s.pop
for t in i:
 if t=="+":a(b()+b())
 elif t=="-":m=b();a(b()-m)
 elif t=="*":a(b()*b())
 elif t=="/":m=b();a(b()/m)
 else:a(float(t))
print(b())

非高尔夫版本：

# RPN

import sys

input = sys.argv[1].split()
stack = []

# Eval postfix notation
for tkn in input:
    if tkn == "+":
        stack.append(stack.pop() + stack.pop())
    elif tkn == "-":
        tmp = stack.pop()
        stack.append(stack.pop() - tmp)
    elif tkn == "*":
        stack.append(stack.pop() * stack.pop())
    elif tkn == "/":
        tmp = stack.pop()
        stack.append(stack.pop()/tmp)
    else:
        stack.append(float(tkn))

print(stack.pop())

从命令行参数输入；在标准输出上输出。

— 高尔夫球手9338
source
1

ECMAScript 6（131）

只需几秒钟即可一起输入，因此它可能会打得更远，甚至可能更好。我明天可能会重新审视它：

f=s=>(p=[],s.split(/\s+/).forEach(t=>+t==t?p.push(t):(b=+p.pop(),a=+p.pop(),p.push(t=='+'?a+b:t=='-'?a-b:t=='*'?a*b:a/b))),p.pop())
— 英戈·布尔克（IngoBürk）
source
1

C＃ - 323 284 241

class P{static void Main(string[] i){int x=0;var a=new float[i.Length];foreach(var s in i){var o="+-*/".IndexOf(s);if(o>-1){float y=a[--x],z=a[--x];a[x++]=o>3?z/y:o>2?z*y:o>1?z-y:y+z;}else a[x++]=float.Parse(s);}System.Console.Write(a[0]);}}

编辑：用数组替换堆栈更短

Edit2：用三元表达式替换ifs

— 凯夫
source
string[] i=> string[]i。
— 扎卡里
1

Python 2

对于到目前为止发布的方法，我已经尝试了一些不同的方法。这些都不是最好的Python解决方案那么短，但是对于某些人来说，它们可能仍然很有趣。

使用递归146

def f(s):
 try:x=s.pop();r=float(x)
 except:b,s=f(s);a,s=f(s);r=[a+b,a-b,a*b,b and a/b]['+-*'.find(x)]
 return r,s
print f(raw_input().split())[0]

使用列表操作，149

s=raw_input().split()
i=0
while s[1:]:
 o='+-*/'.find(s[i])
 if~o:i-=2;a,b=map(float,s[i:i+2]);s[i:i+3]=[[a+b,a-b,a*b,b and a/b][o]]
 i+=1
print s[0]

使用中reduce()，145

print reduce(lambda s,x:x in'+-*/'and[(lambda b,a:[a+b,a-b,a*b,b and a/b])(*s[:2])['+-*'.find(x)]]+s[2:]or[float(x)]+s,raw_input().split(),[])[0]
— 地震
source
1

Matlab，228

F='+-/*';f={@plus,@minus,@rdivide,@times};t=strsplit(input('','s'),' ');i=str2double(t);j=~isnan(i);t(j)=num2cell(i(j));while numel(t)>1
n=find(cellfun(@(x)isstr(x),t),1);t{n}=bsxfun(f{t{n}==F},t{n-2:n-1});t(n-2:n-1)=[];end
t{1}

取消高尔夫：

F = '+-/*'; %// possible operators
f = {@plus,@minus,@rdivide,@times}; %// to be used with bsxfun
t = strsplit(input('','s'),' '); %// input string and split by one or multiple spaces
i = str2double(t); %// convert each split string to number
j =~ isnan(i); %// these were operators, not numbers ...
t(j) = num2cell(i(j)); %// ... so restore them
while numel(t)>1
    n = find(cellfun(@(x)isstr(x),t),1); %// find left-most operator
    t{n} = bsxfun(f{t{n}==F}, t{n-2:n-1}); %// apply it to preceding numbers and replace
    t(n-2:n-1)=[]; %// remove used numbers
end
t{1} %// display result
— 路易斯·门多
source
您可以通过将所有内容放到一行中来另外保存2个字节（或使用仅对换行符使用一个字符的文本编辑器）
— Hoki 2015年
@Hoki我只在不换行的情况下才使用换行符;。所以我认为字节数相同
— Luis Mendo
不完全是，大多数窗口文本编辑器都使用cr+lf换行符，即2个字符。我的notepad ++在您的3行版本中计算了230个字符，但是如果我将所有内容都粘在一行中，则只有128个字符（从2个新行中删除了2 * 2 = 4个字符，并添加了2个;）。自己尝试；）
— Hoki
@Hoki你是对的。实际上，如果我将三行版本的代码粘贴到mothereff.in/byte-counter上（这是我用来计算文本字节的数量），则它的值是228。线。我不知道我从哪里得到230。谢谢！已更正
— Luis Mendo 2015年
1

K5，70个字节

`0:*{$[-9=@*x;((*(+;-;*;%)@"+-*/"?y).-2#x;x,.y)@47<y;(.x;.y)]}/" "\0:`

我不确定K5何时发布，所以这可能不算在内。还是很棒！

— kirbyfan64sos
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.