您知道，它们看起来像这样：

^资源

目的是绘制如下的音乐节拍插图：

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

规则是：

• 插图的宽度为33个符号，但如果需要-允许任何超出此宽度的尾随空格。
• 每列均由等号（=）组成。
• 每列都有一个随机的高度（下一列的高度不应以任何方式取决于上一列的高度），范围是1到6。如果至少有可能在没有严格限制的情况下获得一些输入，也可以数学概率（即某些输入比其他输入少出现）。
• 列不能浮在底部上方并且在其中有空隙。
• 由于每一列的最小高度均为1，因此最后一行也不能有任何间隙-它始终由33个等号组成。
• 由于可能没有高度为6的列（毕竟都是随机的）：在这种情况下，您不需要由空格组成的顶行。适用于这种性质的任何边缘情况：如果您的代码突然没有提供高度大于1的列，则无需在底行上方用空格构成其他行。
• 你什么都不输入。

Pyth，13个字节

而且我超过果冻。

j_.tm*hO6\=33

在线尝试！

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 个字节

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

说明

33⍴6 33次重复6次

?33 6s中的每一个在[1，n ] 范围内的随机整数

'='⍴¨⍨ 等号重复上述次数

↑ 将列表列表转换为行表

⍉ 将行转置为列，将列转置为行

⊖ 上下颠倒

运行示例

输入缩进六个空格：

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

果冻，14个字节

6x33X€”=ẋz⁶Ṛj⁷

在这里尝试。

JavaScript（ES6），116个字节

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

在下面的动画片段中查看：

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字节

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

呼叫为f();。此答案取决于以下事实：六个连续的调用time(0)返回相同的结果（以秒为单位）。这几乎总是正确的，但可能值得一提。

Cheddar，68 65字节（无竞争）

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

O_O Cheddar实际上做得很好！使用sprintf和turn做大量的工作。vfuse是vertical-fuse的意思是它垂直连接到数组。这非常打高尔夫球，但速度也很快。版本是prerelease v 1.0.0-beta.10，它在挑战之后过时。

说明

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

运行一些示例：

05AB1E，22字节

没有自动加入，转置时没有自动填充，osabie注定要失败。码：

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

使用CP-1252编码。在线尝试！。

Python 2，95个字节

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

Python 3，115个字节

Python甚至没有机会...

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

怎么运行的

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上尝试

MATL，20 19 18 17字节

@Luis节省了1个字节

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

在线尝试

SpecaBAS-76字节

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

在相关的屏幕坐标处打印等号。

有斑点和一个GOTO循环，它变成

K4，18个字节

本质上是APL解决方案的一个端口（毫不奇怪）。

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

C＃，200个 117字节

()=>{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 算法并节省83个字节！

没有输入且输出为字符串的C＃lambda。在线尝试。

码：

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

作为一种纯粹的功能性语言，Haskell从一开始就注定要失败。无论如何，我做到了，事实证明，所需的开销实际上并没有那么大。

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

说明：

import System.Random

能够使用newStdGen和randoms

import Data.List

能够使用 transpose

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

定义一个函数，如果它的第一个参数大于第二个参数，则打印一个空格，否则返回一个空格=。用map (f m) [0..5]给定的编号m和列表调用它[0,1,2,3,4,5]。（见下文）

s=do
g<-newStdGen

创建一个新的标准随机数生成器

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

取33个随机整数。

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

计算m = n % 6并映射(f m)到列表[0,1,2,3,4,5]，结果为之一"======", " =====", ..., " ="。这些行被映射到33个随机整数的列表中，形成一个表。（Haskell中的一个表是列表的列表）

transpose$

切换表格的列和行

mapM_ putStrLn$

打印表格中的每一行

CJam，19个字节

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

在线尝试！

说明

{       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个字节

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

匿名函数。不接受任何输入，并返回一个字符串作为输出。Unicode字符为U + F3C7，表示\[Transpose]。

R，102字节

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

说明

m=rep(" ",33) 为即将到来的循环初始化一个空向量

n=ifelse(m=="=",m,sample(c(" ","="),33,T,c(6-i,i)))如果=上面的行中有一个，请确保下面的位置也有一个=；否则随机选择。对随机选择权进行加权，以确保a）最下一行是全部=，b）您得到的整齐的形状。

cat(n,"\n",sep="") 将该行输出到控制台，末尾有换行符，元素之间没有空格！

PHP，95 92 89字节

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

实际上，对此感到非常满意。有一段时间，我有一个版本，理论上可以生成任何输入，但实际上只能生成=的实心块，但这更短并且分布均匀！
每当您运行它时，都会生成7条未定义的通知，但这很好。

编辑：好吧，我刚刚了解到join是implode的别名，所以很好。

J，18个字节

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

很简单的东西。远距离的错误修正！

Perl，64个字节

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

用法

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

Perl，68个字节

替代版本依赖于ANSI转义码来移动光标，首先向下移动6行，然后写入原始行（所有=s），向上移动一行并s/=/rand>.4?$&:$"/ge重复打印替换的字符串（），直到不再进行替换为止。最终可能会写超过六行，但最终将其替换为空行。

注意：\x1bs实际上是ASCII Esc字符。

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

红宝石， 102 99 84 83个字节

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

一种新的且明显更短的方法，我从充满新行的字符串开始。

旧版本...

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

...以新行开头输出 我在Ruby中的第一个提交，使用与@Barbarossa相似的方法，但处于单循环中。

在该程序上工作时，我喜欢Ruby：

• .times 环
• rand() 这很短
• 没有括号的堆叠三元运算符

我不喜欢（主要在打高尔夫球方面）：

• $全局变量强制.times循环中不太强制
• do和end关键字 可以用单行块代替
• 0 不虚假

JavaScript，179个字节

仍在打高尔夫球。我喜欢这个，因为它很简单。

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

用法：

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

190个字节

我必须创建自己的PRNG，这是从这里获取的异或。这个词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

在线尝试 -请注意，系统时间是两个值之一，取决于运行该代码的服务器（或某物）。除此之外，由于某些原因它们不会在在线IDE中更改。因此，您只会看到两个可能的输出。您可以通过更改utime为整数来手动设置种子。

不打高尔夫球

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

在线取消高尔夫

JavaScript，165字节

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

换行是不必要的，但它们使查看情况变得更加容易。这不是最理想的解决方案，但至少对我来说有意义。