रिवर्स पोलिश नोटेशन

Question

आपको रिवर्स पोलिश नोटेशन में लिखे स्ट्रिंग का मूल्यांकन करना होगा और परिणाम को आउटपुट करना होगा।

कार्यक्रम को एक इनपुट स्वीकार करना चाहिए और आउटपुट वापस करना चाहिए। प्रोग्रामिंग भाषाओं के लिए जिनके पास इनपुट / आउटपुट प्राप्त करने के लिए फ़ंक्शन नहीं हैं, आप रीडलाइन / प्रिंट जैसे फ़ंक्शन ग्रहण कर सकते हैं।

आपको प्रोग्राम में किसी भी तरह के "ईवैल" का उपयोग करने की अनुमति नहीं है।

नंबर और ऑपरेटरों को एक या अधिक रिक्त स्थान द्वारा अलग किया जाता है ।

आपको कम से कम +, -, * और / ऑपरेटरों का समर्थन करना चाहिए।

आपको नकारात्मक संख्याओं के लिए समर्थन जोड़ने की आवश्यकता है (उदाहरण के लिए, -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

Comments

यह शर्म की बात है कि कोई भी अनुमति नहीं है, अन्यथा GolfScript समाधान 1 वर्ण है ~:। :-P

— क्रिस जस्टर-यंग

इसलिए इसकी अनुमति नहीं है :-P, StackOverflow पर इस प्रश्न को dc के साथ 4 वर्णों का उत्तर मिला।

@SHiNKiROU: किस भाषा के लिए आपको evalनंबर पार्स करने के लिए उपयोग करने की आवश्यकता है ? यह काफी टूटा हुआ लगता है। (गोल्फस्क्रिप्ट एक ऐसी भाषा है, जहां तक ​​मैं जानता हूं। मुझे लगता है कि यह भी टूट गया है।)

— क्रिस जस्टर-यंग

कैसे -4 0 0 के समान नहीं है -?

— कीथ रान्डेल

मुझे लगता है कि eval ठीक होना चाहिए अगर यह संख्याओं को स्ट्रिंग्स में बदलना है। जैसे। अजगर में eval(s)से बेहतर हैfloat(s)

— gnibbler

Answer 1

रूबी - 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]

स्टड पर इनपुट लेता है।

परीक्षण कोड

[
  "-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 संस्करण के विपरीत, यह अंतिम वैध परिणाम देता है यदि ऐसा लगता है कि इनपुट में जोड़े गए अतिरिक्त नंबर हैं।

Comments

आप प्रत्येक के बजाय मानचित्र का उपयोग करके एक चरित्र को दाढ़ी कर सकते हैं

— एडिसन

Answer 2

पायथन - 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]

अजगर - 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]

Comments

मुझे स्टैक हेरफेर पसंद है।

— अलेक्जेंड्रू

आपके पास 0दूसरे ऑपरेंड के रूप में नहीं हो सकता ...

— जेबरनार्दो

[a/b]के साथ प्रतिस्थापित किया जाना चाहिए b and[a/b]ताकि आपके पास दूसरे ऑपरेंड के रूप में 0 हो सके।

— कांटा

Answer 3

स्कीम, 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)))))

पूरी तरह से स्वरूपित (ungolfed) संस्करण:

(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के लिए prepended bar), को छोड़कर यह एक चरित्र छोटा है अगर आप सभी रिक्त स्थान बाहर सेक।

इस प्रकार, आप के रूप में यात्रा खंड पढ़ सकते हैं (loop (cons token stack))और (loop (cons ((cadr ass) (cadr stack) (car stack)) (cddr stack)))है कि अगर तुम्हारी आँखों पर आसान है।

`((+ ,+) (- ,-) (* ,*) (/ ,/))प्रक्रिया के साथ जोड़े गए प्रतीक + के साथ एक संघ सूची बनाता है , और इसी तरह अन्य ऑपरेटरों के साथ। इस प्रकार यह एक साधारण प्रतीक देखने की मेज है (नंगे शब्द प्रतीकों के रूप में हैं , यही वजह है कि आगे कोई प्रसंस्करण आवश्यक नहीं है)। एसोसिएशन सूचियों में O (n) लुकअप है, और इस प्रकार केवल छोटी सूचियों के लिए उपयुक्त है, जैसा कि यहाँ है। :-P +(read)token

Techn यह तकनीकी रूप से सटीक नहीं है, लेकिन, गैर-लिस्प प्रोग्रामर के लिए, यह एक सही-पर्याप्त विचार प्राप्त करता है।

Comments

क्या आप इसे पढ़ सकते हैं? गंभीरता से?

@ M28: अनगुल्ड संस्करण, हाँ। मैं योजना में अर्ध-नियमित आधार पर (वास्तविक, गंभीर कार्यक्रमों के लिए) कार्यक्रम करता हूं।

— क्रिस जेस्टर-यंग

दुर्भाग्य से, स्कीम एक क्रियात्मक भाषा है और कुएं को अच्छी तरह से गोल्फ के लिए कठिन है। इसलिए मुझे यह देखकर आश्चर्य नहीं होगा कि कुछ पर्ल ने इसे पेश किया।

— क्रिस जस्टर-यंग

मुझे गोल्फ संस्करण में चार स्माइली पसंद हैं।

— tomsmeding

lambda (ass)वेरिएबल नेम पसंद के लिए +1: पी

— डाउनगोट

Answer 4

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));}}

मान लें कि आपके पास getdelimstdio.h में शामिल करने के लिए एक नया पर्याप्त libc है । दृष्टिकोण सीधे आगे है, पूरे इनपुट को एक बफर में पढ़ा जाता है, फिर हम 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

हे! इसके साथ कुछ भी कहना होगा *...

 $ 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

Comments

आप कुछ पात्रों caseको एक makro के साथ बदलकर सुरक्षित कर सकते हैं ।

— फ़ूजएक्सएक्सएल

Answer 5

हास्केल (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

Comments

आप "(s: _)! [] = S" से "(s: _)! [] = प्रिंट s" और "main = getLine >> = putStrLn.show। ([]] को बदलकर 9 वर्णों को हटा सकते हैं! ) .words "to" main = getLine >> = ([]! शब्द। "

— Fors

और फिर एक-लाइन केस-स्टेटमेंट का उपयोग करके कुछ अन्य वर्णों को हटा दें।

— फोर्स

s!(n:v)=case n of{"+"->(+)#s;"-"->(-)#s;"*"->(*)#s;"/"->(/)#s;_->(read n:s)}!v14 वर्णों को बचाएगा।

— फोर्स

Answer 6

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

Answer 7

पर्ल (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

अगली बार, मैं पुनरावर्ती rexxp चीज़ का उपयोग करने जा रहा हूँ।

Ungolfed:

@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);

हालांकि मैं एफ # मेरी एकमात्र सपना प्रोग्रामिंग भाषा है ...

Comments

मेरे पास एक छोटा पर्ल 5 कार्यान्वयन है।

— dolmen

Answer 8

विंडोज पॉवरशेल, 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) - स्कोप इश्यू को हल नहीं किया, टेस्ट केस ने इसे पूरा किया। हालांकि, अंतिम आउटपुट से सूचकांक को हटा दिया और एक शानदार लाइन ब्रेक को हटा दिया। और डबल में बदल गया float।

2010-01-30 11:19 (181) - मेरी खुद की सलाह भी याद नहीं कर सकते। एक संख्यात्मक प्रकार के लिए कास्टिंग एक चार में किया जा सकता है।

2010-01-30 11:39 (152) - रेगेक्स मिलान का उपयोग करके बहुत कम किया गया switch। स्टैक तक इसे पॉप करने के लिए पिछले स्कोप के मुद्दों को पूरी तरह से हल करता है।

Answer 9

रैकेट 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)]))

लाइन वैकल्पिक रूप से टूट जाती है।

योजना के लिए क्रिस जस्टर-यंग समाधान पर आधारित।

Answer 10

पायथन, 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]

Comments

उपयोग raw_input()कोड कई लाइनों पर विभाजित नहीं है।

— JPvdMerwe

तब आप कोशिश कर सकते हैं: from operator import*और के o.divसाथ बदलें div।

— JPvdMerwe

Answer 11

पायथन 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-वर्ण पायथन 2 संस्करण पा सकते हैं।)

Comments

बहुत चालाक :) मुझे पसंद है कि आपको /स्ट्रिंग में कैसे ज़रूरत नहीं है ।

— डेनियल लुबरोव

114 बाइट्स

— एलिक आउटफोलर

@EriktheOutgolfer ZeroDivisionErrorजब दूसरी ऑपरेंड 0 (जैसे 5 0 +) के साथ टूट जाता है ।

— फलावना

आप ord(x) - 42विधि का उपयोग करके 1 वर्ण बचा सकते हैं ।

— frederick99

@ frederick99 मैं नहीं देखता कि कैसे।

— 21

Answer 12

जावास्क्रिप्ट (157)

यह कोड मानता है कि ये दो कार्य हैं: रीडलाइन और प्रिंट

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])

Comments

यदि आप prompt()इसके बजाय readLine()(और शायद मैच के alert()बजाय ) का उपयोग करते हैं, तो छोटा करें । print()prompt()

— nyuszika7h

Answer 13

पर्ल, 128

यह वास्तव में अन्य पर्ल जवाब के बगल में प्रतिस्पर्धी नहीं है, लेकिन एक अलग (सबॉप्टिमल) पथ की पड़ताल करता है।

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 ''आह्वान के रूप में गिना जाता है ।

Answer 14

पायथन, 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])

Answer 15

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];

इस कोड को स्टडिन के साथ काम करना चाहिए, हालांकि यह स्टड के साथ परीक्षण नहीं किया गया है।

यह सभी मामलों पर परीक्षण किया गया है, पिछले एक के लिए आउटपुट (और कोड) यहाँ है:
http://codepad.viper-7.com/fGbnv6

अनगोल्डेड, 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];

Comments

कार्य विवरण से उद्धरण: »उन प्रोग्रामिंग भाषाओं के लिए जिनके पास इनपुट / आउटपुट प्राप्त करने के लिए फ़ंक्शन नहीं हैं, आप रीडाइन / प्रिंट जैसे कार्यों को मान सकते हैं।« - demonstrably PHP में ऐसा करने के लिए फ़ंक्शन हैं, इसलिए यह धारणा गलत है।

— जॉय

स्टडिन का उपयोग करने के लिए इसे अपडेट किया गया और इसे थोड़ा और गोल किया गया।

— केविन ब्राउन

Answer 16

फ्लेक्स - 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

Answer 17

पायथन, 130 वर्ण

अगर हम गिरा b and(जो पायथन के कुछ उत्तर गायब हैं) 124 वर्ण होंगे । और यह 42 को शामिल करता है!

s=[]
for x in raw_input().split():
 try:s=[float(x)]+s
 except:b,a=s[:2];s[:2]=[[a*b,a+b,0,a-b,0,b and a/b][ord(x)-42]]
print s[0]

Comments

वास्तव में अच्छा जवाब। लेकिन मैं 130 किरदार गिनता हूं। ;)

— flornquake

@flornquake आप सही हैं, सुधार के लिए धन्यवाद।

— डेनियल लुबरोव

Answer 18

पायथन 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])

पहले से ही बेहतर समाधान हो गए हैं, लेकिन अब जब मैंने इसे लिखा था (बिना पूर्व प्रस्तुतियाँ पढ़े, बेशक - भले ही मुझे यह स्वीकार करना पड़े कि मेरा कोड ऐसा लगता है जैसे मैंने उन्हें एक साथ कॉपी किया था), मैं इसे साझा करना चाहता था, भी।

Comments

b/aके साथ प्रतिस्थापित किया जाना चाहिए a and b/a, अन्यथा यह समाधान काम नहीं करेगा यदि दूसरा ऑपरेंड 0 (जैसे 4 0 -) है।

— 10

@flornquake ने उसके लिए यह तय किया।

— mbomb007

Answer 19

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

Answer 20

सी, 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)));}

Ungolfed:

#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

Answer 21

जावास्क्रिप्ट ईएस 7, 119 बाइट्स

मुझे ऐरे कॉम्प्रिहेंशन वाला बग मिल रहा है इसलिए मैंने इस्तेमाल किया है .map

(s,t=[])=>(s.split` `.map(i=>+i?t.unshift(+i):t.unshift((r=t.pop(),o=t.pop(),[r+o,r-o,r*o,r/o]['+-*/'.indexOf(i)]))),t)

ESFiddle पर इसे ऑनलाइन आज़माएं

Comments

क्या कोई ES7 दुभाषिया उपलब्ध है?

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ यह फ़ायरफ़ॉक्स पर काम करना चाहिए। आप Babeljs.io/repl

— Downgoat

ओह मैं समझा। ^ _ ^ धन्यवाद!

— कोनोर ओ'ब्रायन

Answer 22

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 ।

Comments

मूल विवरण से उद्धृत »उन प्रोग्रामिंग भाषाओं के लिए जिनके पास इनपुट / आउटपुट प्राप्त करने के लिए फ़ंक्शन नहीं हैं, आप रीडाइन / प्रिंट जैसे कार्यों को मान सकते हैं।« PHP में धाराओं के माध्यम से स्टडिन प्राप्त करने का एक तरीका है।

— केविन ब्राउन

Answer 23

सी # - 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());}}}

Comments

आप 23 पात्रों को थोड़े अनुकूलन के साथ सहेज सकते हैं: 1. नेमस्पेस ट्रिक को हटा दें, स्पष्ट रूप से उन दो प्रकारों को अर्हता प्राप्त करें जिनकी आवश्यकता है। आप "नाम स्थान" कीवर्ड और संबंधित कोष्ठक सहेजते हैं। 2. स्ट्रिंग [] और i, केस कीवर्ड और लेबल, स्विच और उसके परेंस के बीच रिक्त स्थान निकालें। 3. फ्लोट ओ से छुटकारा पाएं और सही परिणाम प्राप्त करने के लिए गणित का उपयोग करें (यानी। -k.Pop () + k.Pop () माइनस के लिए, और 1 / k.Pop () * k.Pop () को विभाजित करें ।

— माइक

Answer 24

स्केल 412 376 349 335 312:

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))}

Answer 25

अजगर - 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())

Ungolfed संस्करण:

# 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())

कमांड-लाइन तर्क से इनपुट; मानक उत्पादन पर उत्पादन।

Answer 26

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())

Answer 27

सी # - 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]);}}

संपादित करें: स्टैक को एक ऐरे से बदलना छोटे तरीके से है

एडिट 2: टर्नरी एक्सप्रेशन के साथ इफ़्स को रिप्लेस किया

Comments

string[] i=> string[]i।

— जचार्इ

Answer 28

अजगर २

मैंने अब तक प्रकाशित कुछ अलग तरीकों की कोशिश की है। इनमें से कोई भी सबसे अच्छा पायथन समाधान के रूप में छोटा नहीं है, लेकिन वे अभी भी आप में से कुछ के लिए दिलचस्प हो सकते हैं।

पुनरावृत्ति का उपयोग, 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]

Answer 29

मतलाब, 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}

Ungolfed:

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

Comments

आप एक पंक्ति में सब कुछ डालकर 2 बाइट्स बचा सकते हैं (या एक टेक्स्ट एडिटर का उपयोग कर सकते हैं जो केवल न्यूलाइन के लिए एक वर्ण का उपयोग करता है)

— होकी

@ होकी मैं केवल नई लाइनों का उपयोग कर रहा हूं जब लाइन को नहीं तोड़ना एक की आवश्यकता होगी ;। इसलिए मुझे लगता है कि बाइट की गिनती एक ही है

— लुइस मेंडो

बिल्कुल नहीं, ज्यादातर विंडो टेक्स्ट एडिटर cr+lfएक नई लाइन के लिए उपयोग करते हैं, जो कि 2 अक्षर हैं। मेरे नोटपैड ++ ने आपके 3 लाइनों संस्करण में 230 वर्णों को गिना है, लेकिन केवल 128 अगर मैं एक पंक्ति में सब कुछ छड़ी करता हूं (2 newlines से 2 * 2 = 4 वर्णों को हटा दिया, और दो जोड़े ;)। इसे स्वयं आज़माएँ;)

— होकी

@ होकी तुम सही हो। वास्तव में, अगर मैं mothereff.in/byte-counter पर तीन-लाइन संस्करण पेस्ट करता हूं (जो कि मैंने टेक्स्ट बाइट्स की गिनती के लिए उपयोग किया है), यह 228 देता है। और निश्चित रूप से यह भी है कि मुझे यह सब एक में डालने से क्या मिलता है लाइन। मुझे नहीं पता कि मुझे 230 नंबर कहां से मिला। धन्यवाद! ठीक किया

— लुइस मेन्डो

Answer 30

K5, 70 बाइट्स

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

मुझे यकीन नहीं है कि जब K5 जारी किया गया था, तो यह गिनती नहीं हो सकती है। अभी भी कमाल!