Sie sehen so aus:

^Quelle

Das Ziel ist es, eine Musikbeats-Illustration wie die folgende zu zeichnen:

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

Die Regeln sind:

• Die Breite der Abbildung beträgt 33 Symbole. Falls erforderlich, sind Leerzeichen zulässig, die diese Breite überschreiten.
• Jede Spalte besteht aus Gleichheitszeichen ( =).
• Jede Spalte hat eine zufällige Höhe (die Höhe der nächsten Spalte sollte in keiner Weise von der Höhe der vorherigen Spalte abhängen), die von 1 bis 6 variiert. Es ist auch in Ordnung, wenn es zumindest möglich ist , Eingaben ohne strikte zu erhalten mathematische Wahrscheinlichkeit (dh einige Eingaben könnten seltener erscheinen als andere).
• Eine Spalte kann nicht über dem Boden schweben und Lücken aufweisen.
• Da jede Spalte die minimale Höhe von 1 hat, darf die letzte Zeile auch keine Lücken aufweisen - sie besteht immer aus 33 Gleichheitszeichen.
• Da es möglich ist, keine Spalten mit der Höhe 6 zu haben (es ist immerhin alles zufällig): In diesem Fall muss keine obere Zeile aus Leerzeichen bestehen. Gilt für Kantenfälle dieser Art: Wenn Ihr Code plötzlich keine Spalten mit einer Höhe von mehr als 1 bereitgestellt hat, müssen Sie keine zusätzlichen Zeilen mit Leerzeichen über der untersten Zeile einfügen.
• Sie nehmen keine Eingabe .

Pyth , 13 Bytes

Und ich habe Jelly überholt .

j_.tm*hO6\=33

Probieren Sie es online!

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

Erläuterung

33⍴6 33 Wiederholungen von 6

?zufällige ganze Zahl im Bereich [1, n ] für jede der 33 6s

'='⍴¨⍨ Das Gleichheitszeichen wurde jeweils so oft wiederholt

↑ Liste der Listen in Zeilentabelle konvertieren

⍉ transponiere Zeilen in Spalten, Spalten in Zeilen

⊖ umdrehen

Beispiel läuft

Die Eingabe wird um sechs Leerzeichen eingerückt:

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

Jelly, 14 Bytes

6x33X€”=ẋz⁶Ṛj⁷

Probieren Sie es hier aus.

JavaScript (ES6), 116 Byte

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

Schauen Sie sich das untenstehende animierte Snippet an:

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

Anrufen als f();. Diese Antwort beruht auf der Tatsache, dass sechs aufeinanderfolgende Aufrufe time(0)dasselbe Ergebnis (in Sekunden) zurückgeben. Dies ist praktisch immer wahr, aber wahrscheinlich erwähnenswert.

Cheddar, 68 65 Bytes (nicht konkurrierend)

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

O_O Cheddar geht es eigentlich gut! Verwendet sprintfund turnerledigt einen Großteil der Arbeit. vfuseist eine vertikale Sicherung, was bedeutet, dass sie sich dem Array aber vertikal anschließt. Das ist sehr golfig aber auch ziemlich schnell. Die Version ist die Vorabversion 1.0.0-Beta.10 , die die Herausforderung nachbearbeitet .

Erläuterung

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

Einige Beispielläufe:

05AB1E , 22 Bytes

Kein automatisches Zusammenfügen, kein automatisches Füllen beim Transponieren, osabie ist in diesem Fall zum Scheitern verurteilt. Code:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

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 hatte noch nie eine 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='')

Wie es funktioniert

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

Probieren Sie es auf Ideone

MATL, 20 19 18 17 Bytes

1 Byte gespart dank @Luis

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

Probieren Sie es online

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

Druckt ein Gleichheitszeichen an der entsprechenden Bildschirmkoordinate.

mit einem farbfleck und einer GOTOschleife wird es

K4, 18 Bytes

Im Wesentlichen ein Port der APL-Lösung (nicht überraschend).

+-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;};

Ich gehe zum @Lynn- Algorithmus und spare 83 Bytes!

C # Lambda ohne Eingabe und wobei Ausgabe eine Zeichenfolge ist. Probieren Sie es online aus .

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 Bytes

Als rein funktionale Sprache war Haskell von Anfang an zum Scheitern verurteilt. Ich habe es trotzdem gemacht und es stellt sich heraus, dass der notwendige Aufwand eigentlich nicht so groß ist.

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

Verwendung:

s

Erläuterung:

import System.Random

verwenden können newStdGenundrandoms

import Data.List

verwenden können transpose

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

definiert eine Funktion, die ein Leerzeichen ausgibt, wenn das erste Argument größer als das zweite ist, und ein =anderes. Es wird mit map (f m) [0..5]einer bestimmten Nummer mund der Liste angerufen [0,1,2,3,4,5]. (Siehe unten)

s=do
g<-newStdGen

Erstellt einen neuen Standard-Zufallsgenerator

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

dauert 33 zufällige ganze Zahlen.

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

Berechnet m = n % 6und ordnet (f m)der Liste zu [0,1,2,3,4,5], was zu einem von führt "======", " =====", ..., " =". Diese Zeilen werden der Liste der 33 Zufallszahlen zugeordnet, die zu einer Tabelle führen. (Eine Tabelle in Haskell ist eine Liste von Listen.)

transpose$

wechselt Spalten und Zeilen der Tabelle

mapM_ putStrLn$

druckt jede Zeile in der Tabelle

CJam, 19 Bytes

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

Probieren Sie es online!

Erläuterung

{       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),"
",""]&

Anonyme Funktion. Nimmt keine Eingabe an und gibt eine Zeichenfolge als Ausgabe zurück. Das Unicode-Zeichen ist U + F3C7 und steht für \[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="")}

Erläuterung

m=rep(" ",33) Initialisiere einen leeren Vektor für die kommende Schleife

n=ifelse(m=="=",m,sample(c(" ","="),33,T,c(6-i,i)))Wenn sich =in der Zeile darüber ein befindet, stellen Sie sicher, dass die Stelle darunter auch ein hat =. ansonsten zufällig auswählen. Zufällige Picks werden gewichtet, um sicherzustellen, dass a) die unterste Reihe alles ist =und b) Sie eine ordentliche Form für das Ganze erhalten.

cat(n,"\n",sep="") Gib diese Zeile mit einem Zeilenumbruch am Ende und ohne Leerzeichen zwischen den Elementen auf der Konsole aus!

PHP, 95 92 89 Bytes

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

Eigentlich ziemlich glücklich mit diesem. Für eine Weile hatte ich eine Version, die theoretisch jede Eingabe erzeugen konnte, aber in der Praxis nur feste Blöcke von = erzeugen würde, aber dies ist sowohl kürzer als auch gleichmäßig verteilt!
Generiert 7 undefinierte Benachrichtigungen, wenn Sie es ausführen, aber das ist in Ordnung.

edit: naja ich habe gerade gelernt, dass join ein alias von implode ist, das ist also nett.

J, 18 Bytes

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

Sehr einfaches Zeug. Mit einem Bugfix von Meilen!

Perl, 64 Bytes

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

Verwendung

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

Perl, 68 Bytes

Alternative Version, die sich auf ANSI-Escape-Codes stützt, um den Cursor zu bewegen, zuerst 6 Zeilen nach unten zu bewegen, dann die ursprüngliche Zeile (alle =s) zu schreiben , eine Zeile nach oben zu verschieben und die ersetzte Zeichenfolge ( s/=/rand>.4?$&:$"/ge) wiederholt zu drucken, bis keine Substitutionen mehr vorgenommen werden. Dies kann dazu führen, dass mehr als sechs Zeilen geschrieben werden, wird aber schließlich durch eine leere Zeile ersetzt.

Hinweis: \x1bs ist eigentlich das ASCII- EscZeichen.

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

Rubin, 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

Neuer und deutlich kürzerer Ansatz, bei dem ich mit einer Zeichenfolge voller Zeilenumbrüche beginne.

Ältere Version...

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

... gab eine Ausgabe mit führender neuer Zeile aus. Meine erste Einreichung in Ruby, mit einem ähnlichen Ansatz wie bei @ Barbarossa, aber in einer einzigen Schleife.

Was mir in Ruby bei der Arbeit an diesem Programm gefallen hat:

• .times Schleife
• rand() das ist ziemlich kurz
• ternäre Operatoren ohne Klammern stapeln

Ich mochte nicht (hauptsächlich in Bezug auf das Golfen):

• obligatorisch $für globale Variablennicht so obligatorisch in der .timesSchleife
• dound endSchlüsselwörter die durch einzeiligen Block ersetzt werden kann
• 0 ist nicht falsch

JavaScript, 179 Bytes

Ich arbeite immer noch ein bisschen am Golfen. Ich mag das, weil es einfach ist.

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

Verwendung:

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

Viertens 190 Bytes

Ich musste mein eigenes PRNG erstellen , eine Xor-Shift von hier . Das Wort fist das Wort, das Sie mehrmals aufrufen würden, um die Ausgabe zu sehen.

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

Online ausprobieren - Beachten Sie, dass die Systemzeit einer von zwei Werten ist, die davon abhängen, auf welchem ​​Server (oder auf welchem ​​Server) der Code ausgeführt wird. Ansonsten ändern sie sich in der Online-IDE aus irgendeinem Grund nicht. Sie sehen also nur zwei mögliche Ausgaben. Sie können den Startwert manuell festlegen, indem Sie ihnutimein eine Ganzzahländern.

Ungolfed

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 online

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

Die Zeilenumbrüche sind nicht erforderlich, machen es jedoch einfacher zu sehen, was los ist. Nicht die optimalste Lösung, aber es macht zumindest für mich Sinn.