RLE Brainfuck

(relacionado ao BF-RLE )

O hipotético dialeto RLE ( Run-Length Encoding ) de Brainfuck aceita os símbolos para os 8 comandos e também aceita dígitos. Os dígitos são usados ​​para representar o número de repetições sucessivas de um comando, permitindo assim a codificação no código de execução.

8>é igual a >>>>>>>>.

O comprimento está sempre no lado esquerdo do comando.

Sua tarefa é escrever o programa / função mais curto que converta a sequência de entrada (fragmento RLE Brainfuck) em um programa regular do Brainfuck.

Por exemplo:

Entrada:

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

Ouptut:

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

O código mais curto na contagem de bytes em cada idioma vencerá.

Python 2 , 62 61 bytes

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

Experimente online!

A substituição do regex se expande 3<2+-para a cadeia:

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

que é então evaled. (Observe como \1fica vazio quando chegamos 1**1 = 1.) O primeiro +é um operador unário que se liga ao primeiro número e os outros +s são concatenação de strings. Isso supera o mais óbvio

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

por 14 bytes. Normalmente "\2", nem sempre funciona, mas felizmente \e "não são comandos de foda cerebral.

O xnor salvou um byte, fornecendo o 1*\1*1truque. Anteriormente, eu tinha \1Lno regex e definido L=1como um argumento lambda, que também é bem legal: 3Lé um int longo e Lé uma variável.

Pitão , 2 bytes

r9

Experimente aqui!

Como funciona

r9 - Programa completo recebendo a String do STDIN.

r - Conjunto de operações estendidas de Pyth.
 9 - O nono comando desse conjunto (decodificação em comprimento de execução). Isso suporta números de vários dígitos.

Lua, 65 64 63 Bytes

Ótimo ! Pela primeira vez, Lua vence o Python!

Edit: salvou um byte graças a @Jarhmander, graças a ele pelo truque útil para forçar um único resultado

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

Experimente online!

Explicações

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

Experimente online!

Perl 5 , 18 bytes

Código de 17 bytes + 1 para -p.

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

Experimente online!

vim, 29 25 23 22 16 bytes

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

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

Ele funciona substituindo cada não dígito por um comando que acrescenta esse caractere ao buffer. As contagens são deixadas em paz e modificam esses comandos. Neste ponto, o buffer é um programa vimscript que produz o programa Brainfuck desejado, então o atraímos para um registro e o executamos.

Experimente online!

Edit: Reduções de tamanho graças a sugestões: 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>-]<,]

Pelo que entendi, as especificações para o ambiente do cérebro não são super bem definidas. Este programa pressupõe que as células da fita permitam números inteiros positivos e negativos arbitrariamente grandes, sem transbordamento. Esse código também transcreverá comentários que não são de comando, mas expandirá a codificação de duração dos comentários (por exemplo, "consulte 3b" → "consulte bbb"). O programa resultante deve executar o mesmo, então não estou muito preocupado.

Tenho certeza de que ainda consegui jogar alguns bytes com isso, mas estou exausta de trabalhar com ele.

Aqui está o intérprete personalizado + testes que eu tenho usado para testá-lo. Se você passar a entrada na caixa Entrada padrão, ela deverá ser executada nessa entrada em vez de executar os testes.

Meu bloco de trabalho desarrumado e desarrumado:

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

Empilhados , 24 bytes

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

Experimente online!

Explicação

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

(escrito em duas linhas para ficar visível, mas o código pode ser escrito em uma linha)

Isso define uma macro \bque recebe a entrada no formulário \b<input>;e imprime a saída desejada no documento.

Retina , 28 23 bytes

graças a @Leo por -5 bytes

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

Experimente online!

Pyon , 66 bytes

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

Experimente online!

Pyon é basicamente Python, mas é mais curto porque re é importado automaticamente quando você o usa e aé automaticamente definido como argumento ou entrada

-4 bytes graças ao Sr. Xcoder

Python 2 , 100 93 89 bytes

-7 com agradecimentos 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

Experimente 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

Experimente online!

R , 121 106 90 bytes

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

Experimente online!

Salva 15 bytes ao perceber que isso rep()será coercitivo para numérico. Economizou mais 16 graças a Giuseppe, principalmente pelo uso de pmaxpara substituir cadeias vazias por1

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

Experimente online!

Demolir

Que bagunça!

Começando de $args , que é uma matriz de elemento único que contém a string RLE, estou forçando uma string real, envolvendo as aspas.

Em seguida, divida-o pelo limite da palavra ( \bem regex). Isso me dará uma matriz de strings, onde cada elemento é um número ou o (s) token (s) BF que vem após o número. Assim, no exemplo, os primeiros elementos 4 de matriz esta separação são 10, +]>+>, 3,+> (todos são corda).

Em seguida, canalizo isso para ForEach-Object( %) para lidar com cada elemento .

O meio é um conhecido golfismo do PowerShell, com um toque; é essencialmente um operador ternário DIY, no qual você cria uma matriz de 2 elementos e a indexa usando a expressão booleana que deseja testar, em que um resultado falso fornece o elemento 0 e um resultado verdadeiro fornece o elemento 1.

Nesse caso, eu realmente crio uma matriz de elemento único com a vírgula unária , , porque não quero saída no caso verdadeiro.

Primeiro, vamos olhar para o indexador, mesmo que seja executado mais tarde.

A ideia disso é que $_ (o elemento atual) possa ser um número válido ou alguma outra string. Se for um número, quero $nser o valor desse número menos 1 (como um número, não como uma sequência). Se não for, eu quero$n ser falso.

O PowerShell geralmente tenta coagir o valor do lado direito ao tipo do lado esquerdo, mas pode depender da operação. Além disso,"10"+5 forneceria uma nova string,, "105"enquanto 10+"5"forneceria um número inteiro ( 15).

Como as seqüências não podem ser subtraídas, o PowerShell pode inferir o valor numérico automaticamente com uma sequência no lado esquerdo da subtração. Portanto, "10"-5 fornece 5.

Então, eu começo com $_-1 , o que me dará o número que eu quero quando $_na verdade é um número, mas quando não é, não recebo nada. Na superfície, "nada" é falsey, mas o problema é que interrompe a execução dessa atribuição, $nmantendo assim seu valor anterior; não é o que eu quero!

Se o envolver em uma subexpressão, quando falhar, obtenho meu valor de falsey: $($_-1) .

Tudo isso é atribuído a $ne, uma vez que essa atribuição é entre parênteses, o valor que foi atribuído a$n também é passado para o pipeline.

Como estou usando-o no indexador e quero 1que a conversão seja bem-sucedida, uso duas notexpressões booleanas !!para converter esse valor em booleano. Uma conversão bem-sucedida de números acaba sendo verdadeira, enquanto o nada falsey nos dá aquele doce, doce0 que permite retornar o único elemento nesse falso array ternário.

Voltando a essa matriz, o elemento é este: $("$($_[0])"*$n*$_) $(,$_[0]*$n+$_)

"$($_[0])"- esta é uma maneira irritantemente longa de obter o primeiro caractere do elemento atual (digamos, sair +de +[>+), mas como uma string e não como um [char]objeto. Preciso que seja uma sequência, porque eu posso multiplicar uma sequência por um número para duplicá-la, mas não posso fazer isso com um caractere.

Na verdade, eu consegui salvar 4 caracteres usando uma [char]matriz em vez de uma string (usando outra vírgula unária ,), para que eu pudesse remover as aspas e subexpressão extra. Eu posso multiplicar uma matriz para duplicar seus elementos. E como todo o resultado dessa iteração acaba sendo uma matriz de qualquer maneira e precisa ser-join editado, o uso de uma matriz aqui não gera custos adicionais.

Então, eu multiplicar esse corda array $n, para duplicá-lo $nvezes. Lembre-se de que $npoderia ser $nullou poderia ser o valor dos dígitos anteriores menos um.

Em seguida, +$_adiciona o elemento atual ao final do primeiro caractere duplicado desse elemento. É por isso que $né menos um.

Dessa forma, 10+[>+termina com $nigual a 9, então criamos 9 +e adicionamos isso de volta à +[>+string para obter os 10 necessários, além dos outros elementos únicos durante o passeio.

O elemento é envolvido em uma subexpressão $()porque, quando $nocorre $null, toda a expressão falha, portanto, a criação da matriz falha, portanto o indexador nunca é executado e $nnunca é designado.

A razão pela qual usei esse truque ternário é por causa de uma de suas peculiaridades: ao contrário de um operador ternário real, as expressões que definem os elementos fazer se avaliou se eles estão ou não "selecionado", e em primeiro lugar para esse assunto.

Como preciso atribuir e usar $nem iterações separadas, isso é útil. O valor do elemento ternário da matriz é avaliado com o $nvalor da iteração anterior e , em seguida, o indexador reatribui$n para a iteração atual.

Então o ForEach-Object loops acabam gerando tudo o que deveria (um monte de erros que ignoramos), mas como uma série de novas strings.

Portanto, tudo é colocado entre parênteses e precedido por unário -joinpara fornecer a sequência de saída.

QuadR , 17 bytes

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

Experimente online!

Agradecemos a Adám por fornecer a versão correta do código.

Como funciona:

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

Próton , 50 bytes

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

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

^Gdamn expressões regulares Java são às vezes tão inúteis .. última vez foia falta do uso do grupo de captura"$1"para qualquer coisa, agora isso .. Eu quero substituir3ccomcccou000ccomccccomo um one-liner, mas, infelizmente, Java não tem nenhuma maneira de fazer isso sem um ciclo. Ah bem.

Explicação:

Experimente aqui.

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

Experimente online!

Explicação:

span(`elem`['0'..'9'])sdivide a string especificada sem um prefixo de dígitos e o restante. A correspondência no resultado no padrão (n:m,x:r)garante que o prefixo do dígito não esteja vazio e vincule o caractere após os dígitos xe o restante a r. x<$[1..read$n:m]lê a sequência de dígitos n:mcomo número e repete xisso muitas vezes. O resultado é concatenado ao tratamento recursivo da sequência restante r.

R , 151 bytes

Superado pelo usuário2390246 ! Agora, essa é basicamente uma abordagem de lixo em comparação com essa, mas continuarei melhorando.

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

Experimente online!

Também gera vários avisos.

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

A seguir, veja se o uso de a grepé mais eficiente do quesubstr

JavaScript (ES6), 46 bytes

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

Explicação bastante direta:

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

Rubi , 35 bytes

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

Experimente online!

Cálculo lambda sem tipo , 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))))))

A entrada e a saída são compostas por listas do lado direito dos códigos de caracteres codificados pela igreja ; por exemplo, o código de caractere de uma nova linha é 10, portanto a codificação da igreja seriaλf.λx.f(f(f(f(f(f(f(f(f(f x))))))))) . Converter "ABCD" em uma lista pareceλf.λx.f 65 (f 66 (f 67 (f 68 x))) mas com os números codificados pela igreja.

A aplicação de uma sequência codificada ao programa e a redução total devem fornecer uma sequência de saída codificada com o RLE aplicado.

Funky , 42 bytes

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

Experimente online!

C ++, 239 235 bytes

-4 bytes graças 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 bytes (com regex), 102 bytes (sem regex)

Com Regex:

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

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

Ambos devem ser chamados como (<code here>)("input string") .

O regex one é bastante padrão, mas o regex-less é bastante especial.

O Regex-less abusa de parâmetros opcionais para alocar variáveis ​​locais na função "retorno único", caso contrário, você precisaria criar um bloco e ter a palavra-chave return. Para cada unidade de código, se a unidade de código estiver entre 0 e 9, ela é acumulada ne uma string vazia é retornada. Caso contrário, o caractere é multiplicado pelo valor de n(case especial se n == 0, nesse caso, sempre emitirá 1 caractere) e né definido como 0. (n=0*(c=n))+cdefine o argumento do código de char para o valor de n, multiplica n/ ccom 0 , armazena 0 ne depois adiciona c. Isso redefine o nosso nsem estar em um contexto de declaração.

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)

Tentei outra implementação em Python, mas não supero /codegolf//a/146923/56846 :(