당신은 알고 있습니다 – 그들은 다음과 같습니다 :

^출처

목표는 다음과 같은 음악 비트 그림을 그리는 것입니다.

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

규칙은 다음과 같습니다.

• 그림의 너비는 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 6 회 33 회 반복

?33 초 각각에 대해 [1, n ] 범위의 난수

'='⍴¨⍨ 평등 기호는 그 횟수만큼 반복

↑ 목록 목록을 행 테이블로 변환

⍉ 행을 열로, 열을 행으로 전치

⊖ 거꾸로 뒤집다

예제 실행

입력은 6 칸 들여 쓰기됩니다 :

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

젤리, 14 바이트

6x33X€”=ẋz⁶Ṛj⁷

여기에서 시도하십시오.

자바 스크립트 (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();. 이 답변은 6 회의 연속 호출 time(0)이 동일한 결과 (초) 를 반환 한다는 사실에 의존합니다 . 이것은 항상 사실이지만 언급 할 가치가 있습니다.

체다, 68 65 바이트 (비경쟁)

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

O_O Cheddar가 실제로 잘하고 있습니다! 사용 sprintf및 turn작업의 대부분을 할 수 있습니다. vfuse수직 퓨즈는 배열을 결합하지만 수직입니다. 이것은 매우 골프이지만 다소 빠릅니다. 버전은 시험판 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 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

파이썬 2, 95 바이트

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

파이썬 3, 115 바이트

파이썬은 기회조차 없었습니다 ...

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 # 람다 온라인으로 사용해보십시오 .

암호:

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

하스켈, 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 개의 임의 정수 목록에 맵핑되어 테이블이됩니다. (하스켈의 표는 목록의 목록입니다)

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

익명의 기능. 입력을받지 않고 문자열을 출력으로 반환합니다. 유니 코드 문자는을 나타내는 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

아주 간단한 것들. 마일에서 버그 수정으로!

펄, 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'
  = =           =  ==      =    =
  = =         ===  ==      =    =
= = =         ===  ==      =    =
= = =   = =   ===  ===   = =    =
= = == =====  === ====   ===  = =
=================================

펄, 68 바이트

ANSI 이스케이프 코드를 사용하여 커서를 움직이고 먼저 6 줄을 드롭 다운 한 다음 원래 줄 (모든 =s) 을 작성하고 줄을 위로 이동하고 s/=/rand>.4?$&:$"/ge더 이상 대체하지 않을 때까지 대체 된 문자열 ( )을 반복적으로 인쇄하는 대체 버전 . 결과적으로 6 줄 이상을 쓸 수 있지만 결국 빈 줄로 바뀝니다.

참고 : \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

... 새로운 라인으로 출력을 개량했습니다. @Barbarossa와 비슷한 접근법을 사용하지만 루비로 처음 제출 한 것은 단일 루프입니다.

이 프로그램에서 작업하는 동안 Ruby에서 좋아했던 것 :

• .times 고리
• rand() 꽤 짧은
• 괄호없이 삼항 연산자 쌓기

나는 (주로 골프 측면에서) 싫어했습니다.

• $전역 변수에 필수.times루프 에서 그렇게 의무적이지 않은
• do및 end키워드 단일 라인 블록으로 대체 될 수 있습니다
• 0 거짓이 아니다

자바 스크립트, 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 바이트

나는 여기 에서 가져온 xor-shift 인 내 자신의 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

언 골프 드 온라인

자바 스크립트, 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``))

줄 바꿈은 불필요하지만 진행 상황을 쉽게 볼 수 있습니다. 가장 최적의 솔루션은 아니지만 적어도 나에게는 의미가 있습니다.