RLE Brainfuck Dialekt

14

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.

Galen Ivanov
quelle
10
Hallo, ich habe diese Frage abgelehnt, weil ich glaube, dass sie von einem oder zwei RLE-basierten Regex-Algorithmen dominiert wird, die dann einfach in die individuelle Regex-Formatierung jeder Sprache kopiert werden. Hier ist sehr wenig Platz zum Golfen.
AdmBorkBork
13
Dies ähnelt in etwa einer generischen Herausforderung für die Lauflängendekodierung . Der Unterschied besteht darin, dass mehrstellige Zahlen unterstützt werden. Ich denke, es ist immer noch ein Betrüger, aber ich werde es nicht hämmern.
2.
4
@xnor Der andere Unterschied ist, dass Ziffern nicht immer vorhanden sind - diese Form von RLE garantiert eine weitaus geringere Struktur und IMO kann zu interessanten Techniken führen (vergleiche meine Python-Antwort hier mit der in der verknüpften Herausforderung!)
Lynn
1
@Lynn Ich habe das nicht explizit beschrieben, aber wie im Beispiel zu sehen ist, wird 1 weggelassen. Durch das Hinzufügen von 0 wird die Zeichenfolge nicht kürzer, daher lautet die Antwort "Nein". Nullen können keinen Befehl voranstellen.
Galen Ivanov
6
Die andere Richtung wäre meiner Meinung nach interessanter (dh ein Brainfuck-Programm in das kürzeste entsprechende RLE-Brainfuck-Programm umwandeln).
Paŭlo Ebermann

Antworten:

24

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.

Lynn
quelle
1
Das ist eine kluge Verwendung L, um mit der leeren Zeichenfolge umzugehen. Es gibt aber einen kürzeren Weg r'+1*\1*1*"\2"'.
xnor
3
... Warum ist import reunter dem Lambda?
Fund Monica's Lawsuit
1
Wenn ich das Lambda an die erste Stelle setze, kann ich mit der Kopf- / Fußzeile von tio.run zeigen, wie der Code aufgerufen werden soll (ich habe es f=\ in die Kopfzeile eingefügt - jetzt hat das Lambda einen Namen!)
Lynn
18

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.
Mr. Xcoder
quelle
31
Notwendige Erinnerung: Hören Sie auf, triviale Lösungen (wie diese) zu wählen .
Mr. Xcoder
4
Es ist nicht so trivial, diesen Befehl zu kennen, und zu wissen, dass er funktioniert, wenn Zahlen fehlen
Luis Mendo
1
@ Mr.Xcoder Warten Sie, was? Ist es nicht so, dass der gesamte Code-Punkt Golf die niedrigste Byteanzahl hat?
Diakon
4
@Deacon ja, aber eine Golf-Python-Antwort ist normalerweise viel schwieriger und interessanter als eine 2-Byte-Golflang-Antwort.
Stephen
8
@Deacon Bei Upvoting geht es nicht nur um das Upvoten kurzer Lösungen. Benutzer werden generell aufgefordert, interessante und kreative Lösungen zu bewerten, im Gegensatz zu einfachen Kurzlösungen in Golfsprachen.
Text
17

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)))                    
Katenkyo
quelle
@Lynn Ein Byte nach unten, noch 3 übrig!
Katenkyo
Sie können ein Byte speichern, indem Sie ,""das gesamte print-Argument entfernen und in parens einschließen. In Parens eingeschlossene Ausdrücke werden in Lua auf einen Wert angepasst (siehe lua.org/manual/5.3/manual.html#3.4 ).
Jarhmander
11

Scala , 73 69 Bytes

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

Probieren Sie es online!

oowekyala
quelle
2
Das ist eine schöne Antwort! Willkommen auf der Seite. :)
DJMcMayhem
8

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

Ray
quelle
TheFamilyFroot hatte einen schönen Golftipp : Sie müssen keine Erfassungsgruppe verwenden,sondern können stattdessendie Gruppe 0 (&oder\0) ohne Klammern verwenden. Auch ein Tipp von mir, nicht TheFamilyFroot istdass Sie verwenden könnenDanstattddfür-1Byte.
DJMcMayhem
1
Vielen Dank für alle Vorschläge, H.PWiz, TheFamilyFroot und DJMcMayhem. Das brachte es unter die 18-Byte-Perl-Lösung und auf den zweiten Platz. Jetzt müssen wir nur noch 15 Bytes finden, die wir loswerden können, und es schlägt den eingebauten Pyth. :-)
Ray
8

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 -
  ]
  <
  ,
]
Orez
quelle
Bezieht sich der Brutto-0-Fall nur auf tatsächliche Nullzählungen, oder geschieht dies auch beim Parsen, z 10+. B. ? Das OP hat in einem Kommentar klargestellt, dass count immer größer als 0 ist, so dass Sie möglicherweise einige Bytes wegschneiden können, wenn es das erstere ist.
Ray
Gross 0 ist für das Parsen von 0. Da die while maxSchleife immer mindestens einmal ausgeführt wird und ich den Puffer, in dem ich den Wert der Ziffer in dieser Schleife speichere, bedingungslos erhöhe, muss ich diesen Puffer bei -1 beginnen. Ich frage mich, ob ich ein paar Bytes einsparen könnte, wenn ich diesen Puffer logisch bei value+1🤔
Orez,
6

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
Conor O'Brien
quelle
5

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.

Manuel
quelle
5

Retina , 28 23 Bytes

danke an @Leo für -5 bytes

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

Probieren Sie es online!

ovs
quelle
Können Sie \bim zweiten regulären Ausdruck nur einen 1pro Lauf von 1s zuordnen ?
Neil
Oder Sie könnten so etwas wie tun dies
Leo
4

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

HyperNeutrino
quelle
Sie sollten ändern , g[0]um g[:-1](für den gegebenen Testfall oder eine beliebige Anzahl von mehr als 9 ausfällt).
Mr. Xcoder
Wie auch immer, warum brauchst du überhaupt eine, lambdadie tatsächlich Bytes verschwendet? Golfed und korrigiert für 66 Bytes
Mr. Xcoder
@ Mr.Xcoder whoops, nicht sicher, was ich dachte ... danke
HyperNeutrino
@ Mr.Xcoder oh yeah Ich versuche, Dinge viel Golf zu spielen, die am Ende ungolfs xD
HyperNeutrino
4

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!

ElPedro
quelle
Ein paar Golfplätze für 93 Bytes . Es kann aber weiter golfen werden.
Mr. Xcoder
3

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
}
user2390246
quelle
Sehr schön! Ich glaube, es ifelse(x>"",x,1)ist ein Byte kürzer und \\Dentspricht [^\\d] und das Beste von allem ist, dass Sie es nicht brauchen. Das perl=Tsind also süße 99 Bytes . Ich hätte wirklich nicht gedacht, dass das weniger als 100 Bytes sein könnten!
Giuseppe
90 Bytes mitpmax
Giuseppe
@ Giuseppe Sehr kluger Umgang pmaxmit einer schönen großen Verbesserung - danke!
user2390246
Ersetzen Sie "1"mit 1as pmax, characterum den Vergleich zu erzwingen .
Giuseppe
85 Bytes durch Ändern der Aliase
Giuseppe
2

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.

Briantist
quelle
1
Tolle Erklärung, das allein rechtfertigt schon eine Aufwertung.
Mast
1
Danke @Mast, und aufgrund deines Kommentars habe ich meine Antwort nochmal durchgesehen und festgestellt, wie ich 4 Bytes einsparen kann.
Briantist
2

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.
J. Sallé
quelle
Entspricht der APL-Funktion'\d+.'⎕R{¯1((⍎↓)⍴↑)⍵.Match}
Adám
1

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
Kevin Cruijssen
quelle
1
Hallo Kevin, schön dich hier zu sehen, wenn du dich mit anderen Rätseln als kurvenreichen beschäftigst :)
Galen Ivanov
@GalenIvanov Oh, hi! Ich hatte keine Ahnung, dass Sie auch bei PPCG aktiv waren.
Kevin Cruijssen
Ich habe J erst kürzlich gelernt und bin zu dem Schluss gekommen, dass dies eine gute Gelegenheit ist, meine Fähigkeiten zu testen.
Galen Ivanov
1

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.

Laikoni
quelle
1

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

Giuseppe
quelle
Ein anderer Ansatz
user2390246
1

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
XavCo7
quelle
1

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.

PixelToast
quelle
1
Hallo und willkommen auf der Seite! Dies sieht nach einer interessanten Lösung aus, aber wir erwarten, dass die Sprachen einen gültigen Interpreter haben. Haben Sie einen von Untyped Lambda Calculus?
Post Rock Garf Hunter
Was bedeutet die qλqNotation auch? Das habe ich noch nie gesehen.
Zacharý
1

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;}
HatsuPointerKun
quelle
1
Können Sie ändern g=(g?g:1)zu g+=!g? Wenn das nicht funktioniert, können Sie die Klammern nicht entferneng?g:1
Zacharý
0

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.

Dwayne Slater
quelle
0

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

user285259
quelle