Desafio:

Seu trabalho é criar um intérprete simples para uma linguagem simples de golfe.

Entrada:

A entrada será na forma de sequência separada por espaços.

Você pode substituir a separação de espaço pelo que deseja

Resultado:

Produza o resultado (um número ou uma sequência) obtido após a execução de todas as operações. Se houver mais de uma saída, junte-se para fornecer um único resultado (sem separadores). O valor inicial da variável é sempre zero. ou seja: começa às0

Sintaxe do idioma:

O idioma possui os seguintes operadores:

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)

Exemplos:

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 

Restrição:

Este é o código-golfe, pelo que o código mais curto em bytes para cada idioma vencerá.

Nota:

• A entrada sempre será válida. (sequência de operadores separados por espaço)
• Você pode arredondar para o número inteiro mais próximo se não desejar casas decimais.

Bash , 61 bytes

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

Experimente online!

Converte o programa em um programa dc e o avalia como código dc. Isso separa a entrada por novas linhas. Observe que dc é baseado em pilha e usa a notação de polimento reverso.

A entrada é canalizada primeiro para sed

1i0 na primeira linha de entrada, insira (prepend) um 0, este será o acumulador

s/.//2g remova tudo, exceto o primeiro caractere de cada linha

y"idmhe"+-*/q"transliterar idmhepara +-*/qrespectivamente, + - * / são os comandos aritméticos eq sai do programa

/+\|-/em todas as linhas que contêm + ou -, i1insira 1

/*\|\//em cada linha contendo * ou /, i2insira um 2

/P/em cada linha que contém P, cdnmude paradn equivalente à duplicação e saída sem nova linha em dc

Agora isso é avaliado como uma expressão dc.

Gelatina , 21 bytes

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

Experimente online!

Observe que os valores ASCII dos primeiros caracteres ( idmhPe) módulo 11 são o módulo exclusivo 6.

Usando o módulo 16:

Gelatina , 21 bytes

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

Experimente online!

A sequência usada para indexar é ḤH‘’IȮneste caso. Não ‘’estão mais nos limites.

R , 128 bytes 125

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)

Experimente online!

Deve ser chamado com source(echo=FALSE)para impedir que o valor de retorno seja impresso automaticamente. A alternativa seria envolver tudo,invisible mas isso é muito menos golfe (e arruina minha [ainda] boa contagem de bytes).

05AB1E , 25 bytes

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

Experimente online!

Mapeia cada uma das funções de idioma com a função 05AB1E correspondente (usando o primeiro caractere de cada função) e, em seguida, executa a sequência resultante como código 05AB1E.

Vermelho , 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]]]

Experimente online!

Legível:

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

Experimente online!

-6 e -3 com agradecimentos a @Rod

-3 e -2 com agradecimentos a @etene

-1 substituindo "Pri"==xpor"P"in x

Python 3 , 110 91 82 bytes

exit fará com que o programa saia com um erro.

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

Experimente online!

JavaScript (ES6), 83 79 bytes

Guardado 4 bytes graças a @ l4m2

Substitui iterativamente as instruções pela saída ou pelas seqüências de caracteres vazias.

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

Experimente online!

Comentado

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

Carvão , 37 35 bytes

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

Experimente online! Link é a versão detalhada do código. Inspirado pela resposta de @ RickHitchcock. Explicação:

≔⁰η

Limpe a variável.

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

Trunque a entrada no xse houver um, faça um loop e ligue cada caractere (o restante) da entrada.

n≦⊕η

ni n incrementa a variável.

d≦⊖η

d d cria a variável.

m≦⊗η

m m ultiplies a variável por dois (isto é, duplos).

h≦⊘η

h h alves a variável.

rＩη

rp r insere a variável convertida em string.

JavaScript (ES6), 77 75 bytes

(Emprestado ( roubado ) @ O truque de Arnauld de usar mcomo o nome da variável, economizando 2 bytes.)

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

Percorre recursivamente a string, procurando letras distintas por instrução e ignorando o resto:

• n: inc
• d: dec
• m: mult
• h: metade
• P: Pri
• x: exit

Tira proveito do fato de que undefinednão é nem maior que nem menos do que 'x', fazendo com que a recursão para parar no final da string ou quando encontra o 'x'na saída .

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 bytes

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

Experimente online!

JavaScript (Node.js) , 91 bytes

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

Experimente online!

JavaScript (Node.js) , 96 bytes

_=>_.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

Experimente online!

JavaScript (Node.js) , 99 bytes

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

Experimente 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

Experimente online!

Essencialmente, uma tradução da resposta Python do 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

Na verdade, seria necessário dois bytes a menos no Python 2 porque execé uma declaração e não precisa de parênteses ...

• Guardou 4 bytes adicionais graças a @ElPedro

• Economizou um byte extra aproveitando o fato de findretornar -1 com erro, que pode ser usado como índice

• +7 bytes porque eu não havia notado a regra de não novas linhas :(

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

Experimente online!

Mapeia o primeiro caractere de cada palavra de entrada para um pedaço do código Python. Estes são então concatenados eexec editados.

Abordagem bastante direta, que provavelmente poderia ser um pouco mais golfe. A dificuldade reside principalmente em encontrar a forma mais curta dentre as possíveis ...

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

Experimente online!

Bem direto. Para a primeira letra de cada palavra, encontre a sequência de comandos correspondente e evalela. Usa divisão inteira e exitsjogando a ZeroDivisionError.

-5 bytes: use em .ord%11%6vez de uma pesquisa de sequência. O crédito vai para user202729

-3 bytes: .ordconsidera apenas o primeiro caractere da string, para que eu possa pular a [0].

-8 bytes: use o -asinalizador para dividir automaticamente a entrada, graças a Kirill L.

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🍉🍓🍇🍎🍉🍉🍉

Experimente 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

Experimente online!

Bruto.

	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

Experimente online!

Roubou @ user202729 ord%11%6 truque de

Quão?

-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

Suíte de teste

explicação

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

Isso tira proveito de algumas suposições que são perfeitamente aceitáveis ​​pelo AFAIK. O número um é que todas as variáveis ​​são inicializadas em zero antes da execução; número dois sendo que a entrada é obtida via 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 bytes

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

Experimente online!

Acima está minha solução que arredonda para números inteiros, mas abaixo está minha solução que lida com decimais. A maneira desagradável que o java imprime dobra adiciona mais 55 bytes à pontuação. Deixei as novas linhas para tornar o código mais legível no segundo envio apenas porque é essencialmente a mesma solução com um comando extra e uma declaração de importação.

Java (OpenJDK 8) , 219 bytes

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

Experimente online!

C (gcc) , 120 114 111 bytes

-6 bytes graças ao 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);}

Experimente online!

124 bytes

Versão de ponto flutuante:

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

Experimente online!

Eu não me incomodei com uma versão que arredonda para baixo, mas abre uma exceção para 0, o que seria permitido se eu entendesse a cadeia de comentários corretamente.

33 , 62 bytes

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

Experimente online!

Este programa segue as instruções delimitadas por novas linhas

Explicação:

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

O código antes desse segmento define todas as funções.