RoboCritters ( etymologia ) to nowy ezoteryczny język programowania (nie przejmuj się jego wyszukiwaniem, właśnie go wymyśliłem). Jest to wariant z brainfuck (BF), nieco bardziej złożone niż w zwykłych systemach podstawienia operatora. Każdy program w RoboCritters jest prostokątną siatką tekstu, która zawiera tylko siedem znaków . []/\|plus nowe linie do kształtowania siatki.

Przykładowy program RoboCritters:

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

Aby przetłumaczyć program RoboCritters na BF, spójrz na każdy nie-nowy wiersz w siatce w normalnej kolejności czytania (od lewej do prawej, a następnie od góry do dołu), np |\/||./|[]||[..][][] ||/\|[..][..][..] \/\/.

Jeśli sekcja 4 × 2 siatki rozciągająca się w prawo iw dół od bieżącego znaku dokładnie pasuje do jednego z ośmiu stworzeń robota wymienionych poniżej, dołącz odpowiednią komendę BF ( ><+-.,[]) do (początkowo pustego) programu BF.

Jeśli sekcja siatki 4 × 2 nie pasuje do żadnego ze stworzeń robota lub wykracza poza granice , nic nie jest dodawane do programu BF.

1. Joybot, >polecenie:

   [..]
   \][/
   

2. Calmbot, <polecenie:

   [..]
   /][\
   

3. Squidbot, +polecenie:

   [..]
   //\\
   

4. Spiderbot, -polecenie:

   [..]
   ||||
   

5. Bunnybot, .polecenie:

   [][]
   [..]
   

6. Toothbot, ,polecenie:

   [..]
   |/\|
   

7. Foxbot, [polecenie:

   |\/|
   [..]
   

8. Batbot, ]polecenie:

   [..]
   \/\/
   

Czytając przykładowy program

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

widzimy, że najpierw spotykamy Foxbota (w kolumnie 1, rząd 1), potem Toothbota (c1, r2), następnie Bunnybota (c5, r2), a na końcu Batbota (c9, r3). To odpowiada programowi BF [,.].

Zauważ, że Foxbot i Toothbot pokrywają się. To jest celowe; stworzenia robota nie są interpretowane inaczej, gdy się nakładają .

Wyzwanie

Napisz najkrótszy możliwy program, który pobierze program RoboCritters i wyświetli jego odpowiednik BF. Nie musisz uruchamiać BF ani sprawdzać, czy jest poprawny, tłumacz tylko kod RoboCritters na kod BF.

Detale

• Wszystkie wejściowe programy RoboCritters będą ważne, to znaczy będą one dokładnie prostokątnym blokiem tekstu zawierającym tylko siedem znaków . []/\|plus znaki nowej linii do jego ukształtowania. Nowe linie mogą być w dowolnej wygodnej wspólnej reprezentacji . Opcjonalnie możesz założyć, że programy mają jeden końcowy znak nowej linii.

• Musisz obsługiwać programy RoboCritters mniejsze niż 4 × 2, w tym program 0 × 0 pusty (lub pojedynczy znak nowej linii). Wszystkie odpowiadają pustemu programowi BF (pusty ciąg znaków).

• Wyjściowy program BF powinien składać się z jednego wiersza zawierającego tylko osiem znaków polecenia BF ><+-.,[]. Opcjonalnie może występować pojedynczy znak nowej linii.

• Wejdź w jakikolwiek zwykły sposób (stdin / plik tekstowy / wiersz poleceń) i wypisz na stdout lub najbliższą alternatywę twojego języka.

• Zamiast programu możesz napisać funkcję, która pobiera program RoboCritters jako ciąg znaków i wypisuje lub zwraca ciąg programu BF.

Przykłady

1. Dane wejściowe: (wariant powyższego przykładu)

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

   Wynik: [,.]

2. Dane wejściowe: (testuje wszystkie stworzenia robota)

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

   Wynik: >+[<,-.]

3. Wejście:

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

   Wyjście: ( program BF Hello World )

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

4. Dane wejściowe: (brak stworzeń robota)

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

   Dane wyjściowe: (pusty ciąg)

Punktacja

Najkrótsze przesłanie w bajtach wygrywa. ( Handy byte counter. ) Tiebreaker jest najwyżej głosowanym postem.

CJam, 86 85 bajtów

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

Sprawdź to tutaj.

Wyjaśnienie

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.

Zwierzęta zostały zakodowane za pomocą tego skryptu . Znalazłem bazę 296 do kodowania z następującym, dość naiwnym skryptem Mathematica (który wciąż działa w poszukiwaniu lepszej bazy):

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

JavaScript ES6, 209 198 192 bajtów

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}

Poniższy fragment stosu zawiera nieoznakowany kod, który można łatwo uruchomić w dowolnej przeglądarce.

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>