RLE Brainfuck

(correlato a BF-RLE )

L'ipotetico dialetto RLE ( Run-Length Encoding ) di Brainfuck accetta i simboli per gli 8 comandi e accetta anche le cifre. Le cifre vengono utilizzate per rappresentare il numero di ripetizioni successive di un comando, consentendo così la codifica della lunghezza del codice sorgente.

8>è uguale a >>>>>>>>.

La lunghezza è sempre sul lato sinistro del comando.

Il tuo compito è scrivere il programma / funzione più breve che traduca la stringa di input (frammento RLE Brainfuck) in un normale programma Brainfuck.

Per esempio:

Ingresso:

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

ouptut:

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

Vincerà il codice più breve nel conteggio dei byte in ciascuna lingua.

Python 2 , 62 61 byte

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

Provalo online!

La sostituzione regex si espande 3<2+-nella stringa:

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

che viene quindi evaled. (Notate come quando \1è vuoto, otteniamo 1**1 = 1.) Il primo +è un operatore unario che si lega al primo numero e gli altri +sono concatenazione di stringhe. Questo batte il più ovvio

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

di 14 byte. Di solito "\2"non funzionerebbe sempre, ma per fortuna \e "non sono comandi brainfuck.

xnor ha salvato un byte, fornendo il 1*\1*1trucco. In precedenza ho avuto \1Lnel regex, e definito L=1come un argomento lambda, che è anche piuttosto bello: 3Lè un lungo int letterale ed Lè una variabile.

Pyth , 2 byte

r9

Provalo qui!

Come funziona

r9 - Programma completo che riceve la stringa da STDIN.

r - Set di operazioni di stringa estese di Pyth.
 9 - Il nono comando di quell'insieme (decodifica di lunghezza). Questo supporta numeri a più cifre.

Lua, 65 64 63 byte

Grande ! Per una volta, Lua batte Python!

Modifica: salvato un byte grazie a @Jarhmander, grazie a lui per l'utile trucco per forzare un singolo risultato

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

Provalo online!

spiegazioni

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 byte

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

Provalo online!

Perl 5 , 18 byte

17 byte codice + 1 per -p.

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

Provalo online!

vim, 29 25 23 22 16 byte

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

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

Funziona sostituendo ogni non cifra con un comando che aggiunge quel carattere al buffer. I conteggi vengono lasciati soli e modificano tali comandi. A questo punto, il buffer è un programma vimscript che produce il programma Brainfuck desiderato, quindi lo estraiamo in un registro e lo eseguiamo.

Provalo online!

Modifica: Riduzioni delle dimensioni grazie ai suggerimenti: H.PWiz: 5, TheFamilyFroot: 5, DJMcMayhem: 1

RLE Brainfuck, 204 byte

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

Da quanto ho capito, le specifiche per l'ambiente di Brainfuck non sono molto ben definite. Questo programma presuppone che le celle nel nastro consentano numeri interi positivi e negativi arbitrariamente grandi, senza overflow. Questo codice trascriverà anche commenti non di comando, ma espanderà la codifica della lunghezza dei commenti (ad es. "Vedi 3b" → "vedi bbb"). Il programma risultante dovrebbe funzionare allo stesso modo, quindi non sono troppo preoccupato.

Sono abbastanza sicuro di poter ancora giocare a golf a pochi byte, ma sono stanco di lavorarci.

Ecco l'interprete personalizzato + i test che ho usato per testarlo. Se si passa l'input nella casella Input standard, dovrebbe essere eseguito su quell'input anziché eseguire i test.

Il mio disordinato blocco di lavoro non golfato:

->>>,
[
  [->+>+<<]>>  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 -
  ]
  <
  ,
]

Impilato , 24 byte

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

Provalo online!

Spiegazione

['(\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 byte

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

(scritto in due righe per essere visibile, ma il codice può essere scritto in una riga)

Ciò definisce una macro \bche accetta l'input nel modulo \b<input>;e stampa l'output desiderato nel documento.

Retina , 28 23 byte

grazie a @Leo per -5 byte

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

Provalo online!

Pyon , 66 byte

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

Provalo online!

Pyon è praticamente solo Python, ma è più breve perché reviene importato automaticamente quando lo si utilizza e aviene automaticamente impostato su un argomento o l'input

-4 byte grazie a Mr. Xcoder

Python 2 , 100 93 89 byte

-7 grazie a Mr.Xcoder

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

Provalo online!

Haskell , 60 byte

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

Provalo online!

R , 121 106 90 byte

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

Provalo online!

Hai salvato 15 byte realizzando che rep()diventerà numerico. Ne ho salvati altri 16 grazie a Giuseppe, principalmente dall'uso di pmaxsostituire stringhe vuote con1

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 byte

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

Provalo online!

Abbattersi

Che casino!

A partire da $args, che è un array a singolo elemento contenente la stringa RLE, sto forzando una stringa effettiva avvolgendola tra virgolette.

Quindi dividerlo per parola limite ( \bin regex). Questo mi darà una serie di stringhe, in cui ogni elemento è un numero o i token BF che seguono il numero. Così, nell'esempio, i primi 4 elementi della matrice scissione sono 10, +]>+>, 3, +>(tutti sono stringa).

Successivamente, lo installo in ForEach-Object( %) per gestire ogni elemento .

Il mezzo è un noto golfismo PowerShell, con una svolta; si tratta essenzialmente di un operatore ternario fai-da-te, in cui si crea un array di 2 elementi per indicizzarlo utilizzando l'espressione booleana che si desidera testare, per cui un risultato falso ti dà l'elemento 0 e un risultato vero ti dà l'elemento 1.

In questo caso, in realtà creo un array di elementi singoli con la virgola unaria , , perché non voglio l'output nel caso vero.

Per prima cosa diamo un'occhiata all'indicizzatore, anche se viene eseguito in seguito.

L'idea è che $_(l'elemento corrente) potrebbe essere un numero valido o un'altra stringa. Se è un numero, voglio $nessere il valore di quel numero meno 1 (come numero, non come stringa). Se non lo è, voglio$n essere falso.

In genere PowerShell tenta di forzare il valore della mano destra sul tipo del lato sinistro, ma può dipendere dall'operazione. Inoltre, "10"+5ti darebbe una nuova stringa "105", mentre 10+"5"ti darà un intero ( 15).

Ma le stringhe non possono essere sottratte, quindi PowerShell può inferire automaticamente il valore numerico con una stringa sul lato sinistro della sottrazione, quindi "10"-5dà 5.

Quindi, inizio con $_-1, che mi darà il numero che desidero quando in $_realtà è un numero, ma quando non lo è non ottengo nulla. In apparenza, "niente" è falso, ma il problema è che si ferma l'esecuzione di quel compito, quindi $nmanterrà il suo valore precedente; non quello che voglio!

Se lo avvolgo in una sottoespressione, quando fallisce, ottengo il mio valore di falso: $($_-1) .

A tutto ciò che viene assegnato $ne poiché tale compito è racchiuso tra parentesi, anche il valore assegnato $nviene passato alla pipeline.

Dato che lo sto usando nell'indicizzatore e voglio 1che la conversione abbia avuto successo, uso due notespressioni booleane !!per convertire questo valore in booleano. Una conversione numerica di successo finisce come vera, mentre il falso nulla ci dà quel dolce, dolce 0che consente di restituire l'unico elemento in quel falso array ternario.

Tornando a quell'array, l'elemento è questo: $("$($_[0])"*$n*$_) $(,$_[0]*$n+$_)

"$($_[0])"- questo è un modo fastidiosamente lungo di ottenere il primo carattere dell'elemento corrente (diciamo, ottenere +da +[>+), ma come una stringa e non come un [char]oggetto. Ho bisogno che sia una stringa perché posso moltiplicare una stringa per un numero per duplicarla, ma non posso farlo con un carattere.

In realtà sono riuscito a salvare 4 caratteri utilizzando un [char]array anziché una stringa (utilizzando un'altra virgola unaria ,), quindi sono stato in grado di rimuovere le virgolette e la sottoespressione aggiuntiva. Io posso moltiplicare una matrice di duplicare i suoi elementi. E poiché l'intero risultato di questa iterazione finisce comunque per essere un array e deve essere modificato -join, l'utilizzo di un array qui non comporta costi aggiuntivi.

Quindi, moltiplico quell'array di stringhe per $n, per duplicarlo $nvolte. Ricordiamo che $npotrebbe essere $nullo potrebbe essere il valore delle cifre precedenti meno uno.

Quindi +$_aggiunge l'elemento corrente alla fine del primo carattere duplicato di quell'elemento. Ecco perché $nè meno uno.

In questo modo, 10+[>+finisce con $nuguale a 9, quindi facciamo 9 +e lo aggiungiamo alla +[>+stringa per ottenere il 10 richiesto, più gli altri singoli elementi lungo per il giro.

L'elemento è racchiuso in una sottoespressione $()perché quando lo $nè $null, l'intera espressione non riesce, quindi la creazione dell'array non riesce, quindi l'indicizzatore non viene mai eseguito, quindi $nnon viene mai assegnato.

Il motivo per cui ho usato questo trucco ternario è a causa di una delle sue peculiarità: a differenza di un vero operatore ternario, le espressioni che definiscono gli elementi fanno vengono valutati indipendentemente dal fatto che siano "selezionati", e il primo per quella materia.

Dal momento che ho bisogno di assegnare e quindi utilizzare $nsu iterazioni separate, questo è utile. Il valore dell'elemento dell'array ternario viene valutato con il $nvalore dell'iterazione precedente , quindi l'indicizzatore si riassegna $nper l'iterazione corrente.

Quindi i ForEach-Objectloop finiscono per emettere tutto ciò che dovrebbe (un mucchio di errori che ignoriamo), ma come una serie di nuove stringhe.

Quindi l'intera cosa viene racchiusa tra parentesi e quindi preceduta da unario -joinper dare la stringa di output.

quadr , 17 byte

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

Provalo online!

Grazie a Adám per aver fornito la versione corretta del codice.

Come funziona:

\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 byte

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

Provalo online!

Java 8, 148 byte

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

^Le regex di ^Gdamn Java a volte sono così inutili .. L'ultima volta è stata lamancanza di utilizzare il gruppo di acquisizione"$1"per qualsiasi cosa, ora questo .. Voglio sostituirlo3cconccco000cconcccuna sola riga, ma sfortunatamente Java non ha modo di farlo senza un ciclo continuo. Ah bene.

Spiegazione:

Provalo qui.

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 byte

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

Provalo online!

Spiegazione:

span(`elem`['0'..'9'])sdivide la stringa data sin un prefisso di cifre e il resto. La corrispondenza del risultato sul modello (n:m,x:r)garantisce che il prefisso delle cifre non sia vuoto e associ il carattere dopo le cifre a xe il resto ar . x<$[1..read$n:m]legge la stringa di cifre n:mcome numero e lo ripete xmolte volte. Il risultato è concatenato al trattamento ricorsivo della stringa rimanente r.

R , 151 byte

Superato dall'utente2390246 ! Questo è fondamentalmente un approccio di immondizia rispetto a quello, ma continuerò a migliorarlo.

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='')

Provalo online!

Emette anche un sacco di avvertimenti.

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

Successivamente, vedere se l'utilizzo di a grepè più efficiente disubstr

JavaScript (ES6), 46 byte

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

Spiegazione piuttosto semplice:

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

Rubino , 35 byte

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

Provalo online!

Calcolo lambda non tipizzato , 452 byte

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

L'input e l'output comprendono liste a destra dei codici dei caratteri codificati nella chiesa , ad esempio il codice dei caratteri di una nuova riga è 10, quindi la codifica della chiesa sarebbe λf.λx.f(f(f(f(f(f(f(f(f(f x))))))))). La conversione di "ABCD" in un elenco è simile λf.λx.f 65 (f 66 (f 67 (f 68 x)))ma con i numeri codificati in chiesa.

Applicare una stringa codificata al programma e ridurla completamente dovrebbe fornire una stringa di output codificata con l'RLE applicato.

Funky , 42 byte

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

Provalo online!

C ++, 239 235 byte

-4 byte grazie a 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;}

Dardo, 78 byte (con regex), 102 byte (senza regex)

Con Regex:

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

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

Entrambi devono essere invocati come (<code here>)("input string") .

Regex one è abbastanza standard, ma quello senza regex è abbastanza speciale.

Regex-less abusa dei parametri opzionali per allocare variabili locali nella funzione "ritorno singolo", altrimenti dovrai creare un blocco e avere la parola chiave return. Per ogni unità di codice, se l'unità di codice è compresa tra 0 e 9, viene accumulata ne viene restituita una stringa vuota. Altrimenti, il carattere viene moltiplicato per il valore di n(maiuscolo speciale se n == 0, in tal caso emetterà sempre 1 carattere) ed nè impostato su 0. (n=0*(c=n))+cimposta l'argomento del codice char sul valore di n, moltiplica n/ ccon 0 , memorizza 0 in n, quindi aggiunge c. Questo reimposta il nostro nsenza essere in un contesto di istruzione.

Python3, 96 byte

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)

Ho provato un'altra implementazione in Python, ma non ho battuto /codegolf//a/146923/56846 :(