El título lo dice todo. Su objetivo es escribir un programa que forme un rectángulo de caracteres aw × h que se pueda rotar y volver a ejecutar para generar el número de rotaciones de 90 ° en sentido antihorario (CCW) que se han realizado.

Por ejemplo, si el programa 3 × 2

abc
def

resuelto el problema, inicialmente produciría 0 y rotaciones sucesivas de 90 ° CCW

cf    fed    da
be    cba    eb
ad           fc

produciría 1, 2 y 3 respectivamente.

El uso de comentarios hace que esta sea una tarea trivial en la mayoría de los idiomas. En Ruby, por ejemplo, se puede hacer en un rectángulo de 7 × 7:

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

El desafío es hacer esto sin ningún tipo de comentario.

Puntuación

Su puntaje es w * h, el área de su rectángulo. Las líneas nuevas están excluidas. En otras palabras, code-golf, nuevas líneas no contadas.

La puntuación para el ejemplo de Ruby es 49 (aunque, por supuesto, no es válida ya que tiene comentarios).

Notas

• Su código debe ser realmente rectangular sin caracteres faltantes al final de las líneas.
• Si lo desea, puede generar otros valores legales "mod 90 °" en lugar de 0 1 2 3. Entonces 8 está bien en lugar de 0 y -1 está bien en lugar de 3, etc.
• La salida puede ir a la consola o a un archivo.
• Se aplican lagunas estándar.

Espero que esta, mi primera pregunta, realmente intriga a algunas personas. ¡Disfrutar!

APL (1x3 = 3)

5!3

Esta solución utiliza la regla adicional de que cualquier salida que sea correcta mod 4 funciona.

En APL, x!yes el número de formas de elegir xelementos y, comúnmente conocido como binom(y,x)o choose(y,x). Verifiquemos que cada rotación dé la respuesta correcta.

0 rotaciones

5!3

No hay forma de elegir 5 elementos de 3, por lo que obtenemos 0, que se imprime automáticamente.

1 rotación CCW

3
!
5

APL evalúa felizmente cada línea, obteniendo el número 3, el operador !y luego el número 5, imprimiendo solo el último de estos ( 5), que es 1 mod 4.

2 rotaciones CCW

3!5

Esto es binom(5,3), que (5*4*3*2*1)/(3*2*1)/(2*1) = 10es 2 mod 4.

3 rotaciones CCW

5
!
3

Como antes, solo el último valor evaluado de 3es la impresora.

En realidad no conozco APL, así que dígame si me equivoqué en alguna de las explicaciones. Lo encontré por prueba y error como el primer idioma en este sitio que:

1. Imprime automáticamente el resultado de una expresión
2. Dadas múltiples líneas de expresiones, solo genera la última
3. No tiene ningún problema con un operador parado solo en una línea
4. Toma operadores infijo
5. Tiene un operador binario aritmético de un solo carácter que es asimétrico (aRb! = BRa) y lo suficientemente flexible como para devolver una variedad de números.

Para (5), revisé la lista de funciones diádicas APL . Mi primera operación candidata fue la división entera /de C y Python 2, pero la división APL ÷da flotantes. La exponenciación es tentadora, pero falla porque ay a^btiene la misma paridad, pero se obtienen rotaciones consecutivas (a menos que b=0, pero luego b^a=0). A los operadores booleanos les gusta <dar 0y 1180 grados de separación, lo que no funciona. Finalmente, encontré el operador binomial !y probé números hasta que obtuve algo de ese trabajo.

Gracias a Quincunx por su confianza en que existe una solución más pequeña que 2x2.

Rubí, 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 

Un poco más largo que la otra solución, pero al menos esta solución no depende de ninguna impresión implícita o abuso de reglas. Para las cuatro rotaciones, se analiza el código completo y, aparte de algunos cortocircuitos, se ejecuta todo. Sorprendentemente, no hay absolutamente ninguna simetría en el código.

Esta solución se basa en el hecho de que todavía es posible llamar a la pfunción (que se utiliza para imprimir los números) incluso si ya se ha definido una variable con el mismo nombre. Por ejemplo, algo así como p pllama a la función pcon la variable pcomo argumento (por lo tanto, imprime el valor de p).

Explicación de algunas de las expresiones comunes utilizadas en el código:

• p: Como se mencionó anteriormente, esta es una llamada a una función o una variable. Cuando la variable no está definida, esto llama a la función psin argumentos, que no hace nada y devuelve nil.
• p p: Imprime la variable p.
• p|x: Cuando pes la función, esta es idéntica a nil|x, que devuelve verdadero / falso dependiendo del valor de x. Si pes un entero, es bit a bit o. De cualquier manera, esta declaración no tiene efectos secundarios.
• p=p||x: Efectivamente lo mismo que p||=x(asignación condicional) con la ventaja de ser sintácticamente válido y no operativo cuando se invierte.

Versión simétrica (9 × 10 = 90)

    p    

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

    p    

Esta es la solución simétrica más corta (C ₂ al ignorar los números para imprimir) que se me ocurrió.

Script de prueba

Aquí hay un script de prueba para verificar el código anterior ( #se han agregado los extremos de la línea para que el espacio en blanco no se elimine y se elimine antes de la ejecución):

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 4312cuál es 0(mod 4). Las rotaciones se imprimen 3241(1 mod 4), 2134(2 mod 4) y 1423(3 mod 4).

Provocado por:

Si lo desea, puede generar otros valores legales "mod 90 °" en lugar de 0 1 2 3. Entonces 8 está bien en lugar de 0 y -1 está bien en lugar de 3, etc.

En realidad, hay muchos conjuntos de números para los que esto funciona. Encontré esto con este programa de 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))

Aunque el programa genera 0s (que probablemente no funcionaría), las soluciones válidas son de la forma

ab
cd

Donde 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 es de 24 soluciones.

Pitón - 23 x 23 = 529

Ok, esta pregunta ya tiene un ganador, pero todavía no hay una solución de Python. Así que lo pensé, ¡en serio! - y encontré una manera de hacer que el printcomando voluminoso funcione en cualquier dirección sin producir errores cuando se analiza desde una de las otras direcciones.

El avance fue la siguiente línea:

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

Mientras forward_codese ejecuta, backward_codeforma parte de una cadena y, por lo tanto, no se imprime. Esto es exactamente al revés cuando se lee al revés.

Entonces, combinado con dos direcciones más y ajustado para que todas las citas coincidan correctamente, termino con la siguiente solución:

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

Editar: encontré una manera de lidiar con todo ese espacio en blanco. ;)

BÁSICO, 64

No ganará, pero aquí está de todos modos. (Probado en Chipmunk Basic )

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

Nota: ?es la abreviatura de PRINTvarios dialectos de BASIC. Aunque hay muchos errores de sintaxis en el código, la ENDdeclaración en la primera línea evita que el intérprete los vea.

Pyth , 9 caracteres (3x3)

0 1

3 2

En pyth, todo se imprime por defecto, a menos que esté precedido por un espacio. Las líneas después de la primera línea son para la entrada del usuario y no se evalúan en este programa.

Otra forma de obtener 9 caracteres:

"0"
3 1
"2"

Pyth 1.0.5 , 4 caracteres

Si bien los cambios recientes en pyth han dificultado la generación de números de 2 dígitos (un cambio que estoy considerando revertir), las versiones anteriores de Pyth tienen una generación de números de dos dígitos fácil, que, combinada con la impresión implícita y el hecho de que todas las líneas menos la primera son ignorados, da la siguiente solución:

32
41

Impresiones 32,21,14,43.

Befunge, 16

0.@1
@@@.
.@@@
[email protected]

Explicación: dígitos desde 0para 9empujar el número correspondiente a la pila,. saca un valor de la pila y lo imprime como un entero, y @finaliza el programa.

(probado aquí )

Piet, 49

Solo decidí usar los colores amarillo y rojo, y tratar de hacerlo más o menos simétrico. Cuando se gira, imprime 0, 1, 2 o 3. Desafortunadamente, salir del programa en Piet es difícil y ocupa aproximadamente la mitad del espacio en la imagen.

GNU dc , 6 (3x2)

Creo que esta es la respuesta más corta para no requerir la relajación de la regla "mod 90 °":

3z1
0p2

Salidas 0, 1,2 o 3para cada rotación.

Para los 0, 2y 3las rotaciones, el psimplemente hace estallar e imprime el número literal de haber sido empujado a la pila. Para la 1rotación, zempuja la profundidad de la pila actual (1) a la pila, luego la psaca e imprime.

GolfScript, 9 (3x3)

0}1
} }
3}2

Una especie de abuso de las reglas. El }sucede para finalizar el programa si no hay coincidencia {, y el contenido de la pila se imprimen al final del programa.

JavaScript, 4

03
12

Cuando ejecuta este programa (o una rotación de este programa) en una consola javaScript, solo la última línea se evalúa y se repite en la consola.

Entonces:

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

Aquí están todos los programas 2x2 similares que también funcionan:

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

En otros términos,

ab
cd

donde a está en [0,4,8], b está en [3,7], c está en [1,5,9] yd está en [2,6]

CJam / GolfScript - 3 * 3

2;3
;7;
1;0

El punto y coma muestra el número anterior, por lo que solo se imprime la esquina inferior derecha.

Aheui , 8

바몽희뷸
뷷희몽반

Como Aheui no tiene una letra que empuje 1 a la pila, decidí imprimir 0, 5, 2 y 3.

Explicación: 바 y 반 empujan 0 y 2, respectivamente, a la pila y mueven el cursor hacia la derecha en un carácter. 뷸 y 뷷 empujan 5 y 3, respectivamente, a la pila y mueven el cursor hacia abajo dos caracteres. 몽 aparece e imprime el número en la pila y mueve el cursor un carácter hacia arriba. 희 termina el programa.

JavaScript

(Ingresado en la consola del navegador, shell u otro REPL, por lo que se imprime el resultado)

1+2
-3-
4+5

Debería funcionar para cualquier otro idioma con expresiones, líneas nuevas no significativas e impresión automática del resultado.

Matlab / Octave - 144 100

Golfizado: 10 x 10 = 100

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

Solución 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

Un poco tarde para la fiesta. El solitario -determina qué número se imprime.

JavaScript, 3

2
1
4

Funciona ... en la base 7.

Versión de base 9:

2
7
0

Explicación

Cuando se ejecuta de forma interactiva, por ejemplo, desde una consola de depuración, se generará el valor de la última declaración / expresión.

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

Se pueden encontrar soluciones similares para cualquier base impar.

Befunge, 12 (6x2)

Me las arreglé para llegar a una ligera mejora en la respuesta Befunge existente aprovechando al máximo la naturaleza bidimensional de Befunge y haciendo que la ruta del código se ejecute verticalmente en dos de las orientaciones.

[email protected]
[email protected]

Pruébelo en línea: Inicio 0 , Rotación 1 , Rotación 2 , Rotación 3 .

Maravilloso, 7 * 14 = 98

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

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

¿Qué fue eso de usar la herramienta adecuada para el trabajo? No hay comentarios (en el idioma en general).

Toda la familia de programas (generados en J: ((|.@:|:) ^: (i. 4)) >'hpqh';'q01p';'p32q';'hqph'o ((|.@:|:) ^: (i. 4)) 4 4 $ 'hpqhq01pp32qhqph')

hpqh
q01p
p32q
hqph

girado una vez:

hpqh
q12p
p03q
hqph

rotado dos veces:

hpqh
q23p
p10q
hqph

rotado tres veces:

hpqh
q30p
p21q
hqph

Para explicar esto, podría ser mejor mirar una versión "con sangría" (que también funciona en todas las rotaciones):

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

Esta versión muestra que el programa consta de 4 partes separadas, una para cada rotación individual.

• h - establecer el flujo de control a la izquierda

• p - Imprimir elemento en el ráster de datos / código debajo de él

• q - salga del programa

Flotador - 9 × 5 = 45

Imprime 4, 1, 2 o 3 en la consola.

Tenga en cuenta que 'Black' es una instrucción válida (NOP) y es sintáctica. Sin ella, no puede encontrar la posición inicial. Por lo tanto, todas las posiciones en el rectángulo están ocupadas.

Elemento, 2x3 = 6

1*
`2
3 

Esta es una mejora sobre la solución ingenua 3x3, que tiene un `en el medio con un número en cada lado. El caso 0, que se muestra arriba, es el más interesante, ya que el* se usa para multiplicar el 3 por nada para obtener 0. Aparte de eso, no es tan complicado.

Si encuentra el espacio incómodo, puede reemplazarlo con casi cualquier otro personaje, excluyendo []{}`_ .

Como referencia, aquí están las otras tres rotaciones:

case 1
*2 
1`3

case 2
 3
2`
*1

case 3
3`1
 2*

Chip, (2x5) 10

b~
+a
~t
e*
 f

*activa todos los elementos vecinos: norte, este, sur y oeste (fuente)
~si no se activa desde el oeste, activa el vecino este (puerta NO) (nunca activado aquí)
tfinaliza la ejecución después de imprimir el byte actual
aestablece el bit 0x01de los
bconjuntos de salida el bit 0x02de la salida
eestablece el bit 0x10de la salida
festablece el bit 0x20de la salida
+si algún vecino lo activa, active todos los demás vecinos (cable)

Chip requiere ya sea el -w indicador (para permitir la ejecución sin entrada) o alguna entrada para poder ejecutarse.

Impresiones 0, 1, 2, o 3en ASCII. Si los puntos de código 0x00que 0x03se desea, eliminar el ey f, a continuación, mover el espacio para llenar la brecha.

Japt , 3 * 1 = 3 bytes

5zB

Pruébelo en línea: tal como está , rotado una vez , dos veces , tres veces .

Salidas 0, 5, 2, 11 respectivamente.

La variable Btiene el valor 11, y Number.z(other)es la división del piso (aparentemente todos buscaron: p). Para el código de varias líneas, la última línea se pasa a la salida, que aquí es simplemente una constante.

2 * 2 = 4 bytes

2J
1T

Pruébelo en línea: tal como está , rotado una vez , dos veces , tres veces .

Salidas 0, 21, 2, -1 respectivamente.

Ttiene 0 y Jtiene -1.

El truco es que, si dos literales o variables se ponen uno al lado del otro, se inserta una coma y la salida es solo la última.

La solución 2 * 2 JS también funciona en Japt.