Herausforderung:

Ihre Aufgabe ist es, einen einfachen Dolmetscher für eine einfache Golfsprache zu erstellen.

Eingang:

Die Eingabe erfolgt in Form einer durch Leerzeichen getrennten Zeichenfolge.

Sie können die Raumtrennung durch das ersetzen, was Sie möchten

Ausgabe:

Das Ergebnis (eine Zahl oder eine Zeichenfolge) ausgeben, das nach Ausführung aller Vorgänge erhalten wurde. Wenn es mehr als einen Ausgang gibt, verbinden Sie die beiden, um ein einzelnes Ergebnis zu erhalten (keine Trennzeichen). Der Anfangswert der Variablen ist immer Null. Das heißt: Es beginnt um0

Sprachensyntax:

Die Sprache hat folgende Operatoren:

inc  ---> add one to variable
dec  ---> remove one from variable
mult ---> multiply variable by 2
half ---> divide the variable by 2
Pri  ---> print the variable to console (or whatever your language has)
exit ---> end the program (anything after this is ignored)

Beispiele:

inc inc inc dec Pri exit                 ---> 2
dec inc mult inc inc Pri                 ---> 2
inc inc inc mult half Pri exit inc       ---> 3
inc Pri inc Pri inc Pri exit half mult   ---> 123
Pri exit                                 ---> 0
inc half Pri exit                        ---> 0.5 

Beschränkung:

Dies ist Code-Golf, so dass der kürzeste Code in Bytes für jede Sprache gewinnt.

Hinweis:

• Die Eingabe ist immer gültig. (durch Leerzeichen getrennte Zeichenfolge von Operatoren)
• Sie können auf die nächste Ganzzahl abrunden, wenn Sie keine Dezimalstellen möchten.

Bash , 61 Bytes

sed '1i0
s/.//2g;y"idmhe"+-*/q";/+\|-/i1
/*\|\//i2
/P/cdn'|dc

Probieren Sie es online!

Konvertiert das Programm in ein DC-Programm und wertet es dann als DC-Code aus. Dies nimmt die Eingabe durch Zeilenumbrüche getrennt. Beachten Sie, dass DC stapelbasiert ist und die umgekehrte polnische Notation verwendet.

Der Eingang wird zuerst zu sed geleitet

1i0 Fügen Sie in der ersten Eingabezeile eine 0 ein (voranstellen), dies ist der Akkumulator

s/.//2g entferne alles außer dem ersten Zeichen in jeder Zeile

y"idmhe"+-*/q"transliterate idmhein +-*/q, + - * / sind die arithmetischen Befehle und q beendet das Programm

/+\|-/Fügen Sie in jede Zeile, die + oder - enthält, i1eine 1 ein

/*\|\//Fügen Sie in jede Zeile, die * oder / enthält, i2eine 2 ein

/P/cdnÄndern Sie in jeder Zeile, die P enthält, diese in dn, was dem Duplizieren entspricht, und geben Sie sie ohne neue Zeile in dc aus

Dies wird nun als ein DC-Ausdruck ausgewertet.

Jelly , 21 Bytes

ḲḢ€O%11ị⁾’‘j“IȮḤH”¤VI

Probieren Sie es online!

Beachten Sie, dass die ASCII-Werte der ersten Zeichen ( idmhPe) modulo 11 eindeutig modulo 6 sind.

Modulo 16 verwenden:

Jelly , 21 Bytes

ḲḢ€O%⁴ị“ḢwġḞkz’ṃØJ¤VI

Probieren Sie es online!

Die Zeichenfolge, in die indiziert wird, ist ḤH‘’IȮin diesem Fall. Die ‘’sind nicht mehr an den Grenzen.

R , 128 125 Bytes

Reduce(function(x,y)switch(y,i=x+1,d=x-1,m=x*2,h=x/2,P={cat(x);x}),substr(el(strsplit(gsub("e.*$","",scan(,""))," ")),1,1),0)

Probieren Sie es online!

Muss mit aufgerufen werden source(echo=FALSE), um zu verhindern, dass der Rückgabewert automatisch gedruckt wird. Die Alternative wäre, allesinvisible einzupacken, aber das ist viel weniger golfen (und ruiniert meine [noch] nette Byteanzahl).

05AB1E , 25 Bytes

΀¬"idmhPe"S"><·;=q"S‡J.V

Probieren Sie es online!

Ordnet jede Sprachfunktion der entsprechenden 05AB1E-Funktion zu (unter Verwendung des ersten Zeichens jeder Funktion) und führt dann die resultierende Zeichenfolge als 05AB1E-Code aus.

Rot , 121 Bytes

func[s][v: 0 parse s[any[["i"(v: v + 1)|"d"(v: v - 1)|"m"(v: v * 2)|"h"(v: v / 2.0)|"P"(prin v)|"e"(exit)]thru" "| end]]]

Probieren Sie es online!

Lesbar:

f: func [s] [
    v: 0
    parse s [
        any [
            [ "i" (v: v + 1)
            | "d" (v: v - 1)
            | "m" (v: v * 2)
            | "h" (v: v / 2.0)
            | "P" (prin v)
            | "e" (exit)]
            thru [" " | end]
        ]
    ]
] 

Python 2 , 131 125 122 121 118 117 115 Bytes

v=0;o=""
for x in input().split("x")[0].split():
 if"Q">x:o+=`v`
 else:v+=(1,-1,v,-v/2.)['idmh'.find(x[0])]
print o

Probieren Sie es online!

-6 und -3 danke an @Rod

-3 und -2 danke an @etene

-1 durch Ersetzen "Pri"==xdurch"P"in x

Python 3 , 110 91 82 Bytes

exit führt dazu, dass das Programm mit einem Fehler beendet wird.

x=0
for c in input():c=='P'==print(x,end='');x+=(1,-1,x,-x/2,c,0)['ndmhx'.find(c)]

Probieren Sie es online!

JavaScript (ES6), 83 79 Bytes

4 Bytes gespart dank @ l4m2

Ersetzt die Anweisungen iterativ entweder durch die Ausgabe oder durch leere Zeichenfolgen.

s=>s.replace(/\S+./g,w=>m<s?'':w<{}?m:(m+={d:-1,e:w,i:1,m}[w[0]]||-m/2,''),m=0)

Probieren Sie es online!

Kommentiert

s =>                       // given the input string s
  s.replace(/\S+./g, w =>  // for each word w in s:
    m < s ?                //   if m is a string:
      ''                   //     ignore this instruction
    :                      //   else:
      w < {} ?             //     if w is 'Pri' ({} is coerced to '[object Object]'):
        m                  //       output the current value of m
      : (                  //     else:
          m +=             //       add to m:
            { d: -1,       //         -1 if w is 'dec'
              e: w,        //         w  if w is 'exit' (which turns m into a string)
              i: 1,        //         1  if w is 'inc'
              m            //         m  if w is 'mult'
            }[w[0]]        //       using the first character of w to decide
            || -m / 2,     //       or add -m/2 (for 'half') if the above result was falsy
        ''),               //       do not output anything
    m = 0                  //   m = unique register of our mighty CPU, initialized to 0
  )                        // end of replace()

Kohle , 37-35 Bytes

≔⁰ηＦ⎇№θx…θ⌕θxθ≡ιn≦⊕ηd≦⊖ηm≦⊗ηh≦⊘ηrＩη

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Inspiriert von @ RickHitchcocks Antwort. Erläuterung:

≔⁰η

Löschen Sie die Variable.

Ｆ⎇№θx…θ⌕θxθ≡ι

Kürzen Sie die Eingabe am x es eine gibt, und schalten Sie dann jedes Zeichen der Eingabe (den Rest der Eingabe) in einer Schleife ein.

n≦⊕η

n ich n Inkrementen die Variable.

d≦⊖η

d d ecrements die Variable.

m≦⊗η

m m multipliziert die Variable mit zwei (dh doppelt).

h≦⊘η

h h alves die Variable.

rＩη

rp r fügt die Variable in einen String um.

JavaScript (ES6), 77 bis 75 Byte

(Geliehen ( gestohlen ) @ Arnauld's Trick zu benutzenm als Variablennamen 2 Bytes zu sparen.)

f=([c,...s],m=0)=>c<'x'?(c=='P'?m:'')+f(s,m+({h:-m/2,d:-1,n:1,m}[c]||0)):''

Durchläuft die Zeichenfolge rekursiv, sucht nach eindeutigen Buchstaben pro Anweisung und ignoriert den Rest:

• n: inc
• d: dez
• m: mult
• h: halb
• P: Pri
• x: beenden

Nutzt die Tatsache, dass sie undefinedweder größer noch kleiner als ist 'x', und beendet die Rekursion am Ende der Zeichenfolge oder wenn sie auf den 'x'In- Exit stößt .

f=([c,...s],n=0)=>c<'x'?(c=='P'?n:'')+f(s,n+({h:-n/2,d:-1,n:1,m}[c]||0)):''

console.log(f('inc inc inc dec Pri exit'));                 //--> 2
console.log(f('dec inc mult inc inc Pri'));                 //--> 2
console.log(f('inc inc inc mult half Pri exit inc'));       //--> 3
console.log(f('inc Pri inc Pri inc Pri exit half mult'));   //--> 123
console.log(f('Pri exit'));                                 //--> 0
console.log(f('inc half Pri exit'));                        //--> 0.5 

JavaScript (Node.js) , 107 Byte

f=s=>s.split` `.map(([o])=>F?0:o=="i"?i++:o=="d"?i--:o=="m"?i*=2:o=="h"?i/=2:o=="P"?S+=i:F=1,F=i=0,S="")&&S

Probieren Sie es online!

JavaScript (Node.js) , 91 Byte

_=>_.split` `.map(o=>o<{}>!_?S+=+i:o<"e"?i--:o<"f"?++_:o<"i"?i/=2:o<"j"?i++:i*=2,i=S="")&&S

Probieren Sie es online!

JavaScript (Node.js) , 96 Byte

_=>_.split` `.map(o=>F?0:o<"Q"?S+=i:o<"e"?i--:o<"f"?F=1:o<"i"?i/=2:o<"j"?i++:i*=2,F=i=0,S="")&&S

Probieren Sie es online!

JavaScript (Node.js) , 99 Byte

s=>s.split` `.map(_=>eval('++i7--i7++e7u+=+i7i*=27i/=2'.split(7)[Buffer(e+_)[0]%11%6]),e=i=u='')&&u

Probieren Sie es online!

JavaScript, 107 Bytes

s=>eval('x=0;x'+(s.split` `.map(v=>({i:"++",d:"--",m:"*=2",h:"/=2",P:";alert(x)",e:"//"})[v[0]]).join`;x`))

Haskell , 93 Bytes

(0!)
a!(c:t)|c=='P'=show a++a!t|c>'w'=""|1<2=(a+sum(lookup c$zip"ndmh"[1,-1,a,-a/2]))!t;a!e=e

Probieren Sie es online!

Im Wesentlichen eine Übersetzung der Python-Antwort von mbomb007 .

Lua, 207 Bytes

s=0;n=0;for a in io.read():gmatch'.'do if s==0 then s=1;n=a=='i'and n+1 or a=='d'and n-1 or a=='m'and n*2 or a=='h'and n/2 or n;if a=='P'then print(n)elseif a=="e"then break end elseif a==' 'then s=0 end end

Python 3 , 114 110 109 116 Bytes

Eigentlich hätte Python 2 zwei Bytes weniger gekostet, da execes sich um eine Anweisung handelt und keine Klammern benötigt ...

• 4 zusätzliche Bytes dank @ElPedro gespeichert

• Sie haben ein zusätzliches Byte gespeichert, indem Sie die Tatsache ausgenutzt haben, dass findbei einem Fehler -1 zurückgegeben wird, das dann als Index verwendet werden kann

• +7 Bytes, weil ich die No-Newlines-Regel nicht bemerkt hatte :(

i=0;exec(";".join("i+=1 i-=1 i*=2 i/=2 print(i,end='') exit()".split()["idmhP".find(h[0])]for h in input().split()))

Probieren Sie es online!

Ordnet das erste Zeichen jedes Eingabeworts einem Teil des Python-Codes zu. Diese werden dann verkettet undexec bearbeitet.

Ziemlich unkomplizierte Herangehensweise, die man wahrscheinlich etwas mehr golfen könnte. Die Schwierigkeit besteht hauptsächlich darin, aus vielen möglichen Formen die kürzeste zu finden ...

Ruby + -na, 81 73 65 Bytes

x=0;$F.map{|w|eval %w{x+=1 x-=1 1/0 $><<x x*=2 x/=2}[w.ord%11%6]}

Probieren Sie es online!

Ziemlich einfach. Suchen Sie für den ersten Buchstaben jedes Wortes die entsprechende Befehlszeichenfolge und evaldiese. Verwendet die Ganzzahldivision und exitswirft a ZeroDivisionError.

-5 Bytes: Verwenden Sie diese Option .ord%11%6anstelle einer Zeichenfolgensuche. Das Guthaben geht an user202729

-3 Bytes: .ordberücksichtigt nur das erste Zeichen der Zeichenkette, so dass ich a überspringen kann [0].

-8 Bytes: Benutze -aFlag, um die Eingabe dank Kirill L automatisch aufzuteilen.

Emojicode , 270 Bytes

🐖🔥🍇🍮c 0🔂j🍡💣🐕🔟 🍇🍊😛j🔤inc🔤🍇🍮c➕c 1🍉🍋😛j🔤dec🔤🍇🍮c➖c 1🍉🍋😛j🔤mult🔤🍇🍮c✖️c 2🍉🍋😛j🔤half🔤🍇🍮c➗c 2🍉🍋😛j🔤Pri🔤🍇👄🔡c 10🍉🍓🍇🍎🍉🍉🍉

Probieren Sie es online!

🐋🔡🍇
🐖🔥🍇
🍮c 0
🔂j🍡💣🐕🔟 🍇
🍊😛j🔤inc🔤🍇🍮c➕c 1🍉
🍋😛j🔤dec🔤🍇🍮c➖c 1🍉
🍋😛j🔤mult🔤🍇🍮c✖️c 2🍉
🍋😛j🔤half🔤🍇🍮c➗c 2🍉
🍋😛j🔤Pri🔤🍇👄🔡c 10🍉
🍓🍇🍎🍉🍉🍉🍉

🏁🍇
 🔥🔤inc inc inc dec Pri exit🔤
😀🔤🔤
 🔥🔤dec inc mult inc inc Pri🔤
😀🔤🔤
 🔥🔤inc inc inc mult half Pri exit inc🔤
😀🔤🔤
 🔥🔤inc Pri inc Pri inc Pri exit half mult🔤
😀🔤🔤
 🔥🔤Pri exit🔤
😀🔤🔤
 🔥🔤inc half Pri exit🔤
🍉

SNOBOL4 (CSNOBOL4) , 165 Bytes

	P =INPUT ' exit ' 
	x =0
S	P LEN(1) $ L ARB ' ' REM . P	:S($L)F(end)
i	X =X + 1	:(S)
d	X =X - 1	:(S)
P	O =O X		:(S)
m	X =X * 2	:(S)
h	X =X / 2.	:(S)
e	OUTPUT =O
END

Probieren Sie es online!

Brutto.

	P =INPUT ' exit ' 				;* append ' exit ' to the input to guarantee that the program will stop
	x =0						;* initialize x to 0 else it won't print properly if the program is 'Pri'
S	P LEN(1) $ L ARB ' ' REM . P	:S($L)F(end)	;* set L to the first letter of the word and goto the appropriate label
i	X =X + 1	:(S)
d	X =X - 1	:(S)
P	O =O X		:(S)				;* append X to the output string
m	X =X * 2	:(S)
h	X =X / 2.	:(S)				;* divide by 2. to ensure floating point
e	OUTPUT =O					;* print whatever's in O, which starts off as ''
END

C # (.NET Core), 186 Bytes

class P{static void Main(string[]a){int v=0;foreach(var s in a){var i=s[0];if(i=='i')v++;if(i=='d')v--;if(i=='m')v*=2;if(i=='h')v/=2;if(i=='P')System.Console.Write(v);if(i=='e')break;}}}

Perl 5 -a , 61 Bytes

eval'$,'.qw(++ -- ;exit ;print$,||0 *=2 /=2)[(ord)%11%6]for@F

Probieren Sie es online!

Hat den ord%11%6Trick von @ user202729 gestohlen

Wie?

-a            # split the input by whitespace, store in @F
eval          # Execute the string that results from:
'$,'          # $, (the accumulator)
.             # appending:
qw(           # create an array for the following whitespace separated values:
++ --            # operators for inc & dec
;exit            # exit
;print$,||0      # Pri  (||0 ensures that 0 is output if accumulator is null
*=2 /=2)         # mult div
[(ord)%11%6] # @user202729's trick selects one of the preceding operations
for@F        # for every term input

Pyth, 44 Bytes

Vmx"idmhPe"hdcwd=Z@[hZtZyZcZ2ZZ)NIqN4pZIqN6B

Test Suite

Erläuterung

Vmx"idmhPe"hdcwd=Z@[hZtZyZcZ2ZZ)NIqN4pZIqN6B   ## full program
             cwd                               ## split input on space
Vmx"idmhPe"hd                                  ## iterate through list of numbers corresponding to operators
                =Z@[hZtZyZcZ2ZZ)N              ## assign the variable Z (initialliy Zero) it's new value
                                 IqN4pZ        ## print Z if the current operator is "Pri" (4)
                                       IqN6B   ## break if the current operator is "exit" (5)

TI-BASIC, 112 Bytes

Dies stützt sich auf einige Annahmen, die von AFAIK durchaus akzeptiert werden. Nummer eins ist, dass alle Variablen vor der Ausführung auf Null initialisiert werden; Nummer zwei ist, dass die Eingabe über übernommen wird Ans.

Ans+" E→Str1
While 1
I+4→I
sub(Str1,I-3,1→Str2
A+(Ans="I")-(Ans="D
If inString("MH",Str2
Then
I+1→I
2AAns+A/2(1-Ans
End
If Str2="P
Disp A
If Str2="E
Stop
Ans→A
End

Java (OpenJDK 8) , 164 Byte

a->{int c=0;for(String g:a.split(" ")){char b=g.charAt(0);if(b==105)c++;if(b==100)c--;if(b==109)c*=2;if(b==104)c/=2;if(b==80)System.out.print(c);if(b==101)return;}}

Probieren Sie es online!

Oben ist meine Lösung, die auf ganze Zahlen abrundet, unten ist meine Lösung, die Dezimalzahlen verarbeitet. Die widerwärtige Art und Weise, wie Java das Doppelte druckt, fügt der Partitur weitere 55 Byes hinzu. Ich habe die neuen Zeilen belassen, um den Code in der zweiten Einreichung besser lesbar zu machen, nur weil es im Wesentlichen dieselbe Lösung mit einem zusätzlichen Befehl und einer import-Anweisung ist.

Java (OpenJDK 8) , 219 Byte

a->{
double c=0;
for(String g:a.split(" ")){
char b=g.charAt(0);
if(b==105)c++;
if(b==100)c--;
if(b==109)c*=2;
if(b==104)c/=2;
if(b==80)System.out.print(new DecimalFormat("0.#").format(c));
if(b==101)return;}}

Probieren Sie es online!

C (GCC) , 120 114 111 Bytes

-6 bytes dank ceilingcat.

x,d;f(char*s){for(x=0;s>1;s=index(d^1?s:"",32)+1)d=*s-100,x+=d?d==5:-1,x*=d^9?d^4?1:.5:2,d+20||printf("%d",x);}

Probieren Sie es online!

124 Bytes

Gleitkomma-Version:

d;f(char*s){for(float f=0;s>1;s=strchr(s,32)+1)d=*s-80,f+=d==25,f-=d==20,f*=d^29?d^24?1:.5:2,s=d^21?s:"",d?:printf("%f",f);}

Probieren Sie es online!

Ich habe mich nicht mit einer abrundenden Version befasst, sondern mit einer Ausnahme für 0, die zulässig wäre, wenn ich die Kommentarkette richtig verstehe.

33 , 62 Bytes

s'i'{1a}'d'{1m}'m'{2x}'h'{2d}'P'{o}'e'{@}It[mzsjk""ltqztItn1a]

Probieren Sie es online!

Dieses Programm nimmt die durch Zeilenumbrüche begrenzten Anweisungen entgegen

Erläuterung:

It[mzsjk""ltqztItn1a]
  [mz            n1a] | Forever
It    jk       It     | - Get the first character of the next instruction
            qz        | - Call the function declared previously
     s  ""lt  t       | - Make sure we don't lose track of the variable

Der Code vor diesem Segment definiert alle Funktionen.