Ya sabes, se ven así:

^fuente

El objetivo es dibujar una ilustración de ritmos musicales como la siguiente:

=     =      =
=  =  =      =          =
== = ==   =  ==     = ====
== ====  == ===   = = =======
======== == ====  = ========= =
=================================

Las reglas son:

• El ancho de la ilustración es de 33 símbolos, pero si es necesario, se permiten los espacios finales que excedan este ancho.
• Cada columna está hecha de signos iguales ( =).
• Cada columna tiene una altura aleatoria (la altura de la siguiente columna no debe depender de ninguna manera de la altura de la columna anterior), que varía de 1 a 6. También está bien si al menos es posible obtener alguna entrada sin estricta probabilidad matemática (es decir, algunas entradas podrían aparecer más raramente que otras).
• Una columna no puede flotar sobre la parte inferior y tiene huecos.
• Como cada columna tiene la altura mínima de 1, la última fila tampoco puede tener espacios, siempre consta de 33 signos iguales.
• Dado que es posible no tener columnas con una altura de 6 (después de todo, todo es aleatorio): en este caso no necesita tener una línea superior hecha de espacios. Se aplica a cualquier caso de borde de esta naturaleza: si de repente su código no proporcionó columnas con una altura mayor que 1, no necesita tener líneas adicionales hechas de espacios sobre la línea inferior.
• No tomas ninguna entrada .

Pyth , 13 bytes

Y superé a Jelly .

j_.tm*hO6\=33

Pruébalo en línea!

j_.tm*hO6\=33
    m      33  for 33 times:
       O6          yield a random number in [0,1,2,3,4,5].
      h            add one.
     *   \=        repeat "=" that number of times.
  .t           transpose, filling with whitespace
 _             reverse
j              join by newlines.

Dyalog APL , 14 bytes

⊖⍉↑'='⍴¨⍨?33⍴6

Explicación

33⍴6 33 repeticiones de 6

?entero aleatorio en el rango [1, n ] para cada uno de los 33 6s

'='⍴¨⍨ símbolo de igualdad repetido cada una de esas veces

↑ convertir lista de listas a tabla de filas

⍉ transponer filas en columnas, columnas en filas

⊖ voltear al revés

Ejecuciones de ejemplo

La entrada tiene sangría en seis espacios:

      ⊖⍉↑'='⍴¨⍨?33⍴6
=          ==        =      ==   
= =    =   ==      ====     ==   
= = = ===  ==  === ==== =  ===  =
= = ===== ==== === ==== = ====  =
=== ============== ==== ====== ==
=================================
      ⊖⍉↑'='⍴¨⍨?33⍴6
         =  =  =    =    =       
  =      =  =  ==  == == =  =    
 === == ==  =  === =======  =    
==== == ==  ====== ==========   =
==== ============= ========== = =
=================================
      ⊖⍉↑'='⍴¨⍨?33⍴6
             =    =   =  =       
         =   =    =   = == =     
=      = =   =    ==  = ==== === 
= = =  = =   =    ==  = ==== ====
=====  = == ==  ============ ====
=================================

Jalea, 14 bytes

6x33X€”=ẋz⁶Ṛj⁷

Pruébalo aquí

JavaScript (ES6), 116 bytes

(a=Array(33).fill``.map(_=>[,,,,,,].fill` `.fill('=',Math.random()*6)))[0].map((x,i)=>a.map(x=>x[i]).join``).join`
`

Compruébalo en el fragmento animado a continuación:

F = () => (a=Array(33).fill``.map(_=>[,,,,,,].fill` `.fill('=',Math.random()*6)))[0].map((x,i)=>a.map(x=>x[i]).join``).join`
`

var interval;
G = () => output.innerHTML = F().split('\n').map((r, i) => `<span id="row-${6-i}">${r}</span>`).join('\n');
A = () => {
  clearInterval(interval);
  if (auto.checked) {
    speed.disabled = false;
    interval = setInterval(G, speed.value);
  } else {
    speed.disabled = true;
  }
}
S = () => {
  if (stylized.checked) {
    output.classList.add('stylized');
  } else {
    output.classList.remove('stylized');
  }
}

generate.onclick = G;
auto.onchange = speed.onchange = A;
stylized.onchange = S;

G();
A();
S();

#output {
  background: #000;
  color: #9fff8a;
  overflow: hidden;
  padding: 1em;
  line-height: 1;
}

#output.stylized {
  line-height: 0.25;
  font-size: 2em;
  margin: 0.5em 0 0 0;
  padding: 0.5em;
}

.stylized #row-1 { color: #9fff8a; }
.stylized #row-2 { color: #c5ff8a; }
.stylized #row-3 { color: #e0ff8a; }
.stylized #row-4 { color: #ffe88a; }
.stylized #row-5 { color: #ffc28a; }
.stylized #row-6 { color: #ff8a8a; }

<button id="generate">Generate</button>
<label>Auto: <input id="auto" type="checkbox" checked/></label>
<label>Speed: <select id="speed">
  <option value="25">25</option>
  <option value="50">50</option>
  <option value="100" selected>100</option>
  <option value="200">200</option>
  <option value="400">400</option>
  <option value="600">600</option>
  <option value="800">800</option>
  <option value="1000">1000</option>
</select></label>
<label>Stylized: <input id="stylized" type="checkbox" checked/></label>
<pre id="output"></pre>

C, 87 bytes

f(x,y){for(y=6;y--;){srand(time(0));for(x=33;x--;)putchar("= "[rand()%6<y]);puts("");}}

Llamar como f();. Esta respuesta se basa en el hecho de que seis llamadas consecutivas time(0)devuelven el mismo resultado (en segundos). Esto es prácticamente siempre cierto, pero probablemente valga la pena mencionarlo.

Cheddar, 68 65 bytes (no competidor)

->(1:33).map(->IO.sprintf("%6s","="*Math.rand(1,7))).turn().vfuse

¡O_O Cheddar está realmente bien! Usos sprintfy turnpara hacer una gran parte del trabajo. vfusees fusible vertical, lo que significa que se une a la matriz pero verticalmente. Esto es muy golfístico pero también bastante rápido. La versión es la versión preliminar 1.0.0-beta.10 , que es posterior al desafío.

Explicación

->           // Anonymous function
  (1:33)     // Range 1-33 inclusive
  .map(->    // Loop through the above range
    IO.sprintf("%6s",       // `sprintf` from C/C++
      "="*Math.rand(1,7)    // Repeat `=` a random time from [1,7)
    )
  ).turn().vfuse     // Turn it 90deg, and fuse it vertically

Algunos ejemplos se ejecutan:

05AB1E , 22 bytes

Sin unión automática, sin relleno automático durante la transposición, osabie está condenada a esto. Código:

33F6ð×6L.R'=×ðñ})ø€J¶ý

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Python 2, 95 bytes

from random import*
x=map(randrange,[6]*33)
for y in range(6):print''.join('= '[z>y]for z in x)

Python 3, 115 bytes

Python nunca tuvo la oportunidad ...

from random import*
for k in zip(*[[' ']*(6-len(j))+j for j in[randint(1,6)*['=']for i in[0]*33]]):print(*k,sep='')

Cómo funciona

from random import*    Import everything in the random module
randint(1,6)*['=']     Create a list containing a random number in [1,6] of '='...
...for i in[0]*33      ...33 times...
[...]                  ...and store in a list X
for j in...            For all lists j in X...
[' ']*(6-len(j))+j     ...create a list containing j padded with the correct number of
                       spaces to give a height of 6...
[...]                  ...and store in a list Y

Y now contains a list for each output line, but transposed.

for k in zip(*...):...  For all lists k in the transpose of Y...
print(*k,sep='')        Print all elements in k with no separating space

Pruébalo en Ideone

MATL, 20 19 18 17 bytes

1 byte guardado gracias a @Luis

33l2$r6*6:>!~61*c

Pruébalo en línea

SpecaBAS - 76 bytes

1 FOR x=1 TO 33: r=1+INT(RND*6): FOR y=7-r TO 6: ?AT y,x;"=": NEXT y: NEXT x

Imprime un signo igual en la coordenada de pantalla correspondiente.

con una mancha de color y un GOTObucle se convierte

K4, 18 bytes

Esencialmente un puerto de la solución APL (como era de esperar).

+-6$(33?1+!6)#'"="

C #, 200 117 bytes

()=>{var s="";int x,y=6;for(;y-->0;){var r=new Random();for(x=33;x-->0;)s+="= "[r.Next(6)<y?1:0];s+='\n';}return s;};

¡Me muevo al algoritmo @Lynn y guardo 83 bytes!

C # lambda sin entrada y donde la salida es una cadena. Pruébalo en línea .

Código:

()=>{
    var s="";int x,y=6;
    for(;y-->0;){
        var r=new Random();
        for(x=33;x-->0;)
            s+="= "[r.Next(6)<y?1:0];
        s+='\n';
    }return s;
};

Haskell, 164 bytes

Al ser un lenguaje puramente funcional, Haskell estaba condenado desde el principio. Lo hice de todos modos y resulta que la sobrecarga necesaria en realidad no es tan grande.

import System.Random
import Data.List
f r n|r>n=' '|0<1='='
s=do
g<-newStdGen
mapM_ putStrLn$transpose$map(\n->map(f$mod n 6)[0..5])(take 33(randoms g)::[Int])

Uso:

s

Explicación:

import System.Random

para poder usar newStdGenyrandoms

import Data.List

para poder usar transpose

f r n|r>n=' '|0<1='='

define una función que imprime un espacio si su primer argumento es mayor que el segundo y un valor distinto =. Se llama con map (f m) [0..5]un número dado my la lista [0,1,2,3,4,5]. (Vea abajo)

s=do
g<-newStdGen

Crea un nuevo generador de números aleatorios estándar

(take 33(randoms g)::[Int])

toma 33 enteros aleatorios.

map(\n->map(f$mod n 6)[0..5])

Calcula m = n % 6y asigna (f m)a la lista [0,1,2,3,4,5], lo que resulta en uno de "======", " =====", ..., " =". Estas líneas se asignan a la lista de los 33 enteros aleatorios que dan como resultado una tabla. (Una tabla en Haskell es una lista de listas)

transpose$

cambia columnas y filas de la tabla

mapM_ putStrLn$

imprime cada línea en la tabla

CJam, 19 bytes

{5mrS*6'=e]}33*]zN*

Pruébalo en línea!

Explicación

{       e# 33 times...
  5mr   e#   Push a random number in [0 1 2 3 4 5].
  S*    e#   Create a string with that many spaces.
  6'=e] e#   Pad to length 6 with =.
}33*    
]       e# Wrap all 33 strings in a list.
z       e# Transpose that list.
N*      e# Join the lines with linefeeds.

Mathematica, 78 bytes

StringRiffle[(PadLeft[Array["="&,#+1],6," "]&/@5~RandomInteger~33),"
",""]&

Función anónima. No realiza ninguna entrada y devuelve una cadena como salida. El carácter Unicode es U + F3C7, que representa \[Transpose].

R, 102 bytes

m=rep(" ",33);for(i in 1:6){n=ifelse(m=="=",m,sample(c(" ","="),33,T,c(6-i,i)));m=n;cat(n,"\n",sep="")}

Explicación

m=rep(" ",33) iniciar un vector vacío para el próximo ciclo

n=ifelse(m=="=",m,sample(c(" ","="),33,T,c(6-i,i)))Si hay un =en la fila de arriba, entonces asegúrese de que el punto de abajo también tenga un =; de lo contrario elegir al azar. Las selecciones aleatorias se ponderan para asegurarse de que a) la fila inferior sea todo= yb) tenga una forma ordenada de todo.

cat(n,"\n",sep="") ¡envíe esa fila a la consola con una nueva línea al final y sin espacios entre los elementos!

PHP, 95 92 89 bytes

<?php for(;++$i<34;)for($j=6,$e=' ';$j--;)$a[$j].=$e=rand(0,$j)?$e:'=';echo join("
",$a);

Bastante feliz con este en realidad. Durante un tiempo tuve una versión que en teoría podría generar cualquier entrada, pero en la práctica solo generaría bloques sólidos de = ¡pero esto es más corto e igualmente distribuido!
Genera 7 avisos de algo indefinido cada vez que lo ejecutas, pero está bien.

edit: bueno, acabo de enterarme de que join es un alias de implode, así que está bien.

J, 18 bytes

|.|:'='#~"0>:?33#6

Cosas muy simples. Con una corrección de errores de millas!

Perl, 64 bytes

@f=$_="="x33;s/=/rand>.4?$&:$"/ge,@f=($_.$/,@f)while@f<6;print@f

Uso

perl -e '@f=$_="="x33;s/=/rand>.3?$&:$"/ge,@f=($_.$/,@f)while@f<6;print@f'
  = =           =  ==      =    =
  = =         ===  ==      =    =
= = =         ===  ==      =    =
= = =   = =   ===  ===   = =    =
= = == =====  === ====   ===  = =
=================================

Perl, 68 bytes

Versión alternativa que se basa en códigos de escape ANSI para mover el cursor, primero bajando 6 líneas, luego escribiendo la línea original (todas las =s), moviendo una línea hacia arriba e imprimiendo la cadena reemplazada ( s/=/rand>.4?$&:$"/ge) repetidamente hasta que no haga más sustituciones. Esto puede terminar escribiendo más de seis líneas, pero eventualmente se reemplaza con una línea vacía.

Nota: los \x1bs son en realidad el Esccarácter ASCII .

print"\x1bc\x1b[6B",$_="="x33;print"\x1b[1A\x1b[33D$_"while s/=/rand>.4?$&:$"/ge

Rubí, 102 99 84 83 bytes

s='
'*203;33.times{|j|a=(' '*rand(6)).ljust 6,'=';6.times{|i|s[i*34+j]=a[i]}};$><<s

Enfoque nuevo y significativamente más corto, donde comienzo con una cadena llena de nuevas líneas.

Versión antigua...

s='';204.times do|i|s+=->i{i%34==0?"\n":i>170?'=':s[i-34]=='='?'=':rand(2)==1?'=':' '}[i]end;puts s

... dio salida con una nueva línea líder. Mi primera presentación en Ruby, usando un enfoque similar al de @ Barbarroja, pero en un solo ciclo.

Lo que me gustó de Ruby mientras trabajaba en este programa:

• .times lazo
• rand() que es bastante corto
• apilar operadores ternarios sin paréntesis

No me gustó (principalmente en términos de golf):

• obligatorio $para variables globalesno tan obligatorio en .timesbucle
• doy endpalabras clave que se puede reemplazar con un bloque de una sola línea
• 0 no es falso

JavaScript, 179 bytes

Todavía estoy trabajando en esto un poco. Me gusta esto ya que es sencillo.

n=>{a=Array(33).fill(0).map(n=>Math.floor(Math.random()*6)+1);r=Array(6).fill("");r.map((e,m)=>{a.map(n=>{if (n<=m+1){r[m]+="="}else r[m]+=" "})});return r.join('\n');}

Uso:

>q=n=>{a=Array(33).fill(0).map(n=>{return Math.floor(Math.random() * 6)+1});
r=Array(6).fill("");r.map((e,m)=>{a.map(n=>{if (n<=m+1){r[m]+="="}else r[m]+=" "})});return r.join('\n');}
>q();
           = =  =   =    = =     
=   =    = = =  =  == =  = =  =  
= = =  = === ====  ====  = = === 
= = =  = === ==========  ======= 
= === ===========================
=================================

Adelante, 190 bytes

Tuve que crear mi propio PRNG , un cambio xor tomado de aquí . La palabra fes la palabra que llamaría varias veces para ver la salida.

variable S utime S !
: L lshift xor ;
: R S @ dup 13 L dup 17 rshift xor dup 5 L dup S ! 6 mod ;
: f
33 0 DO R LOOP
1 -5 DO
33 0 DO
I PICK J + 0< 1+ IF ." =" ELSE SPACE THEN
LOOP CR
LOOP
; f

Pruébelo en línea : tenga en cuenta que la hora del sistema es uno de los dos valores según el servidor (o algo) que ejecuta el código. Aparte de eso, no cambian en el IDE en línea por alguna razón. Entonces solo verá dos salidas posibles. Puede establecer manualmente la semilla cambiandoutimea un número entero.

Sin golf

variable seed                   \ seed with time
utime seed !

: RNG                           \ xor-shift PRNG
seed @
dup 13 lshift xor
dup 17 rshift xor
dup 5 lshift xor
dup seed !
6 mod                           \ between 0 and 6, exclusive
;

: f 33 0 DO RNG LOOP            \ push 33 randoms
    1 -5 DO                     \ for (J = -6; J <  0; J++)
        33 0 DO                 \ for (I =  0; I < 33; I++)
            I PICK J + 0< 1+ IF \ if  (stack[I] < J)
                61 EMIT         \ print "="
            ELSE
                32 EMIT         \ print " "
            THEN
        LOOP
        CR                      \ print "\n"
    LOOP
; f

Ungolfed en línea

JavaScript, 165 bytes

// function that fills a column with a specified number of = signs
m=l=>Array(6).fill``.map((e,i)=>i<l?"=":" ");
// fill an array of 33 length with columns of random number of = signs
a=Array(33).fill``.map(e=>m(Math.ceil(Math.random()*6)));
// transponse the rows and columns and print to console
a[0].map((c,i)=>a.map(r=>r[5-i])).map(r=>console.log(r.join``))

Las nuevas líneas son innecesarias, pero hacen que sea más fácil ver lo que está sucediendo. No es la solución más óptima, pero tiene sentido al menos para mí.