Vous savez, ils ressemblent à ceci:

^{la source}

Le but est de dessiner une illustration de battements de musique comme suit:

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

Les règles sont les suivantes:

• La largeur de l'illustration est de 33 symboles, mais si vous en avez besoin, tous les espaces de fin dépassant cette largeur sont autorisés.
• Chaque colonne est composée de signes égaux ( =).
• Chaque colonne a une hauteur aléatoire (la hauteur de la colonne suivante ne devrait en aucun cas dépendre de la hauteur de la colonne précédente), variant de 1 à 6. C'est aussi bien si c'est au moins possible d'obtenir une entrée sans stricte probabilité mathématique (c'est-à-dire que certaines entrées peuvent apparaître plus rarement que d'autres).
• Une colonne ne peut pas flotter au-dessus du fond et comporter des lacunes.
• Étant donné que chaque colonne a la hauteur minimale de 1, la dernière ligne ne peut pas non plus avoir de lacunes - elle se compose toujours de 33 signes égaux.
• Puisqu'il est possible de ne pas avoir de colonnes d'une hauteur de 6 (tout est aléatoire après tout): dans ce cas, vous n'avez pas besoin d'avoir une ligne supérieure faite d'espaces. S'applique à tous les cas marginaux de cette nature: si tout à coup votre code ne fournit aucune colonne avec une hauteur supérieure à 1, vous n'avez pas besoin d'avoir des lignes supplémentaires faites d'espaces au-dessus de la ligne du bas.
• Vous ne prenez aucune entrée .

Pyth , 13 octets

Et j'ai déjoué Jelly .

j_.tm*hO6\=33

Essayez-le en ligne!

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 octets

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

Explication

33⍴6 33 répétitions de 6

?entier aléatoire dans la plage [1, n ] pour chacun des 33 6s

'='⍴¨⍨ symbole d'égalité répété chacun de ces nombre de fois

↑ convertir la liste des listes en table de lignes

⍉ transposer des lignes en colonnes, des colonnes en lignes

⊖ retourner la tête en bas

Exemple d'exécutions

L'entrée est en retrait de six espaces:

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

Gelée, 14 octets

6x33X€”=ẋz⁶Ṛj⁷

Essayez-le ici.

JavaScript (ES6), 116 octets

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

Découvrez-le dans l'extrait animé ci-dessous:

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 octets

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

Appelez le f();. Cette réponse repose sur le fait que six appels consécutifs time(0)renvoient le même résultat (en secondes). Ceci est pratiquement toujours vrai, mais mérite probablement d'être mentionné.

Cheddar, 68 65 octets (non concurrent)

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

O_O Cheddar fait vraiment du bien! Utilise sprintfet turnpour faire une grande partie du travail. vfuseest un fusible vertical signifiant qu'il rejoint le tableau mais verticalement. C'est très golfique mais aussi assez rapide. La version est la version préliminaire 1.0.0-beta.10 , qui le défi.

Explication

->           // 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

Quelques exemples d'exécutions:

05AB1E , 22 octets

Pas de jointure automatique, pas de remplissage automatique lors de la transposition, l'osabie est voué à l'échec. Code:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Python 2, 95 octets

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

Python 3, 115 octets

Python n'a même jamais eu de chance ...

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='')

Comment ça marche

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

Essayez-le sur Ideone

MATL, 20 19 18 17 octets

1 octet enregistré grâce à @Luis

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

Essayez-le en ligne

SpecaBAS - 76 octets

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 signe égal aux coordonnées d'écran appropriées.

avec une tache de couleur et une GOTOboucle ça devient

K4, 18 octets

Essentiellement un portage de la solution APL (sans surprise).

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

C #, 200 117 octets

()=>{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;};

Je passe à l' algorithme @Lynn et économise 83 octets!

C # lambda sans entrée et où sortie est une chaîne. Essayez-le en ligne .

Code:

()=>{
    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 octets

Étant un langage purement fonctionnel, Haskell était condamné dès le départ. Je l'ai quand même fait et il s'avère que les frais généraux nécessaires ne sont pas si importants.

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])

Usage:

s

Explication:

import System.Random

pouvoir utiliser newStdGenetrandoms

import Data.List

pouvoir utiliser transpose

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

définit une fonction qui imprime un espace si son premier argument est plus grand que le second et =sinon. Il est appelé avec map (f m) [0..5]un numéro donné met la liste [0,1,2,3,4,5]. (Voir ci-dessous)

s=do
g<-newStdGen

Crée un nouveau générateur de nombres aléatoires standard

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

prend 33 entiers aléatoires.

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

Calcule m = n % 6et mappe (f m)à la liste [0,1,2,3,4,5], ce qui donne l'un des"======", " =====", ..., " =" . Ces lignes sont mappées à la liste des 33 entiers aléatoires résultant en une table. (Un tableau dans Haskell est une liste de listes)

transpose$

bascule les colonnes et les lignes du tableau

mapM_ putStrLn$

imprime chaque ligne du tableau

CJam, 19 octets

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

Essayez-le en ligne!

Explication

{       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 octets

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

Fonction anonyme. Ne prend aucune entrée et renvoie une chaîne en sortie. Le caractère Unicode est U + F3C7, représentant \[Transpose].

R, 102 octets

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="")}

Explication

m=rep(" ",33) init un vecteur vide pour la boucle à venir

n=ifelse(m=="=",m,sample(c(" ","="),33,T,c(6-i,i)))S'il y a un =dans la rangée ci-dessus, assurez-vous que l'endroit ci-dessous a également un =; sinon choisissez au hasard. Les choix aléatoires sont pondérés pour s'assurer que a) la rangée du bas est tout= et b) vous obtenez une forme soignée pour le tout.

cat(n,"\n",sep="") affiche cette ligne sur la console avec une nouvelle ligne à la fin et aucun espace entre les éléments!

PHP, 95 92 89 octets

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

Assez content avec celui-ci en fait. Pendant un certain temps, j'ai eu une version qui, en théorie, pourrait générer n'importe quelle entrée, mais en pratique, ne générerait que des blocs solides de = mais c'est à la fois plus court et également distribué!
Génère 7 notifications de quelque chose d'indéfini chaque fois que vous l'exécutez, mais ça va.

edit: eh bien je viens d'apprendre que join est un alias d'implode, donc c'est bien.

J, 18 octets

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

Des trucs très simples. Avec un correctif de miles!

Perl, 64 octets

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

Usage

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

Perl, 68 octets

Version alternative qui s'appuie sur les codes d'échappement ANSI pour déplacer le curseur, en baissant d'abord 6 lignes, puis en écrivant la ligne d'origine (tous les =s), en remontant d'une ligne et en imprimant la chaîne remplacée (s/=/rand>.4?$&:$"/ge ) à plusieurs reprises jusqu'à ce qu'elle ne fasse plus de substitutions. Cela peut finir par écrire plus de six lignes, mais il est finalement remplacé par une ligne vide.

Remarque: les \x1bs sont en fait le Esccaractère ASCII .

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

Rubis, 102 99 84 83 octets

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

Nouvelle approche et beaucoup plus courte, où je commence avec une chaîne pleine de nouvelles lignes.

Ancienne version...

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

... a donné une sortie avec une nouvelle ligne leader. Ma première soumission dans Ruby, utilisant une approche similaire à celle de @ Barbarossa, mais en boucle unique.

Ce que j'ai aimé dans Ruby en travaillant sur ce programme:

• .times boucle
• rand() ce qui est assez court
• empilement d'opérateurs ternaires sans parenthèses

Je n'ai pas aimé (principalement en termes de golf):

• obligatoire $pour les variables globalespas si obligatoire en .timesboucle
• doet endmots clés qui peut être remplacé par un bloc unifilaire
• 0 n'est pas faux

JavaScript, 179 octets

Je travaille toujours un peu sur le golf. J'aime ça car c'est simple.

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');}

Usage:

>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();
           = =  =   =    = =     
=   =    = = =  =  == =  = =  =  
= = =  = === ====  ====  = = === 
= = =  = === ==========  ======= 
= === ===========================
=================================

Forth, 190 octets

J'ai dû créer mon propre PRNG , un xor-shift pris d' ici . Le mot fest le mot que vous appelleriez plusieurs fois pour voir la sortie.

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

Essayez-le en ligne - Notez que l'heure système est l'une des deux valeurs basées sur le serveur (ou quelque chose) qui exécute le code. En dehors de cela, ils ne changent pas dans l'IDE en ligne pour une raison quelconque. Vous ne verrez donc que deux sorties possibles. Vous pouvez définir manuellement la valeur de départ en modifiantutime un entier.

Non 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

Non golfé en ligne

JavaScript, 165 octets

// 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``))

Les nouvelles lignes ne sont pas nécessaires mais elles permettent de voir plus facilement ce qui se passe. Ce n'est pas la solution la plus optimale, mais cela a du sens pour moi au moins.