Para este desafío, una colcha de arte ASCII será un bloque de texto de 24 caracteres de ancho y 18 líneas de alto, que contiene los caracteres =-<>/\
en un patrón similar a una colcha que es simétrica horizontal y verticalmente.
Edredón de ejemplo:
========================
------------------------
//\\//\\\//\/\\///\\//\\
<<><<>>>>><<>><<<<<>><>>
/\\/\\\\/\/\/\/\////\//\
------------------------
/\/////\\///\\\//\\\\\/\
\///\/\/\\\\////\/\/\\\/
\///\/\/\\\\////\/\/\\\/
/\\\/\/\////\\\\/\/\///\
/\\\/\/\////\\\\/\/\///\
\/\\\\\//\\\///\\/////\/
------------------------
\//\////\/\/\/\/\\\\/\\/
<<><<>>>>><<>><<<<<>><>>
\\//\\///\\/\//\\\//\\//
------------------------
========================
Todos los edredones tienen la misma forma:
- Siempre son 24 por 18.
- La línea superior (línea 1) y la línea inferior (línea 18) están
=
completamente cruzadas. - Las líneas 2, 6, 13 y 17 están
-
al otro lado. - Las líneas 4 y 15 son el mismo patrón aleatorio simétrico horizontalmente de
<
y>
. - Todas las demás líneas (3, 5, 7, 8, 9, 10, 11, 12, 14, 16) se rellenan
/
y\
de forma completamente aleatoria, de modo que toda la colcha permanece horizontal y verticalmente simétrica .
Tenga en cuenta que al plegar la colcha exactamente por la mitad, ya sea vertical u horizontalmente, las formas de los caracteres coinciden exactamente. No confundas esto con los personajes que coinciden. por ejemplo, la línea 3 y la línea 16 no son idénticas, son imágenes especulares verticales.
Reto
Escriba un programa o función que imprima o devuelva una colcha de arte ASCII aleatoria.
Debido a las muchas líneas codificadas y la simetría, la única aleatoriedad real proviene de los primeros 12 caracteres en las líneas 3, 4, 5, 7, 8, 9:
- Los primeros 12 caracteres de la línea 4 deben poder tener una longitud de 12 cadenas de caracteres
<
y>
. - Los primeros 12 caracteres en las líneas 3, 5, 7, 8, 9 deben poder tener una longitud de 12 cadenas de los caracteres
/
y\
(independientes entre sí). - Estas cadenas aleatorias se reflejan en consecuencia para hacer toda la colcha.
La respuesta más corta en bytes gana. Tiebreaker es una publicación anterior.
Puede usar generadores de números pseudoaleatorios. (No, no es necesario demostrar que todas cadena de carbón de 12 <>
o /\
se puede generar con PRNG de que el lenguaje.)
La salida puede contener opcionalmente una nueva línea final, pero no espacios finales u otros caracteres además de lo que es necesario para la colcha.
Respuestas:
CJam,
61605855545251 bytesSe acortó un poco con la ayuda de Sp3000 y Optimizer.
Pruébalo aquí.
Explicación
Como es habitual con estos desafíos de arte ASCII simétricos, estoy generando un cuadrante y luego lo amplío al máximo mediante dos operaciones de duplicación apropiadas.
Para esta explicación, debería comenzar con la función
F
, que estoy definiendo en algún lugar del camino, porque se usa en tres lugares para tres cosas diferentes:Esto espera un número entero en la parte superior de la pila y una cadena debajo de eso. Su propósito es invertir la cadena y también intercambiar algunos caracteres, para obtener el reflejo correcto. El entero es
1
o3
e indica si (1
) se deben intercambiar los corchetes y las barras inclinadas o (3
) solo se deben intercambiar los corchetes. Así es como funciona:Ahora para el resto del código:
Las dos mitades y esa nueva línea se imprimen automáticamente al final del programa.
fuente
Python 3,
257229192185176149143 bytesCon la ayuda de @xnor, ¡finalmente hemos alcanzado a JS!
Salida de muestra:
Explicación
(Ligeramente desactualizado, se actualizará más tarde)
"444046402"
codifica las filas, y cada dígito se refiere al índice inicial de la subcadena de 2 caracteres correspondiente de'--==\/<>'
. Cada fila individual se construye de adentro hacia afuera a través de la combinación repetida de los dos caracteres (usandosample(...,2)
,random.shuffle
desafortunadamente , está en su lugar) y la unión de cadenas.Un ejemplo simplificado de cómo se vería la expansión para la cuarta fila es:
que produciría
><>><><<><
:El edredón general también se construye de adentro hacia afuera, ya que la construcción comienza con las filas 9 y 10, trabajando hacia afuera. Para hacer esto, comenzamos con una lista vacía
L
, a la que agregamos filas al frente y atrás a medida que avanzamosLa
n<"5"
condición es verificar si tenemos una fila que consiste en><
, en cuyo caso agregamos una fila idéntica a la parte posterior, de lo contrario su reverso.Finalmente,
*_,=
es forzar la evaluaciónmap
para que se produzca la impresión, y es solo una forma más corta de hacerloprint("\n".join(L))
.Durante mucho tiempo tuve la función
que toma una cadena y la convierte
/\><
en\/<>
respectivamente, pero finalmente logré deshacerme de ella :)fuente
Python 2, 300 bytes
Este programa utiliza
join, lambda, replace, sample, import
y otras funciones detalladas, por lo que no ganará ningún premio de golf.El código antes de que el auto-golfista lo obtuviera:
Una salida de muestra:
fuente
APL (
5358)Desafortunadamente, no es tan simétrico como pensé que era. La solución me costó 5 caracteres y ahora estoy fuera de la carrera.
Explicación:
L←+,3-⌽
: L es una función que devuelve su argumento seguido de 3, el reverso de su argumentoL{L?12⍴2}¨⍳9
: genera 9 líneas de 12 valores aleatorios a partir de [1,2] más su reverso, luego el reverso de esas 9 líneas732451451260688⊤⍨18/8
: genera la lista0 2 4 6 4 2 4 4 4 4 4 4 2 4 _7_ 4 2 0
(ahí es donde está la maldita asimetría)+
: para cada línea, agregue el número correspondiente a cada valor↑
: formato como matriz'==--/\<><'[
...]
: para cada uno de los números en la matriz, seleccione el carácter de la cadena en esa posiciónSalida:
fuente
<>
líneas no son simétricas verticalmente cuando usas tu tabla de intercambio al hacer el espejo vertical también. (Gracias por publicar la salida por cierto, hace que descubrir si APL funciona mucho más fácilmente; p)<
al final de la cadena e incrementando la segunda línea una vez más, intercambiándola dos veces). Ni siquiera tuve que desechar todo, aunque ya no ganará más. (Tal vez la próxima vez no debería publicar la salida: P)PHP,
408,407,402,387, 379 bytesNo soy un buen golfista, pero este problema sonaba divertido, así que lo probé.
Código sin golf
La versión sin golf tiene una pequeña bonificación: puede pasarle un número entero para sembrar
rand()
y obtener la misma colcha cada vez que se obtiene una semilla:Esto resulta, por ejemplo, en esta hermosa colcha tejida a mano:
Editar : Resulta que mi primera versión no devolvió una colcha correcta. Entonces lo arreglé. Curiosamente, la solución es aún más corta.
fuente
['/','<','\\','>','a','b']
se puede sustituir por['/','<','\\','>',a,b]
(nótese las comillas que faltan alrededor dea
yb
),@$s
se puede sustituir por$s
, puede almacenarstr_repeat('-',12)
ystr_repeat('=',12)
en las variables / constantes globales,for($b=8;$b>=0;$b--)
se puede sustituir porfor($b=9;$b--;)
,str_repeat
y las funciones repetidas se puede acortar, dando su nombre a una variable global (por ejemploglobal$R,$V;$R=str_repeat;$V=strrev;$V($R('=',12))
:) y nuevas líneas (\n
) pueden reemplazarse por una cadena de varias líneas.strrev
sin cambios, eliminé 1 espacio y algunos pequeños cambios.<>><><
líneas) sean iguales.JavaScript (ES6) 169
195 201Editar 6 bytes guardados thx @nderscore. Cuidado, la nueva línea dentro de las comillas inversas es significativa y contada.
Edite2 construcción de filas simplificada, sin necesidad de
reverse
yconcat
Ejecute el fragmento para probar (en Firefox)
fuente
z
. Mover la definición delQ
interior de laMath.random
llamada. Reemplazar'\n'
con una cadena de plantilla de nueva línea.|0
no se necesita conversión de números enteros, ya que los valores se corregirán más adelante.for(_ of-z+z)
?z
no es numérico, entonces -z es NaN (no es un número) NaN convertido a cadena es "NaN" y 3 caracteres + 9 caracteres son 12.Rubí,
162155Me gusta este porque me hizo aprender a abusar de las barras invertidas en los literales de cadena y
String#tr
. De lo contrario, el código no es terriblemente inteligente, solo compacto.fuente
/
adentroa
yb
. El primerotr
probablemente también puede prescindir de paréntesis.'='
Se pueden escribir cadenas de un solo carácter como?=
. Y.join
puede ser reemplazado por*
.join
sinónimos de caracteres me ahorran 6 bytes. Sin embargo, no puedo eliminar los paréntesisx+x.reverse.tr(a,b)
porque+
tiene prioridad,
. Estoy también en realidad no escapar de las barras en mis cuerdas - Estoy fallando escapar una barra invertida en cada una. Una segunda\
es necesariab
debido a la forma en quetr
funciona, aunque ahora me doy cuenta el primero\
ena
superfluo, por lo que no es otro byte.Pyth, 57
59 61Muchas gracias a @Jakube por presentar estas versiones de 57 bytes.
Algoritmo muy similar al de Martin. (Revisado) Explicación por venir.
Pruébalo en línea
Explicación:
fuente
"<>"
con-GK
J"\<>/"K"\/"L+b_mXdK_Kbjbym+d_XdJ_JmsmOk12[\=\-K-JKK\-KKK
o reduciendoJ"\<>/"K"\/"jbu++HGXHK_Km+d_XdJ_JmsmOk12[KKK\-K-JKK\-\=)Y
J,
5654 bytesUso:
1 byte gracias a @FUZxxl.
Explicación próximamente.
Pruébelo en línea aquí.
fuente
5 1 3 1 5 1 1 1
con(3(2})8$5,3#1)
.Python
295287227 bytesNo es tan bueno, pero lo publicaré de todos modos:
Si quieres una explicación solo pregúntame.
fuente
=
y-
end
.Javascript ( Proyecto de ES7 )
174168146Alguna inspiración tomada de @ edc65
Editar: Gracias a edc65 por algunas ideas para optimizar la construcción de filas.
Demostración: ( solo Firefox )
Comentado:
fuente
Pharo 4, 236
o formateado normalmente:
Explicación:
La cadena
s:='====----/\/\/<><<>'
junto con el bloquef:=[:c|s at:(s indexOf:c)+i]
están aquí tanto para lanzar los caracteres como para invertir los patrones ...Para i = 1, realiza la reversión horizontal (
/
<->\
,<
<->>
).Para i = 3, realiza la reversión vertical (
/
<->\
)Para i = 1 o 2 en Random, se lanza entre
/
o\
,<
o>
'=-/</-///'
codifica el tipo de caracteresc
que alimentará el bloquef
para las 9 primeras líneas.#() , '=-/</-///'
es un truco de concatenación para transformar la cadena en una matriz y, por lo tanto, recolectarla en una matriz.El resto es simple concatenación después de aplicar la simetría horizontal / vertical.
fuente
Chirrido 4.X, 247
O formateado:
Explicaciones:
s:='==--/\<>'.
obviamente codifica los cuatro pares posibles.r:=(1<<108)atRandom.
arroje 108 bits (en un LargeInteger) para 9 filas * 12 columnas (arrojamos el == y - sin necesidad, pero el rendimiento no es nuestro problema).h:=''
es la cadena donde concatenaremos (pintor Schlemiel porque una secuencia sería demasiado costosa en caracteres).(16to:0by:-2),(0to:16by:2)do:[:i|
está iterando en las filas (* 2)(11to:0by:-1),(0to:11) do:[:j|
está iterando en las columnas28266
es un número mágico que codifica el par que se utilizará en las primeras 9 líneas.Es el patrón de bits
00 01 10 11 10 01 10 10 10
, donde 00 codifica '==', 01 '-', 10 '/ \' y 11 '<>'.101
es un número mágico que codifica la reversión horizontal y vertical.Es el patrón de bits
0000 0000 0110 1010
, que codifica cuándo invertir (1) o no (0) el primer (0) o segundo (1) carácter de cada par '==' '-' '/ \' y '<>', para la simetría vertical y la simetría horizontal.n:=3 bitAnd: 28266>>i
proporciona la codificación del par de caracteres para la fila i / 2 (0 para '==', 1 para '-', 2 para '/ \' y 3 para '<>').(r-1 bitAt: 6*i+j+1)
seleccione el bit aleatorio para la fila i / 2 columna j (1 es el rango del bit más bajo, por lo tanto, tenemos un +1, k en el lanzamiento aleatorio en el intervalo [1, k], por lo tanto tenemos un -1).(101 bitAt: 3-n*4+m+p)
elija el bit de inversión: (3-n) * 4 es el desplazamiento para el grupo de 4 bits correspondiente al código de par n, m es el desplazamiento de reversión vertical (0 para los primeros 9, 2 para las últimas 9 filas), p es el desplazamiento de reversión horizontal (0 para los primeros 12, 1 para las últimas 12 columnas) +1 porque el rango de bits bajo es 1.bitXor:
realiza la reversión (responde un desplazamiento 0 o 1) ys at:2*n+1+bitXor_offset
selecciona el carácter correcto en s.Pero
(A>>a)+(B>>b) bitAnd: 1
cuesta menos bytes que,(A bitAt:a+1)bitXor:(B bitAt:b+1)
por lo tanto, el bitXor se reescribió y el desplazamiento +1 en p desapareció ...h,#[13]
es un chirrido feo, podemos concatenar una cadena con un ByteArray (que contiene el código para el retorno de carro).fuente