Dibuja una colcha de arte ASCII aleatoria

31

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.

Pasatiempos de Calvin
fuente
¿Podemos tomar la entrada como una semilla aleatoria?
Destructible Lemon

Respuestas:

15

CJam, 61 60 58 55 54 52 51 bytes

Se acortó un poco con la ayuda de Sp3000 y Optimizer.

"=-/</-///"{C*1{"<\/>"%1$W%\_W%er}:F~+mrC<1FN}%s3F(

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:

{"<\/>"%1$W%\_W%er}:F

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 1o 3e indica si ( 1) se deben intercambiar los corchetes y las barras inclinadas o ( 3) solo se deben intercambiar los corchetes. Así es como funciona:

"<\/>"            "Push a string with all four relevant characters.";
      %           "% applied to a string and an integer N (in any order) selects every
                   Nth character, starting from the first. So with N = 1 this just
                   leaves the string unchanged, but with N = 3 it returns a string
                   containing only < and >.";
       1$         "Copy the string we want to mirror.";
         W%       "% also takes negative arguments. Giving it -1 reverses the string.";
           \_     "Swap the two strings and duplicate the <\/> or <> string.";
             W%   "Reverse that one. Due to the symmetry of this string, we'll now
                   have the characters to be swapped at corresponding indices.";
               er "Perform element-wise transliteration on the reversed input string
                   to complete the mirroring operation.";

Ahora para el resto del código:

"=-/</-///"                            "This string encodes the 9 different line types.
                                        Note that for the /\ and <> lines we only use
                                        one of the characters. This idea is due to
                                        Sp3000. Thanks! :)";
           {                   }%      "Map this block onto the characters.";
            C*                         "Repeat the character 12 times, turning it into
                                        a string.";
              1{...}:F~                "Define and call F on the resulting string. The
                                        reversal doesn't do anything, but the character
                                        swapping creates strings containing both \/ and
                                        <>.";
                       +mr             "Add the two halves together and shuffle them.";
                          C<           "Truncate to 12 characters. We've now got our
                                        random half-lines.";
                            1F         "Call F again to mirror the half-line.";
                              N        "Push a newline.";
                                 s     "Join all those separate strings together by
                                        converting the array to a string.";
                                  3F   "Perform one more mirroring operation on the
                                        half-quilt, but this time only swap < and >.
                                        This yields the correct full quilt, except
                                        there are two newlines in the centre.";
                                    (  "This slices the leading newline off the second
                                        half and pushes it onto the stack.";

Las dos mitades y esa nueva línea se imprimen automáticamente al final del programa.

Martin Ender
fuente
12

Python 3, 257 229 192 185 176 149 143 bytes

from random import*
k,*L=80703,
while k:s=eval("''"+".join(sample('--==<>\/'[k%4*2:][:2],2))"*12);L=[s]+L+[s[::(-1)**k]];k//=4
*_,=map(print,L)

Con 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 (usando sample(...,2), random.shuffledesafortunadamente , 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:

''.join(['<','>']).join(['>','<']).join(['>','<']).join(['<','>']).join(['>','<'])

que produciría ><>><><<><:

               ''
    <>         .join(['<','>'])
   >  <        .join(['>','<'])
  >    <       .join(['>','<'])
 <      >      .join(['<','>'])
>        <     .join(['>','<'])

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 avanzamos

L=[s]+L+[[s,s[::-1]][n<"5"]]

La 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ón mappara que se produzca la impresión, y es solo una forma más corta de hacerlo print("\n".join(L)).

Durante mucho tiempo tuve la función

g=lambda s:s.translate({60:62,62:60,92:47,47:92})

que toma una cadena y la convierte /\><en \/<>respectivamente, pero finalmente logré deshacerme de ella :)

Sp3000
fuente
La especificación dice que siempre que pueda generar todas las alfombras posibles, está bien.
6

Python 2, 300 bytes

Este programa utiliza join, lambda, replace, sample, importy otras funciones detalladas, por lo que no ganará ningún premio de golf.

from random import*
f=lambda a,b,t:t.replace(a,'*').replace(b,a).replace('*',b)
k=lambda a:''.join(sample(a*12,12))
c='-'*24
e=k('<>')
h=e+f('<','>',e[::-1])
j=[d+f('/','\\',d[::-1])for d in[k('\\/')for i in'quilt']]
g=['='*24,c,j[0],h,j[1],c]+j[2:]
print'\n'.join(g+[f('/','\\',d)for d in g[::-1]])

El código antes de que el auto-golfista lo obtuviera:

from random import *

change = lambda a,b,t: t.replace(a,'*').replace(b,a).replace('*',b)
pick = lambda a: ''.join(sample(a*12, 12))

innerline = '-' * 24
line4h = pick('<>')
line4 = line4h + change('<', '>', line4h[::-1])
diag = [d + change('/', '\\', d[::-1]) for d in [pick('\\/') for i in 'quilt']]

quilt = ['='*24, innerline, diag[0], line4, diag[1], innerline] + diag[2:]
print '\n'.join(quilt + [change('/', '\\', d) for d in quilt[::-1]])

Una salida de muestra:

========================
------------------------
\\\\/\////\\//\\\\/\////
<><<>>>><><><><><<<<>><>
/\\\\////\\\///\\\\////\
------------------------
\\\\//\///\\//\\\/\\////
//\//\\\\/\/\/\////\\/\\
\/\\\\/\//\/\/\\/\////\/
/\////\/\\/\/\//\/\\\\/\
\\/\\////\/\/\/\\\\//\//
////\\/\\\//\\///\//\\\\
------------------------
\////\\\\///\\\////\\\\/
<><<>>>><><><><><<<<>><>
////\/\\\\//\\////\/\\\\
------------------------
========================
Caballero Lógico
fuente
99
No es el más corto, pero bueno, con 7 bytes más tienes un programa digno de tu nombre : D
Calvin's Hobbies
Veo lo que hiciste alli.
Logic Knight
2
Auto-golfista? ¿Nadie tiene tiempo para jugar al golf a mano?
Lars Ebert
55
Nos conoces hackers. Si tengo que hacer una tarea de 3 minutos más de una vez, pasaré 10 horas escribiendo un programa para automatizarlo. Me interesa la eficiencia ;-)
Logic Knight
6

APL ( 53 58)

Desafortunadamente, no es tan simétrico como pensé que era. La solución me costó 5 caracteres y ahora estoy fuera de la carrera.

L←+,3-⌽⋄'==--/\<><'[↑(732451451260688⊤⍨18/8)+L{L?12⍴2}¨⍳9]

Explicación:

  • L←+,3-⌽: L es una función que devuelve su argumento seguido de 3, el reverso de su argumento
  • L{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íneas
  • 732451451260688⊤⍨18/8: genera la lista 0 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ón

Salida:

========================
------------------------
///////\\///\\\//\\\\\\\
<<><<><><<<<>>>><><>><>>
\\\\\//\/\\\///\/\\/////
------------------------
/\///\\/\/\/\/\/\//\\\/\
\////////\//\\/\\\\\\\\/
\\/\\\//\///\\\/\\///\//
//\///\\/\\\///\//\\\/\\
/\\\\\\\\/\\//\////////\
\/\\\//\/\/\/\/\/\\///\/
------------------------
/////\\/\///\\\/\//\\\\\
<<><<><><<<<>>>><><>><>>
\\\\\\\//\\\///\\///////
------------------------
========================
marinus
fuente
1
Tenía + 1ed porque el algoritmo que publicaste era interesante y original, pero acabo de notar que tus <>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)
FryAmTheEggman
@FryAmTheEggman: mierda, no me di cuenta de eso. Probablemente tendré que desechar todo el algoritmo ahora, ya que hay una línea que no es como las otras. Bueno, gracias por decirme en lugar de solo votar a favor.
marinus
@FryAmTheEggman: bueno, está arreglado (agregando otro <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)
marinus
2
Esa solución es bastante inteligente, puedes mantener el +1 :)
FryAmTheEggman
@ Calvin'sHobbies: arregla una cosa, rompe otra. Ahora está realmente arreglado.
marinus
6

PHP, 408 , 407 , 402 , 387 , 379 bytes

No soy un buen golfista, pero este problema sonaba divertido, así que lo probé.

<?$a=str_replace;$b=str_repeat;function a($l,$a,$b){while(strlen($s)<$l){$s.=rand(0,1)?$a:$b;}return$s;}$c=[$b('=',12),$b('-',12),a(12,'/','\\'),a(12,'<','>'),a(12,'/','\\'),$b('-',12)];while(count($c)<9){$c[]=a(12,'/','\\');}for($d=9;$d--;){$c[$d].=strrev($a(['/','<','\\','>',1,2],[1,2,'/','<','\\','>'],$c[$d]));$c[]=$a(['/','\\',1],[1,'/','\\'],$c[$d]);}echo implode("
",$c);

Código sin golf

<?php

    function randomString($length, $a, $b) {
        $string = '';
        while(strlen($string) < $length) {
            $string .= rand(0, 1) ? $a : $b;
        }
        return $string;
    }

    if(isset($argv[1])) {
        srand(intval($argv[1]));
    }

    $lines = [
        str_repeat('=', 12),
        str_repeat('-', 12),
        randomString(12, '/', '\\'),
        randomString(12, '<', '>'),
        randomString(12, '/', '\\'),
        str_repeat('-', 12)
    ];
    while(count($lines) < 9) {
        $lines[] = randomString(12, '/', '\\');
    }

    for($index = count($lines); $index--;) {
        $lines[$index] .= strrev(str_replace(['/', '<', '\\', '>', 1, 2], [1, 2, '/', '<', '\\', '>'], $lines[$index]));
        $lines[] = str_replace(['/', '\\', 1], [1, '/', '\\'], $lines[$index]);
    }

    echo implode("\n", $lines) . "\n";

?>

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:

php quilt.php 48937

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.

Lars Ebert
fuente
1
Se pueden hacer muchas cosas desde un campo de esto: ['/','<','\\','>','a','b']se puede sustituir por ['/','<','\\','>',a,b](nótese las comillas que faltan alrededor de ay b), @$sse puede sustituir por $s, puede almacenar str_repeat('-',12)y str_repeat('=',12)en las variables / constantes globales, for($b=8;$b>=0;$b--)se puede sustituir por for($b=9;$b--;), str_repeaty las funciones repetidas se puede acortar, dando su nombre a una variable global (por ejemplo global$R,$V;$R=str_repeat;$V=strrev;$V($R('=',12)):) y nuevas líneas ( \n) pueden reemplazarse por una cadena de varias líneas.
Ismael Miguel
Aquí hay una versión más corta: pastebin.com/2TabUqbA (373 bytes). He cambiado algunos consejos: eliminé las variables globales, dejó strrevsin cambios, eliminé 1 espacio y algunos pequeños cambios.
Ismael Miguel
44
Creo que necesitas que la línea 4 y la línea 15 (las <>><><líneas) sean iguales.
Logic Knight el
1
Lo sentimos, aquí hay una solución de 357 bytes: pastebin.com/TugNDjjL Olvidé reducir algunas cosas.
Ismael Miguel
@IsmaelMiguel Gracias por tu ayuda. Tomé algunos de sus consejos, pero algunos de ellos resultan en un aviso que se lanza.
Lars Ebert
4

JavaScript (ES6) 169 195 201

Editar 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 reverseyconcat

F=(o='')=>[...z='/\\/-/<\\-='].map((c,i,_,y=[z,'\\/\\-\\>/-='],q=[for(_ of-z+z)Math.random(Q=k=>q.map(v=>r=y[v^!k][i]+r+y[v^k][i],r='')&&r+`
`)*2])=>o=Q()+o+Q(i!=5))&&o

Ejecute el fragmento para probar (en Firefox)

F=(o='')=>[...z='/\\/-/<\\-='].map((c,i,_,y=[z,'\\/\\-\\>/-='],q=[for(_ of-z+z)Math.random(Q=k=>q.map(v=>r=y[v^!k][i]+r+y[v^k][i],r='')&&r+`
`)*2])=>o=Q()+o+Q(i!=5))&&o

Q.innerHTML=F()
<pre id=Q style='font-size:9px;line-height:9px'>

edc65
fuente
1
-6 bytes: eliminar paréntesis alrededor de la definición de z. Mover la definición del Qinterior de la Math.randomllamada. Reemplazar '\n'con una cadena de plantilla de nueva línea. |0no se necesita conversión de números enteros, ya que los valores se corregirán más adelante.
nderscore
¿Qué significa esto for(_ of-z+z)?
Derek 朕 會 功夫
@Derek Necesito iterar 12 veces y lo mejor que tengo es una cadena de 9 caracteres. zno 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.
edc65
4

Rubí, 162 155

Me 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.

a='/\\'
b='\\\/'
t=Array.new(9){x=''
12.times{x+=a[rand(2)]}
x+x.reverse.tr(a,b)}
t[0]=?=*24
t[1]=t[5]=?-*24
t[3].tr!a,'<>'
puts t,((t.reverse*'
').tr a,b)
ezrast
fuente
2
¡Bienvenido a Programming Puzzles & Code Golf Stack Exchange! Aquí hay un par de consejos específicos de Ruby: no creo que necesite escapar de /adentro ay b. El primero trprobablemente también puede prescindir de paréntesis. '='Se pueden escribir cadenas de un solo carácter como ?=. Y .joinpuede ser reemplazado por *.
Martin Ender
@ MartinBüttner Gracias por la bienvenida y los consejos! Los literales y joinsinónimos de caracteres me ahorran 6 bytes. Sin embargo, no puedo eliminar los paréntesis x+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 necesaria bdebido a la forma en que trfunciona, aunque ahora me doy cuenta el primero \en asuperfluo, por lo que no es otro byte.
Ezrast
3

Pyth, 57 59 61

J"\<>/"K"\/"L+b_mXdK_Kbjbym+d_XdJ_JmsmOk12[\=\-K-JKK\-KKK

J"\<>/"K"\/"jbu++HGXHK_Km+d_XdJ_JmsmOk12[KKK\-K-JKK\-\=)Y

Muchas 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:

=G"\<>/"                            : Set G to be the string "\<>/"
K"\/"                               : Set K to be the string "\/"
Jm+d_XdG_GmsmOk12[\=\-K"<>"K\-KKK;  : Set J to be the top half of the carpet
                 [\=\-K"<>"K\-KKK;  : Make a list of possible chars for each row
          msmOk12                   : for each element of that list,
                                    : make a list of 12 randomly chosen characters
                                    : from it, then join them
Jm+d_XdG_G                          : for each element of that list,
                                    : make a new list with the old element,
                                    : and its horizontal reflection
jb+J_mXdK_KJ                        : Print the whole carpet
     mXdK_KJ                        : For each element of J make its vertical reflection
FryAmTheEggman
fuente
Muy agradable. No debería haber tirado la toalla. 1 ahorro de char reemplazando "<>"con-GK
Jakube
Y otro usando lambda J"\<>/"K"\/"L+b_mXdK_Kbjbym+d_XdJ_JmsmOk12[\=\-K-JKK\-KKKo reduciendoJ"\<>/"K"\/"jbu++HGXHK_Km+d_XdJ_JmsmOk12[KKK\-K-JKK\-\=)Y
Jakube
@Jakube ¡Gracias! Ambas son optimizaciones bastante inteligentes. Realmente me gusta cómo la lambda te permite poner la lista al final.
FryAmTheEggman
2

J, 56 54 bytes

'=/\<>--></\'{~(-,|.)0,(3(2})8$5,3#1)+(,1-|.)"1?8 12$2

Uso:

   '=/\<>--></\'{~(-,|.)0,(3(2})8$5,3#1)+(,1-|.)"1?8 12$2
========================
------------------------
///\\\\/\///\\\/\////\\\
><<><><>><>><<><<><><>><
\\/\//\\/\//\\/\//\\/\//
------------------------
\/\/\//////\/\\\\\\/\/\/
/\/\\//\//\\//\\/\\//\/\
//\\\\/////\/\\\\\////\\
\\////\\\\\/\/////\\\\//
\/\//\\/\\//\\//\//\\/\/
/\/\/\\\\\\/\//////\/\/\
------------------------
//\/\\//\/\\//\/\\//\/\\
><<><><>><>><<><<><><>><
\\\////\/\\\///\/\\\\///
------------------------
========================

1 byte gracias a @FUZxxl.

Explicación próximamente.

Pruébelo en línea aquí.

randomra
fuente
Guardar un personaje: reemplazar 5 1 3 1 5 1 1 1con (3(2})8$5,3#1).
FUZxxl
@FUZxxl ¡Genial! Intenté un montón de alternativas pero no he encontrado esto. (CJam se escapó de la noche a la mañana para que J no los alcance.: P)
randomra
1

Python 295 287 227 bytes

No es tan bueno, pero lo publicaré de todos modos:

from random import*
m,d=[],dict(zip("\/<>=-","/\><=-"))
v=lambda w:[d[x]for x in w]
for e in '=-/>/-///':f=[choice([e,d[e]])for x in[0]*12];t=''.join(f+v(f[::-1]));print t;m+=''.join(e=='/'and v(t)or t),
print'\n'.join(m[::-1])

Si quieres una explicación solo pregúntame.

Def
fuente
@ Sp3000 Gracias por señalarlo, lo arreglé. Una pena que llegó incluso si ya pesar de que ...
Def
Aquí hay un montón de campos de golf que son demasiado largos para caber en un comentario. Es posible que pueda conseguirlo abajo aún más si se pone =y -en d.
Sp3000
@ Sp3000 Muchas gracias por todos los consejos. Mucho de esto era bastante obvio (espacios, eliminación invertida) ya que no soy el mejor golfista (tanto código como irl), pero también aprendí algo nuevo de Python (así que de nuevo, gracias). Eliminar la declaración if al incluir = y - en el dict resultó ser una muy buena idea. PD: ¿te importaría explicar cómo se hace una colcha recursiva en tan poco código (descifrar la traducción es una mierda)
Def
1

Javascript ( Proyecto de ES7 ) 174 168 146

Alguna inspiración tomada de @ edc65

Editar: Gracias a edc65 por algunas ideas para optimizar la construcción de filas.

F=(o='')=>[for(i of'555357531')(z=[for(_ of c='==--/\\<>golf')Math.random(r=x=>z.reduce((s,y)=>c[w=i^y^x]+s+c[w^1],'')+`
`)*2],o=r()+o+r(i<7))]&&o

Demostración: ( solo Firefox )

F=(o='')=>[for(i of'555357531')(z=[for(_ of c='==--/\\<>golf')Math.random(r=x=>z.reduce((s,y)=>c[w=i^y^x]+s+c[w^1],'')+`
`)*2],o=r()+o+r(i<7))]&&o

document.write('<pre>' + F() + '</pre>');


Comentado:

// define function, initialize output to ''
F = (o = '') =>
    // loop through character indexes of first 9 lines
    [
        for (i of '555357531')(
            // build array of 12 random 0/1's, initialize character list
            z = [
                for (_ of c = '==--/\\<>golf')
                    Math.random(
                        // define function for generating lines
                        // if x is true, opposite line is generated
                        r = x =>
                            z.reduce(
                                (s, y) => 
                                    c[w = i ^ y ^ x] + s + c[w ^ 1],
                                ''
                            ) + `\n`
                    ) * 2
            ],
            // build new lines and wrap output in them
            // x true in the second line for indexes < 7 (not character '>')
            o = r() + o + r(i < 7)
        )
    ]
    // return output
    && o
nderscore
fuente
1
Vea mi edición, también es bueno para su solución
edc65
@ edc65 buena idea! He implementado algo similar ahora.
nderscore
0

Pharo 4, 236

|s i f v h|s:='====----/\/\/<><<>'.f:=[:c|s at:(s indexOf:c)+i].v:=#(),'=-/</-///'collect:[:c|h:=(String new:12)collect:[:x|i:=2atRandom.f value:c].i:=1.h,(h reverse collect:f)].i:=3.String cr join:v,(v reverse collect:[:k|k collect:f])

o formateado normalmente:

|s i f v h|
s:='====----/\/\/<><<>'.
f:=[:c|s at:(s indexOf:c)+i].
v:=#() , '=-/</-///'
  collect:[:c|
    h:=(String new:12)collect:[:x|i:=2atRandom.f value:c].
    i:=1.
    h,(h reverse collect:f)].
i:=3.
String cr join:v,(v reverse collect:[:k|k collect:f])

Explicación:

La cadena s:='====----/\/\/<><<>'junto con el bloque f:=[: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 caracteres cque alimentará el bloque fpara 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.

========================
------------------------
\\/\/\\\\/\/\/\////\/\//
>>>><><><>><><<><><><<<<
\/\/\//\///\/\\\/\\/\/\/
------------------------
/\//\/\/////\\\\\/\/\\/\
\\//\//\\\/\/\///\\/\\//
////\\/\/\//\\/\/\//\\\\
\\\\//\/\/\\//\/\/\\////
//\\/\\///\/\/\\\//\//\\
\/\\/\/\\\\\/////\/\//\/
------------------------
/\/\/\\/\\\/\///\//\/\/\
>>>><><><>><><<><><><<<<
//\/\////\/\/\/\\\\/\/\\
------------------------
========================
aka.nice
fuente
0

Chirrido 4.X, 247

|r s h m n p|s:='==--/\<>'.r:=(1<<108)atRandom.h:=''.m:=0.(16to:0by:-2),(0to:16by:2)do:[:i|n:=3bitAnd:28266>>i.p:=0.(11to:0by:-1),(0to:11)do:[:j|h:=h,(s at:n*2+1+(r-1>>(6*i+j)+(101>>(3-n*4+m+p))bitAnd:1)).j=0and:[p:=1]].i=0and:[m:=2].h:=h,#[13]].h

O formateado:

|r s h m n p|
s:='==--/\<>'.
r:=(1<<108)atRandom.
h:=''.
m:=0.
(16to:0by:-2),(0to:16by:2) do:[:i|
  n:=3 bitAnd: 28266>>i.
  p:=0.
  (11to:0 by:-1),(0to:11) do:[:j|
    "h:=h,(s at:n*2+1+((r-1bitAt:6*i+j+1)bitXor:(101bitAt:3-n*4+m+p))). <- originally"
    h:=h,(s at:n*2+1+(r-1>>(6*i+j)+(101>>(3-n*4+m+p))bitAnd:1)).
    j=0and:[p:=1]].
  i=0and:[m:=2].
  h:=h,#[13]].
h

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 columnas

28266es 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 '<>'.

101es 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) y s at:2*n+1+bitXor_offsetselecciona el carácter correcto en s.

Pero (A>>a)+(B>>b) bitAnd: 1cuesta 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).

========================
------------------------
/\/\\\/\//\/\/\\/\///\/\
><>><<>>>><<>><<<<>><<><
////\\////\\//\\\\//\\\\
------------------------
/\\\/\\/\\//\\//\//\///\
\/\\/\//////\\\\\\/\//\/
\\\//\\\////\\\\///\\///
///\\///\\\\////\\\//\\\
/\//\/\\\\\\//////\/\\/\
\///\//\//\\//\\/\\/\\\/
------------------------
\\\\//\\\\//\\////\\////
><>><<>>>><<>><<<<>><<><
\/\///\/\\/\/\//\/\\\/\/
------------------------
========================
aka.nice
fuente