Crea un interprete 3var!


24

3var è una variante del pesce morto che utilizza tre variabili chiamate A, B e R. A e B sono accumulatori, mentre R viene utilizzato come variabile di risultato.

In questo sfida di , devi creare un interprete per una versione ridotta di questa lingua.

Comandi richiesti:

i   Increments A
d   Decrements A
s   Squares A
p   Prints A
P   Prints the ASCII character of A
>   Sets A to R
a   Increments B
k   Decrements B
m   Squares B
o   Prints B
O   Prints the ASCII character of B
<   Sets B to R
+   Adds A and B, stores in R
-   Subtracts B from A, stores in R
*   Multiplies A and B, stores in R
/   Divides A by B, stores in R
w   Prints R
@   Resets A to 0
#   Resets B to 0
e   Resets R to 0

Tutto il resto (compresi gli spazi bianchi) viene ignorato.

chiarimenti

  • oe pdovrebbe produrre senza nulla dopo.
  • La divisione è divisione intera.
  • Sono supportati numeri superiori a 255 e numeri inferiori a 0.
  • 'w' dovrebbe generare uno spazio o una nuova riga dopo R
  • La divisione per 0 si ferma senza errori. (Nessuna uscita su STDERR)
  • A, B e R sono inizialmente 0

Regole

  • Questo è quindi vince la risposta più breve.
  • In caso di pareggio, vince la risposta più vecchia.
  • Il file verrà fornito tramite argomenti della riga di comando o STDIN.
  • È consentita qualsiasi lingua
  • Eval è permesso.

Casi test

Hello world! (tratto da Esolangs)

iisssaa/>e
maa->e#
aamam->e#
dddddddddddddddddddddddddPiiiiiiiiiiiiiiiiiiiiiiiii
iiiiPiiiiiiiPPiiiP
@#e
iis
aamaaaa
*>P
@#e
iisssaa/>e
maa->e#
aamam->e#
iiiiiiiiiiiiiiiiiiiiiiP
ddddddddP
iiiP
ddddddP
ddddddddP
@#e
iiss
aa*>
iP

Uscite 20spooky22me:

iipois+iis<-<aaaO<OkOOkkkkOP@#iippisa+<m+>PaO

Uscite 9P-1420 100 3Q-1 162 0:

iiispsdPkokmo/w<+w#aaaommO-w@ii*wew

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

# Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=63008,OVERRIDE_USER=45220;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.0.3/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>


1
@ Sp3000 A proposito, di recente ho aiutato a correggere un bug del loop nidificato nell'interprete.
LegionMammal978,

2
Ulteriori chiarimenti per le persone che hanno familiarità con Deadfish: dddddprisultati in -5 e iiiissprisultati in 256 come ti aspetteresti, anziché 0.
Sp3000,

1
Nel caso di test Quale dose rfare? non è incluso nel tuo elenco di comandi validi
JimmyJazzx,

1
@JimmyJazzx Il testcase è ora modificato, ma nella lingua 3var completa r reimposta tutto. È lo stesso di @#e.
DJgamer98,

1
A, B e R sono inizializzati su 0 all'avvio dell'interprete?
Tony Ennis,

Risposte:


7

CJam, 112

q{"+-*/dspP>@ikmoO<#awe"_@#\4<"X2 U|{TU :V;}P?"S/f*'T"( _*T cT;V;0)"2/f+":T;"f+_'Tf/'Uf*+"VS 0:V; "S/++=~}%Pa/0=

Provalo online

Spiegazione:

Il programma crea una matrice di pezzi di codice da eseguire ed esegue il pezzo corrispondente per ciascun personaggio. Affrontare la divisione per zero è più difficile, perché CJam non ha ancora un operatore "break". Invece, il programma spinge π come marker (poiché nessun numero in virgola mobile può apparire diversamente), e alla fine mantiene solo l'output prima del primo π.
Inoltre, il programma utilizza le variabili T, U e V anziché A, B e R, poiché sono preinizializzate con 0 in CJam.

q            read the input
{…}%         transform each character
  "…"        push a string with all the 3var commands, in a convenient order
  _@         duplicate the string and bring the current character to the top
  #          find the index of the character in the string (or -1 if not found)
  \          swap with the other string copy
  4<         keep only the first 4 characters ("+-*/")
  "…"        push a string that will be used for implementing those operators
  S/         split by space into ["X2" "U|{TU" ":V;}P?"]
  f*         join with each of '+', '-', '*', '/' -> 4 strings
  'T         push the 'T' character
  "…"        push a string with implementations of commands involving A
  2/         split into pieces of length 2
  f+         prepend 'T' to each piece
  ":T;"f+    append ":T;"to each piece
  _          duplicate the array (containing full A-command implementations)
  'Tf/       split each piece by the 'T' character
  'Uf*       join each split piece using the 'U' character
              practically replacing 'T' with 'U'
              to obtain B-command implementations
  +          concatenate the 2 arrays
  "…"        push a string containing implementations for "w" and "e", 
              separated by space; the string also ends with a space
  S/         split by space, obtaining the implementations for "w" and "e"
              and an empty string, for handling unrecognized characters
  ++         concatenate with the A and B command and +-*/ implementations
  =          get the corresponding string implementing the current command
              if the character was not found, -1 will get the empty string (no-op)
  ~          execute it
Pa/          split the array of results by the π separator
0=           get the first piece (before the first π, if any)

Le attuali implementazioni dei comandi (costruite dal programma):

+: X2+U|{TU+:V;}P?    if (1+2)|U != 0, set V=T+U, else push π
-: X2-U|{TU-:V;}P?    if (1-2)|U != 0, set V=T-U, else push π
*: X2*U|{TU*:V;}P?    if (1*2)|U != 0, set V=T*U, else push π
/: X2/U|{TU/:V;}P?    if (1/2)|U != 0, set V=T/U, else push π
d: T( :T;             set T=T-1
s: T_*:T;             set T=T*T
p: TT :T;             push T and set T=T (no-op)
P: TcT:T;             push T converted to character and set T=T (no-op)
>: T;V:T;             push and pop T (no-op) and set T=V
@: T;0:T;             push and pop T (no-op) and set T=0
i: T):T;              set T=T+1
k: U( :U;             set U=U-1
m: U_*:U;             set U=U*U
o: UU :U;             push U and set U=U (no-op)
O: UcU:U;             push U converted to character and set U=U (no-op)
<: U;V:U;             push and pop U (no-op) and set U=V
#: U;0:U;             push and pop U (no-op) and set U=0
a: U):U;              set U=U+1
w: VS                 push V and a space
e: 0:V;               set V=0
(default): (empty)    no-op

10

JavaScript (ES7) 208 213 223 237 241 311

Edit3 Copiandosi a vicenda, io e Dendrobium stiamo collassando insieme.

Edit2 Utilizzando EcmaScript 7 per salvare solo 2 byte, uniti insieme gestendo A e B.

modificare A seguito delle modifiche alle regole.

Nota, ho aggiunto il rcomando non richiesto nella domanda, solo per eseguire il vecchio esempio Hello world

V=p=>(o='',[for(c of'@#e'+p)eval('++x,--x,x*=x,x=R,x=0,o+=x,o+=String.fromCharCode(x),R=A+B,R=A-B,R=A*B,R=A/B|0,R=0,o+=R+` `'.replace(/x/g,(k='ids>@pP+-*/ewakm<#oO'.indexOf(c))<13?'A':'B').split`,`[k%13])],o)

// More readable
U=p=>(
  o='',
  [for(c of'@#e'+p)
   eval(
   '++x,--x,x*=x,x=R,x=0,o+=x,o+=String.fromCharCode(x),R=A+B,R=A-B,R=A*B,R=A/B|0,R=0,o+=R+` `'
   .replace(/x/g,(k='ids>@pP+-*/ewakm<#oO'.indexOf(c))<13?'A':'B')
   .split`,`[k%13])]
  ,o
)

// ES6, no array comprehension, 2 bytes more
W=p=>
  [...'@#e'+p].map(c=>
    eval(
    '++x,--x,x*=x,x=R,x=0,o+=x,o+=String.fromCharCode(x),R=A+B,R=A-B,R=A*B,R=A/B|0,R=0,o+=R+` `'
    .replace(/x/g,(k='ids>@pP+-*/ewakm<#oO'.indexOf(c))<13?'A':'B')
    .split`,`[k%13]),
    o=''
  )&&o

// Test
function test() 
{ 
  OUT.innerHTML = V(I.value) 
}

test()
textarea { width: 75%; height: 8em }
Test program <button onclick="test()">Run</button><br><textarea id=I>
iisssaa/>e
maa->e#
aamam->e#
dddddddddddddddddddddddddPiiiiiiiiiiiiiiiiiiiiiiiii
iiiiPiiiiiiiPPiiiP
@#e
iis
aamaaaa
*>P
@#e
iisssaa/>e
maa->e#
aamam->e#
iiiiiiiiiiiiiiiiiiiiiiP
ddddddddP
iiiP
ddddddP
ddddddddP
@#e
iiss
aa*>
iP
</textarea><br>Output<pre id=OUT></pre>


Si potrebbe risparmiare 2 byte rimuovendo A=B=R=0,e impostando le variabili utilizzando l'attuale 3var funzioni prima di elaborare la stringa, come: [...'@#e'+p].
insertusernamehere

2
@inserireusernamehere thx, lo adoro
edc65

8

GNU Sed (con opzione eval da valutare dc espressione), 254

Deadfish è mappato abbastanza bene su un sottoinsieme di dc. Quindi usiamo sed per fare quella mappatura:

s/^/@#e/
s/\+/AB+r/g
s/-/AB-r/g
s/\*/AB*r/g
s|/|AB/r|g
s/a/B1+b/g
s/i/A1+a/g
s/d/A1-a/g
s/s/Ad*a/g
s/p/An/g
s/P/AP/g
s/>/Ra/g
s/k/B1-b/g
s/m/Bd*b/g
s/o/Bn/g
s/O/BP/g
s/</Rb/g
s/w/Rn/g
s/@/0a/g
s/#/0b/g
s/e/0r/g
s/[ABR]/l&/g
s/[abr]/s\u&/g
s/.*/dc -e'&'/e

8

Javascript ES6 ES7, 217 215 213 208 byte

f=s=>(O='',[for(c of'@#e'+s)eval('v=0,++v,--v,v*=v,O+=v,O+=String.fromCharCode(v),v=R,R=0,R=A+B,R=A-B,R=A*B,R=A/B|0,O+=R+" "'.replace(/v/g,'AB'[(x='@idspP>e+-*/w#akmoO<'.indexOf(c))/13|0]).split`,`[x%13])],O)

Ungolfed

f=s=>(
    O='',                                                                   // initialize output to empty string
    [for(c of'@#e'+s)eval(                                                  // initialize A, B, and R, loop over all chars in input, eval returned function string
        'v=0,++v,--v,v*=v,O+=v,O+=String.fromCharCode(v),v=R,R=0,R=A+B,R=A-B,R=A*B,R=A/B|0,O+=R+" "' // operation list
            .replace(/v/g,'AB'[(x='@idspP>e+-*/w#akmoO<'.indexOf(c))/13|0]) // replace all instances of v with either A or B
            .split`,`[x%13])],                                              // split ops list, select corresponding function string
    O)                                                                      // return output string

1
+1 Non lontano dal mio, ma meglio. Ora dovrò provare qualcosa di diverso
edc65,

1
Si potrebbe risparmiare 2 byte rimuovendo A=B=R=0,e impostando le variabili utilizzando l'attuale 3var funzioni prima di elaborare la stringa, come: for(c of '@#e'+s).
insertusernamehere

1
@inserireusernamehere Aha, è abbastanza intelligente, grazie!
Dendrobium,

Revisionando la tua risposta, vedo che non hai w
creato

@ edc65 Uno dei proiettili di chiarimento afferma che "'w' dovrebbe generare uno spazio o una nuova riga dopo R"
Dendrobium,

6

APL, 191

{0::→⋄A B R←0⋄{⍵∊G←'aikdms<>':⍎'AB'[1+2|G⍳⍵],'+-*∘'[M],'←','112R'[M←⌈2÷⍨G⍳⍵]⋄⍵∊G←'PpOo':⍞←⎕UCS⍣(2|G⍳⍵)⊢A B[⌈2÷⍨G⍳⍵]⋄⍵∊G←'+-*/':R∘←⌊A(⍎'+-×÷'[G⍳⍵])B⋄⍵∊G←'@#e':⍎'ABR'[G⍳⍵],'∘←0'⋄⍵='w':⍞←R}¨⍵}

Questa è una funzione che prende il programma come argomento, ad esempio:

      ∆3var←{0::→⋄A B R←0⋄{⍵∊G←'aikdms<>':⍎'AB'[1+2|G⍳⍵],'+-*∘'[M],'←','112R'[M←⌈2÷⍨G⍳⍵]⋄⍵∊G←'PpOo':⍞←⎕UCS⍣(2|G⍳⍵)⊢A B[⌈2÷⍨G⍳⍵]⋄⍵∊G←'+-*/':R∘←⌊A(⍎'+-×÷'[G⍳⍵])B⋄⍵∊G←'@#e':⍎'ABR'[G⍳⍵],'∘←0'⋄⍵='w':⍞←R}¨⍵}
      ∆3var 'iipois+iis<-<aaaO<OkOOkkkkOP@#iippisa+<m+>PaO'
20spooky22me

Può essere usato come una funzione anonima, ho appena dato un nome per chiarezza.

Spiegazione:

  • 0::→: se si verifica un errore (ad esempio, divisione per zero), interrompere senza stampare il messaggio di errore
  • A B R←0: inizializza le variabili
  • {... }¨⍵: per ogni comando:

    • ⍵∊G←'aikdms<>': Se il comando è di tipo var ← fn (var, x) , trova i fn e x corretti , sostituiscili e valutali:
      • : valutare
      • 'AB'[1+2|G⍳⍵: Ase la posizione di in 'aikdms<>'è pari, Baltrimenti.
      • '+-*∘'[M]: aggiungi, sottrai, potenza o niente, a seconda di M(definito in seguito)
      • '←': assegnare
      • '112R'[M←⌈2÷⍨G⍳⍵]: 1(per l'aggiunta e la sottrazione), 2(per la potenza) e R(per niente, ovvero imposta semplicemente la variabile su R), a seconda del Mfatto che il comando appartiene alla prima, seconda, terza o quarta coppia.
    • ⍵∊G←'PpOo': produzione:
      • ⍞←: produzione
      • ⎕UCS⍣(2|G⍳⍵): ASCII (bene, Unicode) o numero a seconda che il comando fosse in una posizione pari o dispari PpOo,
      • ⊢A B[⌈2÷⍨G⍳⍵]: Aoppure B, a seconda che il comando fosse nella prima o nella seconda metà.
    • ⍵∊G←'+-*/: matematica:
      • R∘←⌊A(⍎'+-×÷'[G⍳⍵])B: impostato Rsul risultato dell'applicazione dell'operatore dato a Ae B.
    • ⍵∊G←'@#e': reset:

      • : valutare
      • 'ABR'[G⍳⍵]: seleziona la variabile giusta
      • '∘←0': impostato su zero
    • ⍵='w':⍞←R: se il comando è w, output R.


4

C, 253 241 byte

#define _ c--?c--?c--
k="id@s>ak#m<e+-*/wpoPO",*p;main(c,a,b,r){for(a=b=r=0;~c;c=getchar())c=strchr(k,c),c&&(c-=k,p=&a+c/5,*p=_?_?_?_?_?printf(c?c<3?"%d":"%c":"%d ",c?c%2?a:b:r):a/(b?b:exit()):a*b:a-b:a+b:0:r:b*b:0:b-1:b+1:r:a*a:0:a-1:a+1);}

Questo codice utilizza la stringa id@s>ak#m<e+-*/wpoPOcome una tabella di comandi. La stringa è organizzata in base alla destinazione dell'espressione calcolata. Accade semplicemente che ci sono 5 comandi che aggiornano ciascuna delle variabili:

  • id@s> - aggiornare a
  • ak#m< - aggiornare b
  • e+-*/ - aggiornare r
  • wpoPO- aggiorna ... la posizione della memoria dopo a, be r. Spero non sia troppo importante :)

Quindi, dopo aver localizzato il carattere di input nella stringa di comandi, il suo indice viene ripetutamente diminuito e, a seconda di quando raggiunge 0, viene scelta un'espressione.

Se non raggiunge 0 dopo 15 sottrazioni, è a printf con alcuni argomenti scelti correttamente.

Inoltre, durante la divisione, evita la divisione per 0 chiamando exit() .

Questo codice deve essere compilato senza ottimizzazioni, perché presuppone che a, ber si trovano su indirizzi adiacenti nello stack (non nei registri della CPU).

Inoltre, dovrebbe essere compilato in modalità a 32 bit, perché converte i puntatori in numeri interi e viceversa.


4

VBA, 484, 453 380 byte

Troppo desiderare di vincere, ma un modo super semplice di fare le cose, niente di fantasia, solo un bel vecchio Select Case

Aggiunta nella divisione Integer e Div 0 Gestione degli errori Abbiamo mangiato molti byte
Rimossi La gestione degli errori in quanto sembra che la normale gestione degli errori produca la stessa funzionalità. Risolto il problema con la divisione Int per funzionare come previsto. Era anche più breve.

Function Y(x)
For Z=1 To Len(x)
w=Mid(x,Z,1)
Select Case w
Case"i":A=A+1
Case"d":A=A-1
Case"s":A=A^2
Case"p":Y=Y &A
Case"P":Y=Y &Chr(A)
Case">":A=R
Case"a":B=B+1
Case"k":B=B-1
Case"m":B=B^2
Case"o":Y=Y &B
Case"O":Y=Y &Chr(B)
Case"<":B=R
Case"+":R=A+B
Case"-":R=A-B
Case"*":R=A*B
Case"/":R=A\B
Case"w":Y=Y &R &vbCrLf
Case"@":A=0
Case"#":B=0
Case"e":R=0
End Select
Next
End Function

Grazie a Henrik Ilgen per aver salvato 31 104 byte


2
Non del tutto sicuro se questo funziona in VBA (lo fa in VB6), ma si potrebbe risparmiare un mucchio di byte utilizzando DefInt A-Z, omettendo in tal modo la necessità di dichiarare in modo esplicito A, Be Rcome Integer: DefInt A-Z:Dim A, B, R. Si potrebbe anche lavorare per assegnarle solo, senza dichiarazione: A=0:B=0:R=0. I calcoli dovrebbero funzionare anche sulle varianti.
Henrik Ilgen,

@HenrikIlgen grazie mille, DefIntho dimenticato Not Something che uso tutti i giorni ma in futuro diventerò super utile per giocare a golf VBA. Sfortunatamente A=0lo farò sembrare un doppio dai miei test. Lì per fare iiiaa/wprodurre un risultato decimale piuttosto che un intero.
JimmyJazzx,

1
Prova \ per la divisione dei numeri interi;)
Henrik Ilgen

1
Puoi condensarlo fino a 405 byte se lo rendi una funzione e usi il valore restituito per "costruire" il risultato, supponendo che non devi effettivamente stampare il risultato :)
Henrik Ilgen

3

PHP, 310 byte

Prima volta nella mia vita usando eval:

for($A=$B=$R=0;$c=$argv[1][$i++];)eval([i=>'++$A',d=>'--$A',s=>'$A*=$A',p=>'echo$A',P=>'echo chr($A)','>'=>'$A=$R',a=>'++$B',k=>'--$B',m=>'$B*=$B',o=>'echo$B',O=>'echo chr($B)','<'=>'$B=$R','+'=>'$R=$A+$B','-'=>'$R=$A-$B','*'=>'$R=$A*$B','/'=>'$R=$A/$B',w=>'echo$R','@'=>'$A=0','#'=>'$B=0',e=>'$R=0'][$c].';');

Accetta il primo input da riga di comando:

php 3var.php "iipois+iis<-<aaaO<OkOOkkkkOP@#iippisa+<m+>PaO"

Output dagli esempi:

Ciao mondo!
20spooky22me


3

C, 357

Macro FTW!

(Chi sto prendendo in giro - c non vincerà mai questo)

#define X(p,e) case p:e;break;
#define Y(p,a,b,c,d,e,f) X(a,p++)X(b,p--)X(c,p*=p)X(d,printf("%d",p))X(e,printf("%c",p%256))X(f,p=R)
A,B,R;main(int C,char**V){for(;*V[1];)switch(*V[1]++){Y(A,'i','d','s','p','P','>')Y(B,'a','k','m','o','O','<')X('+',R=A+B)X('-',R=A-B)X('*',R=A*B)X('/',R=A/(B?B:exit(0),1))X('w',printf("%d",R))X('@',A=0)X('#',B=0)X('e',R=0)}}

2

JavaScript (ES6), 293 262 byte

f=x=>(o="",a=b=r=0,p=String.fromCharCode,[...x].map(c=>{if(eval(`m={i_a++,d_a--,s_a*=a,p_o+=a,P_o+=p(a),">"_a=r,a_b++,k_b--,m_b*=b,o_o+=b,O_o+=p(b),"<"_b=r,"+"_r=a+b,"-"_r=a-b,"*"_r=a*b,"/"_r=a/b|0,w_o+=r,"@"_a=0,"#"_b=0,e_r=0}[c]`.replace(/_/g,":_=>")))m()}),o)

uso

f(`iisssaa/>e
maa->e#
aamam->e#
dddddddddddddddddddddddddPiiiiiiiiiiiiiiiiiiiiiiiii
iiiiPiiiiiiiPPiiiP
@#e
iis
aamaaaa
*>P
@#e
iisssaa/>e
maa->e#
aamam->e#
iiiiiiiiiiiiiiiiiiiiiiP
ddddddddP
iiiP
ddddddP
ddddddddP
@#e
iiss
aa*>
iP`)

=> "Hello world!"

Spiegazione

Ci sono alcuni dettagli del linguaggio di cui non sono sicuro (dimensioni intere, gestione di caratteri non riconosciuti, ecc.) Ma questa soluzione sembra funzionare in modo sufficiente e ignora i caratteri di spazi bianchi come le nuove righe nel caso di test.

f=x=>(
  o="",                           // o = output string
  a=b=r=0,
  p=String.fromCharCode,
  [...x].map(c=>{                 // iterate through each character
    if(                           // if used for NOP characters (whitespace)

      // Functions:
      eval(`m={
        i_a++,
        d_a--,
        s_a*=a,
        p_o+=a,
        P_o+=p(a),
        ">"_a=r,
        a_b++,
        k_b--,
        m_b*=b,
        o_o+=b,
        O_o+=p(b),
        "<"_b=r,
        "+"_r=a+b,
        "-"_r=a-b,
        "*"_r=a*b,
        "/"_r=a/b|0,
        w_o+=r,
        "@"_a=0,
        "#"_b=0,
        e_r=0
      }[c]`.replace(/_/g,":_=>")) // dynamically add common characters

    )m()                          // execute the function
  }),
  o                               // return the output string
)

1
Penso che potresti salvare qualche byte racchiudendo il dizionario in un eval mentre lo sostituisci :$=>con $, quindi aggiungendo un sostituto per la stringa.
Conor O'Brien,

2

Simplex v.0.8 , 211 byte

(Codificato UTF-8.)

h@u]u2ƒ§I]ƒ§M]ƒ§^O]ƒ§o]ƒ§s]ƒ§@]ƒ§Ah]ƒ§Sh]ƒ§Mh]ƒ§Vh]ƒ§&oh]ƒðI]ƒðM]ƒð^O]ƒðo]ƒðs]ƒð@]ƒðAh]ƒðSh]ƒðMh]ƒðVh]ƒð&oh]ƒ§z]ƒðz]ƒuz@]{"idspP>akmoO<+-*/w@#e"RlyG^u·u†vøÏ}

Spiegazione

Dal momento che questo è il più lungo programma simplex che ho scritto finora, in genere spiegherò come funziona in punti elenco.

  • h@u] - definisce la macro 0. Questa macro scrive semplicemente nel registro e non restituisce nulla a lambda.
  • u2- passa alla striscia precedente e imposta il byte corrente su 2; questo definisce l'arità degli lambda da definire.
  • ƒ- inizia l'espressione lambda; una volta completato da] , spingerà la funzione lambda nello stack lambda. Agisce prendendo le celle (arity) dal puntatore nella sua striscia locale e, dopo il completamento, imposterà la sua striscia locale sulle celle prese, a meno che il byte corrente non sia non scritto. Il puntatore non è interessato. La macro 0 consente di restituire una funzione senza modificare nulla nella striscia.
  • § - passa alla prima cella scritta nella striscia corrente, ad es A .
  • ð - passa all'ultima cella scritta nella striscia corrente, ad es B .
  • ... {"idspP>akmoO<+-*/w@#e"RlyG^u·u†vøÏ}
    • {...Ï} ripetere fino a quando lo stack di input è vuoto
    • "idspP>akmoO<+-*/w@#e" - i comandi
    • Rly - metti la striscia in una tupla
    • G^u - l'indice dell'input nella tupla
    • ·- carica il byte corrente th nel valutatore lambda
    • uRL- va alla striscia tenendo Ae B(scrive AeB se non esistono)
    • - esegue lambda (questo è il valutatore lambda)
    • - ripristina sotto la striscia

ma sono impressionato. È lungo per Simplex, ma è corto per tutto il resto.;)


2

Minkolang 0,11 , 222 byte

Sono sicuro che questo può essere ulteriormente giocato a golf, ma è stato divertente. Inoltre, primo interprete Minkolang di un'altra lingua!

>I3&000V$Vod?.45*[di1q=5&]x00wx1i2+kw
idspP>akmoO<+-*/w@#e
vr1+r
vr1-r
vr2;r
v0c1$((dl%"0"+$rl:d)$Ok
v0cO
vrx0cr
v1g1+1G
v1g1-1G
v1g2;1G
v1c1$((dl%"0"+$rl:d)$Ok
v1cO
v1gxd1G
vx$d+
vx$d-
vx$d*
vx$dd?.:
vdN
vrx0r
v1gx01G
vx0

Provalo qui.

Spiegazione

>I3&000                    Initializes A, B, and R if they don't already exist.
V$V                        An idiom that ensures no time-travel.
od?.                       Reads in a character and halts if input is empty.
45*[di1q=5&]               Looks through the second row for a matching character.
            x00w           Jumps back to beginning if no match.
                x1i2+kw    Jumps to corresponding line upon match.

Il resto delle linee è piuttosto semplice, forse con l'eccezione di quelle con 1$((dl%"0"+$rl:d)$Ok, che è un linguaggio che stampa un numero senza uno spazio finale. (Non ho ancora implementato la funzionalità convert-this-number-in-a-string, che sarà 1Z.) Oh, sì, hanno tutti un vall'inizio, che lo riporta all'inizio.


2

GNU Sed (con opzione eval per valutare l'espressione cc), 289

Ispirato da Digital Trauma che purtroppo non è riuscito a rendersi conto che a) i personaggi illegali devono essere ignorati, b) dc ha bisogno dell'intero programma convertito in un argomento ec) la divisione per 0 deve terminare il programma senza errori.

Se tutte queste regole non fossero applicabili, la mia soluzione sarebbe lunga solo 235 byte;)

H
$!d
x
s/^/@#e/
s:[^-a><de/+i*k@w#opsmOP]::g
s:[e@#]:0&:g
s:[-*+/pPid]:Q&:g
s:[-kaoO*+/]:H&:g
s:[><w]:Z&:g
s:[diak]:1&:g
s:s:Q2^>:g
s:m:H2^<:g
s:[-+*/]:&e:g
s:[ia]:+&:g
s:[dk]:-&:g
y:Oop:Pnn:
s:w:n32P:g
s:[id>@]:sq:g
s:e:sz:g
s:[#<ka]:sh:g
s:[QHZ]:l\l&:g
s:/:d0=t/:g
s/.*/dc -e'[q]st&'/e

2

AWK, 311 309

func p(z,f,x){if(c~z)printf"%"f,x}BEGIN{FS=z}{for(i=0;++i<=NF;){c=$i;A=c~/i/?A+1:c~/d/?A-1:c~/s/?A*A:c~/@/?0:c~/>/?R:A;p("p","d",A);p("P","c",A);B=c~/a/?B+1:c~/k/?B-1:c~/m/?B*B:c~/#/?0:c~/</?R:B;p("o","d",B);p("O","c",B);R=c~/+/?A+B:c~/-/?A-B:c~/*/?A*B:c~/e/?0:R;if(c~"/")if(B)R=A/B;else exit;p("w","d ",R)}}

Le parentesi TIL non erano necessarie intorno a printf. 2 byte salvati!

Versione non golfata per una lettura più semplice:

func p(z,f,x) {
    if(c~z) printf "%"f,x
}

BEGIN {
    FS=z
}

{
    for(i=0;++i<=NF;){
        c=$i;
        A=c~/i/?A+1:c~/d/?A-1:c~/s/?A*A:c~/@/?0:c~/>/?R:A;
        p("p","d",A);
        p("P","c",A);
        B=c~/a/?B+1:c~/k/?B-1:c~/m/?B*B:c~/#/?0:c~/</?R:B;
        p("o","d",B);
        p("O","c",B);
        R=c~/+/?A+B:c~/-/?A-B:c~/*/?A*B:c~/e/?0:R;
        if(c~"/")if(B)R=A/B;else exit;
        p("w","d ",R)
    }
}

1

Python 2, 272

import sys;a,b,r=0,0,0;exec';'.join(filter(None,map(dict(x.split(':')for x in"a:b+=1|@:a=0|#:b=0|/:r=a/b|d:a-=1|PXchr(a)|i:a+=1|-:r=a-b|k:b-=1|*:r=a*b|m:b*=b|oXb|pXa|s:a*=a|OXchr(b)|wXr|+:r=a+b|e:r=0|<:b=r|>:a=r".replace('X',':print ').split('|')).get,sys.stdin.read())))

Questo non funziona Le tue printdichiarazioni includono una nuova riga finale.
Griffin,

1

Rubino, 199 byte

a=b=r=0
$<.read.chars{|c|eval %w{a+=1
a-=1
a*=a
$><<a
$><<a.chr
a=r
b+=1
b-=1
b*=b
$><<b
$><<b.chr
b=r
r=a+b
r=a-b
r=a*b
b==0&&exit||r=a/b
puts\ r
a=0
b=0
r=0
p}["idspP>akmoO<+-*/w@#e".index(c)||-1]}

È possibile salvare 5 byte rimuovendo .readdalla seconda riga se è possibile tollerare la stampa di un avviso su stderr nella versione più recente di Ruby.


1

Python, 244

import sys;P=sys.stdout.write;A=B=R=0;exec';'.join(filter(None,map(dict(zip('idspP>akmoO<+-*/w@#e','A+=1 A-=1 A**=2 P(`A`) P(chr(A)) A=R B+=1 B-=1 B**=2 P(`B`) P(chr(B)) B=R R=A+B R=A-B R=A*B R=A/B print(R) A=0 B=0 R=0'.split())).get,input())))

Un po 'tardi ma volevo provare.


1

Prolog, 759 byte

Non è il programma più breve, ma almeno è strutturato e leggibile.

q(A,B,R,i,X,B,R):-X is A+1.
q(A,B,R,d,X,B,R):-X is A-1.
q(A,B,R,s,X,B,R):-X is A*A.
q(_,B,R,>,R,B,R).
q(A,B,R,a,A,X,R):-X is B+1.
q(A,B,R,k,A,X,R):-X is B-1.
q(A,B,R,m,A,X,R):-X is B*B.
q(A,_,R,<,A,R,R).
q(A,B,_,+,A,B,X):-X is A+B.
q(A,B,_,-,A,B,X):-X is A-B.
q(A,B,_,*,A,B,X):-X is A*B.
q(_,0,_,/,_,_,_):-!,1=2.
q(A,B,_,/,A,B,X):-B>0,X is A/B.
q(_,B,R,@,0,B,R).
q(A,_,R,#,A,0,R).
q(A,B,_,e,A,B,0).
q(A,B,R,p,A,B,R):-write(A).
q(A,B,R,'P',A,B,R):-A>0,format('~c',A).
q(A,B,R,'P',A,B,R):-write(A).
q(A,B,R,o,A,B,R):-write(B).
q(A,B,R,'O',A,B,R):-format('~c',B).
q(A,B,R,'O',A,B,R):-write(B).
q(A,B,R,w,A,B,R):-write(R),nl.
q(A,B,R,_,A,B,R).
f([],_,_,_).
f([H|T],A,B,R):-q(A,B,R,H,X,Y,Z),f(T,X,Y,Z),!.
p(X):-atom_chars(X,Y),f(Y,0,0,0).

Esempio di input

p('iipois+iis<-<aaaO<OkOOkkkkOP@#iippisa+<m+>PaO').

Provalo online qui

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.