Dialeto RLE Brainfuck

14

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

Galen Ivanov
fonte
10
Olá, diminuí a votação desta pergunta porque sinto que ela será dominada por um ou dois algoritmos de regex baseados em RLE que são copiados para a formatação de regex individual de cada idioma. Há muito pouco espaço para jogar golfe aqui.
AdmBorkBork
13
Isso se parece muito com um desafio genérico de decodificação de execução . A diferença aqui é que os números de vários dígitos são suportados. Eu acho que ainda é um idiota, mas não vou martelar.
xnor
4
@xnor A outra diferença é que os dígitos nem sempre estão presentes - essa forma de RLE garante muito menos estrutura e o IMO pode levar a técnicas interessantes (compare minha resposta em Python aqui com a do desafio vinculado!)
Lynn
1
@ Lynn Eu não descrevi isso explicitamente, mas como é visto no exemplo, 1 é omitido; adicionar 0 não torna a string mais curta; portanto, a resposta é não, nenhum zero pode preceder um comando.
Galen Ivanov
6
A outra direção seria mais interessante, eu acho (ou seja, transformar um programa de foda cerebral no menor programa equivalente de foda cerebral RLE).
Pa Elo Ebermann 2/11

Respostas:

24

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.

Lynn
fonte
1
Esse é um bom uso Lpara lidar com a string vazia. Há uma maneira mais curta, porém r'+1*\1*1*"\2"'.
xnor
3
... Por que está import reabaixo da lambda?
Fund Monica's Lawsuit
1
Colocar o lambda primeiro significa que eu posso usar o recurso Cabeçalho / Rodapé do tio.run para mostrar como o código deve ser chamado (eu coloquei f=\ no Cabeçalho - agora o lambda tem um nome!)
Lynn
18

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.
Mr. Xcoder
fonte
31
Lembrete necessário: Pare de votar em soluções triviais (como esta).
Mr. Xcoder
4
Não é tão trivial de saber sobre esse comando, e sei que funciona quando os números estão faltando
Luis Mendo
1
@ Mr.Xcoder Espere, o que? O ponto inteiro do código golf não tem a menor contagem de bytes?
Deacon
4
@ Diácon sim, mas uma resposta em Python com golf é geralmente muito mais difícil de fazer e mais interessante do que uma resposta de 2 bytes em golflang.
Stephen
8
A votação do @Deacon não é apenas sobre a votação de soluções curtas. Geralmente, os usuários são incentivados a votar em soluções interessantes e criativas, em vez de soluções breves triviais em idiomas de golfe.
usar o seguinte código
17

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)))                    
Katenkyo
fonte
@ Lynn Um byte para baixo, faltam mais 3!
Katenkyo
Você pode salvar um byte removendo ,""e colocando entre parênteses todo o argumento de impressão. Expressões entre parênteses são ajustadas para um valor em Lua (consulte lua.org/manual/5.3/manual.html#3.4 ).
21417 Jarhmander
11

Scala , 73 69 bytes

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

Experimente online!

oowekyala
fonte
2
Esta é uma boa resposta! Bem vindo ao site. :)
DJMcMayhem
8

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

Raio
fonte
TheFamilyFroot tinha uma boa dica de golfe: você não precisa usar um grupo de captura, basta usar o grupo 0 (&ou\0) sem parênteses. Além disso, uma dica de mim, não TheFamilyFroot é que você pode usarDem vez deddpara-1byte.
DJMcMayhem
1
Obrigado por todas as sugestões, H.PWiz, TheFamilyFroot e DJMcMayhem. Isso o colocou abaixo da solução Perl de 18 bytes e ficou em segundo lugar. Agora só precisamos encontrar outros 15 bytes dos quais podemos nos livrar e isso vencerá o Pyth embutido. :-) #
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>-]<,]

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 -
  ]
  <
  ,
]
Orez
fonte
O caso 0 bruto refere-se apenas às contagens zero reais ou também ocorre ao analisar, por exemplo 10+? O OP esclareceu em um comentário que a contagem sempre será maior que 0; portanto, você poderá economizar alguns bytes, se for o primeiro.
Raio
O caso bruto 0 é para analisar qualquer 0. Como o while maxloop sempre é executado pelo menos uma vez e estou aumentando incondicionalmente o buffer em que armazeno o valor do dígito nesse loop, preciso iniciar esse buffer em -1. Gostaria de saber se eu poderia salvar alguns bytes, deixando esse buffer logicamente no value+1🤔 #
Orez
6

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
Conor O'Brien
fonte
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}

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

Manuel
fonte
5

Retina , 28 23 bytes

graças a @Leo por -5 bytes

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

Experimente online!

ovs
fonte
Você pode usar \bno segundo regex para corresponder apenas um 1por execução de 1s?
Neil
Ou você poderia fazer algo parecido com isto
Leo
4

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

HyperNeutrino
fonte
Você deve alterar g[0]para g[:-1](falha no caso de teste especificado ou em qualquer número maior que 9).
Mr. Xcoder
De qualquer forma, por que você precisaria de um lambda que realmente desperdice bytes? Golfed e corrigida para 66 bytes
Mr. Xcoder
@ Mr.Xcoder whoops, não tenho certeza o que eu estava pensando ... obrigado
HyperNeutrino
@ Mr.Xcoder oh sim eu tento coisas de golfe muito que acabam sendo ungolfs xD
HyperNeutrino
4

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!

ElPedro
fonte
Alguns tacos para 93 bytes . Pode ser ainda mais jogado de golfe.
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="")

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
}
user2390246
fonte
muito agradável! Eu acredito que ifelse(x>"",x,1)é um byte mais curto e \\Dé equivalente [^\\d] e, o melhor de tudo, você não precisa perl=T, então esse é um doce 99 bytes . Eu realmente não acho que isso possa ter menos de 100 bytes!
21717 Giuseppe
90 bytes compmax
Giuseppe
@ Giuseppe Uso muito inteligente de pmaxdar uma boa grande melhoria - obrigado!
precisa saber é o seguinte
substitua "1"por 1como pmaxcoagirá characterpara a comparação.
Giuseppe
85 bytes alterando os aliases
Giuseppe
2

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.

briantist
fonte
1
Ótima explicação, que por si só já merece um voto positivo.
Mast
1
Obrigado @Mast, e por causa do seu comentário, olhei para a minha resposta novamente e percebi como eu poderia salvar 4 bytes.
Briantist
2

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.
J. Sallé
fonte
Equivalente à função APL'\d+.'⎕R{¯1((⍎↓)⍴↑)⍵.Match}
Adám 07/11/17
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");}

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
Kevin Cruijssen
fonte
1
Oi Kevin, bom vê-lo aqui, lidando com diferentes sinuosa :) puzzles
Galen Ivanov
@GalenIvanov Oh, hi! Eu não tinha ideia de que você também era ativo no PPCG.
Kevin Cruijssen
Eu não estava até recentemente :) Estou aprendendo J e decidi que esta é uma boa oportunidade para testar minhas habilidades.
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

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.

Laikoni
fonte
1

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

Giuseppe
fonte
1

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

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.

PixelToast
fonte
1
Olá e bem-vindo ao site! Isso parece uma solução interessante, mas esperamos que os idiomas tenham um intérprete válido. Você tem um dos Cálculos Lambda sem tipo?
Post Rock Garf Hunter
Além disso, o que significa a qλqnotação? Eu nunca vi isso antes.
Zacharý 7/11
1

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;}
HatsuPointerKun
fonte
1
Você pode mudar g=(g?g:1)para g+=!g? Se isso não funcionar, você não pode remover os parênteses em tornog?g:1
Zachary
0

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.

Dwayne Slater
fonte
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)

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

user285259
fonte