RLE Brainfuck

(bezogen auf BF-RLE )

Die hypothetische RLE ( - Dialekt Run-Length Encoding ) von Brainfuck akzeptiert die Symbole für die 8 Befehle und auch Ziffern. Die Ziffern werden verwendet, um die Anzahl der aufeinanderfolgenden Wiederholungen eines Befehls darzustellen, wodurch eine Codierung des Quellcodes über die gesamte Laufzeit ermöglicht wird.

8> entspricht >>>>>>>> .

Die Länge steht immer auf der linken Seite des Befehls.

Ihre Aufgabe ist es, das kürzeste Programm / die kürzeste Funktion zu schreiben, die die Eingabezeichenfolge (RLE-Brainfuck-Fragment) in ein reguläres Brainfuck-Programm übersetzt.

Beispielsweise:

Eingang:

10+[>+>3+>7+>10+4<-]3>2+.>+.7+2.3+.2<2+.>15+.>.3+.6-.8-.2<+.<.

Ausgang:

++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++.>+.+++++++..+++.<<++.>+++++++++++++++.>.+++.------.--------.<<+.<.

Der kürzeste Byte-Code in jeder Sprache gewinnt.

Python 2 , 62 61 Bytes

lambda s:eval(re.sub('(\d*)(.)',r'+1*\1*1*"\2"',s))
import re

Probieren Sie es online!

Die Regex-Ersetzung wird 3<2+-in die Zeichenfolge erweitert:

+1*3*1*"<"+1*2*1*"+"+1**1*"-"

das ist dann evaled. (Beachten Sie, wenn \1leer ist, erhalten wir 1**1 = 1.) Der erste +ist ein unärer Operator, der an die erste Zahl bindet, und die anderen +s sind Zeichenfolgenverkettung. Dies schlägt umso offensichtlicher

lambda s:re.sub('(\d+)(.)',lambda m:int(m.group(1))*m.group(2),s)
import re

um 14 Bytes. Normalerweise "\2"würde das nicht immer funktionieren, aber zum Glück \und "ohne Brainfuck-Befehle.

xnor speicherte ein Byte und lieferte den 1*\1*1Trick. Zuvor hatte ich \1Lin der Regex und L=1als Lambda-Argument definiert, was auch ziemlich cool ist: 3LIst ein langes Int-Literal und List eine Variable.

Pyth , 2 Bytes

r9

Probieren Sie es hier aus!

Wie es funktioniert

r9 - Vollständiges Programm, das den String von STDIN empfängt.

r - Pyths Satz erweiterter String-Operationen.
 9 - Der neunte Befehl dieses Satzes (Lauflängendecodierung). Dies unterstützt mehrstellige Nummern.

Lua, 65 64 63 Bytes

Groß ! Ausnahmsweise schlägt Lua Python!

Bearbeiten: Ein Byte dank @Jarhmander gespeichert, dank ihm für den nützlichen Trick, ein einzelnes Ergebnis zu erzwingen

print(((...):gsub("(%d+)(.)",function(a,b)return b:rep(a)end)))

Probieren Sie es online!

Erklärungen

print)((...):gsub(             -- iterate over the argument and replace the strings
            "(%d+)(.)",       -- matching this pattern (at least one digit and a non-digit)
            function(a,b)     -- capture the digit and non-digit parts in separate variables
              return b:rep(a) -- repeat the non-digit a times, a being the digit part
            end)))                    

Scala , 73 69 Bytes

"(\\d+)(.)".r.replaceSomeIn(_:String,m=>Some("$2"*m.group(1).toInt))

Probieren Sie es online!

Perl 5 , 18 Bytes

17 Byte Code + 1 für -p.

s/\d+(.)/$1x$&/ge

Probieren Sie es online!

vim, 29 25 23 22 16 Bytes

:s/\D/a&<C-v><ESC>/g
D@"

<C-V>ist 0x16, <ESC>ist 0x1b.

Dabei wird jede Ziffer, die keine Ziffer ist, durch einen Befehl ersetzt, der dieses Zeichen an den Puffer anfügt. Die Zählungen bleiben allein und ändern diese Befehle. Zu diesem Zeitpunkt ist der Puffer ein Vimscript-Programm, das das gewünschte Brainfuck-Programm erzeugt. Daher ziehen wir es in ein Register und führen es aus.

Probieren Sie es online!

Edit: Size reductions thanks to suggestions: H.PWiz: 5, TheFamilyFroot: 5, DJMcMayhem: 1

RLE Brainfuck, 204 Bytes

-3>,[[->+>+<<]>>47-3<10+<->[-<+4>->+<[>-]>[3<+<[-]4>->]5<]3>57+[-]+<<[>>-<<[3>+3<-]]3>[3<+3>-]<[>>+7<+[->11-<+[-<+]->>+[-<[->10+<]>>+]<[-4>.4<]4>[-]-3<-<+7>-7<[8>+8<-]]8>[8<+8>-]<[3<.3<[-]-6>-]7<--5>-]<,]

Soweit ich weiß, sind die Spezifikationen für die Brainfuck-Umgebung nicht besonders gut definiert. Dieses Programm geht davon aus, dass die Zellen im Band beliebig große positive und negative ganze Zahlen ohne Überlauf zulassen. Dieser Code transkribiert auch befehlslose Kommentare, erweitert jedoch die Lauflängencodierung von Kommentaren (z. B. "see 3b" → "see bbb"). Das resultierende Programm sollte dasselbe laufen, damit ich nicht zu besorgt bin.

Ich bin mir ziemlich sicher, dass ich noch ein paar Bytes Golf spielen könnte, aber ich bin erschöpft davon, damit zu arbeiten.

Hier ist der benutzerdefinierte Interpreter + Tests, mit denen ich ihn getestet habe. Wenn Sie die Eingabe im Feld Standardeingabe übergeben, sollte sie für diese Eingabe ausgeführt werden, anstatt die Tests auszuführen.

Mein unordentliches ungolfed workpad:

->>>,
[
  [->+>+<<]>>  clone 2 into 3 and 4
  if read char is between zero and nine
  (num buffer | max | is_digit | original char | read | temp0 | temp1)
                                                   ^
  47-
  <<<10+  set max
  <->  handle gross 0 case
  [  while max
    -  max minus one
    <+  buffer plus one
    >>>>-  read minus one
    IF STATEMENT : if read is 0
    >+<
    [>-]>[<
      <<+  is_digit = 1
      <[-]>>>  max = 0
    >->]<<  back to read
    <<<     back to max
  ]

  >>>57+[-]  reset `read` (need to add first to avoid infinite negative)

  +<<  check is_digit flag
  ( end marker | 0 | is_digit | original char | temp0 | temp1 | temp2 | temp3)
  x[  IF READ WAS DIGIT
    CODE 1a
    >>temp0 -<<x
    [>>>temp1 +<<<x-]
  ]
  >>>temp1 [<<<x+>>>temp1 -]
  <temp0 [
    START CODE 2a
    >>temp2 +
    7<y+[  IF THERE IS A NUMBER PREFIX
      -
      START CODE 1b
      >11-  end marker is negativeone
      <   on smallest digit
      +[-<+]->  find largest digit
      >+[  sum digits until we hit the end marker negativeone
        -
        <[->10+<]>  h1 = ten * h0; h0 = 0
        >
        +
      ]  leave the negativeone at zero though
      num | 0 | 0 | 0 | original char
            ^
      <num
      [->>>>.<<<<]  print `original char` `num` times
      >>>>[-]-  set `char` to negativeone
      <<<- last ditch guess
      END CODE 1b
      <y+
      7>temp2 -
      7<y[8>temp3 +8<y-]
    ]
    8>temp3 [8<y+8>temp3 -]
    <temp2 [
      CODE 2b
      <<<.  print original char
      <<<[-]-  set num buffer to new left edge
      >>>>>>temp2 -
    ]
    7<y--

    END CODE 2a
    5>temp0 -
  ]
  <
  ,
]

Gestapelt , 24 Bytes

['(\d+)(.)'[\#~*]3/repl]

Probieren Sie es online!

Erläuterung

['(\d+)(.)'[\#~*]3/repl]
[                      ]   anonymous function, taking string as argument
 '(\d+)(.)'                for all matches of this regex:
           [    ]3/repl      replace (stack = (whole match, digit, repetend))
            \#~              convert digit to number
               *             repeat the character by that digit

TeX, 124 Bytes

\newcount\n\def\b{\afterassignment\r\n0}\def\r#1{\ifx;#1\else\p#1\expandafter\b\fi
}\def\p#1{#1\ifnum\n>1\advance\n-1\p#1\fi}

(geschrieben in zwei Zeilen, um sichtbar zu sein, aber der Code kann in einer Zeile geschrieben werden)

Dies definiert ein Makro \b, das die Eingabe in das Formular übernimmt \b<input>;und die gewünschte Ausgabe in das Dokument druckt.

Retina , 28 23 Bytes

danke an @Leo für -5 bytes

\d+
$*
+`1(1\D)
$1$1
1

Probieren Sie es online!

Pyon , 66 Bytes

print(re.sub("\d+.",lambda k:(int(k.group()[:-1])*k.group()[-1]),a

Probieren Sie es online!

Pyon ist so ziemlich nur Python, dies ist jedoch kürzer, da rees automatisch importiert wird, wenn Sie es verwenden, und aautomatisch auf ein Argument oder die Eingabe festgelegt wird

-4 Bytes dank Mr. Xcoder

Python 2 , 100 93 89 Bytes

-7 dank Mr.Xcoder

n=b=""
for y in input():
 if"/"<y<":":n+=y
 elif""==n:b+=y
 else:b+=y*int(n);n=""
print b

Probieren Sie es online!

Haskell , 60 Bytes

f(a:b)|[(c,d:e)]<-reads$a:b=(<$)d[1..c]++f e|1<2=a:f b
f a=a

Probieren Sie es online!

R , 121 106 90 Bytes

function(s,a=strsplit)cat(rep(el(a(gsub("\\d","",s),"")),pmax(el(a(s,"\\D")),"1")),sep="")

Probieren Sie es online!

Es wurden 15 Bytes gespart, indem erkannt wurde, dass dies rep()zu numerisch wird. Dank Giuseppe weitere 16 gespart, hauptsächlich durch die Verwendung von pmax, um leere Zeichenfolgen durch zu ersetzen1

function(s) {
  x <- el(strsplit(s,"\\D")) # Split the string on anything that is not a digit...
  x <- pmax(x, "1")          # ... and replace any empty strings with 1. This gets us the numbers of repeats
  y <- gsub("\\d","",s)      # Remove all digits from the original string...
  y <- el(strsplit(y))       # ... and split into individual units. This gets us the symbols to repeat
  z <- rep(y, x)             # Implement the repeats. x is coerced to numeric
  cat(z, sep = "")           # Print without separators
}

PowerShell , 66 62 Bytes

-join("$args"-split'\b'|%{(,$(,$_[0]*$n+$_))[!!($n=$($_-1))]})

Probieren Sie es online!

Nervenzusammenbruch

Was für ein Chaos!

Ausgehend von $args, einem einzelnen Elementarray, das die RLE-Zeichenfolge enthält, erzwinge ich eine tatsächliche Zeichenfolge, indem ich sie in Anführungszeichen setze.

Dann teilen Sie es durch die Wortgrenze ( \bin Regex). Dadurch erhalte ich eine Reihe von Zeichenfolgen, wobei jedes Element entweder eine Zahl oder die BF-Token ist, die nach der Zahl stehen. So in dem Beispiel sind die ersten 4 Elemente dieser Split - Array 10, +]>+>, 3, +>(alle sind string).

Als nächstes leite ich das in ForEach-Object( %), um mich mit jedem Element zu befassen .

Die Mitte ist ein bekannter PowerShell-Golfismus mit einer Wendung. Es handelt sich im Wesentlichen um einen DIY-Ternäroperator, in dem Sie ein Array mit 2 Elementen erstellen und es dann mit dem zu testenden Booleschen Ausdruck indizieren, wobei ein falsches Ergebnis Element 0 und ein wahres Ergebnis Element 1 ergibt.

In diesem Fall erstelle ich tatsächlich ein einzelnes Elementarray mit dem unären Komma , Operator " , da ich keine Ausgabe im wahren Fall möchte.

Schauen wir uns zuerst den Indexer an, auch wenn er später ausgeführt wird.

Die Idee dabei ist, dass $_(das aktuelle Element) entweder eine gültige Zahl oder eine andere Zeichenfolge sein kann. Wenn es sich um eine Zahl handelt, möchte $nich den Wert dieser Zahl minus 1 (als Zahl, nicht als Zeichenfolge) darstellen. Wenn nicht, will ich$n ich falsch sein.

PowerShell versucht normalerweise, den Wert für die rechte Hand auf den Typ der linken Seite zu setzen, dies kann jedoch vom Vorgang abhängen. "10"+5Geben Sie zum Hinzufügen eine neue Zeichenfolge ein "105", während 10+"5"Sie eine Ganzzahl ( 15) erhalten.

Aber Strings kann nicht so statt subtrahiert werden kann Powershell den numerischen Wert automatisch mit einer Schnur auf der linken Seite der Subtraktion schließen, daher "10"-5gibt5 .

Also, ich beginne mit $_-1, was mir die Nummer gibt, die ich möchte, wenn $_es sich tatsächlich um eine Nummer handelt, aber wenn es nicht so ist, bekomme ich nichts. Oberflächlich betrachtet ist "nichts" falsch, aber das Problem ist, dass die Ausführung dieser Zuweisung abgebrochen wird, sodass $nder vorherige Wert beibehalten wird. nicht was ich will!

Wenn ich es in einen Unterausdruck einbinde, erhalte ich meinen falschen Wert, wenn es fehlschlägt: $($_-1) .

Das alles wird zugewiesen $nund da diese Zuweisung selbst in Klammern eingeschlossen ist, der Wert, der zugewiesen wurde$n auch an die Pipeline übergeben.

Da ich es im Indexer verwende und ich möchte, 1dass die Konvertierung erfolgreich war, verwende ich zwei boolesche notAusdrücke !!, um diesen Wert in einen booleschen Wert zu konvertieren. Eine erfolgreiche Zahlenumwandlung endet als wahr, während das falsche Nichts uns so süß, süß gibt0 ermöglicht, das einzige Element in diesem gefälschten ternären Array zurückzugeben.

Zurück zu diesem Array lautet das Element wie folgt: $("$($_[0])"*$n*$_) $(,$_[0]*$n+$_)

"$($_[0])"- Dies ist ein ärgerlich langer Weg, um das erste Zeichen des aktuellen Elements zu erhalten (sagen wir mal +von +[>+), aber als Zeichenfolge und nicht als [char]Objekt. Ich muss eine Zeichenfolge sein, da ich eine Zeichenfolge mit einer Zahl multiplizieren kann, um sie zu duplizieren, aber ich kann das nicht mit einem Zeichen tun.

Tatsächlich konnte ich 4 Zeichen speichern, indem ich ein [char]Array anstelle eines Strings verwendete (indem ,ich ein anderes unäres Komma verwendete ), sodass ich die Anführungszeichen und den zusätzlichen Unterausdruck entfernen konnte. Ich kann ein Array multiplizieren, um seine Elemente zu duplizieren. Und da das gesamte Ergebnis dieser Iteration ohnehin ein Array ist und bearbeitet werden muss -join, verursacht die Verwendung eines Arrays hier keine zusätzlichen Kosten.

Dann multipliziere ich dieses String- Array mit $n, um es $nmal zu duplizieren . Recall , die $nsein könnte , $nulloder es könnte der Wert der vorstehenden Ziffern minus eins sein.

Dann +$_addiert das aktuelle Element auf das Ende der duplizierten ersten Zeichen dieses Elements. Deshalb $nist minus eins.

Auf diese Weise 10+[>+endet mit bis $ngleich 9, dann wir 9 machen +‚s und die zurück zum hinzufügen+[>+ Zeichenfolge für die Fahrt entlang der erforderlichen 10 sowie die anderen einzelnen Elemente zu erhalten.

Das Element wird in einen Unterausdruck eingeschlossen $() , weil , wenn $nist $null, der gesamte Ausdruck fehlschlägt, so dass die Anordnung zu schaffen ausfällt, so dass die Weitertaktungs nie ausgeführt wird , so $nwird nie zugewiesen.

Der Grund , warum ich diesen ternären Trick ist , weil eines seiner Besonderheiten: Im Gegensatz zu einem echten ternären Operator, die Ausdrücke, die die Elemente definieren Sie bekommen ausgewertet , ob sie „ausgewählt“ werden, und das erste was das betrifft.

Da muss ich das zuordnen und dann nutzen $n separate Iterationen , ist dies hilfreich. Der Wert des ternären Array-Elements wird mit dem Wert der vorherigen Iteration bewertet $n, und der Indexer weist $ndie aktuelle Iteration neu zu.

Also die ForEach-Object Schleifen geben also alles aus, was sie sollen (eine Reihe von Fehlern, die wir ignorieren), aber als Array von neuen Zeichenfolgen.

Das Ganze wird also in Klammern eingeschlossen und dann mit unary eingeleitet -join, um die Ausgabezeichenfolge zu erhalten.

QuadR , 17 Bytes

\d+.
¯1((⍎↓)⍴↑)⍵M

Probieren Sie es online!

Vielen Dank an Adám für die korrekte Version des Codes.

Wie es funktioniert:

\d+.          ⍝ Regex to match any sequence of digits followed by a character.
¯1((⍎↓)⍴↑)⍵M  ⍝ Transformation line
¯1(      )⍵M  ⍝ Arguments: -1 and the matching expression
   ( ↓)       ⍝ 'Drop' the last item (-1) from the match (⍵M), yielding a string which is a sequence of digits.
    ⍎         ⍝ Execute. In this case, it transforms a string into a number.
        ↑     ⍝ 'Take' the last item (-1) from the match (⍵M), yielding a character.
       ⍴      ⍝ Reshape it. That will take the character resulting from the 'Take' operation and repeat it n times,
              ⍝ where n is the result from the 'Drop' and 'Execute' operations.

Proton , 50 Bytes

x=>/\d+./.sub(k=>int((e=k.group())[to-1])*e[-1],x)

Probieren Sie es online!

Java 8, 148 Bytes

s->{for(s=s.format(s.replaceAll("(\\d+)","%1\\$0$1d"),0);!s.matches("\\D+");s=s.replaceAll("0(\\D)","$1$1"));return s.replaceAll("((.)+)\\2","$1");}

^Verdammte Java-Regexes sind manchmal so nutzlos. Das letzte Mal war es einMangel, die Erfassungsgruppe"$1"für irgendetwas zu verwenden, jetzt dies. Ich möchte3cmitcccoder000cmitersetzenccc als Einzeiler, aber leider hat Java keine Möglichkeit , dies zu tun , ohne eine Schleife. Ah, gut.

Erläuterung:

Probieren Sie es hier aus.

s->{                          // Method with String as both parameter and return-type
  for(s=s.format(s.replaceAll("(\\d+)","%1\\$0$1d"),0);
                              //  Replace every numbers of that many zeroes
                              //  (i.e. "3>2+" -> "000>00+")
      !s.matches("\\D+");     //  Loop as long as the String contains zeroes
    s=s.replaceAll("0(\\D)",  //   Replace every 0 followed by a non-0 character,
                   "$1$1")    //   with two times this captured non-0 character
  );                          //  End of loop
  return s.replaceAll("((.)+)\\2","$1");
                              //  Reduce every repeated character amount by 1,
                              //  and return this as result
}                             // End of method

Haskell , 84 Bytes

f s@(x:r)|(n:m,x:r)<-span(`elem`['0'..'9'])s=(x<$[1..read$n:m])++f r|1<3=x:f r
f e=e

Probieren Sie es online!

Erläuterung:

span(`elem`['0'..'9'])sTeilt die angegebene Zeichenfolge sin ein Präfix aus Ziffern und den Rest auf. Die Zuordnung des Ergebnisses zum Muster (n:m,x:r)stellt sicher, dass das Ziffernpräfix nicht leer ist und bindet das Zeichen nach den Ziffern an xund den Rest an r. x<$[1..read$n:m]Liest die Ziffernfolge n:mals Zahl und wiederholt sie xso oft. Das Ergebnis wird mit der rekursiven Behandlung der verbleibenden Zeichenfolge verknüpft r.

R , 151 Bytes

Outgolfed von user2390246 ! Dies ist nun im Grunde ein Müllansatz im Vergleich zu diesem, aber ich werde ihn weiter verbessern.

function(s,G=substr)for(i in el(strsplit(gsub("(\\d+.)","!\\1!",s),"!")))cat("if"(is.na(g<-as.double(G(i,1,(n=nchar(i))-1))),i,rep(G(i,n,n),g)),sep='')

Probieren Sie es online!

Gibt auch eine Reihe von Warnungen aus.

function(s){
s <- gsub("(\\d+.)","!\\1!",s)               # surround groups with !
X <- el(strsplit(s,"!"))                   # split to groups
for( i in X ){                             # iterate over groups
 n <- nchar(i)                             # length of group
 r <- substr(i,1,n-1)                      # potential number (first n-1 chars)
 d <- substr(i,n,n)                        # last character
 if( is.na(as.double(r)) ){                # if it's not a number
   cat(i)                                  # print out the whole string
  } else {
   cat(rep(d,as.double(r)),sep="")         # repeat d r times, and print with no separator
  }
 }
}

Als nächstes prüfen, ob die Verwendung von a grepeffizienter ist alssubstr

JavaScript (ES6), 46 Byte

a=>a.replace(/(\d+)(.)/g,(_,n,b)=>b.repeat(n))

Ziemlich einfache Erklärung:

a=>a.replace(/(\d+)(.)/g,                      // Match globally the following: a number N followed by a character
                         (_,n,b)=>b.repeat(n)) // Replace each occurrence by the matched character repeated N times

Ruby , 35 Bytes

->s{s.gsub(/(\d+)(.)/){$2*$1.to_i}}

Probieren Sie es online!

Untyped Lambda Calculus , 452 Bytes

(λp.λq.(λb.λg.(λi.(λp.λq.λb.p q b)(q(λq.λj.λl.j((λq.λj.qλq.λl.(λu.g i j(λp.u)(g j(λq.λg.q(b(p(λp.λq.p q))(p(λp.λq.p(p q)))q g))(λp.u)(λu.u qλq.λu.g j i q(b l(p(λp.λq.p(p(p(p q)))))q u))))λp.p(λp.λb.q p((λp.λq.l(λp.l)(λp.λq.p q)(λq.p j q)q)p b))λp.λp.p)l q))(λp.p)(λp.p(λp.λp.p)λp.λp.p)(λp.λq.p)))(b(p(λp.λp.p))(p(λp.λq.p(p q)))))(λp.λq.λb.p(q b))λp.λq.q(λp.λq.λb.p(λp.λb.b(p q))(λp.b)λp.p)p)λp.λq.λb.q(q(q(q(q(q(p q b))))))

Eingabe und Ausgabe bestehen aus rechts gefalteten Listen der Kirche, die codiert sind Zeichencodes, beispielsweise der Zeichencode einer Neuen - Zeile ist 10 , so dass die Kirche Codierung wäre λf.λx.f(f(f(f(f(f(f(f(f(f x))))))))). Das Umwandeln von "ABCD" in eine Liste sieht so aus, λf.λx.f 65 (f 66 (f 67 (f 68 x)))aber die Zahlen sind kirchencodiert.

Wenn Sie eine codierte Zeichenfolge auf das Programm anwenden und sie vollständig reduzieren, erhalten Sie eine codierte Ausgabezeichenfolge mit der angewendeten RLE.

Funky , 42 Bytes

s=>s::gsub("(\\d+)(.)",(_,a,b)=>b::rep(a))

Probieren Sie es online!

C ++, 239 235 Bytes

-4 Bytes dank Zacharý

#include<regex>
using s=std::string;std::regex m("[0-9]*[<>+.,\\[\\]-]");s t(s r){s d,h;std::sregex_iterator i(r.begin(),r.end(),m),e;while(i!=e){h=(*i)[0];int g=std::strtol(h.data(),NULL,10);g+=!g;d+=s(g,h[h.size()-1]);++i;}return d;}

Dart, 78 Bytes (mit Regex), 102 Bytes (ohne Regex)

Mit Regex:

(i)=>i.splitMapJoin(new RegExp(r"(\d+)(.)"),onMatch:(m)=>m[2]*int.parse(m[1]))

Ohne Regex:

(i,[n=0,d=0])=>i.codeUnits.map((c)=>i[d++]*((c-=48)>=0&&c<10?0*(n=n*10+c):n<1?1:(n=0*(c=n))+c)).join()

Beides muss gerne aufgerufen werden (<code here>)("input string").

Regex ist ein Standard, aber der ohne Regex ist etwas ganz Besonderes.

Regex-less missbraucht optionale Parameter, um lokale Variablen in der Funktion "single return" zuzuweisen. Andernfalls müssen Sie einen Block erstellen und das Schlüsselwort return verwenden. Wenn die Codeeinheit zwischen 0 und 9 liegt, wird sie für jede Codeeinheit akkumuliert nund eine leere Zeichenfolge zurückgegeben. Andernfalls wird das Zeichen mit dem Wert von multipliziert n(Sonderfall bei n == 0, in diesem Fall wird immer 1 Zeichen ausgegeben) und nauf 0 gesetzt.(n=0*(c=n))+c das Zeichencodeargument auf den Wert von n, multipliziert n/ cmit 0 speichert 0 bis nund addiert dann c. Dies setzt unser zurück, nohne in einem Anweisungskontext zu sein.

Python3, 96 Bytes

s,r=input(),""
while s:
 d=0
 while"/"<s[d]<":":d+=1
 r+=int(s[:d] or 1)*s[d];s=s[d+1:]
print(r)

Ich habe es mit einer anderen Implementierung in Python versucht, aber ich kann /codegolf//a/146923/56846 nicht übertreffen :(