O título diz tudo. Seu objetivo é escrever um programa que forme um retângulo de caracteres × × h que possa ser girado e execute novamente para gerar o número de rotações 90 ° no sentido anti-horário (CCW) que foram feitas.

Por exemplo, se o programa 3 × 2

abc
def

resolvido o problema, inicialmente produziria 0 e rotações sucessivas de 90 ° CCW

cf    fed    da
be    cba    eb
ad           fc

produziria 1, 2 e 3, respectivamente.

O uso de comentários faz desta uma tarefa trivial a maioria dos idiomas. Em Ruby, por exemplo, isso pode ser feito em um retângulo 7 × 7:

###p###
### ###
###1###
p 0#2 p
###3###
### ###
###p###

O desafio é fazer isso sem nenhum tipo de comentário.

Pontuação

Sua pontuação é w * h, a área do seu retângulo. Novas linhas são excluídas. Em outras palavras, code-golf, novas linhas não são contadas.

A pontuação para o exemplo do Ruby é 49 (embora, é claro, seja inválida, pois possui comentários).

Notas

• Seu código deve ser realmente retangular, sem caracteres ausentes no final das linhas.
• Se você desejar, pode gerar outros valores legais de "mod 90 °" em vez de 0 1 2 3. Portanto, 8 é bom em vez de 0 e -1 é bom em vez de 3, etc.
• A saída pode ir para o console ou para um arquivo.
• Aplicam-se brechas padrão.

Espero que isso, minha primeira pergunta, realmente intrigue algumas pessoas. Desfrutar!

APL (1x3 = 3)

5!3

Esta solução usa a regra extra de que qualquer saída que esteja correta no mod 4 funcione.

No APL, x!yé o número de maneiras de escolher xelementos y, comumente conhecido como binom(y,x)ou choose(y,x). Vamos verificar se cada rotação dá a resposta certa.

0 rotações

5!3

Não há como escolher 5 elementos de 3, então obtemos 0, que é impresso automaticamente.

1 rotação no sentido anti-horário

3
!
5

A APL avalia felizmente cada linha, obtendo o número 3, o operador !e o número 5, imprimindo apenas o último destes ( 5), que é 1 mod 4.

2 rotações no sentido anti-horário

3!5

Isto é binom(5,3), qual é (5*4*3*2*1)/(3*2*1)/(2*1) = 10, que é 2 mod 4.

3 rotações no sentido anti-horário

5
!
3

Como antes, apenas o último valor avaliado de 3é impressora.

Na verdade, eu não conheço o APL, então, por favor, me diga se tenho alguma explicação errada. Encontrei por tentativa e erro como o primeiro idioma neste site que:

1. Imprime automaticamente o resultado de uma expressão
2. Dadas várias linhas de expressão, apenas produz a última
3. Não há problema com um operador sozinho na linha
4. Leva operadores infix
5. Possui um operador binário aritmético de caractere único que é assimétrico (aRb! = BRa) e flexível o suficiente para retornar uma variedade de números.

Em (5), desci a lista de funções diádicas da APL . Minha primeira operação candidata foi a divisão inteira /de C e Python 2, mas a divisão APL ÷fornece flutuadores. Exponenciação é tentador, mas falha porque ae a^btêm a mesma paridade, mas são obtidas por rotações consecutivas (a não ser b=0, mas então b^a=0). Operadores booleanos como <doação 0e 1180 graus de diferença, o que não funciona. Finalmente, encontrei o operador binomial !e tentei números até conseguir alguns que funcionassem.

Agradecemos a Quincunx por sua confiança de que existe uma solução menor que 2x2.

Rubi, 7 × 9 (63)

 30;p  
0||p=p 
0|0;p;p
;p;p|p;
p=p ||0
;p   p;
2||p =p
 00;1  
     p 

Um pouco mais do que a outra solução, mas pelo menos essa solução não depende de qualquer impressão implícita ou abuso de regras. Para todas as quatro rotações, o código completo é analisado e, com exceção de um curto-circuito, tudo é executado. Surpreendentemente, não há absolutamente nenhuma simetria no código

Esta solução depende do fato de que ainda é possível chamar a pfunção (que é usada para imprimir os números), mesmo que uma variável com o mesmo nome já tenha sido definida. Por exemplo, algo como p pchama a função pcom a variável pcomo argumento (assim, imprimindo o valor de p).

Explicação para algumas das expressões comuns usadas no código:

• p: Como mencionado acima, isso é uma chamada de função ou uma variável. Quando a variável não está definida, isso chama a função psem argumentos, que não faz nada e retorna nil.
• p p: Imprime a variável p.
• p|x: Quando pé a função, isso é idêntico a nil|x, que retorna verdadeiro / falso, dependendo do valor de x. Se pé um número inteiro, é bit a bit ou. De qualquer forma, esta afirmação não tem efeito colateral.
• p=p||x: Efetivamente o mesmo que p||=x(atribuição condicional) com a vantagem de ser sintaticamente válido e não-op quando revertido.

Versão simétrica (9 × 10 = 90)

    p    

  0 * 0  
  00100  
  0||2* p
p *0||0  
  00300  
  0 * 0  

    p    

Esta é a solução simétrica mais curta (C ₂ ao ignorar os números a serem impressos) que eu poderia apresentar.

Script de teste

Aqui está um script de teste para verificar o código acima (o #final da linha foi adicionado para que o espaço em branco não seja removido e seja removido antes da execução):

rotate=->s{s.split($/).map{|i|i.chars.reverse}.transpose.map(&:join).join($/)}

s=<<EOD.gsub(?#,"")
 30;p  #
0||p=p #
0|0;p;p#
;p;p|p;#
p=p ||0#
;p   p;#
2||p =p#
 00;1  #
     p #
EOD


puts ">>> 0°"
eval s
puts ">>> 90°"
eval rotate[s]
puts ">>> 180°"
eval rotate[rotate[s]]
puts ">>> 270°"
eval rotate[rotate[rotate[s]]]

GolfScript, 4 (2x2)

43
12

Imprime 4312qual é 0(mod 4). As rotações são impressas 3241(1 mod 4), 2134(2 mod 4) e 1423(3 mod 4).

Solicitado por:

Se você desejar, pode gerar outros valores legais de "mod 90 °" em vez de 0 1 2 3. Portanto, 8 é bom em vez de 0 e -1 é bom em vez de 3, etc.

Na verdade, existem muitos conjuntos de números para os quais isso funciona. Eu os encontrei com este programa Python:

def f(a,b,c,d):
    return int("%i%i%i%i"%(a,b,c,d))
for a in range(10):
    for b in range(10):
        for c in range(10):
            for d in range(10):
                candidate = f(a,b,c,d) % 4 == 0
                candidate &= f(b,d,a,c) % 4 == 1
                candidate &= f(d,c,b,a) % 4 == 2
                candidate &= f(c,a,d,b) % 4 == 3
                if candidate:
                    print("%i, %i, %i, %i"%(a,b,c,d))

Embora o programa produza 0s (o que provavelmente não funcionaria), as soluções válidas são da forma

ab
cd

Onde a∈{4,8}, b∈{3,7}, c∈{1,5,9}, d∈{2,6}. IE, (a,b,c,d)∈{4,8}×{3,7}×{1,5,9}×{2,6}que são 24 soluções.

Python - 23 x 23 = 529

Ok, esta pergunta já foi vencedora, mas ainda não existe uma solução Python. Então eu pensei sobre isso - fortemente! - e encontrou uma maneira de fazer com que o printcomando volumoso funcionasse em qualquer direção sem gerar erros quando analisado de uma das outras direções.

O avanço foi a seguinte linha:

'"\'';forward_code;"';backward_code;""\'"''

Enquanto o forward_codeé executado, o backward_codefaz parte de uma sequência e, portanto, não é impresso. É exatamente o contrário ao ler para trás.

Então, combinada com mais duas direções e ajustada para obter todas as cotações correspondentes corretamente, acabo com a seguinte solução:

''"''""''"''"''"'"''""'
"  ""                 "
"  \\                 "
'"\'';print 1;"'""\'"''
'"\''"';3 tnirp;""\'"''
"  ;""                "
"  p'                 "
'  r;                 '
'  i2                 '
"  n                  "
"  tt                 "
'   n                 '
'  4i                 '
"  ;r     .-=<>=-.    "
' \"p    /__----__\   '
"  ';'  |/ (')(') \|  "
"  ""    \   __   /   "
'  ""    .`--__--`.   '
"  \\   /    :|    \  "
'  ''  (_)   :|   (_) '
'  ""    |___:|____|  '
"  ''    |_________|  "
''"''""''"''"''"'"''""'

Edit: Encontrei uma maneira de lidar com todo esse espaço em branco. ;)

BASIC, 64

Não vai ganhar, mas aqui está assim mesmo. (Testado no Chipmunk Basic )

?0:END:?
:::::::1
D:::::::
N::::::E
E::::::N
:::::::D
3:::::::
?:DNE:2?

Nota: ?é uma abreviação para PRINTvários dialetos do BASIC. Embora existam muitos erros de sintaxe no código, a ENDinstrução na primeira linha impede que eles sejam vistos pelo intérprete.

Pitão , 9 caracteres (3x3)

0 1

3 2

Em pyth, tudo é impresso por padrão, a menos que seja precedido por um espaço. Linhas após a primeira linha são para entrada do usuário e não são avaliadas neste programa.

Outra maneira de obter 9 caracteres:

"0"
3 1
"2"

Pyth 1.0.5 , 4 caracteres

Embora alterações recentes no pyth tenham tornado mais difícil a geração de números de 2 dígitos (uma alteração que estou pensando em reverter), as versões mais antigas do Pyth têm uma geração fácil de números de dois dígitos, que, combinada com a impressão implícita e o fato de que todas as linhas, exceto a primeira são ignorados, fornece a seguinte solução:

32
41

Imprime 32,21,14,43.

Befunge, 16

0.@1
@@@.
.@@@
3@.2

Explicação: Dígitos de 0para 9empurrar o número correspondente na pilha, .exibe um valor da pilha e o imprime como um número inteiro e @finaliza o programa.

(testado aqui )

Piet, 49

Fiz questão apenas de usar as cores amarela e vermelha e tentar torná-la mais ou menos simétrica. Quando girado, imprime 0, 1, 2 ou 3. Sair do programa em Piet é difícil e ocupa, infelizmente, metade do espaço da imagem.

GNU dc , 6 (3x2)

Eu acho que esta é a resposta mais curta para não exigir o relaxamento da regra "mod 90 °":

3z1
0p2

Saídas 0, 1, 2ou 3para cada rotação.

Para as rotações 0, 2e 3, psimplesmente aparece e imprime o último número literal que foi enviado à pilha. Para a 1rotação, zempurra a profundidade atual da pilha (1) para a pilha, depois a ppopa e a imprime.

GolfScript, 9 (3x3)

0}1
} }
3}2

Meio que abusando das regras. O }acontece para terminar o programa, se não houver correspondência {, e o conteúdo da pilha são impressos no final do programa.

JavaScript, 4

03
12

Quando você executa este programa (ou uma rotação deste programa) em um console javaScript, apenas a última linha é avaliada e ecoada no console.

Assim:

12 modulo 4 == 0
01 modulo 4 == 1
30 modulo 4 == 2
23 modulo 4 == 3

Aqui estão todos os programas 2x2 semelhantes que também funcionam:

03
12

03
16

03
52

03
56

03
92

03
96

07
12

07
16

07
52

07
56

07
92

07
96

43
12

43
16

43
52

43
56

43
92

43
96

47
12

47
16

47
52

47
56

47
92

47
96

83
12

83
16

83
52

83
56

83
92

83
96

87
12

87
16

87
52

87
56

87
92

87
96

Em outros termos,

ab
cd

onde a está em [0,4,8], b está em [3,7], c está em [1,5,9] e d está em [2,6]

CJam / GolfScript - 3 * 3

2;3
;7;
1;0

O ponto e vírgula exibe o número anterior, portanto, apenas o canto inferior direito é impresso.

Aheui , 8

바몽희뷸
뷷희몽반

Como Aheui não possui uma letra que empurre 1 na pilha, decidi imprimir 0, 5, 2 e 3.

Explicação: 바 e 반 pressionam 0 e 2, respectivamente, na pilha e movem o cursor para a direita por um caractere. 뷷 e 뷷 pressionam 5 e 3, respectivamente, na pilha e move o cursor para baixo em dois caracteres. 몽 aparece e imprime o número na pilha e move o cursor para cima em um caractere. 희 finaliza o programa.

Javascript

(Introduzido no console do navegador, shell ou outro REPL, para que o resultado seja impresso)

1+2
-3-
4+5

Deve funcionar para qualquer outro idioma com expressões, novas linhas não significativas e impressão automática do resultado.

Matlab / Oitava - 144 100

Golfe: 10 x 10 = 100

....d.....
....i.....
....s.....
... p2 ...
disp  1...
...3  psid
... 4p ...
.....s....
.....i....
.....d....

Solução alternativa: 15 x 15 = 225

.......d.......
.......i.......
.......s.......
...    p    ...
...         ...
...    4    ...
...    .    ...
disp 1...3 psid
...    .    ...
...    2    ...
...         ...
...    p    ...
.......s.......
.......i.......
.......d.......

Perl 5x7 (35)

1+p+t+1
-print+
1+i+i+1
+tnirp+
1+t+p+1

Um pouco atrasado para a festa. O solitário -determina qual número é impresso.

JavaScript, 3

2
1
4

Funciona ... na base 7.

Versão base 9:

2
7
0

Explicação

Quando executado interativamente, por exemplo, a partir de um console de depuração, o valor da última instrução / expressão será gerado.

4 ₇ = 4 ₁₀ ≣ 0 (mod 4 )
412 ₇ = 205 ₁₀ ≣ 1 (mod 4 )
2 ₇ = 2 ₁₀ ≣ 2 (mod 4 )
214 ₇ = 109 ₁₀ ≣ 3 (mod 4 )

Soluções semelhantes podem ser encontradas para qualquer base ímpar.

Befunge, 12 (6x2)

Consegui apresentar uma pequena melhoria na resposta existente do Befunge, aproveitando ao máximo a natureza bidimensional do Befunge e fazendo com que o caminho do código fosse executado verticalmente em duas das orientações.

0.@.1v
v3.@.2

Experimente online: Início 0 , Rotação 1 , Rotação 2 , Rotação 3 .

Marbelous, 7 * 14 = 98

.. \/ \/ .. ..
.. 31 \\ 32 \/
\/ \\ \/ \\ \/
\/ 30 \\ 33 ..
.. .. \/ \/ ..

Argh! / Aargh! (4 * 4 = 16)

O que houve com o uso da ferramenta certa para o trabalho? Não há comentários (no idioma em geral).

Toda a família de programas (gerada em J: ((|.@:|:) ^: (i. 4)) >'hpqh';'q01p';'p32q';'hqph'ou ((|.@:|:) ^: (i. 4)) 4 4 $ 'hpqhq01pp32qhqph')

hpqh
q01p
p32q
hqph

girado uma vez:

hpqh
q12p
p03q
hqph

girado duas vezes:

hpqh
q23p
p10q
hqph

girado três vezes:

hpqh
q30p
p21q
hqph

Para explicar isso, talvez seja melhor consultar uma versão "recuada" (que também funciona em todas as rotações):

hhpq h
  0  h
q   1p
p3   q
h  2  
h qphh

Esta versão mostra que o programa consiste em 4 partes separadas, uma para cada rotação individual.

• h - ajuste o fluxo de controle para a esquerda

• p - imprime item na varredura de dados / código abaixo dele

• q - saia do programa

Flutuador - 9 × 5 = 45

Imprime 4, 1, 2 ou 3 no console.

Observe que 'Black' é uma instrução válida (NOP) e é sintática. Sem ele, ele não consegue encontrar a posição inicial. Assim, todas as posições no retângulo são ocupadas.

Elemento, 2x3 = 6

1*
`2
3 

Esta é uma melhoria em relação à solução ingênua 3x3, que possui uma `no meio com um número em cada lado. O caso 0, mostrado acima, é o mais interessante, já que o *é usado para multiplicar os 3 por nada para obter 0. Fora isso, não é tão complicado.

Se você achar o espaço estranho, poderá substituí-lo por praticamente qualquer outro caractere, exceto []{}`_.

Para referência, aqui estão as outras três rotações:

case 1
*2 
1`3

case 2
 3
2`
*1

case 3
3`1
 2*

Chip, (2x5) 10

b~
+a
~t
e*
 f

*ativa todos os elementos vizinhos: norte, leste, sul e oeste (origem)
~se não for ativado a partir do oeste, ativa o vizinho leste (NOT-gate) (nunca ativado aqui)
tfinaliza a execução após a impressão do byte atual
adefinir o bit 0x01dos
bconjuntos de saída o bit 0x02da saída
edefine o bit 0x10da saída
fdefine o bit 0x20da saída,
+se ativado por qualquer vizinho, ative todos os outros vizinhos (fio)

O chip requer o -wsinalizador (para permitir a execução sem entrada) ou alguma entrada para ser executado.

Prints 0, 1, 2, ou 3em ASCII. Se os pontos de código 0x00para 0x03se desejado, remover o ee f, em seguida, deslocar o espaço até preencher a lacuna.

Japt , 3 * 1 = 3 bytes

5zB

Experimente on-line: como está , girado uma vez , duas vezes , três vezes .

Saídas 0, 5, 2, 11 respectivamente.

A variável Bpossui o valor 11 e Number.z(other)é a divisão do piso (todos procuraram aparentemente: p). Para código de várias linhas, a última linha é passada para a saída, o que é simplesmente uma constante aqui.

2 * 2 = 4 bytes

2J
1T

Experimente on-line: como está , girado uma vez , duas vezes , três vezes .

Saídas 0, 21, 2, -1 respectivamente.

Tdetém 0 e Jdetém -1.

O truque é que, se dois literais ou variáveis ​​forem colocados lado a lado, uma vírgula será inserida e a saída será apenas a última.

A solução 2 * 2 JS também funciona em Japt.