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á.
Respostas:
Python 2 ,
6261 bytesExperimente online!
A substituição do regex se expande
3<2+-
para a cadeia:que é então
eval
ed. (Observe como\1
fica vazio quando chegamos1**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 óbviopor 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*1
truque. Anteriormente, eu tinha\1L
no regex e definidoL=1
como um argumento lambda, que também é bem legal:3L
é um int longo eL
é uma variável.fonte
L
para lidar com a string vazia. Há uma maneira mais curta, porémr'+1*\1*1*"\2"'
.import re
abaixo da lambda?f=\
no Cabeçalho - agora o lambda tem um nome!)Pitão , 2 bytes
Experimente aqui!
Como funciona
fonte
Lua,
656463 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
Experimente online!
Explicações
fonte
,""
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 ).Scala ,
7369 bytesExperimente online!
fonte
Perl 5 , 18 bytes
Código de 17 bytes + 1 para
-p
.Experimente online!
fonte
vim,
2925232216 bytes<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
fonte
&
ou\0
) sem parênteses. Além disso, uma dica de mim, não TheFamilyFroot é que você pode usarD
em vez dedd
para-1
byte.RLE Brainfuck, 204 bytes
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:
fonte
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.while max
loop 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 novalue+1
🤔 #Empilhados , 24 bytes
Experimente online!
Explicação
fonte
TeX, 124 bytes
(escrito em duas linhas para ficar visível, mas o código pode ser escrito em uma linha)
Isso define uma macro
\b
que recebe a entrada no formulário\b<input>;
e imprime a saída desejada no documento.fonte
Retina ,
2823 bytesgraças a @Leo por -5 bytes
Experimente online!
fonte
\b
no segundo regex para corresponder apenas um1
por execução de1
s?Pyon , 66 bytes
Experimente online!
Pyon é basicamente Python, mas é mais curto porque
re
é importado automaticamente quando você o usa ea
é automaticamente definido como argumento ou entrada-4 bytes graças ao Sr. Xcoder
fonte
g[0]
parag[:-1]
(falha no caso de teste especificado ou em qualquer número maior que 9).lambda
que realmente desperdice bytes? Golfed e corrigida para 66 bytesPython 2 ,
1009389 bytes-7 com agradecimentos a Mr.Xcoder
Experimente online!
fonte
Haskell , 60 bytes
Experimente online!
fonte
R ,
12110690 bytesExperimente online!
Salva 15 bytes ao perceber que isso
rep()
será coercitivo para numérico. Economizou mais 16 graças a Giuseppe, principalmente pelo uso depmax
para substituir cadeias vazias por1
fonte
ifelse(x>"",x,1)
é um byte mais curto e\\D
é equivalente[^\\d]
e, o melhor de tudo, você não precisaperl=T
, então esse é um doce 99 bytes . Eu realmente não acho que isso possa ter menos de 100 bytes!pmax
pmax
dar uma boa grande melhoria - obrigado!"1"
por1
comopmax
coagirácharacter
para a comparação.PowerShell ,
6662 bytesExperimente 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 (
\b
em 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ão10
,+]>+>
,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$n
ser 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"
enquanto10+"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
fornece5
.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,$n
mantendo 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
$n
e, 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
1
que a conversão seja bem-sucedida, uso duasnot
expressõ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
cordaarray$n
, para duplicá-lo$n
vezes. Lembre-se de que$n
poderia ser$null
ou 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$n
igual 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$n
ocorre$null
, toda a expressão falha, portanto, a criação da matriz falha, portanto o indexador nunca é executado e$n
nunca é 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
$n
em iterações separadas, isso é útil. O valor do elemento ternário da matriz é avaliado com o$n
valor 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
-join
para fornecer a sequência de saída.fonte
QuadR , 17 bytes
Experimente online!
Agradecemos a Adám por fornecer a versão correta do código.
Como funciona:
fonte
'\d+.'⎕R{¯1((⍎↓)⍴↑)⍵.Match}
Próton , 50 bytes
Experimente online!
fonte
Java 8, 148 bytes
Gdamnexpressõ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 substituir3c
comccc
ou000c
comccc
como um one-liner, mas, infelizmente, Java não tem nenhuma maneira de fazer isso sem um ciclo. Ah bem.Explicação:
Experimente aqui.
fonte
Haskell , 84 bytes
Experimente online!
Explicação:
span(`elem`['0'..'9'])s
divide a string especificadas
em 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ígitosx
e o restante ar
.x<$[1..read$n:m]
lê a sequência de dígitosn:m
como número e repetex
isso muitas vezes. O resultado é concatenado ao tratamento recursivo da sequência restanter
.fonte
R , 151 bytes
Superado pelo usuário2390246 ! Agora, essa é basicamente uma abordagem de lixo em comparação com essa, mas continuarei melhorando.
Experimente online!
Também gera vários avisos.
A seguir, veja se o uso de a
grep
é mais eficiente do quesubstr
fonte
JavaScript (ES6), 46 bytes
Explicação bastante direta:
fonte
Rubi , 35 bytes
Experimente online!
fonte
Cálculo lambda sem tipo , 452 bytes
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.
fonte
qλq
notação? Eu nunca vi isso antes.Funky , 42 bytes
Experimente online!
fonte
C ++,
239235 bytes-4 bytes graças a Zacharý
fonte
g=(g?g:1)
parag+=!g
? Se isso não funcionar, você não pode remover os parênteses em tornog?g:1
Dardo, 78 bytes (com regex), 102 bytes (sem regex)
Com Regex:
Sem Regex:
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
n
e uma string vazia é retornada. Caso contrário, o caractere é multiplicado pelo valor den
(case especial se n == 0, nesse caso, sempre emitirá 1 caractere) en
é definido como 0.(n=0*(c=n))+c
define o argumento do código de char para o valor den
, multiplican
/c
com 0 , armazena 0n
e depois adicionac
. Isso redefine o nosson
sem estar em um contexto de declaração.fonte
Python3, 96 bytes
Tentei outra implementação em Python, mas não supero /codegolf//a/146923/56846 :(
fonte