Bilirsin, şöyle gözüküyorlar:

^kaynak

Amaç, bir müzik aşağıdaki gibi atım örnek çizmektir:

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

Kurallar:

• Çizimin genişliği 33 semboldür, ancak gerekirse - bu genişliği aşan izler bırakılabilir.
• Her sütun eşittir işaretlerinden ( =) oluşur.
• Her sütun vardır rastgele yükseklik O en azından eğer ince de var 1'den 6'ya değişen (önceki sütunun yüksekliğini hiçbir şekilde bağımlı olmamalıdır sonraki sütunun yüksekliğini), olası hiçbir sıkı bazı giriş almak için matematik olasılığı (örneğin, bazı girdiler diğerlerinden daha nadir görünebilir).
• Bir sütun , tabanın üzerinde yüzemez ve içinde boşluklar olamaz .
• Her sütun en az 1 yüksekliğe sahip olduğundan, son satırda da boşluk kalmaz - her zaman 33 eşittir işaretinden oluşur.
• 6 yüksekliğinde sütunların bulunmaması mümkün olduğundan (hepsinden sonra rastgele): bu durumda boşluklardan oluşan bir üst çizgiye sahip olmanız gerekmez. Bu nitelikteki herhangi bir kenar durumu için geçerlidir: eğer aniden kodunuz 1'den daha yüksek bir sütun içermiyorsa, alt satırın üzerinde boşluklardan yapılmış ilave satırlara ihtiyacınız yoktur.
• Hiçbir giriş yapmadınız .

Pyth , 13 bayt

Ve ben Jelly'i aştım .

j_.tm*hO6\=33

Çevrimiçi deneyin!

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 bayt

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

açıklama

33⍴6 6 33 tekrarı

?336'ların her biri için [1, n ] aralığında rasgele tamsayı

'='⍴¨⍨ eşitlik sembolü bu sayıların her birini tekrarladı

↑ listeler listesini satır tablosuna dönüştür

⍉ satırları sütunlara, sütunları satırlara dönüştürmek

⊖ ters çevir

Örnek çalıştırmalar

Giriş altı boşluk girintilidir:

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

Jöle, 14 bayt

6x33X€”=ẋz⁶Ṛj⁷

Burada dene.

JavaScript (ES6), 116 bayt

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

Aşağıdaki animasyonlu snippet'te kontrol edin:

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 bayt

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

Olarak arayın f();. Bu cevap, art arda altı çağrının time(0)aynı sonucu döndürmesi (saniye olarak) gerçeğine dayanır . Bu hemen hemen her zaman doğrudur, ancak muhtemelen söylemeye değer.

Çedar, 68 65 bayt (yarışma dışı)

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

O_O Cheddar aslında iyi gidiyor! İşlerin bir kısmını kullanır sprintfve turnyapar. vfusedikey sigortadır, diziye katılır, ancak dikey olarak katılır. Bu çok golfçü ama aynı zamanda oldukça hızlı. Sürüm, mücadelenin sonrasına tarihlenen , yayın öncesi sürüm 1.0.0-beta.10'dur .

açıklama

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

Bazı örnekler çalışıyor:

05AB1E , 22 bayt

Otomatik birleşme yok, transpozisyon yapılırken otomatik dolum yok, bunun üzerine osabie mahkum edildi. Kod:

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

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin! .

Python 2,95 bayt

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

Python 3, 115 bayt

Python'un hiç şansı olmadı ...

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

Nasıl çalışır

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

Ideone'da dene

MATL, 20 19 18 17 bayt

@Luis sayesinde 1 bayt kurtarıldı

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

Çevrimiçi Deneyin

SpecaBAS - 76 bayt

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

İlgili ekran koordinatında eşit bir işaret basar.

bir renk lekesi ve bir GOTOdöngü ile o olur

K4, 18 bayt

Temelde APL çözümünün bir limanı (şaşırtıcı derecede).

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

C #, 200 117 bayt

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

@ Lynn algoritmasına geçiyorum ve 83 byte tasarruf ediyorum !

C # lambda girişi olmadan ve çıktı bir dizedir. Çevrimiçi deneyin .

Kod:

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

Tamamen işlevsel bir dil olan Haskell, başından beri mahkum edildi. Yine de yaptım ve ortaya çıktı, gerekli ek yükün aslında o kadar büyük olmadığı ortaya çıktı.

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

Kullanımı:

s

Açıklama:

import System.Random

kullanabilmek newStdGenverandoms

import Data.List

kullanabilmek transpose

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

İlk argümanı ikinciden daha büyükse boşluğu basan bir işlevi tanımlar =. map (f m) [0..5]Verilen bir numara mve liste ile çağrılır [0,1,2,3,4,5]. (Aşağıya bakınız)

s=do
g<-newStdGen

Yeni bir standart rasgele sayı üreteci yaratır

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

33 rastgele tamsayı alır.

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

Biri ile sonuçlanan listeyi hesaplar m = n % 6ve eşler . Bu çizgiler bir tablodaki 33 rastgele tamsayı listesine eşleştirilir. (Haskell'deki bir tablo listelerin bir listesidir)(f m)[0,1,2,3,4,5]"======", " =====", ..., " ="

transpose$

tablonun sütunlarını ve satırlarını değiştirir

mapM_ putStrLn$

tablodaki her satırı yazdırır

CJam, 19 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Anonim işlev Girdi almaz ve bir dize çıktı olarak döndürür. Unicode karakter U + F3C7'dir, temsil eder \[Transpose].

R, 102 bayt

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

açıklama

m=rep(" ",33) yaklaşan döngü için boş bir vektör init

n=ifelse(m=="=",m,sample(c(" ","="),33,T,c(6-i,i)))=Yukarıdaki satırda bir varsa , aşağıdaki noktanın da =; Aksi takdirde rasgele seçim. Rasgele seçmeler, a) en alt sıranın tümü olduğundan =ve b) her şeye düzgün bir şekil aldığınızdan emin olmak için ağırlıklandırılır .

cat(n,"\n",sep="") Sonunda bir satırsonu olan ve elemanları arasında boşluk bırakmayan bu satırı konsola çıkardın!

PHP, 95 92 89 bayt

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

Aslında bununla çok mutluyum. Bir süredir teoride herhangi bir girdi yaratabilecek bir versiyonum vardı ancak pratikte sadece katı bloklar oluşturacaktı ancak bu hem kısa hem de eşit olarak dağıtılmış!
Ne zaman çalıştırsan, 7 tanımsız bir şey fark eder, ama sorun değil.

düzenleme: ben sadece katılmak bir implode takma olduğunu öğrendim, bu yüzden bu güzel.

J, 18 bayt

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

Çok basit şeyler. Millerden gelen bir hata ile!

Perl, 64 bayt

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

kullanım

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

Perl, 68 bayt

İmleci hareket ettirmek, önce 6 satır bırakmak, sonra orijinal satırı (tümü =s) yazmak, bir satır yukarı taşımak ve değiştirilen dizeyi ( s/=/rand>.4?$&:$"/ge) başka bir değişiklik yapmadan tekrar tekrar yazdırmak için ANSI çıkış kodlarına dayanan alternatif sürüm . Bu, altıdan fazla satır yazmakla sonuçlanabilir, ancak sonunda boş bir satırla değiştirilir.

Not: \x1bs aslında ASCII Esckarakteridir.

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

Yakut, 102 99 84 83 bayt

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

Yeni satırlarla dolu bir dizeyle başladığım yeni ve önemli ölçüde daha kısa yaklaşım.

Eski versiyon...

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

... öncü yeni hat ile çıktı verdi. Ruby'deki ilk gönderim, @ Barbarossa'nınkine benzer bir yaklaşım kullanarak, ancak tek döngüde.

Bu program üzerinde çalışırken Ruby'de neleri sevdim:

• .times döngü
• rand() bu oldukça kısa
• üçlü operatörlerin parantez olmadan istiflenmesi

Sevmedim (çoğunlukla golf açısından):

• $global değişkenler için zorunlu.timesdöngü içinde çok zorunlu değil
• dove endanahtar kelimeler tek satırlı blok ile değiştirilebilir
• 0 sahte değil

JavaScript, 179 bayt

Hala bu biraz golf üzerinde çalışıyor. Bunu basit olduğundan beri seviyorum.

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

Kullanımı:

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

İleri, 190 bayt

Buradan alınan bir xordi-vardiya olan kendi PRNG'mi yaratmak zorunda kaldım . Kelime çıktıyı görmek için defalarca çağıracağınız kelimedir.f

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

Çevrimiçi deneyin - Sistem saatinin, hangi sunucunun (veya başka bir şeyin) kodu çalıştırdığına bağlı olarak iki değerden biri olduğunu unutmayın. Bunun dışında, çevrimiçi IDE'de bazı nedenlerden dolayı değişmezler. Böylece sadece iki olası çıktı göreceksiniz. utimeBir tamsayıyadeğiştirerek tohumu el ile ayarlayabilirsiniz.

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

Çevrimiçi olmayan

JavaScript, 165 Bayt

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

Yeni hatlar gereksizdir, ancak neler olup bittiğini görmeyi kolaylaştırır. En uygun çözüm değil, ama en azından bana mantıklı geliyor.