Bạn biết rằng họ trông giống như thế này:

^nguồn

Mục đích là để vẽ một minh họa nhịp đập âm nhạc như sau:

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

Các quy tắc là:

• Chiều rộng của hình minh họa là 33 biểu tượng, nhưng nếu bạn cần thì bất kỳ khoảng trống nào vượt quá chiều rộng này đều được phép.
• Mỗi cột được làm bằng các dấu bằng (= ).
• Mỗi cột có chiều cao ngẫu nhiên (chiều cao của cột tiếp theo không nên phụ thuộc vào bất kỳ cách nào vào chiều cao của cột trước đó), thay đổi từ 1 đến 6. Sẽ tốt hơn nếu ít nhất là như vậy có thể có được một số đầu vào không nghiêm ngặt xác suất toán học (tức là một số đầu vào có thể hiếm khi xuất hiện hơn các đầu vào khác).
• Một cột không thể nổi phía trên đáy và có những khoảng trống trong đó.
• Vì mỗi cột có chiều cao tối thiểu là 1, hàng cuối cùng không thể có bất kỳ khoảng trống nào cả, nó luôn luôn bao gồm 33 dấu bằng.
• Vì có thể không có cột nào có chiều cao là 6 (tất cả đều ngẫu nhiên): trong trường hợp này, bạn không cần phải có một dòng trên cùng được tạo bởi các khoảng trắng. Áp dụng cho bất kỳ trường hợp cạnh nào có tính chất này: nếu đột nhiên mã của bạn không cung cấp cột nào có chiều cao lớn hơn 1, bạn không cần phải có các dòng bổ sung được tạo từ các khoảng trắng phía trên dòng dưới cùng.
• Bạn không nhận bất kỳ đầu vào .

Bình , 13 byte

Và tôi đã vượt qua Jelly .

j_.tm*hO6\=33

Hãy thử trực tuyến!

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.

APL Dyalog , 14 byte

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

Giải trình

33⍴6 33 lần lặp lại của 6

?số nguyên ngẫu nhiên trong phạm vi [1, n ] cho mỗi 33 giây

'='⍴¨⍨ biểu tượng bình đẳng lặp lại mỗi số lần đó

↑ chuyển đổi danh sách danh sách sang bảng hàng

⍉ hoán đổi hàng thành cột, cột thành hàng

⊖ lộn ngược

Ví dụ chạy

Đầu vào được thụt vào sáu dấu cách:

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

Thạch, 14 byte

6x33X€”=ẋz⁶Ṛj⁷

Hãy thử nó ở đây.

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

Kiểm tra nó trong đoạn trích hoạt hình dưới đây:

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

Gọi như f();. Câu trả lời này dựa trên thực tế là sáu cuộc gọi liên tiếp để time(0)trả về cùng một kết quả (tính bằng giây). Điều này hầu như luôn luôn đúng, nhưng có lẽ đáng nói.

Cheddar, 68 65 byte (không cạnh tranh)

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

O_O Cheddar thực sự đang làm rất tốt! Sử dụng sprintfvà turnđể làm một số lượng lớn công việc. vfuselà cầu chì dọc có nghĩa là nó tham gia vào mảng nhưng theo chiều dọc. Điều này rất golf nhưng cũng khá nhanh. Phiên bản được phát hành trước phiên bản 1.0.0-beta.10 , sau ngày thử thách.

Giải trình

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

Một số ví dụ chạy:

05AB1E , 22 byte

Không tham gia tự động, không điền tự động trong khi chuyển vị, osabie sẽ phải chịu số phận này. Mã số:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

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 thậm chí không bao giờ có cơ hội ...

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

Làm thế nào nó hoạt động

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

Hãy thử nó trên Ideone

MATL, 20 19 18 17 byte

Lưu 1 byte nhờ @Luis

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

Dùng thử trực tuyến

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

In một dấu bằng ở tọa độ màn hình có liên quan.

với một đốm màu và một GOTOvòng lặp nó trở thành

K4, 18 byte

Về cơ bản là một cổng của giải pháp APL (không ngạc nhiên).

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

Tôi chuyển sang thuật toán @Lynn và lưu 83 byte!

C # lambda không có đầu vào và đầu ra là một chuỗi. Hãy thử trực tuyến .

Mã số:

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

Là một ngôn ngữ chức năng thuần túy, Haskell đã bị tiêu diệt ngay từ đầu. Tôi đã làm điều đó và hóa ra, rằng chi phí cần thiết thực sự không lớn.

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

Sử dụng:

s

Giải trình:

import System.Random

để có thể sử dụng newStdGenvàrandoms

import Data.List

để có thể sử dụng transpose

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

định nghĩa một hàm in một khoảng trắng nếu đối số thứ nhất của nó lớn hơn đối số thứ hai và =khác. Nó được gọi với map (f m) [0..5]một số nhất định mvà danh sách [0,1,2,3,4,5]. (Xem bên dưới)

s=do
g<-newStdGen

Tạo một bộ tạo số ngẫu nhiên tiêu chuẩn mới

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

mất 33 số nguyên ngẫu nhiên.

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

Tính toán m = n % 6và ánh xạ (f m)vào danh sách [0,1,2,3,4,5], kết quả là một trong"======", " =====", ..., " =" . Các dòng này được ánh xạ tới danh sách 33 số nguyên ngẫu nhiên dẫn đến một bảng. (Một bảng trong Haskell là danh sách các danh sách)

transpose$

chuyển cột và hàng của bảng

mapM_ putStrLn$

in mọi dòng trong bảng

CJam, 19 byte

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

Hãy thử trực tuyến!

Giải trình

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

Toán học, 78 byte

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

Chức năng ẩn danh. Không có đầu vào và trả về một chuỗi như đầu ra. Ký tự Unicode là U + F3C7, đại diện \[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="")}

Giải trình

m=rep(" ",33) khởi tạo một vector trống cho vòng lặp sắp tới

n=ifelse(m=="=",m,sample(c(" ","="),33,T,c(6-i,i)))Nếu có một =hàng ở trên, thì hãy chắc chắn rằng vị trí bên dưới cũng có một =; Nếu không thì chọn ngẫu nhiên. Lựa chọn ngẫu nhiên được tính trọng số để đảm bảo rằng a) hàng dưới cùng là tất cả =và b) bạn có được một hình dạng gọn gàng cho toàn bộ.

cat(n,"\n",sep="") xuất hàng đó ra bàn điều khiển với một dòng mới ở cuối và không có khoảng cách giữa các phần tử!

PHP, 95 92 89 byte

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

Khá hạnh phúc với điều này thực sự. Trong một thời gian, tôi đã có một phiên bản về lý thuyết có thể tạo ra bất kỳ đầu vào nào nhưng trong thực tế sẽ chỉ tạo ra các khối rắn = nhưng điều này vừa ngắn lại vừa phân phối đều!
Tạo 7 thông báo không xác định bất cứ khi nào bạn chạy nó nhưng điều đó tốt.

chỉnh sửa: tôi mới biết rằng tham gia là một bí danh của implode, vì vậy điều đó thật tuyệt.

J, 18 byte

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

Những thứ rất đơn giản. Với một bugfix từ dặm!

Perl, 64 byte

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

Sử dụng

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

Perl, 68 byte

Phiên bản thay thế dựa trên mã thoát ANSI để di chuyển con trỏ xung quanh, đầu tiên thả xuống 6 dòng, sau đó viết dòng gốc (tất cả các =), di chuyển lên một dòng và in chuỗi thay thế (s/=/rand>.4?$&:$"/ge ) liên tục cho đến khi nó không thay thế nữa. Điều này có thể kết thúc bằng cách viết nhiều hơn sáu dòng, nhưng cuối cùng nó được thay thế bằng một dòng trống.

Lưu ý: \x1bs thực sự là ký tự ASCII Esc.

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

Hồng ngọc 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

Cách tiếp cận mới và ngắn hơn đáng kể, nơi tôi bắt đầu với chuỗi đầy đủ các dòng mới.

Phiên bản cũ hơn ...

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

... đã cho đầu ra với dòng mới hàng đầu. Bài nộp đầu tiên của tôi về Ruby, sử dụng cách tiếp cận tương tự với bài của @ Barbarossa, nhưng trong một vòng lặp.

Những gì tôi thích ở Ruby khi làm việc trong chương trình này:

• .times vòng lặp
• rand() cái này khá ngắn
• xếp chồng các toán tử ternary không có dấu ngoặc đơn

Tôi không thích (chủ yếu là về chơi gôn):

• bắt buộc $ cho các biến toàn cụckhông bắt buộc trong .timesvòng lặp
• do và end từ khóa có thể được thay thế bằng khối đơn dòng
• 0 không phải là giả

JavaScript, 179 byte

Vẫn đang làm việc trên sân golf này một chút. Tôi thích điều này vì nó đơn giản.

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

Sử dụng:

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

Tôi đã phải tạo PRNG của riêng mình , một ca xor được lấy từ đây . Từ fnày là từ bạn sẽ gọi nhiều lần để xem đầu ra.

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

Dùng thử trực tuyến - Lưu ý rằng thời gian hệ thống là một trong hai giá trị dựa trên máy chủ nào (hoặc một cái gì đó) đang chạy mã. Ngoài ra, họ không thay đổi trong IDE trực tuyến vì một số lý do. Vì vậy, bạn sẽ chỉ thấy hai đầu ra có thể. Bạn có thể tự đặt hạt giống bằng cách thay đổiutime thành một số nguyên.

Bị đánh cắp

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 trực tuyến

JavaScript, 165 byte

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

Các dòng mới là không cần thiết nhưng chúng giúp dễ dàng nhìn thấy những gì đang diễn ra. Không phải là giải pháp tối ưu nhất, nhưng ít nhất nó có ý nghĩa với tôi.