O idioma inglês e a maioria das linguagens de programação são escritas e lidas da esquerda para a direita, de cima para baixo, mas esse não precisa ser o caso .

De fato, para o bloco de texto

ABC
DEF

Posso pensar em oito maneiras relacionadas que podem ser lidas:

1. Da esquerda para a direita, de cima para baixo (LTR-TTB): ABCDEF
2. De cima para baixo, da esquerda para a direita (TTB-LTR): ADBECF
3. Da esquerda para a direita, de baixo para cima (LTR-BTT): DEFABC
4. De baixo para cima, da esquerda para a direita (BTT-LTR): DAEBFC
5. Direita para a esquerda, de cima para baixo (RTL-TTB): CBAFED
6. De cima para baixo, da direita para a esquerda (TTB-RTL): CFBEAD
7. Direita para a esquerda, de baixo para cima (RTL-BTT): FEDCBA
8. De baixo para cima, da direita para a esquerda (BTT-RTL): FCEBDA

Desafio

Escreva um bloco retangular de texto que possa ser lido em cada uma das oito maneiras acima, como oito programas de linha única no idioma de sua escolha. Cada um desses programas deve gerar um número inteiro diferente de um a oito.

Não importa qual direção de leitura gera qual número, eles não precisam corresponder aos números acima. Por exemplo, se o seu bloco de texto ainda estivesse

ABC
DEF

em seguida, o programa de ABCDEFsaída de poder 5e FEDCBAsaída de poder 2, e os outros seis programas saída seria 1, 3, 4, 6, 7, e 8em alguma ordem.

O bloco de texto pode conter qualquer caractere, exceto os terminadores de linha .

A saída deve ir para stdout ou uma alternativa semelhante se o seu idioma não tiver um stdout adequado. Não há entrada. Você pode assumir que os programas são executados em um ambiente REPL.

Pietu1998 caridosamente escreveu um JSFiddle que fornece os 8 programas de linha única diferentes quando recebe um bloco de texto. Eu fiz isso em um snippet de pilha:

<script>function f(n){n=n.split("\n");var e=n.map(function(n){return n.length}).sort()[n.length-1];n=n.map(function(n){return(n+Array(e+1).join(" ")).substring(0,e)});var t=n[0].split("").map(function(e,t){return n.map(function(n){return n[t]}).join("")});n=[n.join(""),n.reverse().join(""),t.join(""),t.reverse().join("")],n=n.concat(n.map(function(n){return n.split("").reverse().join("")})),document.getElementById("a").innerHTML=n.map(function(n,e){return document.getElementById("b").checked?n+"   "+"LLTTRRBB"[e]+"T"+"RRBBLLTT"[e]+"-"+"TBLRBTRL"[e]+"T"+"BTRLTBLR"[e]:n}).join("\n")}</script><textarea onkeyup="f(this.value)" id="c" placeholder="Code"></textarea><br/><input type="checkbox" id="b" onchange="f(document.getElementById('c').value)" checked/>&nbsp;<label for="b">Show directions</label><br/><pre id="a"></pre>

^{Você ainda pode encontrar a versão CJam de Martin aqui .}

Pontuação

Sua pontuação é a área do seu bloco de texto (a largura é a altura). A finalização com a menor pontuação vence. (Essencialmente o menor código vence, daí a tag code-golf .) O desempate vai para o envio publicado anteriormente.

O exemplo é 2 por 3, portanto, sua pontuação é 6. Uma pontuação menor que 4 (2 por 2) é impossível porque alguns dos 8 programas seriam idênticos e não poderiam gerar dois valores diferentes.

J, 3 * 3 = 9

1[2
+2+
2+2

Executando todas as direções:

       ". '1[2+2+2+2','2+2+2+1[2','1+2[2+2+2','2+2[2+1+2','2+2+2+2[1','2[1+2+2+2','2+2+2[2+1',:'2+1+2[2+2'
1 7 3 4 8 2 6 5

Explicação:

• Em J, a execução vai da direita para a esquerda e não há precedência do operador.
• O [( left) pega o lado esquerdo de seus dois operandos e, portanto, basicamente cancela todo o lado direito da nossa expressão, por exemplo, 1+2[2+2+2torna 1+2[6- se e então 1+2.
• As expressões esquerdas são adições com um total de 1, 2, 3 e 4 operandos. Existem duas nexpressões de cada operando, uma com o número 1e outra com apenas 2s. As adições com 1geram os números ímpares e os outros geram os pares.

Befunge-98 ,5x5 = 25 5x3 = 15

1+4+2
$.@.$
3+4+4

Escrevi um pequeno script que encontrou os números corretos para mim. Demorou um pouco, mas, ei, acabei de vencer o GolfScript! : D

Os scripts que usei estão aqui e aqui , mas não sugiro examiná-los, pois o estilo do código é extremamente cancerígeno.

Subprogramas

1+4+2$.@.$3+4+4   LTR-TTB   5
3+4+4$.@.$1+4+2   LTR-BTT   7
1$3+.+4@4+.+2$4   TTB-LTR   3
2$4+.+4@4+.+1$3   TTB-RTL   4
4+4+3$.@.$2+4+1   RTL-BTT   8
2+4+1$.@.$4+4+3   RTL-TTB   6
4$2+.+4@4+.+3$1   BTT-RTL   2
3$1+.+4@4+.+4$2   BTT-LTR   1

Versão antiga

 1.6
3 @ 4
.@ @.
8 @ 7
 2.5

Subprogramas

Saída os números 1-8 respectivamente.

 1.6 3 @ 4.@ @.8 @ 7 2.5    LTR-TTB
 2.5 8 @ 7.@ @.3 @ 4 1.6    LTR-BTT
 3.8 1 @ 2.@ @.6 @ 5 4.7    TTB-LTR
 4.7 6 @ 5.@ @.1 @ 2 3.8    TTB-RTL
 5.2 7 @ 8.@ @.4 @ 3 6.1    RTL-BTT
 6.1 4 @ 3.@ @.7 @ 8 5.2    RTL-TTB
 7.4 5 @ 6.@ @.2 @ 1 8.3    BTT-RTL
 8.3 2 @ 1.@ @.5 @ 6 7.4    BTT-LTR

Brainfuck $ , 4x3 = 12

O Brainfuck $ é muito semelhante ao Brainfuck , mas possui mais alguns comandos, incluindo um comando para gerar o valor atual da célula como saída numérica, o que foi muito útil para esse desafio.

++:+
  ++
++++

Comandos de uma linha:

++:+  ++++++   LTR-TTB, outputs 2
++++  ++++:+   LTR-BTT, outputs 8
+ ++ +:+++++   TTB-LTR, outputs 4
+++:+++ ++ +   TTB-RTL, outputs 3
++++++  +:++   RTL-BTT, outputs 7
+:++++  ++++   RTL-TTB, outputs 1
+++++:+ ++ +   BTT-RTL, outputs 5
+ ++ +++:+++   BTT-LTR, outputs 6

TECO, 3 * 5 = 15

 +4 5
+2=4 
 +1 \

=imprime o valor da última expressão numérica. \é usado para ler ou escrever números de strings, mas eu o uso apenas como descarte aqui.

• +4 5+2=4 +1 \ 7
• + +2+4=1 4 5 \ 6
• + +2+1=4 4 \ 5 3
• +1 \+2=4 +4 5 2
• \ 1+ 4=2+5 4+ 5
• \ 5 4 1=4+2+ + 1 1
• 5 \ 4 4=1+2+ + 4
• 5 4+ 4=2+\ 1+ 8

piet - 12x12 = 144

Como um programa de uma linha nunca pode terminar, assuma que ele termina após a primeira saída.

8 subprogramas em uma única imagem:

GolfScript, 4x4 = 16

1})7
)  }
}  )
3)}5

Utiliza o bom e velho "super comentário": um inigualável }ignora o restante do código (na verdade, nesse caso, um comentário normal #teria funcionado tão bem, pois todo o código é executado como uma única linha). Portanto, em cada canto, existe apenas um único número ou (na outra direção) esse número incrementado em 1, porque a execução termina e o conteúdo da pilha é impresso. Os 8 programas são

1})7)  }}  )3)}5  # LTR-TTB
1)}3}  ))  }7})5  # TTB-LTR
3})1)  }}  )5)}7  # BTT-LTR
3)}5}  ))  }1})7  # LTR-BTT
5})3)  }}  )7)}1  # RTL-BTT
5)}7}  ))  }3})1  # BTT-RTL
7})5)  }}  )1)}3  # TTB-RTL
7)}1}  ))  }5})3  # RTL-BTT

Haskell, 26x26 = 676

Usa comments ( --) para ocultar os bits para trás e para os lados. Isso o torna terrivelmente longo

main=print 1--2 tnirp=niam
a                        a
i                        i
n                        n
=                        =
p                        p
r                        r
i                        i
n                        n
t                        t

3                        4
-                        -
-                        -
5                        6

t                        t
n                        n
i                        i
r                        r
p                        p
=                        =
n                        n
i                        i
a                        a
main=print 7--8 tnirp=niam

Prelúdio , 5x3 = 15

12 34
  !  
56 78

Isso pressupõe que o intérprete Python , que imprime valores como números em vez de códigos de caracteres.

Isso não supera o Befunge $, mas supera a minha apresentação no GolfScript, e eu gosto da sua simplicidade. Observe também que ele usa apenas 9 caracteres não espaciais, o que é menor do que qualquer outro envio até o momento (J ataca novamente :)). No Prelude, cada dígito é empurrado para a pilha individualmente e, dependendo do caminho, há um dígito diferente logo antes do !, que apenas imprime o elemento superior da pilha. Os 8 programas são:

12 34  !  56 78   LTR-TTB   4
56 78  !  12 34   LTR-BTT   8
1 52 6 ! 3 74 8   TTB-LTR   6
4 83 7 ! 2 61 5   TTB-RTL   7
87 65  !  43 21   RTL-BTT   5
43 21  !  87 65   RTL-TTB   1
8 47 3 ! 6 25 1   BTT-RTL   3
5 16 2 ! 7 38 4   BTT-LTR   2

Como alternativa, há também

 1 3 
1+!+1
 5 7 

O que empurra os números ímpares nos caminhos verticais e os incrementa 1nos caminhos horizontais:

 1 3 1+!+1 5 7    LTR-TTB   4
 5 7 1+!+1 1 3    LTR-BTT   8
 1 1+5 ! 3+7 1    TTB-LTR   5
 1 3+7 ! 1+5 1    TTB-RTL   7
 7 5 1+!+1 3 1    RTL-BTT   6
 3 1 1+!+1 7 5    RTL-TTB   2
 1 7+3 ! 5+1 1    BTT-RTL   3
 1 5+1 ! 7+3 1    BTT-LTR   1

CJam - 7 × 7

Não é impressionante, mas não houve resposta CJam e eu gosto da aparência :)

 8;];1 
7     2
;  0  ;
] 0 0 ]
;  0  ;
6     3
 5;];4 

Ele usa principalmente o fato de ];limpar a pilha.

Experimente online

Ruby - 7x7

Também não é impressionante, a mesma tática da resposta de Haskell.

p 1#2 p

3     7
#     #
4     8

p 5#6 p

R, 9x9

Sem espaço em branco, sem comentários.

75%%99299
99%%99699
%%299%%41
%%699%%06
995999997
11%%999%%
99%%799%%
39719%%99
59519%%16

Eu acho que isso pode ser expandido para o tamanho que você quiser. Eu pensei que o operador de módulo era o mais flexível dos operadores disponíveis, pois evita que os valores sejam muito grandes, independentemente do tamanho dos dados, e não há efeito de ter números realmente grandes no meio.

75%%9929999%%99699%%299%%41%%699%%0699599999711%%999%%99%%799%%39719%%9959519%%16   LTR-TTB  2
59519%%1639719%%9999%%799%%11%%999%%995999997%%699%%06%%299%%4199%%9969975%%99299   LTR-BTT  3
79%%9193559%%91999%%265%%75%%999%%1199999979999%%999%%26%%999%%99409%%9199167%%96   TTB-LTR  4
99167%%9699409%%9126%%999%%99%%999%%999999799%%999%%11%%265%%7559%%9199979%%91935   TTB-RTL  1
61%%9159599%%91793%%997%%99%%999%%1179999959960%%996%%14%%992%%99699%%9999299%%57   RTL-BTT  5
99299%%5799699%%9914%%992%%60%%996%%799999599%%999%%11%%997%%9999%%9179361%%91595   RTL-TTB  6
69%%7619919%%90499%%999%%62%%999%%9999799999911%%999%%57%%562%%99919%%9553919%%97   BTT-RTL  7
53919%%9799919%%9557%%562%%11%%999%%997999999%%999%%99%%999%%6219%%9049969%%76199   BTT-LTR  8

Esta linguagem de programação, 5 * 9 = 45

1i;i2
2   2
+   +
i   i
;   ;
i   i
+   +
2   2
5i;i6

O que significa isso:

1i;i22   2+   +i   i;   ;i   i+   +2   25i;i6
5i;i62   2+   +i   i;   ;i   i+   +2   21i;i2
12+i;i+25i       i;       ;i       i22+i;i+26
22+i;i+26i       i;       ;i       i12+i;i+25
6i;i52   2+   +i   i;   ;i   i+   +2   22i;i1
2i;i12   2+   +i   i;   ;i   i+   +2   26i;i5
62+i;i+22i       i;       ;i       i52+i;i+21
52+i;i+21i       i;       ;i       i62+i;i+22

Como ;encerra o programa, o acima se traduz no seguinte:

1i;   - outputs 1
5i;   - outputs 5
12+i; - outputs 3
22+i; - outputs 4
6i;   - outputs 6
2i;   - outputs 2
62+i; - outputs 8
52+i; - outputs 7

Explicação: qualquer número de 0para 9coloca o dígito correspondente na pilha. +aparece os dois principais valores xe ysai da pilha e empurra x + ypara a pilha. igera a pilha como um número inteiro.