이게 내 베개 야

66

... 불멸하도록 도와 주실 래요?

여기에 이미지 설명을 입력하십시오

나는이 베개를 몇 년 동안 가지고 있었고, 분명히 그것을 없애야 할 때입니다. 내가 소중하게 생각하고 싶을 때마다이 베개를 다시 만드는 데 사용할 수있는 기능이나 프로그램을 작성해 주시겠습니까?

입력 인수없이 작동해야합니다.

결과는 정확히 다음과 같아야합니다 (트레일 링 줄 바꾸기 및 공백은 괜찮습니다).

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

이것은 코드 골프이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

리더 보드

코드 스 니펫 표시

code-golf  ascii-art  kolmogorov-complexity 
— 스튜이 그리핀
소스
7
베개의 다른 선 두께를 나타 내기 위해 패턴이 조금 더 복잡하지 않다는 것에 다소 실망했습니다.
— Sparr
4
@Sparr 나는 시도했지만 ASCII 문자 만 사용하여 잘 보이게 만들지는 못했습니다. 이 : 충분히 가까이라고 생각 했어요
— 스튜이 그리핀
3
방금 공간을 추가했을 것입니다
— Sparr
1
'명백히': P
— Pysis
7
이제 빈 베개를 사서 우승자 스 니펫을 인쇄 할 수 있습니다.
— coredump

답변:

24

05AB1E , 18 15 바이트

암호:

„/\5×{4Å6×»6F=R

설명:

„/\               # Push the string "/\"
   5×             # Repeat 5 times: "/\/\/\/\/\"
     {            # Sort, resulting in: "/////\\\\\"
      4Å6         # Create a list of 6's with length 4: [6, 6, 6, 6]
         ×        # Vectorized string multiplication
          »       # Join by newlines
           6F     # Do the following six times..
             =    #   Print with a newline without popping
              R   #   Reverse the string

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

— 아드 난
소스
2
와우 ... 두 개의 다른 테이크, 같은 바이트 수 ...
— Oliver Ni
30

/// , 116 바이트

/a/\\\\\\\\\\\\\\\///b/\\\\\\\\\\\\\\\\//A/aaaaa//B/bbbbb//C/ABABABABABAB
//D/BABABABABABA
/CCCCDDDDCCCCDDDDCCCCDDDD

온라인으로 사용해보십시오!

편집은 다음 \\\\\\\\\\\\\\\/과 \\\\\\\\\\\\\\\\실제로있는 단일 각각 / 및 \.

편집 : -3 제거하려고 생각했기 때문에 i. 더 이상 골프를 칠 수 없다고 생각합니다.

— 아웃 골퍼 에릭
소스
15

파이썬 2, 49 바이트

b,a='\/';exec("print(a*5+b*5)*6;"*4+"a,b=b,a;")*6

바이트를 절약하는이 깔끔한 방법에 대한 Mitch Schwartz에게 감사합니다. 아이디어는의 네 줄을 인쇄 ('\\'*5+'/'*5)*6하고 슬래시와 백 슬래시의 역할을 바꾼 다음 전체 프로세스를 6 번 수행하는 것입니다. 두 문자는 a및 에 저장 b되고로 바뀝니다 a,b=b,a. 이중 루프는 다음 코드 문자열을 생성 한 후 다음과 같이 실행하여 이중입니다 exec.

print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;

50 바이트 :

s='/'*5+'\\'*5;exec("print s*6;"*4+"s=s[::-1];")*6

줄 문자열을 만들고 4 번 인쇄 한 다음 반대로 뒤집은 다음 6 번 수행합니다. 다음 코드를 생성 한 다음 실행하면됩니다.

print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1]

내 골프의 반복 중 일부는 다음과 같습니다.

for c in([1]*4+[-1]*4)*3:print('/'*5+'\\'*5)[::c]*6

for i in range(24):print('/\\'*5+'\/'*5)[i/4%2::2]*6

for c in range(24):print('\\'*5+'/'*5)[::(c&4)/2-1]*6

for i in range(24):print('/'*5+'\\'*5)[::1-i/4%2*2]*6

for c in([1]*4+[0]*4)*3:print('\/'*5+'/\\'*5)[c::2]*6

for c in([1]*4+[0]*4)*3:print('\/'[c]*5+'/\\'[c]*5)*6

for c in(['/\\']*4+['\/']*4)*3:print(c[0]*5+c[1]*5)*6

for c in([5]*4+[-5]*4)*3:print('/'*c+'\\'*5+'/'*-c)*6

print((('/'*5+'\\'*5)*6+'\n')*4+(('\\'*5+'/'*5)*6+'\n')*4)*3

for x in(['/'*5+'\\'*5]*4+['\\'*5+'/'*5]*4)*3:print x*6

a='/'*5;b='\\'*5
for x in([a+b]*4+[b+a]*4)*3:print x*6

s='/'*5+'\\'*5
for x in([s]*4+[s[::-1]]*4)*3:print x*6

s=('/'*5+'\\'*5)*9
exec("print s[:60];"*4+"s=s[5:];")*6

a='/'*5;b='\\'*5
for i in range(24):print[a+b,b+a][i/4%2]*6
— xnor
소스
12

05AB1E, 15 바이트

„/\5×{R6×6FR4F=

온라인으로 사용해보십시오!

설명:

„/\             # Push "/\"
   5×           # Repeat string five times: "/\/\/\/\/\"
     {          # Sort: "/////\\\\\"
      R         # Reverse: "\\\\\/////
       6×       # Repeat string six times
         6F     # Repeat the following six times:
           R    #   Reverse
            4F  #   Repeat the following four times:
              = #     Print without popping

CP-1252 인코딩을 사용합니다 .

— 올리버 니
소스
8

자바 스크립트 (ES6), 68 60 58 바이트

재귀 함수 chocochaos answer 에서 영감을 얻은 여러 최적화 .

f=(n=1440)=>n--?'/\\'[n/240&1^n/5&1]+(n%60?'':`
`)+f(n):''

데모

코드 스 니펫 표시

— 아르나 울드
소스
난 당신이 처음을 떠날 수 있다고 생각 &1하고 두 바이트 저장
— 헨릭 크리스텐슨을
@HenrikChristensen 그것은 오직 작동합니다 n < 480. 의 경우 n >= 480괄호가 필요 (n/240^n/5)&1합니다..
— Arnauld
8

풍선 껌 , 30 바이트

00000000: d307 8118 1020 9dc5 3544 3523 f8a4 b386  ..... ..5D5#....
00000010: aae6 e113 cfa3 f13c 1acf a3f1 0c00       .......<......

필수 풍선 껌 답변.

— 군단 포유류 978
소스
오 세상에이 언어는 대단합니다!
— Pedro A
7

하스켈, 77 70 57 바이트

a%b=(<*[1..a]).([1..b]>>)
unlines$4%3$5%6<$>["/\\","\\/"]

죄를 짓는 대신 지루한 concats replicate. 오래된 것 :

unlines[["\\/"!!(ceiling$sin(pi*x/5)*sin(pi*y/4))|x<-[0.5..59]]|y<-[0.5..23]]
— 앙스
소스
6

Brainfuck, 140 바이트

>>>++++++++[>++++++>++++++++++++<<-]++++++++++>->----<<<<<+++[>++++[>++++++[>>.....>.....<<<-]>.<<-]++++[>++++++[>>>.....<.....<<-]>.<<-]<-]

:-디

— 0WJYxW9FMN
소스
3
오 봐! brainfuck 솔루션은 Java 솔루션보다 8 바이트 짧습니다. 자바 코더를위한 시간 ... 브레인 퍽로 전환
— 0WJYxW9FMN
자바 파업
— cliffroot
6

파이썬 2, 86 80 76 74 73 바이트

for z in range(24):a=('/'*5+'\\'*5)*24;print((a+a[::-1])*3)[z*60:z*60+60]

아마 골프를 조금 더 할 수도 있지만 시작입니다.

편집하다

불필요한 괄호를 제거하여 6 절약

하나의 문자열을 사용한 후 반전하여 다른 4

감사합니다 @Adnan. 어젯밤 늦은 밤을 보냈지 만 아직 완전히 깨지 않았습니다 : p

*24변수를 두 번 사용하는 대신 변수 로 이동하여 -1

— 엘 페드로
소스
4
나는 그것 *6*4과 같다고 생각 *24합니까? : p
— Adnan
6

Brainfuck, 149 바이트

++++++++++>++++++[>++++++++<-]>->+++++++++[>++++++++++<-]>++>+++[<<++++[<<++++++[>.....>>.....<<<-]<.>>>-]++++[<<++++++[>>>.....<<.....<-]<.>>>-]>>-]

최고의 통역사 EVAR!

이것은 6 셀을 사용합니다 (랩핑 없음, 모듈러스 없음). 여기 있습니다:

0A 00 2F 00 5C 00

00세포 루프 카운터에 사용됩니다. 여기에 카운터는 초기 값으로 채워집니다.

0A 06 2F 04 5C 03

가장 왼쪽의 카운터는 가장 안쪽의 루프를위한 것입니다 (예, 깊이가 3 인 중첩 루프를 사용합니다). 4 셀 (주의하시기 바랍니다 04카운터)에 대해 한 번, 두 번 사용 /////\\\\\...을 위해 한 번, 그리고 \\\\\/////...때마다.

0A, 2F및 5C문자입니다 \n, /그리고 \각각.

— 아웃 골퍼 에릭
소스
6

파이썬 2.7 66-> 56-> 55 바이트

a="/"*5+"\\"*5;b=a[::-1];c=6*a+"\n";d=6*b+"\n";e=4*c+4*d;print e*3

코드 골프에 새로운

a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3

감사합니다 Stewie Griffin

바보 같은 공백을 잊었다.)

— 이바 마트 톰
소스
2
PPCG에 오신 것을 환영합니다! 좋은 첫 번째 대답 :) 중간 변수 중 일부를 건너 뛸 수 있습니까? 적어도 d그리고 e아마도 더. 나는 이것을 테스트하지는 않았지만 가까이 있어야합니다 print(4*c+4*(6*b+"\n"))*3. 5 바이트가 적습니다.
— Stewie Griffin
3
55 바이트 :a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3
— Stewie Griffin
6

Brainfuck, 179 바이트

->++++++++[-<++++++>]++>+++++++++[-<++++++++++>]++++++++++>>>>+++[-<++++[-<++++++[-<+++++[-<<<.>>>]+++++[-<<.>>]>]<<.>>>]++++[-<++++++[-<+++++[-<<.>>]+++++[-<<<.>>>]>]<<.>>>]>]

나는 이것이 스레드에서 최고 점수가 아니라는 것을 알고 있지만 나는 brainfuck을 시도하고 이것을 시도하고 싶었다.

편집 : 복사하여 붙여 넣는 동안 오류가 발생했습니다. 이 버전은 작동합니다

— 악셀 Matstoms
소스
사이트에 오신 것을 환영합니다!
— DJMcMayhem
나를 위해 작동하지 않습니다. 브라우저는 이 인터프리터 와 끊어지고 개인은 예상치 않은 5 줄 출력을 보여줍니다 : /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\ 4 번, 무한 \ .
— aluriak
네, 그것은 작동합니다 :)
— aluriak
5

MATL , 18 16 바이트

'\/'6:&+thK5&Y")

온라인으로 사용해보십시오!

설명

'\/'   % Push this string
6:     % Push array [1 2 3 4 5 6]
&+     % 6×6 matrix with all pair-wise additions from that array
th     % Concatenate horizontally with itself. Gives a 6×12 matrix
K      % Push 4
5      % Push 5
&Y"    % Repeat each entry of the matrix 4 times vertically and 5 times horizontally
       % This gives a 24×60 matrix
)      % Index (modularly) into the string. This produces the desired 24×60 char array
— 루이스 멘도
소스
5

Pyth, 22 바이트

V6V4V12p*5?%+bN2\\\/)k

여기에서 시도 하십시오 .

설명:

V6                     Loop 6 times, with N from 0 to 5:
  V4                   Loop 4 times, with H from 0 to 3:
    V12                Loop 12 times, with b from 0 to 11:
      p                Print without newline
        *              The repetition
          5            5 times of
          ?            if
            %          the remainder
              + b N    when the sum of b and N
              2        is divided by 2
          \\           then the "\" character
          \/           else the "/" character
    )                  End
                       (implicitly print with newline)
  k                    k (empty string)
                       (implicit end)
                       (implicit end)

설명이 이해하기 힘들지만 미안하지만 다소 복잡했습니다.

— RK.
소스
5

V , 22 21 바이트

@DjMcMayhem 덕분에 1 바이트 원을 편집하십시오 .

5á\5á/05ä$4Ä5x$p4Ä3ä}

변경 사항은 다음과 같습니다.

  • Y4P-> 4ÄVim 내장 명령 대신 V 중복 행을 사용하십시오 (단락 끝에 빈 줄이 추가됩니다)
  • 3äG-> 3ä}전체 버퍼 대신 단락을 복제하십시오 (이전 변경으로 생성 된 빈 줄을 피하기 위해)

원본 게시물

5á\5á/05ä$Y4P5x$p4Ä3äG

온라인으로 사용해보십시오

다음과 같이 분해됩니다.

5á\                    Write 5 \
   5á/                 Write 5 / after
      0                Go to the beginning of the line
       5ä$             Copy the text to the end of the line and repeat it 5 times
          Y4P          Copy the line and create 4 new copies
             5x$p      Delete the 5 first characters and put them at the end of the line
                 4Ä    Duplicate this line
                   3äG Duplicate the whole text
— 스태 톡스
소스
V를 사용하는 다른 사람을 만나는 것이 좋습니다! 최근까지만, 나는 단지 나였다. 도움이 필요하시면 , 19 번째 바이트로
— 보내 주시기 바랍니다
@DrMcMoylex 그래 언어 내가이 일에 문제가 있었다 :-) 사용하는 재미를 보인다 : 처음에 내가 사용하고 싶었 5á\5á/05ä$5Ä5x$p4Ä3äG대체 예 Y4P에 의한 4Ä하지만 난 ... 당신이 할 수있는 경우 사본을 추가로 빈 줄을 이해하지 않는 이유 이것에 대해 나를 밝히십시오 그것은 좋을 것입니다. 또한 자유 시간을 찾으면 기꺼이 언어에 기여할 것입니다 (특히 # 4 호 )
— statox
아, 그렇습니다. 알려진 문제입니다. 문제는 그렇지 않다는 Ä것과 동의어입니다 . 이것은 일반적으로 문제가 아니지만 버퍼에 한 줄만 있거나 마지막 줄에 있으면 문제가 발생합니다. ddY
— DJMcMayhem
당신이 교체하면 사실, 난 그냥 실현, 그 접근 방식은 여전히 작동 할 3äG로 3ä}는 마지막 줄 바꿈을 잡아 당기지 때문에. v.tryitonline.net/…
— DJMcMayhem
좋아, 왜 지금 작동하지 않는지 알 것 같아. 그리고 1 바이트를 얻는 좋은 방법, 감사합니다!
— statox
4

실제로 21 바이트

"/\"5*SR6*;4α@R4α+3αi

온라인으로 사용해보십시오!

Adnan에서 -1 바이트

설명:

"/\"5*SR6*;4α@R4α+3αi
"/\"5*                 "/\" repeated 5 times
      SR               sort and reverse (result: "\\\\\/////")
        6*             repeat string 6 times (forms one row)
          ;4α          copy and push a list containing 4 copies
             @R4α+     push a list containing 4 copies of the reversed string, append to previous list (now we have one row of diamonds)
                  3α   repeat pattern vertically 2 more times
                    i  flatten and implicitly print
— 메고
소스
"/\"5*S슬래시 문자열을 만드는 것과 같은 것을 할 수 있습니까 ?
— Adnan
@Adnan 좋은 생각!
— Mego
4

루비, 46 바이트

다음 문자열 (70 자, 한 세트 이상 필요)을 만든 다음 샘플링 문자 0..59와 문자열 사이를 번갈아 표시 5..64합니다.

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\

코드 및 출력

24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*5,60]}

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

흥미로운 실수 (5 대신 7 대)

24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*7,60]}

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
— 레벨 리버 스트리트
소스
4

APL, 30 바이트

A←240⍴'/////\\\\\'⋄24 60⍴A,⊖A

나는 APL에 익숙하지 않다. (APLX를 사용하고 있지만 대부분의 APL 구현에서 작동해야 함) 매우 간단한 솔루션이다.

설명:

A ← 240 ⍴ '/////\\\\\' ⍝ set A to be a 240 character vector populated with '/////\\\\\'
⋄                      ⍝ statement separator
24 60 ⍴ A,⊖A           ⍝ populate a 24 by 60 character matrix with the concatenation 
                          of A and the reverse of A (⊖A)
— 렌
소스
4

C, 66 61 바이트

orlp 덕분에 5 바이트가 절약되었습니다.

문자 인쇄를 통한 간단한 문자. 행당 61 자, 마지막은 개행 (ASCII 10)이고 나머지는 /47과 \92 사이에서 번갈아 나타납니다 .

i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);‌​}

//call like this
main(){f();}
— 레벨 리버 스트리트
소스
61 바이트 : i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}.
— orlp
@ orlp 덕분에, 나는 더 좋은 방법이 있어야한다는 것을 알았지 i--만 그것을 찾을 시간이 없었습니다.
— Level River St
3

파이썬 2, 63 바이트

a='\n'.join([('/'*5+'\\'*5)*6]*4);print'\n'.join([a,a[::-1]]*3)

Python 3의 경우 다음을 수행하십시오 (65 바이트).

a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
— 아웃 골퍼 에릭
소스
1
이것은 Jelly 답변 과 동일한 방법을 사용합니다 .
— Outgolfer Erik
내 것보다 더 효율적인 방법
— ElPedro
@ElPedro 기본적으로 방금 문자열 / 배열 조작을했습니다. 비결은 더 큰 줄을 준비했다는 것입니다. 줄 /////\\\\\/////...바꿈으로 구분 된 4 번
— 에릭 더 아웃 골퍼
3

J, 31 28 19 바이트

4#_60]`|.\5#72$'/\'

용법

   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
— 마일
소스
3

옥타브, 50 48 바이트

익명의 기능 :

@()repmat([A=repmat(47,4,5) B=A*2-2;B A ''],3,6)

여기서 온라인으로 시도 할 수 있습니다 . 위의 명령을 실행 한 다음로 기능을 실행하십시오 ans().

본질적으로 이것은 4 높이와 5 너비 인 47 값의 배열을 만듭니다. 그런 다음 같은 크기의 값 92의 두 번째 배열을 만듭니다.

두 배열은의 바둑판으로 연결됩니다 [A B;B A]. 가 ''문자열로 변환 강제뿐만 연접된다.

마지막으로 전체 어레이가 3 배 축소 및 6 배 복제되어 최종 크기를 형성합니다.

  • @StewieGriffin 덕분에 2 바이트를 절약했습니다.
— 톰 카펜터
소스
익명의 기능이 필요하지 않습니다. 3 바이트를 절약하십시오.
— Tasos Papastylianou
@TasosPapastylianou가 있습니다. 그렇지 않으면 ans=베개 앞에 인쇄됩니다 . 함수에 표시하면 답변을 표시하지 않고 변수에 반환 할 것으로 예상 되므로이 문제를 해결합니다.
— 톰 카펜터
그것은 의미론 일뿐입니다. 내 말은, 만약 당신이 pedantic이라면 나는 대신에 나타나는 3 줄 경고 메시지에 대해 더 걱정할 것이다. 기능 핸들. 즉, 익명 함수를 핸들에 할당해야합니다 (또는 pring을 설명하기 위해 다른 5 바이트를 추가해야 함 ans()). 실행할 때 ans() 여전히 인쇄 되기 때문에 무의미 ans합니다!
— Tasos Papastylianou
@TasosPapastylianou ans()는 호출 가능한 함수 핸들이므로 a=@...암시 적 ans으로 핸들로 할당되므로 예를 들어 무언가에 할당 할 필요가 없습니다 . 또한 ans=반환 된 값으로 아무것도하지 않고을 추가하지 않으면 특별히 요청하지 않는 한 실행시 인쇄되지 않습니다 ;. 그렇게 disp(ans())하면 정확한 출력 만 인쇄됩니다 (아니오 ans=). 그러나 예, 경고는 성가신 일이지만 이전에는 발생하지 않았으므로 언어별로가 아니라 통역사별로 다릅니다.
— 톰 카펜터
우리는 동의하지 않을 것입니다. 내가 보는 방식으로, disp(ans())출력을 얻기 전에 의지한다면 12 바이트를 답에 추가해야합니다. 내 자신의 의견은 이것이 옥타브가 결과를 제시하는 방식과 같다는 것입니다.
— Tasos Papastylianou
3

PHP, 73 69 바이트

for($s='/\\';$i<1440;$i++)echo$i%60<1?'
':'',$s[($i/5+($i/240|0))%2];

데모

http://ideone.com/z7N1Md

— 초코
소스
1
69 바이트 : for($s='/\\';$i<1440;$i++)echo$i%60<1?'\n':'',$s[($i/5+($i/240|0))%2];( \n실제 개행 문자로 대체 ) echo함수가 아니므로 괄호가 필요하지 않습니다. 또한 echo쉼표로 구분하여 여러 값을 수신 할 수 있습니다. 이렇게하면 해당 괄호가 필요하지 않습니다. 그리고, 내부 $s[...]에서 가장 바깥 쪽 계산에는 withes가 포함되어 있기 때문에 괄호가 필요하지 않습니다 []. 사용 $s[($i/5+($i/240|0))%2]하는 것과 같은 효과가 있으며 더 짧습니다.
— Ismael Miguel
감사합니다 업데이트! 난 받아 여러 매개 변수 ^ _ ^ 에코에 대해 알고하지 않았다
— chocochaos
echo및 print여러 매개 변수를 받아들입니다. 그러나 print루프의 증분, 조건 또는 할당에 사용될 때 여러 매개 변수가있는 괄호가 필요합니다.
— 이스마엘 미구엘
이 떨어져 면도 할 수 <1식을 전환하여,, echo$i%60?'':' ',, 삼항의 표현 3 새로운 라인.
— Progrock
3

자바 7, 120 바이트

String c(){String r="";for(int i=0;i<1440;r+=(i%60<1?"\n":"")+(i/60%8<4?i%10<5?"/":"\\":i%10<5?"\\":"/"),i++);return r;}

모든 것을 하나의 루프로 밀어 넣었습니다. Brainfuck을 이겼고 임무를 완수했습니다.

온라인으로 참조하십시오 : https://ideone.com/pZjma3

— 절벽 뿌리
소스
3

Vim, 44 27 바이트

편집 @DrMcMoylex 덕분에 많은 바이트 수를 얻었습니다.

5i\<esc>5a/<esc>0y$5PY4P5x$pY3PyGPP

원래 답변 :

이 사이트의 규칙에 실제로 맞는지 확실하지 않지만 시도하기가 재미 있다고 생각했습니다.

i\<esc>59.:s;\v(.{5})\1;\1/////;g<CR>Y4P5x$pY3PyGPP

다음과 같이 분해 될 수 있습니다.

i\<esc>                       Insert a \
59.                           Repeat 59 time the insertion
:s;\v(.{5})\1;\1/////;g<CR>   Match 5 characters followed by the same 5 characters
                              And replace them by these 5 characters followed by 5 /
Y4P                           Copy the line and repeat it 4 times
5x$p                          On the current line delete 5 characters and put them 
                              at the end of the line
Y3P                           Copy the line and repeat it 3 times
yG                            Copy all the lines
PP                            Repeat them 2 times
— 스태 톡스
소스
오, statox, 사이트에 오신 것을 환영합니다! 이것은 규칙에 완전히 맞습니다. 나는 주로 vim에서 골프를칩니다. 아시다시피, 5i/<esc>5a\<esc>0y$5P처음에는 9 바이트를 절약 할 수 있습니다.
— DJMcMayhem
DrMcMoylex (새로운 이름? :-))가 당신을 만나서 반갑습니다. 또한 감사 힌트, 나는 내 대답을 편집 할 수 있습니다
— statox
2
하하, 그래, 난 이 도전 때문에 내 이름을 일시적으로 바꿨다 . 30 일 후에 다시 변경하겠습니다
— DJMcMayhem
3

Brainfuck, 168 바이트

++++++[>++++++++<-]>-<+++++++++[>>++++++++++<<-]>>++<<+++++[>>>++<<<-]>>>>+++[>++++[>++++++[<<<<<.....>.....>>>>-]<<<.>>-]++++[>++++++[<<<<.....<.....>>>>>-]<<<.>>-]<-]
— 미첼 험프리
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.