Illustrer les rythmes de la musique

24

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 .
nicael
la source
@Lynn Oh, à l'origine, il le précisait, mais je l'ai accidentellement supprimé du message.
nicael
11
(Nitpicking) Cela me ressemble à un spectrogramme à un instant donné, plutôt qu'à une représentation de battements
Luis Mendo
2
Les colonnes peuvent-elles être séparées par des espaces? (c.-à-d., la rangée du bas serait = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =)
LegionMammal978
2
Est-il correct d'avoir des lignes supplémentaires au-dessus de la sortie?
John Dvorak
1
"la hauteur de la colonne suivante ne devrait en aucun cas dépendre de la hauteur de la colonne précédente" - la plupart des générateurs de nombres aléatoires intégrés dans les langues sont prédéfinis. Pour cette raison, une fonction comme Math.random()est directement calculable à partir de son appel précédent si les paramètres du générateur congruentiel linéaire sont connus, ce qui signifie que vous devrez modifier la plupart des fonctionnalités aléatoires intégrées afin de répondre à ces critères. Je suggère que ce soit mieux libellé.
Patrick Roberts

Réponses:

12

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.
Leaky Nun
la source
Pourquoi ça ne marche pas ici ?
Insane
@Insane Pyth est assez obsolète sur TIO.
Dennis
@Dennis Mais j'aime TIO: '(
Insane
13

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
             =    =   =  =       
         =   =    =   = == =     
=      = =   =    ==  = ==== === 
= = =  = =   =    ==  = ==== ====
=====  = == ==  ============ ====
=================================
Adam
la source
9

Gelée, 14 octets

6x33X€”=ẋz⁶Ṛj⁷

Essayez-le ici.

Lynn
la source
11
Euh oh, ça ne peut pas être vrai. La gelée doit par définition être plus courte que l'APL.
Adám
Ce n'est pas très efficace, mais ça 6ṗ33Xmarche aussi.
Dennis
9

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

Snippet preview

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>

George Reith
la source
1
Wow, c'est vraiment cool!
nicael
8

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

Lynn
la source
Vous mettez xet ypour éviter de les déclarer comme int. Puisqu'il n'y a pas d'entrée, est-ce autorisé? Si oui, c'est une bonne idée!
aloisdg dit Réintégrer Monica le
2
Je viens de vous essayer de coder. Vous pouvez l'exécuter avec f();Thats nice! Je ne savais pas que C pouvait faire ça.
aloisdg dit Réintégrer Monica le
J'aime vraiment votre code. Je le porte en C # pour un résultat de 117 octets, je ne suis pas sûr de le poster car c'est littéralement votre code.
aloisdg dit Réintégrer Monica le
1
N'hésitez pas à le poster, tant que vous me créditez. :)
Lynn
8

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:

enter image description here

Downgoat
la source
5

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

Adnan
la source
5

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)
Lynn
la source
4

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

TheBikingViking
la source
4

MATL, 20 19 18 17 octets

1 octet enregistré grâce à @Luis

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

Essayez-le en ligne

Suever
la source
3

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.

enter image description here

avec une tache de couleur et une GOTOboucle ça devient

enter image description here

Brian
la source
2

K4, 18 octets

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

+-6$(33?1+!6)#'"="
Aaron Davies
la source
2

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;
};
aloisdg dit Réintégrer Monica
la source
2

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

AplusKminus
la source
1

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.
Martin Ender
la source
1

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

LegionMammal978
la source
1

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!

Barbarossa
la source
1

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.

user55641
la source
1

J, 18 octets

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

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

Conor O'Brien
la source
Cela sélectionne des entiers aléatoires dans la plage [0, 6] alors que l'OP voulait [1, 6]. Vous pourriez faire >:?33#6pour obtenir des entiers aléatoires dans la plage [1, 6]. En outre, une copie de rang 0 serait plus courte à utiliser '='#~"0. Il en résulte, |.|:'='#~"0>:?33#6mais malheureusement, les économies de 2 octets finissent par être atténuées par l'inclusion de l'opérateur d'incrémentation.
miles
@miles Whoa, merci! Très sympa.
Conor O'Brien
1

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
Dom Hastings
la source
1

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
Leibrug
la source
0

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();
           = =  =   =    = =     
=   =    = = =  =  == =  = =  =  
= = =  = === ====  ====  = = === 
= = =  = === ==========  ======= 
= === ===========================
=================================
charredgrass
la source
Vous devriez pouvoir remplacer .map(n=>{return Math.floor(Math.random() * 6)+1})par .map(n=>Math.floor(Math.random()*6)+1). Lambda sont des grands :)
Aloisdg dit Reinstate Monica
if (n<=m+1){r[m]+="="}elsepeut êtreif(n<=m+1)r[m]+="=" else
aloisdg dit Réintégrer Monica
J'ai dû faire mon propre PRNG, et mon programme Forth n'est pas beaucoup plus long. : P
mbomb007
0

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

mbomb007
la source
0

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.

Davis
la source