Código Escolha o Seu Próprio Idioma

Vamos pegar uma grade de caracteres ASCII imprimíveis de 16x16 (pontos de código 0x20 a 0x7E). Existem 30 caminhos para escolher 15 do canto superior esquerdo ao canto inferior direito, fazendo apenas movimentos ortogonais, como no exemplo a seguir:

##..............
.#..............
.######.........
......##........
.......##.......
........#.......
........#.......
........#.......
........###.....
..........###...
............#...
............####
...............#
...............#
...............#

Cada caminho consiste em exatamente 31 caracteres. Observe que cada um desses caracteres está em um dos 31 anti-diagonais diferentes:

0123456789ABCDEF
123456789ABCDEFG
23456789ABCDEFGH
3456789ABCDEFGHI
456789ABCDEFGHIJ
56789ABCDEFGHIJK
6789ABCDEFGHIJKL
789ABCDEFGHIJKLM
89ABCDEFGHIJKLMN
9ABCDEFGHIJKLMNO
ABCDEFGHIJKLMNOP
BCDEFGHIJKLMNOPQ
CDEFGHIJKLMNOPQR
DEFGHIJKLMNOPQRS
EFGHIJKLMNOPQRST
FGHIJKLMNOPQRSTU

^{Esta não é uma grade de exemplo. Esta é uma visualização dos 31 anti-diagonais.}

Chamaremos uma grade de diagonalmente única se nenhum anti-diagonal contiver o mesmo caractere duas vezes. Se a grade tiver essa propriedade, dois caminhos não conterão a mesma sequência. (Apenas para esclarecer, a visualização em si é basicamente o oposto de diagonalmente exclusivo.)

O desafio

Crie uma grade 16x16 na diagonal exclusiva, para que o maior número possível de caminhos seja um código válido que seja impresso Jabberwockyem STDOUT (com quebra de linha à direita opcional) no maior número possível de idiomas. Cada código pode ser um programa completo ou o corpo de uma função sem parâmetros sem declaração de retorno (isso é para não desencorajar os idiomas que precisam ter seu código em alguma função / classe / espaço de nome padrão).

Nota: Para simplificar, você pode usar algum caractere reservado para células não utilizadas, como Ypnypn .

Para cada caminho válido, indique claramente uma linguagem de programação em que é válida.

O vencedor é o envio com o maior número de idiomas cobertos pela lista acima. (Como alternativa, para cada idioma que você deseja contar, mostre um caminho válido nesse idioma, mas certifique-se de não contar nenhum caminho para dois idiomas.)

Em caso de empate, conte as células da grade que não são cobertas por nenhum caminho válido. Menos células não utilizadas vencem. Se ainda houver um empate, aceitarei a resposta com mais votos (líquidos).

Script de validação

Acabei de montar rapidamente um pequeno trecho de CJam que você pode usar para validar que uma grade é diagonalmente única.

Vá para o intérprete CJam online .

Cole o seguinte código

l:A;
qN/W%A16**33/z{A-__|=}%:*"D""Not d"?"iagonally unique"

No campo de entrada, coloque seu caractere reservado na primeira linha (use um caractere não utilizado se não processar um caractere reservado) e, em seguida, sua grade na linha 2 a 17. Por exemplo, para a resposta de Ypnypn:

~
 pr~~~~~~~~~~~~~
 tin~~~~~~~~~~~~
~ypt(~~~~~~~~~~~
~~ef(~~~~~~~~~~~
~~  "J~~~~~~~~~~
~~~~~ab~~~~~~~~~
~~~~~~be~~~~~~~~
~~~~~~~rwo~~~~~~
~~~~~~~~~ck~~~~~
~~~~~~~~~~y~~~~~
~~~~~~~~~~\n~~~~
~~~~~~~~~~~")) ~
~~~~~~~~~~~  ;  
~~~~~~~~~~~~~~~ 
~~~~~~~~~~~~~~~ 
~~~~~~~~~~~~~~~

Corre.

Deixe-me saber se você acha que tem um bug.

— Martin Ender
fonte

'Twill brillig, e os slithey toves gyre e gimble no wabe ... (sim, eu tenho isso memorizado);)

— Maçaneta da porta

Parece uma das perguntas de Calvin's Hobbies, que é uma conquista fantástica. Ainda não consegui entender como isso é feito.

— Soham Chowdhury

Respostas:

30 33 35 Idiomas

Caractere reservado: ~

 println!~~~~~~~
 puts    (1,~~~~
    echo   '~~~~
"cWprintfn"Ja~~~
Eork~~~;'Jabbe~~
\ui)K00~~~~~br~~
]tteL~0~~~~~ew~~
]<~ln(0~~~~~ro~~
`<~~~ 0~~~~~wc~~
m"~~~ "~~~~~ok~~
rJ~~~'J~~~~~cy~~
j"<< "a~~~~~k'..
^~~~~~bberwoy");
f~~~~~~~~~~c'  ;
t~~~~~~~~~~ky"  
XX"););  5f+');

Línguas:

01. Rust        | println! (  "Jabberwocky") ;  |
02. Groovy      | println     "Jabberwocky"     |
03. E           | println  (  "Jabberwocky")    |
04. Swift       | println  (  "Jabberwocky") ;  |
05. Julia       | println  (  "Jabberwocky");;  |
06. Processing  | println  (  "Jabberwocky")  ; |
07. Falcon      | printl   (  "Jabberwocky")    |
08. ALGOL 68    | print    (  "Jabberwocky")    |
09. Vala        | print    (  "Jabberwocky") ;  |
10. Pawn        | print    (  "Jabberwocky");;  |
11. Batsh       | print    (  "Jabberwocky")  ; |
12. freeBASIC   | print       "Jabberwocky"     |
13. Rebol       | print       "Jabberwocky"  ;  |
14. Red         | print       "Jabberwocky"   ; |
15. AWK         | print       'Jabberwocky'     |
16. Perl        | print       'Jabberwocky'  ;  |
17. bc          | print       'Jabberwocky'   ; |
18. Euphoria    |  puts    (1,"Jabberwocky")    |
19. C           |  puts    (  "Jabberwocky") ;  |
20. Tcl         |  puts       "Jabberwocky"     |
21. Ruby        |  puts       'Jabberwocky'     |
22. Zsh         |      echo   "Jabberwocky"     |
23. Bash        |      echo   "Jabberwocky"  ;  |
24. tcsh        |      echo   "Jabberwocky"   ; |
25. PHP         |      echo   'Jabberwocky'     |
26. Fish        |      echo   'Jabberwocky'  ;  |
27. Dash        |      echo   'Jabberwocky'   ; |
28. F#          |      printfn"Jabberwocky"   ; |
29. C++         |    cout<<"J"<< "abberwocky" ; |
30. D           |     Writeln(  'Jabberwocky'); |
31. Pascal      |     WriteLn(  'Jabberwocky'); |
32. Delphi      |     Writeln(  "Jabberwocky"); |
33. GolfScript  |      print;'Jabberwocky'..;;  |
34. CJam        |   "E\]]`mrj^ftXX"););  5f+'); |
35. Pyth        |      pk)K00000"Jabberwocky"   |

(Pyth e CJam graças a user23013)

— Optimizer
fonte

Na verdade, o código haskell imprime a string entre aspas. Para imprimi-lo sem eles, você precisaria putStr[ln].... Além disso, haskell não tem ;;. Eu acredito que você misturou com Ocaml.

— proud haskeller

Até Ocaml não tem isso. (O intérprete online dá erro se eu colocar ;;). De qualquer forma, substituiu Haskell por outra coisa.

— Optimizer

Pyth seria fácil adicionar - | p b"Jabberwocky" |obras, por exemplo

— isaacg

@isaacg Thanks! Eu também estava olhando Pyth. Isso economiza meu tempo :)

— Optimizer

@isaacg BTW, onde está esse caminho?

— Optimizer

17 línguas

Aqui está a grade, com .o caractere reservado:

 prin...........
 utstln!........
       (1,......
<?echo    ".....
.........'Jab...
............b...
............e...
............r...
............w...
............o...
............c...
............k...
............y"..
............' ).
.............  ;
..............

E aqui estão os idiomas e seus caminhos (ignore as barras verticais):

01. Rust        | println!(   "Jabberwocky" ) ; |
02. Swift       | println (   "Jabberwocky" ) ; |
03. Scala       | println (   "Jabberwocky" )   |
04. Falcon      | printl  (   "Jabberwocky" )   |
05. Vala        | print   (   "Jabberwocky" ) ; |
06. Lua         | print   (   'Jabberwocky' ) ; |
07. ALGOL 68    | print   (   "Jabberwocky" )   |
08. Dart        | print   (   'Jabberwocky' )   |
09. Rebol       | print       "Jabberwocky"   ; |
10. Perl        | print       'Jabberwocky'   ; |
11. AWK         | print       "Jabberwocky"     |
12. Euphoria    | puts    (1, "Jabberwocky" )   |
13. C           | puts    (   "Jabberwocky" ) ; |
14. Tcl         | puts        "Jabberwocky"     |
15. Ruby        | puts        'Jabberwocky'     |
16. Bash        |     echo    "Jabberwocky"     |
17. PHP         |     echo    "Jabberwocky"   ; |

Não pude testar todos eles, então, deixe-me saber se algo não funcionar.

— grc
fonte

Eu acho que você não pode usar o mesmo caminho para mais de um idioma e adicioná-lo à sua pontuação.

— Otimizador

@ Optimizer Eu não acho que existem caminhos usados duas vezes. É certo que as diferenças são bem pequenas.

— grc 28/10

Ugh, seu cara sorrateiro! : P

— Otimizador

Para o PHP, após remover o clichê, `echo" foobar "` (mais de 1 espaço de cada vez) é impresso corretamente. Sem espaços em branco. Experimente aqui

— Otimizador

Não há problema em remover o clichê do código, que está <?aqui #

— Optimizer

18 idiomas e mais

Caráter reservado: ~.

         "~~~~~~
12345678 "~~~~~~
12345678 "~~~~~~
12345678 "~~~~~~
1234567: ea~~~~~
1234567: c;~~~~~
1234567: hL~~~~~
1234567: o'~~~~~
1234567:  Jab~~~
1234567:?""""~~~
~~~~~~~~~Jabberw
~~~~~~~~~~~~~~~o
~~~~~~~~~~~~~~~c
~~~~~~~~~~~~~~~k
~~~~~~~~~~~~~~~y
~~~~~~~~~~~~~~~"

Línguas:

CJam                             |             ea;L'J"abberwocky"|
GolfScript                       |              cho "Jabberwocky"|
Bc                               |                  "Jabberwocky"|
Bash                             |         """"echo J"abberwocky"|
Zsh                              |           ""echo J"abberwocky"|
Fish                             |             echo J"abberwocky"|
Tcsh                             |         """"echo Ja"bberwocky"|
Dash                             |           ""echo Ja"bberwocky"|
Ksh                              |             echo Ja"bberwocky"|
Mksh                             |         """"echo Jab"berwocky"|
Yash                             |           ""echo Jab"berwocky"|
Sash                             |             echo Jab"berwocky"|
Posh                             |         """"echo "Jabberwocky"|
Csh                              |           ""echo "Jabberwocky"|
PHP                              |             echo "Jabberwocky"|

e...

FreeBasic                        |                 ?"Jabberwocky"|
QBasic                           | 12345678        ?"Jabberwocky"|
QB64                             | 123456788       ?"Jabberwocky"|

Deve haver muito mais dialetos básicos que funcionem. Mas ainda não tenho tempo para testar todos eles.

— jimmy23013
fonte

Lembre-se de que você não pode usar o mesmo caminho para mais de um idioma. Portanto, nem todos os dialetos do BASIC se encaixam.

— Optimizer

@Optimizer Pelo menos esses dialetos que têm números de linha e não verifica estouro (e têm ?a print) deve funcionar ... Basta selecionar um número de linha diferente.

— jimmy23013