Anda tahu — mereka terlihat seperti ini:

^sumber

Tujuannya adalah untuk menggambar ilustrasi ketukan musik seperti berikut:

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

Aturannya adalah:

• Lebar ilustrasi adalah 33 simbol, tetapi jika Anda perlu — setiap spasi tambahan yang melebihi lebar ini diperbolehkan.
• Setiap kolom terbuat dari tanda sama dengan ( =).
• Setiap kolom memiliki tinggi acak (tinggi kolom berikutnya tidak boleh tergantung pada ketinggian kolom sebelumnya), bervariasi dari 1 hingga 6. Ini juga baik jika setidaknya mungkin untuk mendapatkan beberapa input tanpa ketat probabilitas matematika (yaitu beberapa input dapat muncul lebih jarang daripada yang lain).
• Kolom tidak bisa mengapung di atas bagian bawah dan ada celah di dalamnya.
• Karena setiap kolom memiliki tinggi minimal 1, baris terakhir juga tidak memiliki celah — selalu terdiri dari 33 tanda sama dengan.
• Karena dimungkinkan untuk tidak memiliki kolom dengan ketinggian 6 (semuanya acak setelah semua): dalam hal ini Anda tidak perlu memiliki garis atas yang terbuat dari spasi. Berlaku untuk setiap tepi kasus seperti ini: jika tiba-tiba kode Anda tidak memberikan kolom dengan ketinggian lebih dari 1, Anda tidak perlu memiliki garis tambahan yang terbuat dari spasi di atas garis bawah.
• Anda tidak mengambil input apa pun .

Pyth , 13 byte

Dan aku mengalahkan Jelly .

j_.tm*hO6\=33

Cobalah 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 byte

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

Penjelasan

33⍴6 33 pengulangan 6

? bilangan bulat acak dalam rentang [1, n ] untuk masing-masing 33 6s

'='⍴¨⍨ Simbol kesetaraan mengulangi setiap kali itu

↑ konversi daftar daftar ke daftar baris

⍉ transpos baris menjadi kolom, kolom menjadi baris

⊖ terbalik terbalik

Contoh berjalan

Input diberi indentasi enam spasi:

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

Jelly, 14 byte

6x33X€”=ẋz⁶Ṛj⁷

Coba di sini.

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

Lihat di cuplikan animasi di bawah ini:

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 byte

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

Sebut sebagai f();. Jawaban ini bergantung pada kenyataan bahwa enam panggilan berurutan untuk time(0)mengembalikan hasil yang sama (dalam detik). Ini sebenarnya selalu benar, tetapi mungkin perlu disebutkan.

Cheddar, 68 65 byte (tidak bersaing)

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

O_O Cheddar sebenarnya baik-baik saja! Penggunaansprintf dan turnmelakukan sebagian besar pekerjaan. vfuseadalah vertikal-fuse artinya bergabung dengan array tetapi secara vertikal. Ini sangat golf tetapi juga agak cepat. Versi prerelease v 1.0.0-beta.10 , yang mengunggah tanggal tantangan.

Penjelasan

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

Beberapa contoh berjalan:

05AB1E , 22 byte

Tidak ada penggabungan otomatis, tidak ada pengisian otomatis saat mentransposisi, osabie akan mengalami kegagalan dalam hal ini. Kode:

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

Menggunakan pengkodean CP-1252 . Cobalah online! .

Python 2, 95 byte

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

Python 3, 115 byte

Python bahkan tidak pernah punya kesempatan ...

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

Bagaimana itu bekerja

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

Cobalah di Ideone

MATL, 20 19 18 17 byte

1 byte disimpan berkat @Luis

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

Cobalah secara Online

SpecaBAS - 76 byte

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

Mencetak tanda sama dengan pada koordinat layar yang relevan.

dengan bintik warna dan GOTOlingkaran itu menjadi

K4, 18 byte

Pada dasarnya sebuah port dari solusi APL (tidak mengejutkan).

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

C #, 200 117 byte

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

Saya pindah ke algoritma @ Lynn dan menghemat 83 byte!

C # lambda tanpa input dan di mana output adalah sebuah string. Cobalah online .

Kode:

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

Menjadi bahasa yang murni fungsional, Haskell dikutuk sejak awal. Saya tetap melakukannya dan ternyata, overhead yang diperlukan sebenarnya tidak sebesar itu.

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

Pemakaian:

s

Penjelasan:

import System.Random

untuk dapat menggunakan newStdGendanrandoms

import Data.List

untuk dapat digunakan transpose

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

mendefinisikan fungsi yang mencetak spasi jika argumen pertama lebih besar dari argumen kedua dan =sebaliknya. Itu disebut dengan map (f m) [0..5]nomor mdan daftar yang diberikan [0,1,2,3,4,5]. (Lihat di bawah)

s=do
g<-newStdGen

Membuat generator nomor acak standar baru

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

membutuhkan 33 bilangan bulat acak.

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

Menghitung m = n % 6dan memetakan (f m)ke daftar [0,1,2,3,4,5], yang menghasilkan salah satu dari"======", " =====", ..., " =" . Garis-garis ini dipetakan ke daftar 33 bilangan bulat acak yang menghasilkan tabel. (Tabel di Haskell adalah daftar daftar)

transpose$

mengganti kolom dan baris tabel

mapM_ putStrLn$

mencetak setiap baris dalam tabel

CJam, 19 byte

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

Cobalah online!

Penjelasan

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

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

Fungsi anonim. Tidak mengambil input dan mengembalikan string sebagai output. Karakter Unicode adalah U + F3C7, mewakili \[Transpose].

R, 102 byte

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

Penjelasan

m=rep(" ",33) init vektor kosong untuk loop yang akan datang

n=ifelse(m=="=",m,sample(c(" ","="),33,T,c(6-i,i)))Jika ada =baris di atas, maka pastikan tempat di bawahnya juga memiliki =; jika tidak pilih secara acak. Pilihan acak ditimbang untuk memastikan bahwa a) baris paling bawah adalah semua= dan b) Anda mendapatkan bentuk yang rapi untuk semuanya.

cat(n,"\n",sep="") Keluarkan baris itu ke konsol dengan baris baru di bagian akhir dan tidak ada spasi di antara elemen!

PHP, 95 92 89 byte

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

Cukup senang dengan yang ini sebenarnya. Untuk sementara saya memiliki versi yang secara teori dapat menghasilkan input apa pun tetapi dalam praktiknya hanya akan menghasilkan blok =, tetapi ini lebih pendek dan sama-sama terdistribusi!
Menghasilkan 7 pemberitahuan sesuatu yang tidak terdefinisi setiap kali Anda menjalankannya, tetapi itu tidak masalah.

sunting: baik saya baru tahu bahwa bergabung adalah alias implode, jadi itu bagus.

J, 18 byte

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

Hal yang sangat sederhana. Dengan perbaikan bug dari mil!

Perl, 64 byte

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

Pemakaian

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

Perl, 68 byte

Versi alternatif yang bergantung pada kode pelarian ANSI untuk menggerakkan kursor, pertama-tama menjatuhkan 6 baris, kemudian menulis garis asli (semua huruf =), memindahkan garis dan mencetak string yang diganti ( s/=/rand>.4?$&:$"/ge) berulang kali hingga tidak ada lagi penggantian. Ini akhirnya bisa menulis lebih dari enam baris, tetapi akhirnya diganti dengan baris kosong.

Catatan: \x1bs sebenarnya adalah Esckarakter ASCII .

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

Rubi, 102 99 84 83 byte

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

Pendekatan baru dan jauh lebih singkat, di mana saya mulai dengan string yang penuh dengan baris baru.

Versi lebih lama ...

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

... memberikan output dengan memimpin baris baru. Kiriman pertama saya di Ruby, menggunakan pendekatan yang mirip dengan @ Barbarossa, tetapi dalam satu lingkaran.

Apa yang saya sukai di Ruby saat mengerjakan program ini:

• .times lingkaran
• rand() yang cukup singkat
• menumpuk operator ternary tanpa tanda kurung

Saya tidak suka (terutama dalam hal bermain golf):

• wajib $ untuk variabel globaltidak begitu wajib dalam .timeslingkaran
• do dan end kata kunci yang bisa diganti dengan blok single-line
• 0 tidak palsu

JavaScript, 179 byte

Masih berusaha sedikit bermain golf. Saya suka ini karena mudah.

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

Pemakaian:

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

Keempat, 190 byte

Saya harus membuat PRNG saya sendiri , sebuah xor-shift yang diambil dari sini . Kata itu fadalah kata yang akan Anda panggil beberapa kali untuk melihat hasilnya.

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

Coba online - Perhatikan bahwa waktu sistem adalah salah satu dari dua nilai berdasarkan server mana (atau sesuatu) yang menjalankan kode. Selain itu, mereka tidak berubah dalam IDE online karena beberapa alasan. Jadi Anda hanya akan melihat dua kemungkinan output. Anda dapat secara manual mengatur seed dengan mengubahutimeke integer.

Tidak disatukan

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

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

Baris baru tidak perlu tetapi mereka membuatnya lebih mudah untuk melihat apa yang terjadi. Bukan solusi yang paling optimal, tetapi setidaknya masuk akal bagi saya.