Traduzir RoboCritters em Brainf ***

15

RoboCritters ( etimologia ) é uma nova linguagem de programação esotérica (não se preocupe em procurá-la, eu a inventei). É uma variante do Brainfuck (BF), um pouco mais complexa do que os esquemas normais de substituição de operadores. Todo programa no RoboCritters é uma grade retangular de texto que contém apenas os sete caracteres . []/\|, além de novas linhas para moldar a grade.

Exemplo de programa RoboCritters:

|\/||./|[]||
[..][][]   |
|/\|[..][..]
[..]    \/\/

Para converter um programa RoboCritters em BF, observe cada caractere que não seja de nova linha na grade na ordem de leitura normal (da esquerda para a direita e de cima para baixo), por exemplo |\/||./|[]||[..][][] ||/\|[..][..][..] \/\/.

Se a seção 4 × 2 da grade que se estende para a direita e para baixo a partir do caractere atual corresponder exatamente a uma das oito criaturas de robôs listadas abaixo, anexe o comando BF correspondente ( ><+-.,[]) ao programa BF (inicialmente vazio).

Se a seção da grade 4 × 2 não corresponder a nenhum dos bichos do robô ou sair dos limites , nada será adicionado ao programa BF.

  1. Joybot, >comando:

    [..]
\][/

  2. Calmbot, <comando:

    [..]
/][\

  3. Squidbot, +comando:

    [..]
//\\

  4. Spiderbot, -comando:

    [..]
||||

  5. Bunnybot, .comando:

    [][]
[..]

  6. Toothbot, ,comando:

    [..]
|/\|

  7. Foxbot, [comando:

    |\/|
[..]

  8. Batbot, ]comando:

    [..]
\/\/

Então, lendo o programa de exemplo

|\/||./|[]||
[..][][]   |
|/\|[..][..]
[..]    \/\/

podemos ver que primeiro encontramos um Foxbot (na coluna 1, linha 1), depois um Toothbot (c1, r2), depois um Bunnybot (c5, r2) e, finalmente, um Batbot (c9, r3). Isso corresponde ao programa BF [,.].

Observe que o Foxbot e o Toothbot se sobrepõem. Isso é intencional;os bichos-robôs não são interpretados de maneira diferente quando se sobrepõem .

Desafio

Escreva o programa mais curto possível que aceite um programa RoboCritters e produz seu equivalente BF. Você não precisa executar o BF ou verificar se ele é válido, apenas traduza o código RoboCritters para o código BF.

Detalhes

  • Todos os programas de entrada do RoboCritters serão válidos, ou seja, serão um bloco de texto exatamente retangular contendo apenas os sete caracteres . []/\|, além de novas linhas para moldá-lo. As novas linhas podem estar em qualquer representação comum conveniente . Opcionalmente, você pode supor que os programas tenham uma única nova linha à direita.

  • Você deve oferecer suporte a programas RoboCritters menores que 4 × 2, incluindo o programa 0 × 0 vazio (ou uma nova linha). Todos eles correspondem ao programa BF vazio (a sequência vazia).

  • O programa BF de saída deve ser uma sequência de uma linha contendo apenas os oito caracteres de comando BF ><+-.,[]. Opcionalmente, pode haver uma nova linha final à direita.

  • Tome entrada da maneira usual (stdin / arquivo de texto / linha de comando) e envie para stdout ou a alternativa mais próxima do seu idioma.

  • Em vez de um programa, você pode escrever uma função que aceita o programa RoboCritters como uma sequência e imprime ou retorna a sequência do programa BF.

Exemplos

  1. Entrada: (variante do exemplo acima)

    |\/|[][]
[..][][]
|/\|[..]
    \/\/

    Resultado: [,.]

  2. Entrada: (testa todos os bichos-robôs)

    [..][[[[[..]]. ]|\/|
\][/[..]//\\[..][..]
[..]/][\[][]|/\|[..]
||||/\| [..]|  |\/\/

    Resultado: >+[<,-.]

  3. Entrada:

    [..] [..] [..] [..] [..] [..] [..] [..] |\/| [..] [..] [..] [..] [..] |\/| [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] [..] |\/| [..] [..] [..] [..] [..] [..] [..] [][] [..] [..] [..] [..] [][] [..] [..] [..] [..] [..] [..] [..] [][] [][] [..] [..] [..] [][] [..] [..] [][] [..] [..] [][] [..] [][] [..] [..] [..] [][] [..] [..] [..] [..] [..] [..] [][] [..] [..] [..] [..] [..] [..] [..] [..] [][] [..] [..] [..] [][] [..] [..] [..] [][]
//\\ //\\ //\\ //\\ //\\ //\\ //\\ //\\ [..] \][/ //\\ //\\ //\\ //\\ [..] \][/ //\\ //\\ \][/ //\\ //\\ //\\ \][/ //\\ //\\ //\\ \][/ //\\ /][\ /][\ /][\ /][\ |||| \/\/ \][/ //\\ \][/ //\\ \][/ |||| \][/ \][/ //\\ [..] /][\ \/\/ /][\ |||| \/\/ \][/ \][/ [..] \][/ |||| |||| |||| [..] //\\ //\\ //\\ //\\ //\\ //\\ //\\ [..] [..] //\\ //\\ //\\ [..] \][/ \][/ [..] /][\ |||| [..] /][\ [..] //\\ //\\ //\\ [..] |||| |||| |||| |||| |||| |||| [..] |||| |||| |||| |||| |||| |||| |||| |||| [..] \][/ \][/ //\\ [..] \][/ //\\ //\\ [..]

    Saída: (programa BF Hello World )

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

  4. Entrada: (não há bichos-robôs presentes)

    /\\\[].
]..[..]
\\//||\

    Saída: (string vazia)

Pontuação

O menor envio em bytes vence. ( Contador de bytes à mão. ) O desempate é o posto com maior votação.

code-golf ascii-art brainfuck code-generation Passatempos de Calvin
fonte

Respostas:

9

CJam, 86 85 bytes

qN/S4*f+_W<\1>]z:z4few:~"¨Ý³5&ágûò{wÉ](Ý"296b6b"|[\.]/"f=2/4/"><+-.,[]":Ler{L&},

Teste aqui.

Explicação

qN/    e# Read input and split into lines.
S4*f+  e# Append four spaces to each line. This has two purposes. a) We can later join all
       e# the lines together without worrying about critters appearing across the line
       e# edges because no critter contains spaces. b) It works around a bug in CJam where
       e# the command `ew` crashes when the substring length is longer than the string.
_W<    e# Copy the lines and discard the last one.
\1>    e# Swap with the other copy and discard the first one.
]z     e# Wrap both in an array and zip them up. Now we've got an array which contains
       e# all consecutive pairs of lines.
:z     e# Zip up each of those pairs, such it becomes an array of two-character strings.
       e# We can now find the critters as 4-element subarrays in each of those arrays.
4few   e# Turn each of those arrays into a list of its (overlapping) 4-element subarrays.
:~     e# Flatten those lists, such that we get one huge array of all 4x2 blocks, in order.
"gibberish"296b6b
       e# This is an encoded form of the critters. The above produces a string of the
       e# critters in column-major order, all joined together, where the characters are
       e# represented by numbers 0 to 5.
"|[\.]/"f=
       e# Turn each number into the correct character.
2/4/   e# Split first into columns, then into critters. Now all we need to do is find these
       e# the elements of this array in the processed input.
"><+-.,[]":L
       e# A string of all BF characters in the same order as the critters. Store this in L.
er     e# Do an element-wise replacement. This will leave non-critter blocks untouched.
{L&},  e# Filter the result. The elements are now either characters, or still full 4x2
       e# blocks. We take the set intersection with the array (string) of BF characters.
       e# If the current element is itself a character, it will be coerced into an array
       e# containing that character, such that we get a non-empty intersection. If the
       e# current element is a block instead, if contains arrays itself, so the set
       e# intersection will always be empty.

       e# The resulting array of characters is the desired BF program and will be printed
       e# automatically at the end of the program.

Os bichos foram codificados com este script . Encontrei a base 296 para a codificação com o seguinte script Mathematica, bastante ingênuo (que ainda está sendo executado em busca de uma base melhor):

b = 256;
While[True,
  If[
    FreeQ[
      d = IntegerDigits[15177740418102340299431215985689972594497307279709, b], 
      x_ /; x > 255
    ], 
    Print@{b, Length@d}
  ];
  b += 1;
]
Martin Ender
fonte
3

JavaScript ES6, 209 198 192 bytes

f=c=>{s=''
b=o=>c.substr(o,4)||1
for(i in c)s+=!~(d='1\\][/1/][\\1//\\\\1||||[][]11|/\\||\\/|11\\/\\/'.replace(/1/g,'[..]').indexOf(b(i)+b(++i+c.search(`
`))))|d%8?'':'><+-.,[]'[d/8]
return s}

O snippet de pilha abaixo contém código não-protegido que você pode executar facilmente em qualquer navegador.

var f = function(c) {
  var s = '';
  var b = function(o) {
    // If it is looking on the last line, this will return an empty string
    // the second time, which could cause an inaccurate match.
    // `||1` makes it return 1 instead of '', which won't match.
    return c.substr(o, 4) || 1;
  }
  for (var i in c) {
    r = b(i) + b(++i + c.search('\n'));
    d = '1\\][/1/][\\1//\\\\1||||[][]11|/\\||\\/|11\\/\\/'.replace(/1/g, '[..]').indexOf(r);
    s += !~d || d % 8 ? '' : '><+-.,[]' [d / 8];
  }
  return s;
}

// GUI code below
function run(){document.getElementById('s').innerHTML=f(document.getElementById('t').value);};document.getElementById('run').onclick=run;run()
<textarea id="t" cols="30" rows="10">
[..][[[[[..]]. ]|\/|
\][/[..]//\\[..][..]
[..]/][\[][]|/\|[..]
||||/\| [..]|  |\/\/</textarea><br /><button id="run">Run</button><br /><code id="s"></code>
Expandir snippet

NinjaBearMonkey
fonte