ट्रांसपाइल वर्डमैथ


25

हम सभी ने उन ऑनलाइन "मैथ्स हैक्स" को देखा है जो इस तरह दिखते हैं:

Think of a number, divide by 2, multiply by 0, add 8.

और, जादू से, हर कोई 8 नंबर के साथ समाप्त होता है!


भाषा

आइए एक प्रोग्रामिंग भाषा को परिभाषित करें जो ऊपर दिए गए पाठ के वाक्यविन्यास का उपयोग करता है, जिसे "वर्डमैथ" कहा जाता है। WordMath स्क्रिप्ट इस टेम्पलेट का अनुसरण करती हैं:

Think of a number, <commandlist>.

जिसका मूल रूप से अर्थ है: प्रारंभिक संचयकर्ता के रूप में एक संख्या (एसटीडीआईएन से इनपुट के रूप में) लें, उस पर सभी कमांड निष्पादित करें, और परिणाम आउटपुट करें।

आदेश सीमांकक ,(अल्पविराम + स्थान) द्वारा अलग किए जाते हैं । मान्य आदेश हैं (ध्यान दें कि #एक गैर-नकारात्मक पूर्णांक का प्रतिनिधित्व करता है :) :

  • add #/ subtract #- संचयकर्ता से मान जोड़ें / घटाएँ।
  • divide by #/ multiply by #- फ्लोर्डिव / दिए गए मान से संचायक को गुणा करें।
  • subtract from #- समान subtract, लेकिन acc = # - accइसके बजाय करता हैacc = acc - #
  • repeat- फिर से अंतिम आदेश। यह 1 आदेश नहीं हो सकता है, लेकिन आपको कई बार दोहराए जाने का समर्थन करना चाहिए।

चुनौती

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

उदाहरण के लिए, यदि मेरा कोड पायथन 2 में है और स्क्रिप्ट है:

Think of a number, subtract from 10, add 10, multiply by 2.

आउटपुट प्रोग्राम हो सकता है:

a = input()
a = 10 - a
a += 10
a *= 2
print(a)

या वैकल्पिक रूप से:

print(((10-input())+10)*2)

जब तक यह एक पूर्ण कार्यक्रम है जो इनपुट STDINऔर प्रिंट से STDOUTया भाषा के निकटतम समकक्षों से इनपुट लेता है ।


नियम

  • आपका मूल कार्यक्रम यह मान सकता है कि इनपुट हमेशा एक मान्य वर्डमैथ स्क्रिप्ट है।
  • ट्रांसप्लड प्रोग्राम को गणितीय त्रुटियों जैसे कि 0 से विभाजन को संभालना नहीं है।
  • ट्रांसप्लड प्रोग्राम मान सकते हैं कि इनपुट आपकी भाषा के मानक पूर्णांक सीमा के भीतर एक वैध हस्ताक्षरित पूर्णांक का प्रतिनिधित्व करता है।
  • यह , इसलिए सबसे छोटा समाधान (बाइट्स में) जीतता है।
  • केवल आपके मूल प्रोग्राम की बाइट गिनती - आउटपुट कोड तब तक हो सकता है जब तक आप चाहते हैं!

उदाहरण लिपियों

उदाहरण 1:

Think of a number. 

इनपुट लें, कुछ भी न करें, इसे प्रदर्शित करें: वर्डमैथ का कैट प्रोग्राम।

उदाहरण 2:

Think of a number, divide by 5, subtract from 9.

याद रखें कि "डिवाइड" फर्श विभाजन है, इसलिए इस कार्यक्रम के लिए 6 -> 8, और 29 -> 4

उदाहरण 3:

Think of a number, add 5, add 10, multiply by 2, subtract 15, repeat, divide by 2.

विस्तारित बिल्ली कार्यक्रम!

उदाहरण 4:

Think of a number, subtract 1, repeat, repeat.

एक संख्या लेता है और 3 घटाता है।


क्या हमें लगातार दोहराए जाने का समर्थन करना है?
darrylyeo

1
जब हम भाषा के डिफ़ॉल्ट प्रकार / यदि यह पूर्णांक का समर्थन नहीं करता है तो क्या हम फ्लोट का उपयोग कर सकते हैं?
रेनर पी।

@RainerP। केवल अगर भाषा पूर्णांक / पूर्णांक विभाजन का समर्थन नहीं करती है
FlipTack

1
अपेक्षित परिणाम क्या है -5/3? क्या हम 0नकारात्मक अनंत की ओर या उसकी ओर बढ़ते हैं?
मार्टिन एंडर

1
@MartinEnder मैं नकारात्मक इन्फिनिटी के लिए गोल कहूँगा क्योंकि यह फ्लोर डिवीजन है, लेकिन अगर आपकी भाषा पूर्णांक विभाजन को 0 की ओर लागू करती है तो यह भी ठीक है।
21

जवाबों:


6

05AB1E , 59 56 54 52 बाइट्स

„, ¡¦vyDþs.AJá'bK"dmas""/*+-"‡„-f„s-.:«D'rQi®}©}J'rK

इसे ऑनलाइन आज़माएं!

मेरा दिमाग उसके बाद नरक की तरह दर्द करता है ... यह 05AB1E कोड में निम्नानुसार आउटपुट करता है:

  • Think of a Number निहित इनपुट के कारण हटा दिया गया है।
  • Subtract From #को कवर #s-(स्वैप aऔर bऑपरेशन करते हैं)।
  • Subtract #करने के लिए धर्मान्तरित #-
  • Add #करने के लिए धर्मान्तरित #+
  • Multiply by #करने के लिए धर्मान्तरित #*
  • Divide by #करने के लिए धर्मान्तरित #/
  • Repeat जो कुछ भी आखिरी बार रजिस्टर में संग्रहीत किया गया था और उसे एकत्र करता है।

व्याख्या की:

„, ¡                                                 # Split on ', '.
    ¦                                                # Remove the 'Think of a number'.
     vy                                        }     # Loop through chunks.
       Dþs                                           # Dupe, push only digits, swap.
          .AJá                                       # Acronymify without digits.
              'bK                                    # Remove the `b`.
                 "dmas""/*+-"‡                       # Replace letters with OPs.
                              „-f„s-.:               # Replace '-f' with 's-'.
                                      «              # Concat # with OP.
                                       D'rQ          # Dupe, push 1 if OP='r'.
                                           i®}       # If 'r', push last #OP.
                                              ©      # Store current OP.
                                                J'rK # Join, remove remaining r's.

उदाहरण:

इनपुट:

Think of a number, divide by 2, multiply by 10, add 8, subtract 6, subtract from 9, repeat, repeat, subtract 41.

आउटपुट:

2/10*8+6-9s-9s-9s-41-

10 के इनपुट के साथ समाधान का प्रयास करें:

इसे ऑनलाइन आज़माएं!

इसे Google पर देखें:

यहां उसी समीकरण का लिंक दिया गया है जो Google में टाइप किया गया है।


13

सी प्रीप्रोसेसर, 362 बाइट्स

I ALMOST को JUST C C प्रीप्रोसेसर में यह काम मिला, लेकिन रिपीट कमांड को लागू करना बहुत मुश्किल है। इसलिए इसके बजाय मैंने प्रीप्रोसेसर का उपयोग इनपुट को एक ऐसे सरणी में बदलने के लिए किया, जिसकी व्याख्या कुछ अतिरिक्त कोड द्वारा की जाती है।

main(){int c[]={
#define Think 
#define of
#define a
#define number 0
#define add 1,
#define subtract 2,
#define from 0,3,
#define multiply 4,
#define divide 5,
#define by
#define repeat 6, 0
#include "input.wm"
,'$'};int _,l,v;scanf("%d", &_);for(int i=1;c[i]-'$';++i){c[i]!=6?l=c[i],v=c[++i]:++i;l==1?_+=v:l==2?_-=v:l==3?_=v-_:l==4?_*=v:_/=v;}printf("%d",_);}

इनपुट "input.wm" में प्रदान किया जाना चाहिए या बस उस लाइन में स्रोत में डंप किया जाना चाहिए। मैंने अपनी गिनती में इसकी बाइट्स को शामिल किया क्योंकि मैं इसकी हैकिंग को थोड़ा चुनौती देता हूं और चुनौती के नियमों के खिलाफ है, इसलिए यह केवल फिटिंग है।

वैसे भी, जब आप एक बार अपने WordMath स्रोत को इनपुट में डाल देते हैं। तो जहाँ एक कंपाइलर मिल सकता है, आपको इसे संकलित करने में सक्षम होना चाहिए, जैसा कि एक निष्पादन योग्य बनाने के लिए चेतावनी के साथ होता है जो WordMath स्रोत कहता है।


2
ध्यान दें: यह दुर्भाग्य से कुछ कंपाइलरों के साथ विफल होता है जब आप दोहराव के साथ समाप्त होते हैं। ऐसा इसलिए है क्योंकि वे 0 के बाद एक स्थान टॉस करते हैं और फिर एक आवारा अवधि देखते हैं और नहीं जानते कि इसके साथ क्या करना है।
लैम्ब्डाबेटा

चतुर, मैं प्रभावित हूँ।
बिल्ली

7

रेटिना, 170 बाइट्स

क्योंकि कौन यह देखना नहीं चाहेगा ?!

मैंने सोचा कि रेटिना समाधान को देखना कितना शानदार होगा, और मैंने इसे जल्दी बनाने का फैसला किया। इसमें केवल एक घंटा लगता था। हमेशा की तरह, बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

S`, 
\.

T.*
.*¶$$*
\;+`(.*)¶rep.*(¶?)
$1¶$1$2
\d+
$*
.*f.* (1*)
1¶x¶$¶$1¶+`x1¶
m.* 
1¶
di.* (1*)
^¶$1 ¶^(1+) (\1)+1*$¶x$$#+¶1+ 1*¶x0¶x\d+¶$$*
s.* (1*)
^$1¶
a.* 
^¶
\z
¶1

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

आउटपुट में एक अनुगामी न्यूलाइन है जिसे परिणामस्वरूप प्रोग्राम का परीक्षण करते समय कॉपी नहीं किया जाना चाहिए। कार्यक्रम नकारात्मक का समर्थन नहीं करता है, क्योंकि रेटिना की मानक पूर्णांक सीमा (एकात्मक में) नहीं है।

स्पष्टीकरण:

S`,                 # Split input on ", " putting each command on its own line
\.                  # Remove the period

T.*                 # Think of a number -> .*\n$* (replaces input with unary)
.*¶$$*
\;+`(.*)¶rep.*(¶?)  # Loop, replacing "repeat" with the line before it
$1¶$1$2
\d+                 # Replace all numbers with their unary representation
$*
.*f.* (1*)          # Replace "subtract from " with a subtract from program
1¶x¶$¶$1¶+`x1¶
m.*                 # Replace "multiply by " with a multiply program
1¶
di.* (1*)           # Replace "divide by " by my integer division program
^¶$1 ¶^(1+) (\1)+1*$¶x$$#+¶1+ 1*¶x0¶x\d+¶$$*
s.* (1*)            # Replace "subtract " with a subtraction program
^$1¶
a.*                 # Replace "add " with an addition program
^¶
\z                  # At the end, add a stage to change unary into decimal
¶1

गणित कार्यक्रम:

जोड़ें:

शुरुआत में लोगों की संख्या जोड़ें। 5 जोड़ें:

^
1111

घटाएँ:

शुरू से ही लोगों की संख्या निकालें। घटाना 5:

^11111

से घटाएँ:

इनपुट को 1एस से बदलें x। निर्धारित संख्या के आगे रखें। बार-बार हटाते हैं x1। 10 से घटाएँ:

1
x
$
1111111111
+`x1

से गुणा करो:

1उनमें से प्रत्येक को एक निश्चित संख्या के साथ बदलें । 3 से गुणा करें:

1
111

से विभाजित:

यह इंटेगर डिवीजन के लिए मेरे रेटिना कार्यक्रम का उपयोग करता है । 2 से विभाजित करें:

^                   # Place the fixed divisor before the dividend
11 
^(.+) (\1)+.*$      # Match the divisor, followed by each occurrence in the dividend.
x$#+                # Replace with the number of matches. Trailing ones are dropped
.+ .*               # If there are still two numbers, the result is zero
x0
x\d+                # Replace result (marked with an 'x') with unary
$*

मुझे डर है कि मैं यह नहीं देख सकता कि यह कैसे काम कर सकता है। जो भी इनपुट मैं घटाव कमांड के लिए कोशिश करता हूं, मुझे टूटे हुए परिणाम मिलते हैं (क्या आउटपुट में गायब हैं?) मैं यह भी नहीं देखता कि यह नकारात्मक इनपुट या नकारात्मक मध्यवर्ती परिणाम कैसे संभालता है।
मार्टिन एंडर

@MartinEnder मैं घटाव को ठीक कर सकता हूं यदि आप बताएं कि यह सरलीकृत कार्यक्रम आउटपुट में दो क्यों देता है। retina.tryitonline.net/#code=JArCtjE&input=dGVzdAo
mbomb007

क्योंकि $स्ट्रिंग के बहुत अंत में या अनुगामी लाइनफीड के सामने मैच होता है। आप की जरूरत है \zअगर आप केवल पूर्व चाहते हैं।
मार्टिन एंडर

4

जीएनयू जाग, 139 बाइट्स

BEGIN{RS="[,.]";c="{}{";ORS=";"}
/ad/{c="+="$2}
/c/{c="-="$2}
/om/{c="="$3"-$0"}
/l/{c="*="$3}
/v/{c="=int($0/"$3")"}
!NF{c="}1"}
$0="$0"c

मंगलाचरण:

$> awk `awk -f wordmath <<< "Think of a number, add 1, repeat, repeat."` <<< 0
$> 3

परीक्षण के मामलों:

$> awk -f wordmath <<< "Think of a number."  
$> $0{}{;$0}1;

$> awk -f wordmath <<< "Think of a number, divide by 5, subtract from 9."
$> $0{}{;$0=int($0/5);$0=9-$0;$0}1;

$> awk -f wordmath <<< "Think of a number, add 5, add 10, multiply by 2, subtract 15, repeat, divide by 2."
$> $0{}{;$0+=5;$0+=10;$0*=2;$0-=15;$0-=15;$0=int($0/2);$0}1;

4

हास्केल, 232 231 बाइट्स

बेशक एक कार्यात्मक प्रोग्रामर एक कार्यक्रम का प्रतिनिधित्व करने वाले स्ट्रिंग के बजाय एक फ़ंक्शन को वापस करना पसंद करेगा, लेकिन यहां हम जाते हैं:

t l="main=getLine>>=print."++""%words l++"(0+).read"
x%((o:_):f:n:r)|o=='m'=h"*"n r|o=='d'=h"`div`"n r|f=="from"=h"(-)"n r
x%(s:n:r)|s=="add"=h"+"n r|s!!0=='s'=h s(' ':n)r
x%(_:r)=x%r++x
_%_=""
h s n r|x<-'(':s++init n++")."=x%r++x

टिप्पणी: हम हमेशा शून्य को जोड़ने के साथ शुरू करते हैं, अन्यथा तुच्छ वर्डमैथ प्रोग्राम का ट्रांसप्लीकेशन उस प्रकार का पता लगाने के लिए पर्याप्त जानकारी नहीं देता है जिस पर readइसका उपयोग किया जाता है। subtract from nके रूप में लागू किया जा सकता है (n-), लेकिन मैं ((-)n)अधिक एकरूपता के लिए उपयोग करता हूं । यदि subtract nमैं subtractइनपुट से कॉपी करता हूं, तो मुझे इसे लिखना नहीं है, लेकिन मुझे अंत में लापता स्थान की भरपाई करने की आवश्यकता है। repeatडिफ़ॉल्ट ऑपरेशन के रूप में उपयोग किया जाता है; एक खाली प्रारंभिक पिछले ऑपरेशन के साथ यह पहले चार शब्दों की आसान अनदेखी के लिए अनुमति देता है।

उपयोग उदाहरण:

*Main> t "Think of a number. "
"main=getLine>>=print.(0+).read" 

अन्य उदाहरण निम्नलिखित परिणाम देते हैं:

"main=getLine>>=print.((-)9).(`div`5).(0+).read"
"main=getLine>>=print.(`div`2).(subtract 15).(subtract 15).(*2).(+10).(+5).(0+).read"  
"main=getLine>>=print.(subtract 1).(subtract 1).(subtract 1).(0+).read"

बस जिज्ञासु, आप एक स्ट्रिंग के बजाय वापस जाने के लिए फ़ंक्शन कैसे उत्पन्न करेंगे?
साइकोस

एक फंक्शनल प्रोग्रामिंग लैंग्वेज में, एक फंक्शन बनाना और कंपोज करना, स्ट्रिंग बनाने और अपग्रेड करने से ज्यादा मुश्किल नहीं है। hऐसा कुछ लग सकता है h s n r|x<-s.read.init$n=x%r.xऔर पहले तर्क के साथ एक फ़ंक्शन कहा जा सकता है h(+)n r(और flipसही ऑपरेटर आदेश प्राप्त करने के लिए कुछ कहीं होने की आवश्यकता है ), बेस केस है _%_=id। मुख्य फ़ंक्शन सभी बॉयलरप्लेट से बच सकता है और बस हो सकता है t l=id%words l। - करीने के लिए धन्यवाद, इसे एक दुभाषिया के रूप में देखा जा सकता है, और यह विचार एक आसान और / या छोटा समाधान हो सकता है।
क्रिश्चियन सेवर्स

4

पायथन 2, 263 258 260 221 बाइट्स

यह शायद अभी भी बहुत कम हो सकता है।

def r(s,o="",p=""):c=s.pop(0);c=[c,p]['re'in c];n=c.split()[-1];o=[[o+[['+-'['s'in c],'//']['v'in c],'*']['m'in c]+n,n+'-'+o]['f'in c],'input()']['T'in c];return s and r(s,"(%s)"%o,c)or o
lambda s:"print "+r(s.split(','))

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

मैं //इसके बजाय का उपयोग करता हूं /, क्योंकि अंतिम निर्देश .में अंत में कोई भी संख्या एक फ्लोट होगी। तो विभाजन को सुसंगत रखने के लिए, मैं पूर्णांक विभाजन का उपयोग करता हूं।

परीक्षण मामलों का उत्पादन:

print input()
print 9.-((input())//5)
print ((((((input())+5)+10)+10)-15)-15)//2.
print (((input())-1)-1)-1

यदि आप निम्नलिखित के ifलिए s के उस बड़े ब्लॉक को बदलते हैं o(जो मुझे लगता है कि काम करना चाहिए):, o=[[o+[['+-'['s'in c],'//']['v'in c],'*']['m'in c]+n,n+'-'+o]['f'in c],'input()']['T'in c]आप इसे 224 तक प्राप्त कर सकते हैं।
Kade

@ काडे हाँ, यह अभी भी सुपाठ्य था। ऐसा नहीं हो सकता।
mbomb007

@ कैओस नहीं, लैम्ब्डा को कॉल करने का बहुत कार्य शायद इससे अधिक खर्च होता है जो इसे बचाता है। इसे भुगतान करने के लिए प्रति कॉल 4 या 5 बाइट्स बचाने होंगे।
mbomb007

4

Befunge, 342 305 बाइट्स

>~$1 +:89+`#v_801p
  v_^#`+85~$<
1+>~:5+88+/3-!#v_$
v`"/":~p8p10+1<>>:"/"`!|
 "+"\5+8p4+:1+^:p11:g10<  >:"+"\2+8p:"*"\3+8p:
_$7%:01g\!#v_\2-7g\:1+:01v^p8+1\"5":p8\"5":g10
#8\"\"$#:0#<^v<p8p8\<g80p<>\#+$#12#p
-/+* >:#,_@  #^p8g10<
".@"<^"&"
10<v0<\g8-\g11:<:p1>#1+g11:p10+g
-:^>1g\-8p1-::#^_$8g^  >$$01g11g

इसे ऑनलाइन आज़माएं!

उत्पादन

यह उत्पन्न कोड एक &(इनपुट मान) कमांड के साथ शुरू होता है , और .(आउटपुट मूल्य) और @(बाहर निकलने) कमांड के साथ समाप्त होता है । के बीच हम रूप में विभिन्न गणना की है में <number><operation>, जहां आपरेशन किया जा सकता है +(ऐड), -(घटाना), /(द्वारा विभाजित), *(गुणा), और \-(से घटाना)।

नंबर क्योंकि Befunge केवल, सीमा 0 से 9 तक में संख्यात्मक शाब्दिक समर्थन करता है, तो यह है कि जरूरतों से बड़ा कुछ भी मैन्युअल रूप से गणना करने में ही, थोड़ा जटिल है। चूँकि हम पहले से ही वर्ण में संख्याओं को वर्ण द्वारा पढ़ रहे हैं, हम बस संख्या का निर्माण करते हैं क्योंकि प्रत्येक अंक पढ़ा जाता है, इसलिए उदाहरण के लिए, 123 बन जाता है 155+*2+55+*3+, अर्थात (((1 * 10) + 2) * 10) + 3

उदाहरण

Input:  Think of a number.
Output: &.@

Input:  Think of a number, divide by 5, subtract from 9.
Output: &5/9\-.@

Input:  Think of a number, add 5, add 10, multiply by 2, subtract 15, repeat, divide by 2.
Output: &5+155+*0++2*155+*5+-155+*5+-2/.@

Input:  Think of a number, subtract 1, repeat, repeat.
Output: &1-1-1-.@

व्याख्या

Befunge में स्ट्रिंग्स को मैनिपुलेट करने की क्षमता नहीं होती है, इसलिए अधिकांश पार्सिंग वर्णों को गिनकर नियंत्रित किया जाता है। हम पहले 18 वर्णों को छोड़ कर शुरू करते हैं, जो हमें एक संख्या वाक्यांश के बारे में सोचते हैं (साथ ही एक अल्पविराम या अवधि)। फिर अगर अगला चरित्र न्यूलाइन या ईओएफ का कुछ रूप है, तो हम सीधे आउटपुट रूटीन पर चले जाते हैं, अन्यथा हम एक कमांड सूची की तलाश जारी रखते हैं।

एक कमांड को पार्स करने के लिए, हम केवल वर्णों को गिनते रहते हैं जब तक कि हम एक अंक या विभाजक तक नहीं पहुंच जाते। यदि यह एक विभाजक है, तो यह रिपीट कमांड रहा होगा जिसे हम एक विशेष मामले के रूप में संभालते हैं। यदि यह एक अंक है तो हम इसे अपने आउटपुट बफर में जोड़ते हैं, और अधिक अंकों की तलाश जारी रखते हैं। जब भी कोई अंक आउटपुट होता है, हम इसे 55+*(10 से अब तक के कुल को गुणा करने के लिए) के साथ उपसर्ग करते हैं और इसे +(कुल में जोड़ने के लिए ) के साथ प्रत्यय लगाते हैं । अंक समाप्त हो जाने के बाद हम कमांड कैरेक्टर जोड़ते हैं।

जैसा कि कमांड कैसे निर्धारित किया जाता है, हम वर्णों की गिनती को पहले अंक modulo तक ले जाते हैं। 7. इसके लिए यह 4 है (निम्न स्थान सहित), इसे घटाना 2 के लिए, इसे 3 से विभाजित करने के लिए, इसे 5 से गुणा करने के लिए। , और इससे घटाना के लिए 0. से घटाना के लिए थोड़ी अतिरिक्त हैंडलिंग की आवश्यकता होती है क्योंकि इसे \-कमांड कॉम्बो की आवश्यकता होती है , लेकिन अन्य बस एक तालिका में उपयुक्त कमांड वर्ण को देखने के लिए अपने मूल्य का उपयोग करते हैं।

यह प्रक्रिया प्रत्येक कमांड के लिए दोहराई जाती है, लाइन 8 में एक प्री-कंस्ट्रक्टेड स्ट्रिंग में आउटपुट का निर्माण। प्रत्येक बार जब एक अतिरिक्त कमांड जोड़ा जाता है, तो हम यह सुनिश्चित करने के लिए स्ट्रिंग में एक समापन उद्धरण भी जोड़ते हैं कि यह हमेशा ठीक से समाप्त होता है। फिर जब हम अंततः अपने इनपुट के अंत तक पहुँचते हैं, तो हम इसे स्टैक पर धकेलने के लिए इस स्ट्रिंग को "निष्पादित" करते हैं, फिर इसे बाहर लिखने के लिए एक मानक आउटपुट अनुक्रम के साथ अनुसरण करते हैं।


3

जावास्क्रिप्ट (ईएस 6), 163 बाइट्स

w=>w.split`, `.map(l=>(o={a:'+',s:'-',m:'*',d:'/'}[a=l[0]])?p=(x=l.split` `.pop(),l[9]=='f'?x+`-n`:`n`+o+x+`|0`):a<'r'?'n=+prompt()':p).join`
n=`+`
console.log(n)`

कोशिश करो:

f=w=>w.split`, `.map(l=>(o={a:'+',s:'-',m:'*',d:'/'}[a=l[0]])?p=(x=l.split` `.pop(),l[9]=='f'?x+`-n`:`n`+o+x+`|0`):a<'r'?'n=+prompt()':p).join`
n=`+`
console.log(n)`

const program = f('Think of a number, add 5, add 10, multiply by 2, subtract 15, repeat, divide by 2.')
document.write('<pre>' + program + '</pre>' )

eval(program)

/*
Outputs:

n=+prompt()
n=n+5|0
n=n+10|0
n=n*2|0
n=n-15|0
n=n-15|0
n=n/2.|0
console.log(n)
*/


3

विम 208 171 168 बाइट्स

@ Flp.Tkc के अनुसार एक पंक्ति में कई बार दोहराए जाने की क्षमता को जोड़ा गया है, लेकिन पर्याप्त बाइट्स को बंद कर दिया है कि मैं अभी भी बाइट की संख्या कम कर सकता हूं।

:map s :s;\v
c4wcw="s, s\w* \w+ (\d+); *-1+\1);g
s, ([adms]).{-}(\d+); \1\2);g
qws(\S+), r\w+;\1 \1
@wq@ws.*;\=tr(submatch(0),'adms','+/*-')
qq])T=i(@qq@qx$xA

TryItOnline

अयोग्य वर्ण:

:map s :s;\v
c4wcw^V^R=^V^R"^[s, s\w* \w+ (\d+); *-1+\1);g
s, ([adms]).{-}(\d+); \1\2);g
qws(\S+), r\w+;\1 \1
@wq@ws.*;\=tr(submatch(0),'adms','+/*-')
qq])T=i(^[@qq@qx$xA
^V^[^[

परीक्षण मामलों का उत्पादन:

  1. cw^R=^R" ^[ TryItOnline
  2. cw^R=((^R" /5) *-1+9) ^[ TryItOnline
  3. cw^R=((((((^R" +5) +10) *2) -15) -15) /2) ^[ TryItOnline

यह लगातार कई दोहराव के लिए काम नहीं करता है।
फ्लिपकार्ट

@ Flp.Tkc फिक्स्ड, धन्यवाद! मैंने पहले ऐसा नहीं देखा।
nmjcman101

2

लेक्स, 246 बाइट्स

%{
#define P printf
#define O P("n%s%d;",c,v);
int v;char*c;
%}
%%
T {P("%%%%\n.* {int n=atoi(yytext);");}
ad {c="+=";}
fr {c="=-n+";}
s {c="-=";}
v {c="/=";}
l {c="*=";}
re {O}
[0-9]+ {v=atoi(yytext);O}
\. P("printf(\"%%d\",n);}\n%%%%");
. ;
%%

lex, C को लक्षित करता है, इसलिए C संकलक को इसे कुछ निष्पादन योग्य में संकलित करने की आवश्यकता होगी। लेक्सर लाइब्रेरी ( ll) को भी लिंक करना होगा। यह एक बाइट-पेनल्टी जोड़ सकता है, लेकिन मुझे यकीन नहीं है कि कितने बाइट्स हैं।

कार्यक्रम एक लेक्स प्रोग्राम (प्रति विनिर्देश) आउटपुट करता है जो ट्रांसप्लड वर्डमैथ अभिव्यक्ति का मूल्यांकन करता है। के बीच कोड %{और %}केवल "transpiler" के लिए है:

#define P printf              /* for brevity */
#define O P("n%s%d;",c,v)     /* expression builder, calls P = printf */
int v;char*c;                 /* v=most recent integer read */
                              /* c=the expression infix */

दो %%पंक्तियों के बीच रेगेक्स / एक्शन भाग है। मिलान किया जाने वाला पहला नियम होगा T("थिंक ...") जो प्रस्तावना बनाता है (lex प्रोग्राम्स को नियम खंड को कम से कम शुरू करना चाहिए और yytextअंतिम मिलान पाठ है, इसलिए नियम अनिवार्य रूप से उपयोगकर्ता के इनपुट के साथ संचयकर्ता को बीज देता है। )।

कि को छोड़कर सभी इनपुट कार्यक्रम छोड देता है जो मिलान किया जाता है, और अन्य नियम ( ad, fr, अप करने के लिए re) के रूप में संभव के रूप में कम से कम एक मैच अद्वितीय होना साथ wordmath अभिव्यक्ति खंड संभाल। इनमें से अधिकांश में, यह cएक अभिव्यक्ति infix पर सेट होता है, जिसे कॉल करने के nदौरान और अंतिम पूर्णांक के बीच संक्षिप्त Oहो जाता है (इसलिए उदाहरण के लिए, "ऐड 9" को पढ़ने से इन्फिक्स को +=वी 9, टू , और कॉल टू Oविल आउटपुट सेट हो जाएगा n+=9;) । (एक ओर दिलचस्प बात यह है कि "8 से घटाना" दोनों sऔर frनियमों के मेल खाने का कारण होगा , लेकिन चूंकि Oकेवल संख्या पर कहा जाता है, उचित नियम n=-n+8;एकमात्र अभिव्यक्ति है जो आउटपुट प्राप्त करता है)। re"दोहराने" सिर्फ कॉल के लिए नियमOफिर से, जो अंतिम निर्मित अभिव्यक्ति का उत्पादन करता है (और जब से बाद के मैचों की चर्चा होगी yytext, "रिपीट" का समर्थन करते हुए [0-9]+नियम में पूर्णांक रूपांतरण की आवश्यकता थी)। अंत में, एक अवधि प्रोग्राम ट्रेलर का आउटपुट का कारण बनती है, जो सिर्फ संचायक को आउटपुट करती है और %%आउटपुट लेक्स प्रोग्राम के अंत को दर्शाती जोड़ी के साथ बंद हो जाती है ।

नोट: न तो मुख्य ट्रांसपायलर प्रोग्राम या आउटपुट प्रोग्राम समाप्त होगा। पाइपिंग इनपुट काम करेगा, या EOF (ctrl-D) प्रदान करेगा। यदि पहले इनपुट के बाद समाप्ति की आवश्यकता है, तो निकास () को जोड़ा जा सकता है।

निर्माण / चलाने के लिए:

Build the main program:
% lex -o wordmath.yy.c wordmath.l
% cc -o wordmath wordmath.yy.c -ll

Execute to create a specific transpiled program:
% echo "This is a number, add 8, subtract 5, repeat." | ./wordmath > program.l

Build the transpiled program:
% lex -o program.yy.c program.l
% cc -o program program.yy.c -ll

Execute the transpiled program (with input 3, called via a pipe or inline):
% echo 3 | ./program
1
% ./program
3
1
^D
%

टेस्ट 1:

%%
.* {int n=atoi(yytext);printf("%d",n);}
%%

टेस्ट 2:

%%
.* {int n=atoi(yytext);n/=5;n=-n+9;printf("%d",n);}
%%

टेस्ट 3:

%%
.* {int n=atoi(yytext);n+=5;n+=10;n*=2;n-=15;n-=15;n/=2;printf("%d",n);}
%%

टेस्ट 4:

%%
.* {int n=atoi(yytext);n-=1;n-=1;n-=1;printf("%d",n);}
%%

2

पायथ, 69 67 बाइट्स

J\QVtcQ\,Iq@N1\r=NZ)=Jjd+@"+-/*"x"asdm"@N1.>,J-ecN)\.qh@cN)1\f=ZN)J

एक प्रोग्राम जो इनपुट लेता है "quoted string"और परिणाम प्रिंट करता है।

परीक्षण सूट

यह काम किस प्रकार करता है

पायथ में उपसर्ग ऑपरेटर हैं, इसलिए मूल अंकगणितीय संचालन का उपयोग किया जाता है (operator)(operand1)(operand2), जबकि पूर्व-आरंभिक चर Qइनपुट देता है। इसलिए, एक ट्रांसप्लड वर्डमैथ प्रोग्राम स्ट्रिंग के साथ शुरू करके 'Q'और प्रत्येक चरण में, ऑपरेटर को प्रीपेडिंग करके, और फिर ऑपरेटर को नेक्सेसरी के रूप में प्रस्तुत करने या जोड़ने के लिए बनाया जाता है।

J\Qसेट करें J, ट्रांसपोंड प्रोग्राम स्ट्रिंग, स्ट्रिंग के लिए'Q'

tcQ\, कॉमा पर इनपुट विभाजित करें, और पहला तत्व त्यागें (जो 'है' Think of a number')

V के लिए Nकि में:

  • Iq@N1\r यदि चरित्र N[1]है 'r'(दोहराएँ):
    • =NZसेट Nकरने के लिए Z(के पिछले मूल्य N, पाश के लिए के अंत में सेट)
  • x"asdm"@N1 के सूचकांक का पता लगाएं N[1]में "asdm"(ऐड, घटाव, विभाजन, गुणा)
  • @"+-/*""+-/*"आवश्यक ऑपरेटर को देते हुए उस के साथ सूचकांक
  • ,J-eCN)\.दो-तत्व सूची को यिल्ड करें [J, -eCN)\.], जहां दूसरा तत्व Nकिसी भी '.'वर्णों (हटाए गए) के साथ व्हाट्सएप पर विभाजन का अंतिम तत्व है
  • qh@cN)1\f यदि Nव्हाट्सएप पर विभाजन के दूसरे तत्व का पहला चरित्र है 'f'(से घटाएं):
    • .> दो-तत्व सूची के तत्वों को स्वैप करें
  • + ऑपरेटर और दो-तत्व सूची को एक सूची में मर्ज करें
  • =JjdJरिक्त स्थान पर शामिल होने के लिए सेट करें
  • =ZN को सेट ZकरेंN

J छाप J


अच्छा जवाब आदमी ... मुझे 05AB1E में कोशिश करने के लिए प्रेरित किया, जो ... प्रत्याशित की तुलना में अधिक डराने वाला था।
मैजिक ऑक्टोपस Urn

2

पिप , 58 बाइट्स

बहुत बुरा मैंने उस रिवर्स-घटाव ऑपरेटर को अभी तक लागू नहीं किया है।

{p:a:sNa?ap['Y("-y+  y- y// y+ y* "^sa@?Y`\d`)|'qa@y]}Mq^k

कार्यक्रम स्टीन से वर्डमैथ स्क्रिप्ट लेता है और स्टेपआउट के लिए पिप कोड आउटपुट करता है। कोड जो आउटपुट है, इसी तरह, स्टडिन से एक नंबर लेता है और परिणाम को स्टडआउट के लिए आउटपुट करता है। इसे ऑनलाइन आज़माएं!

रणनीति

इस तरह के इनपुट के लिए:

Think of a number, multiply by 3, add 1.

हम इस तरह से आउटपुट चाहते हैं:

YqYy*3Yy+1

जो निम्नानुसार काम करता है:

Yq    Yank a line of stdin into y
Yy*3  Compute y*3 and yank result into y
Yy+1  Compute y+1 and yank result into y
      Last expression is autoprinted

अघोषित + स्पष्टीकरण

{
 p : a : sNa ? a p
 [
  'Y
  ("-y+  y- y// y+ y* "^s a@?Y`\d`) | 'q
  a@y
 ]
} M q^k

कार्यक्रम की मूल संरचना है {...}Mq^k, जो (अल्पविराम qकी एक पंक्ति) k(अल्पविराम-स्थान) को विभाजित करती है और Mप्रत्येक तत्व के लिए कार्य करती है।

फ़ंक्शन के अंदर, हम repeatमामले को संभालकर शुरू करते हैं । पिप में सबसे छोटी परीक्षा लगती है sNa(क्या कमांड में जगह है)। यदि हां, तो हम उपयोग करना चाहते हैं a; यदि नहीं, तो उपयोग करें p, जो पिछले कमांड को संग्रहीत करता है। उस मान को वापस (और अगली बार) aभी असाइन करेंp

हमारे वापसी मूल्य के लिए, हम एक सूची का उपयोग करते हैं, जो ठीक है क्योंकि सूचियों के लिए डिफ़ॉल्ट आउटपुट प्रारूप सब कुछ एक साथ जोड़ना है। परिणाम हमेशा से शुरू होता है Y। अगला, हमें संचालन के लिए एक लुकअप तालिका की आवश्यकता है।

निरीक्षण करें कि लंबाई add (4), subtract (9), divide by (10), multiply by (12), और subtract from (14) सभी अलग-अलग हैं। इसके अलावा निरीक्षण करें कि जब वे आधुनिक हैं तब भी अलग-अलग हैं। 7. इस प्रकार, हम उन्हें सात-तत्व सूची (पाँच कोड स्निपेट और दो प्लेसहोल्डर) में अनुक्रमित करने के लिए उपयोग कर सकते हैं, प्रत्येक WordMath कमांड को उपयुक्त पिप कोड (संख्या के लिए डिज़ाइन किया गया) पर मैप करने के लिए बस अंत तक संक्षिप्त किया जा सकता है):

  • 0: -y+( subtract from)
  • 1: प्लेसहोल्डर
  • 2: y-( subtract)
  • 3: y//( divide by)
  • 4: y+( add)
  • 5: y*( multiply by)
  • 6: प्लेसहोल्डर

सूचकांकों के लिए, हम कमांड में पहले अंक के सूचकांक को प्राप्त करने के लिए regex का उपयोग करते हैं a@?`\d`:। हम भी yभविष्य में उपयोग के लिए regex yank । लुकअप तालिका स्ट्रिंग "-y+ y- y// y+ y* "को s(स्पेस) पर विभाजित करके उत्पन्न की जाती है ।

हमें अभी भी पहली प्रविष्टि को संभालना है, जिसे कोड में अनुवाद करना चाहिए Yq। चूंकि Think of a numberकिसी भी अंक में नहीं होता है, @?ऑपरेटर ऑपरेटर को शून्य देता है। इंडेक्स के रूप में एनआईएल का उपयोग लुकअप टेबल में भी किया जाता है। निल गलत है, इसलिए हमें इस मामले के लिए एक ऑपरेशन के बजाय |'qउपयोग qकरने की आवश्यकता है।

लौटी हुई सूची का अंतिम तत्व संख्या ही है। हम इसके माध्यम से प्राप्त करते हैं a@y(अंक रेगेक्स की कमान में सभी मैच पाते हैं जो हमने पहले जमा किया था)। यह अंकों की एक सूची देता है, लेकिन फिर से, यह एक समस्या नहीं है क्योंकि सभी सूचियों को आउटपुट करते समय संक्षिप्त किया जाएगा। पहली प्रविष्टि के लिए, a@yकोई अंक से मेल नहीं खाता है और खाली सूची देता है, जो आउटपुट में कुछ भी नहीं जोड़ता है।

उदाहरण के लिए

इनपुट के साथ

Think of a number, subtract from 20, add 2, repeat.

नक्शा अभिव्यक्ति सूची देता है

[["Y";"q";[]]; ["Y";"-y+";[2;0]]; ["Y";"y+";[2]]; ["Y";"y+";[2]]]

जिसे, जब संघनन किया जाता है, तो आउटपुट

YqY-y+20Yy+2Yy+2

2

पायथन 2 , 154 153 146 बाइट्स

फिक्स्ड, और यहां तक ​​कि इस प्रक्रिया में कई बाइट्स को बचाया। ^ __ ^

for c in input()[9:-1].split(","):s=c.rfind(" ");p=o=s and"x="+"-x+ input() x- x// x+ x*".split()[s%7]+c[s:]*(c[0]<"a")or p;print o
print"print x"

इसे ऑनलाइन आज़माएं!

मेरी पिप के जवाब के रूप में एक ही रणनीति के आधार पर । पायथन-विशिष्ट विशेषताएं:

  • Think of और .बंटवारे से पहले स्ट्रिंग से समापन को हटा दिया जाता है ( input()[9:-1])। मुख्य लूप को संभालने के लिए अवधि बहुत अधिक अजीब थी। पहले नौ पात्रों को हटाने से अलग कारण के लिए मदद मिलती है (नीचे देखें)।
  • एक अंक के लिए regex द्वारा प्रत्येक कमांड की लंबाई प्राप्त करने के बजाय (पायथन में महंगा है क्योंकि import re ), हम rfind(" ")कमांड में अंतिम स्थान खोजने के लिए उपयोग करते हैं। हम इसका उपयोग repeatमामले की जांच के लिए भी कर सकते हैं ।
  • पाइथन में पिप की साइक्लिकल इंडेक्सिंग नहीं है, इसलिए हमें इंडेक्स मॉड 7 को स्पष्ट रूप से लेना होगा। दूसरी ओर, इसका मतलब है कि हम लुकअप टेबल में अंतिम डमी वैल्यू को हटा सकते हैं, क्योंकि इंडेक्स मॉड 7 कभी भी 6 नहीं है।
  • "कमांड" के माध्यम से पहली बार है a number, जिसमें अंतरिक्ष का सूचकांक है 1। यह इंडेक्स लुकअप टेबल में दूसरे छेद को आसानी से भर देता है। मुख्य लूप में इनपुट चरण को संसाधित करने के साथ अन्य समस्या +c[s:]भाग थी, जिसके परिणामस्वरूप होगा x=input() number। उस समस्या को हल करने के लिए, हम स्ट्रिंग-गुणा करके c[0]<"a": 1सभी नियमित आदेशों के लिए, जिसमें cएक स्थान से शुरू होता है, लेकिन 0प्रारंभिक के लिए a number

1

WinDbg, 449 388 बाइट्स

as, }@$t1
as. }0;?@$t0
asThink n10;ed8<<22;r$t0=dwo(8<<22);r$t1=0;.do{
aSa " "
asQ .printf";r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0
as/c add Q +"
aSby " "
as/c divide Q /"
asfrom 0;r$t0=-@$t0+
as/c multiply Q *"
aSnumber " "
aSof " "
asrepeat +1
as/c subtract Q -"
.for(r$t9=1;by(@$t0);r$t0=@$t0+1){j44!=by(@$t0) .printf"%c",by(@$t0);.if116!=by(@$t0-1){.printf" , "}};.printf"\b ."

बार-बार कोड के लिए उपनाम को परिभाषित करके -61 बाइट्स

लैम्ब्डाबेटा के उपयोग से प्रेरित #define। यह दृष्टिकोण WordMath सिंटैक्स को थोड़ा संशोधित करता है ( ,और. दूसरे शब्दों की तरह अंतरिक्ष-सीमांकित होना चाहिए, और ,इसका पालन नहीं करता है repeat), और उपनाम बनाता है जैसे कि संशोधित वर्डमैथ सिंटैक्स मान्य WinDbg कोड है। अंतिम पंक्ति वह करती है जो इनपुट को संशोधित सिंटैक्स में परिवर्तित करके प्रश्न पूछता है और ट्रांसपाइल्स करता है।

इनपुट एक मेमोरी पते पर एक स्ट्रिंग सेट करके और $t0उस पते पर छद्म रजिस्टर सेट करके लिया जाता है । नोट: इस के ऊपर लिख देगा intपर0x2000000 , इसलिए यदि आप अपने स्ट्रिंग वहाँ शुरू करते हैं, यह आंशिक रूप से ओवरराइट किया जाएगा। $t0ओवरराइट भी किया जाएगा।

क्योंकि यह उपनाम बनाता है, यह इस बात पर निर्भर करता है कि यह कोड तेह स्ट्रिंग सेट करने से पहले या बाद में चला है, आउटपुट कोड अलग होगा (या तो अलियास किया गया है या नहीं)। दुर्भाग्य से, मुझे व्हाट्सएप को सीमांकित किए बिना विस्तार से ठीक से विस्तार करने का एक तरीका नहीं मिला (जिसका अर्थ है कि वर्डमैथ स्क्रिप्ट को सीधे रूप में परिवर्तित किए बिना सीधे निष्पादित नहीं किया जा सकता है)।

यह काम किस प्रकार करता है:

* $t1 is used for repeating and $t0 is used to read the input and hold the accumulator
* Alias , to }@$t1 -- closing do-while loop and allowing repeat
as , }@$t1

* Alias . to }0;?@$t0 -- close do-while loop and evaluate $t0 (accumulator)
as . }0;?@$t0

* Alias Think to (note this is one line)
as Think n10;               * Set base 10
         ed 8<<22;          * Read ints to address 0x2000000. Enter nothing to exit input mode
         r$t0 = dwo(8<<22); * Set $t0 = first int
         r$t1=0;.do{        * Open do-while

* Alias a to nothing
aS a " "

* Alias add to (note one line):
as add ;                       * Close previous statement
       r$t1=1;.do{r$t1=@$t1-1; * Open do-while (once) loop
       r$t0=@$t0+              * Add number to $t0

* Alias by to nothing
aS by " "

* Alias divide to (note one line):
as divide ;                       * Close previous statement
          r$t1=1;.do{r$t1=@$t1-1; * Open do-while (once) loop
          r$t0=@$t0/              * Divide next number from $t0

* Alias from to (note one line):
as from 0;         * Preceding subtract statement subtracts 0
       r$t0=-@$t0+ * Subtract $t0 from next number

* Alias multiply to (note one line):
as multiply ;                       * Close previous statement
            r$t1=1;.do{r$t1=@$t1-1; * Open do-while (once) loop
            r$t0=@$t0*              * Multiply next number with $t0

* Alias number to nothing
aS number " "

* Alias of to nothing
aS of " "

* Alias repeat to +1 making do-while (once) loops into do-while (once)+1
as repeat +1

* Alias subtract to (note one line):
as subtract ;                       * Close previous statement
            r$t1=1;.do{r$t1=@$t1-1; * Open do-while (once) loop
            r$t0=@$t0-              * Subtract next number from $t0


.for (r$t9=1; by(@$t0); r$t0=@$t0+1) * Enumerate the string
{
    j 44!=by(@$t0)                   * If not comma
        .printf "%c",by(@$t0);       * Print the char
    * implicit else
        .if 116!=by(@$t0-1)          * Else if the previous char is not t
        {
          .printf " , "              * Print the comma with spaces around it
        }
};
.printf "\b ."                       * Replacing ending "." with " ."

नमूना आउटपुट, इस कोड को एक बार चलाने से पहले स्ट्रिंग में प्रवेश करना (परिणामस्वरूप प्रोग्राम वर्डमैथ जैसा दिखता है):

0:000> r$t0=8<<22
0:000> eza8<<22"Think of a number, add 5, add 10, multiply by 2, subtract 15, repeat, divide by 2."
0:000> as, }@$t1
0:000> as. }0;?@$t0
0:000> asThink n10;ed8<<22;r$t0=dwo(8<<22);r$t1=0;.do{
0:000> aSa " "
0:000> asadd ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0+
0:000> aSby " "
0:000> asdivide ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0/
0:000> asfrom 0;r$t0=-@$t0+
0:000> asmultiply ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0*
0:000> aSnumber " "
0:000> aSof " "
0:000> asrepeat +1
0:000> assubtract ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0-
0:000> .for(r$t9=1;by(@$t0);r$t0=@$t0+1){j44!=by(@$t0) .printf"%c",by(@$t0);.if116!=by(@$t0-1){.printf" , "}};.printf"\b ."
Think of a number ,  add 5 ,  add 10 ,  multiply by 2 ,  subtract 15 ,  repeat divide by 2 }0;?@$t0

0:000> Think of a number ,  add 5 ,  add 10 ,  multiply by 2 ,  subtract 15 ,  repeat divide by 2 }0;?@$t0
base is 10
02000000 6e696854 18
18
02000004 666f206b 

Evaluate expression: 18 = 00000012

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

0:000> r$t0=8<<22
0:000> eza8<<22"Think of a number, add 5, add 10, multiply by 2, subtract 15, repeat, divide by 2."
0:000> as, }@$t1
0:000> as. }0;?@$t0
0:000> asThink n10;ed8<<22;r$t0=dwo(8<<22);r$t1=0;.do{
0:000> aSa " "
0:000> asadd ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0+
0:000> aSby " "
0:000> asdivide ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0/
0:000> asfrom 0;r$t0=-@$t0+
0:000> asmultiply ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0*
0:000> aSnumber " "
0:000> aSof " "
0:000> asrepeat +1
0:000> assubtract ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0-
0:000> .for(r$t9=1;by(@$t0);r$t0=@$t0+1){j44!=by(@$t0) .printf"%c",by(@$t0);.if116!=by(@$t0-1){.printf" , "}};.printf"\b ."
n10;ed8<<22;r$t0=dwo(8<<22);r$t1=0;.do{     number ,  ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0+ 5 ,  ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0+ 10 ,  ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0*   2 ,  ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0- 15 ,  repeat ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0/   2 }0;?@$t0

0:000> n10;ed8<<22;r$t0=dwo(8<<22);r$t1=0;.do{     number ,  ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0+ 5 ,  ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0+ 10 ,  ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0*   2 ,  ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0- 15 ,  repeat ;r$t1=1;.do{r$t1=@$t1-1;r$t0=@$t0/   2 }0;?@$t0
base is 10
02000000 3b30316e 26
26
02000004 3c386465 

Evaluate expression: 26 = 0000001a

कुछ और नमूना आउटपुट, बस थोड़ा संशोधित वर्डमैथ सिंटैक्स का उपयोग करके:

0:000> Think of a number , add 1 , repeat repeat repeat divide by 3 .
base is 10
02000000 0000001a 3
3
02000004 3c386465 

Evaluate expression: 2 = 00000002


0:000> Think of a number , divide by 5 , subtract from 9 .
base is 10
02000000 00000003 29
29
02000004 3c386465 

Evaluate expression: 4 = 00000004

0

स्केल, 338 बाइट्स

इसे स्वयं आइडोन पर आज़माएं

s=>{val n=(_:String)filter(_.isDigit)toInt;(Seq("").tail/:s.split(",").tail)((a,&)=> &match{case&if&contains "v"=>a:+"x/="+n(&)
case&if&contains "d"=>a:+"x+="+n(&)
case&if&contains "y"=>a:+"x*="+n(&)
case&if&contains "f"=>a:+"x="+n(&)+"-x"
case&if&contains "s"=>a:+"x-="+n(&)
case p=>a:+a.last})mkString("var x=readInt;",";",";print(x)")}

स्पष्टीकरण:

// define a function with a parameter s
s => {
    // define a function with a String parameter to extract a number from a string
    val n =
        // filter out the chars that arent't digits
        (_: String) filter (_.isDigit)
        // and parse the number
        toInt;
    // take the tail of a list with an empty string,
    // which is the empty list of type Seq[String].
    // This is the start value for the fold...
    (Seq("").tail /:
        // ... of the tail of the sentence splitted at commas
        s.split(",").tail
    ) (
        // This is the function for the fold.
        // a is the accumulator (the list), and the current element is called &
        (a, &) => & match {
            // if & contains a "v", append "x/=" + n(&) to a.
            case & if & contains "v" => a :+ "x/=" + n(&)
            // the other cases are similar
            case & if & contains "d" => a :+ "x+=" + n(&)
            case & if & contains "y" => a :+ "x*=" + n(&)
            case & if & contains "f" => a :+ "x=" + n(&) + "-x"
            case & if & contains "s" => a :+ "x-=" + n(&)
            // for the repeat, apppend the last value of a to a
            case p                   => a :+ a.last
        }
     )
     // make a string out of the parts by joining them with semicolons,
     // prepending "var x=readInt;" and appending ";print(x)"
     mkString("var x=readInt;", ";", ";print(x)")
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.