3var ist eine Variante von Deadfish, die drei Variablen namens A, B und R verwendet. A und B sind Akkumulatoren, während R als Ergebnisvariable verwendet wird.

In diesem Code-Golf- Herausforderung müssen Sie einen Interpreter für eine abgespeckte Version dieser Sprache erstellen .

Erforderliche Befehle:

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

Alles andere (einschließlich Leerzeichen) wird ignoriert.

Klarstellungen

• o und p sollte ohne irgendetwas danach ausgeben.
• Division ist eine Ganzzahldivision.
• Nummern über 255 und Nummern unter 0 werden unterstützt.
• 'w' sollte nach R ein Leerzeichen oder eine neue Zeile ausgeben
• Division durch 0 stoppt ohne Fehler. (Keine Ausgabe nach STDERR)
• A, B und R sind anfänglich 0

Regeln

• Das ist Code-Golf, also gewinnt die kürzeste Antwort.
• Bei einem Gleichstand gewinnt die älteste Antwort.
• Die Datei wird über Befehlszeilenargumente oder STDIN bereitgestellt.
• Jede Sprache ist erlaubt.
• Eval ist erlaubt.

Testfälle

Hello world! (aus 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

Ausgänge 20spooky22me:

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

Ausgänge 9P-1420 100 3Q-1 162 0:

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

Bestenlisten

Hier ist ein Stapel Snippet sowohl eine regelmäßige Rangliste und einen Überblick über die Gewinner von Sprache zu erzeugen.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

# [><>](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>

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=

Probieren Sie es online aus

Erläuterung:

Das Programm baut eine Reihe von Codestücken ausgeführt werden, und führt das entsprechende Stück für jedes Zeichen. Der Umgang mit der Division durch Null ist schwieriger, weil CJam noch keinen „Bruch“ Operator hat. Stattdessen & pgr das Programm Schub als Marker (da keine Gleitkommazahl kann anders erscheinen), und am Ende hält es nur die Ausgabe vor dem ersten π.
Das Programm verwendet außerdem die Variablen T, U und V anstelle von A, B und R, da diese in CJam mit 0 vorinitialisiert sind.

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)

Die tatsächlichen Befehlsimplementierungen (vom Programm erstellt):

+: 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

JavaScript (ES7) 208 213 223 237 241 311

Edit3 sie kopieren, ich und Dendrobium kollabieren zusammen.

Edit2 Mit EcmaScript 7 nur 2 Bytes zu speichern, miteinander verbunden und eine Handhabungs B

Bearbeiten Folgen Sie den Änderungen der Regeln.

Beachten Sie, dass ich den rBefehl hinzugefügt habe, der in der Frage nicht benötigt wird, nur um das alte Beispiel Hello World auszuführen

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>

GNU Sed (mit Evaluierungsoption) dc Ausdrucks), 254

Deadfish ordnet eine Untermenge von ziemlich gut zu dc. Also verwenden wir sed, um dieses Mapping durchzuführen:

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

Javascript ES6 ES7, 217 215 213 208 Bytes

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

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}¨⍵}

Dies ist eine Funktion, die das Programm als Argument verwendet, zB:

      ∆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

Es kann als anonyme Funktion verwendet werden, ich habe es nur der Klarheit halber benannt.

Erläuterung:

• 0::→: Wenn ein Fehler auftritt (z. B. Division durch Null), halten Sie an, ohne die Fehlermeldung zu drucken
• A B R←0: Variablen initialisieren

• {... }¨⍵: für jeden Befehl:

  • ⍵∊G←'aikdms<>': Wenn der Befehl vom Typ var ← fn (var, x) ist , finden Sie die richtigen fn und x , ersetzen Sie sie in und werten Sie sie dann aus:
    • ⍎: bewerten
    • 'AB'[1+2|G⍳⍵: Awenn die Position von ⍵in gerade 'aikdms<>'ist, Bsonst.
    • '+-*∘'[M]: addiere, subtrahiere, macht oder nichts, abhängig von M(später definiert)
    • '←': zuweisen
    • '112R'[M←⌈2÷⍨G⍳⍵]: 1(zum Addieren und Subtrahieren), 2(für Potenz) und R(für nichts, dh es setzt nur die Variable auf R), abhängig vonM , ob der Befehl zum ersten, zweiten, dritten oder vierten Paar gehört.
  • ⍵∊G←'PpOo': Ausgabe:
    • ⍞←: Ausgabe
    • ⎕UCS⍣(2|G⍳⍵): ASCII (naja, Unicode) oder Zahl, je nachdem, ob der Befehl an einer ungeraden oder geraden Position war PpOo ,
    • ⊢A B[⌈2÷⍨G⍳⍵]: Aoder B, abhängig davon, ob der Befehl in der ersten oder zweiten Hälfte war.
  • ⍵∊G←'+-*/: Mathematik:
    • R∘←⌊A(⍎'+-×÷'[G⍳⍵])B: Auf Rdas Ergebnis der Anwendung des angegebenen Operators auf Aund setzen B.

  • ⍵∊G←'@#e': zurücksetzen:

    • ⍎: bewerten
    • 'ABR'[G⍳⍵]: Wählen Sie die richtige Variable
    • '∘←0': auf null gesetzt

  • ⍵='w':⍞←R: Wenn der Befehl ist w, Ausgabe R.

C 253 241 Bytes

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

Dieser Code verwendet die Zeichenfolge id@s>ak#m<e+-*/wpoPOals Befehlstabelle. Die Zeichenfolge ist entsprechend dem Ziel des berechneten Ausdrucks angeordnet. Es kommt einfach so vor, dass es 5 Befehle gibt, die jede der Variablen aktualisieren:

• id@s> - aktualisieren a
• ak#m< - aktualisieren b
• e+-*/ - aktualisieren r
• wpoPO- aktualisieren ... den Speicherort nach a, bund r. Ich hoffe es ist nicht zu wichtig :)

Nachdem das eingegebene Zeichen in der Befehlsfolge gefunden wurde, wird sein Index wiederholt verringert, und je nachdem, wann es 0 erreicht, wird ein Ausdruck ausgewählt.

Wenn es nach 15 Subtraktionen nicht 0 erreicht, ist es a printf mit einigen richtig gewählten Argumenten.

Außerdem wird beim Teilen die Division durch 0 durch Aufrufen vermieden exit().

Dieser Code sollte ohne Optimierungen kompiliert werden, da dies vorausgesetzt awird bund er rsich an benachbarten Adressen im Stapel befindet (nicht in CPU-Registern).

Außerdem sollte es im 32-Bit-Modus kompiliert werden, da es Zeiger in Ganzzahlen konvertiert und umgekehrt.

VBA, 484, 453, 380 Bytes

Zu lange, um zu gewinnen, aber eine super einfache Art, Dinge zu tun, nichts Besonderes, nur gut alt Select Case

Hinzufügen von Integer Division und Div 0
Fehlerbehandlung hat eine Menge Bytes verbraucht Fehlerbehandlung wurde entfernt, da es so aussieht, als würde die normale Fehlerbehandlung dieselbe Funktionalität zur Folge haben. Problem, bei dem Int Division wie erwartet funktionierte - gefixt War auch kürzer.

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

Vielen Dank an Henrik Ilgen für die Einsparung von 31 104 Bytes

PHP, 310 Bytes

Zum ersten Mal in meinem Leben mit 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].';');

Übernimmt die erste Befehlszeileneingabe:

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

Ausgabe aus den Beispielen:

Hallo Welt!
20spooky22me

C 357

Makros FTW!

_{(Wen ich veräpple - c wird dieses nie gewinnen)}

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

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)

Verwendung

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!"

Erläuterung

Es gibt einige Details der Sprache, bei denen ich mir nicht sicher bin (Ganzzahlgrößen, Umgang mit nicht erkannten Zeichen usw.), aber diese Lösung scheint ausreichend zu funktionieren und ignoriert Leerzeichen wie die Zeilenumbrüche im Testfall.

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
)

Simplex v.0.8 , 211 Bytes

^{(UTF-8-codiert.)}

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øÏ}

Erläuterung

Da dies die längste ist Simplex-Programm ist, das ich bisher geschrieben habe, werde ich im Allgemeinen anhand von Stichpunkten erklären, wie dies funktioniert.

• h@u] - definiert Makro 0. Dieses Makro schreibt einfach in das Register und lässt ein Lambda nichts zurückgeben.
• u2- geht zum obigen Strip und setzt das aktuelle Byte auf 2; Dies definiert die Arität der zu definierenden Lambdas.
• ƒ- Lambda-Ausdruck beginnen; einmal abgeschlossen durch] , wird die Lambda-Funktion auf den Lambda-Stack übertragen. Es nimmt (Aritäts-) Zellen aus dem Zeiger in seinen lokalen Streifen und setzt nach Abschluss seinen lokalen Streifen auf die entnommenen Zellen, es sei denn, das aktuelle Byte ist nicht geschrieben. Der Zeiger ist nicht betroffen. Makro 0 ermöglicht, dass eine Funktion zurückkehrt, ohne irgendetwas in dem Streifen zu ändern.
• § - bewegt sich zur ersten geschriebenen Zelle im aktuellen Streifen, d. h A . .
• ð- bewegt sich zur letzten geschriebenen Zelle im aktuellen Streifen, d B. h .
• … {"idspP>akmoO<+-*/w@#e"RlyG^u·u†vøÏ}
  • {...Ï} Wiederholen, bis der Eingabestapel leer ist
  • "idspP>akmoO<+-*/w@#e" - die Befehle
  • Rly - Legen Sie den Streifen in ein Tupel
  • G^u - der Index der Eingabe im Tupel
  • ·- die aktuelle Byte lädt ^th in den Lambda - Auswerter
  • uRL- geht zum Strip Aund hält B(schreibt Aund Bwenn sie nicht existieren)
  • † - führt Lambda aus (dies ist der Lambda-Evaluator)
  • vø - Wird unter dem Streifen zurückgesetzt

Puh, ich bin beeindruckt. Es ist lang für Simplex, aber kurz für alles andere.;)

Minkolang 0,11 , 222 Bytes

Ich bin mir sicher, dass man hier weiter Golf spielen kann, aber es hat Spaß gemacht. Außerdem erster Minkolang-Dolmetscher einer anderen Sprache!

>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

Probieren Sie es hier aus.

Erläuterung

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

Der Rest der Zeilen ist ziemlich einfach, vielleicht mit Ausnahme von denen mit 1$((dl%"0"+$rl:d)$Ok, was eine Redewendung ist, die eine Zahl ohne nachfolgendes Leerzeichen ausgibt. (Ich habe die Funktion zum Konvertieren dieser Zahl in eine Zeichenfolge noch nicht implementiert 1Z.) Oh, ja, sie haben alle eine vam Anfang, die sie zum Anfang zurückführt.

GNU Sed (mit Eval-Option zur Bewertung des DC-Ausdrucks), 289

Inspiriert von Digital Trauma, das leider nicht erkannt hat, dass a) unzulässige Zeichen ignoriert werden müssen, b) DC das gesamte konvertierte Programm in einem Argument benötigt und c) die Division durch 0 das Programm ohne Fehler beenden muss.

Wenn all diese Regeln nicht zutreffen würden, wäre meine Lösung nur 235 Bytes lang;)

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

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

TIL-Klammern wurden um printf nicht benötigt. 2 Bytes gespeichert!

Ungolfed-Version zum leichteren Lesen:

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

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

Ruby, 199 Bytes

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

Durch Entfernen .readaus der zweiten Zeile können 5 Bytes gespart werden, wenn Sie eine Warnung tolerieren, die in einer neueren Version von Ruby an stderr ausgegeben wird.

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

Etwas spät, aber ich wollte es versuchen.

Prolog, 759 Bytes

Nicht das kürzeste Programm, aber zumindest strukturiert und lesbar.

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

Beispiel Eingabe

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

Probieren Sie es hier online aus