Đây là cái gối của tôi

66

... bạn sẽ giúp tôi bất tử chứ?

nhập mô tả hình ảnh ở đây

Tôi đã có chiếc gối này vài năm nay và dường như đã đến lúc loại bỏ nó. Bạn có thể vui lòng viết một chức năng hoặc chương trình, mà tôi có thể mang theo bên mình và sử dụng để tạo lại chiếc gối này bất cứ khi nào tôi muốn gợi nhớ một chút.

Nó phải làm việc không có đối số đầu vào.

Đầu ra sẽ trông chính xác như thế này (theo dõi dòng mới và dấu cách là OK).

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

Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte sẽ thắng!

Bảng xếp hạng

Hiển thị đoạn mã

code-golf  ascii-art  kolmogorov-complexity 
— Stewie Griffin
nguồn
7
Tôi hơi thất vọng vì mô hình không phức tạp hơn một chút, để thể hiện độ dày đường khác nhau của gối.
— Sparr
4
@Sparr Tôi đã thử, nhưng tôi đã không quản lý để làm cho nó trông ổn khi chỉ sử dụng các ký tự ASCII. Hình này đã đủ gần :)
— Stewie Griffin
3
Tôi vừa mới thêm khoảng trắng
— Sparr
1
'Rõ ràng': P
— Pysis
7
Bây giờ bạn có thể mua một chiếc gối trống và in đoạn trích người chiến thắng trên đó.
— coredump

Câu trả lời:

24

05AB1E , 18 15 byte

Mã số:

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

Giải trình:

„/\               # 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

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

— Nam bộ
nguồn
2
Wow ... hai cách khác nhau, cùng một số byte ...
— Oliver Ni
30

/// , 116 byte

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

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

Chỉnh sửa : các \\\\\\\\\\\\\\\/và \\\\\\\\\\\\\\\\đang thực sự là một đơn / và \, tương ứng.

Chỉnh sửa : -3 vì tôi nghĩ loại bỏ i. Tôi nghĩ rằng điều này không thể được chơi thêm.

— Erik là người vượt trội
nguồn
15

Python 2, 49 byte

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

Cảm ơn Mitch Schwartz cho phương pháp sạch này giúp tiết kiệm một byte. Ý tưởng là in bốn dòng ('\\'*5+'/'*5)*6, hoán đổi vai trò của dấu gạch chéo và dấu gạch chéo ngược, sau đó thực hiện toàn bộ quá trình đó 6 lần. Hai ký tự được lưu trữ trong avà b, và hoán đổi như a,b=b,a. Vòng lặp kép là gấp đôi bằng cách tạo chuỗi mã sau, sau đó thực hiện chuỗi đó bằng 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 byte:

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

Làm cho chuỗi dòng, in nó bốn lần và sau đó đảo ngược nó, sau đó thực hiện 6 lần. Làm như vậy bằng cách tạo mã sau đây, sau đó thực thi nó:

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]

Dưới đây là một số lần lặp lại việc chơi golf của tôi:

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
nguồn
12

05AB1E, 15 byte

„/\5×{R6×6FR4F=

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

Giải trình:

„/\             # 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

Sử dụng mã hóa CP-1252 .

— Oliver Ni
nguồn
8

JavaScript (ES6), 68 60 58 byte

Một hàm đệ quy. Một số tối ưu hóa lấy cảm hứng từ câu trả lời chocochaos .

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

Bản giới thiệu

Hiển thị đoạn mã

— Arnauld
nguồn
Tôi nghĩ bạn có thể bỏ qua phần đầu tiên &1và lưu hai byte
— Henrik Christensen
@HenrikChristensen Điều đó sẽ chỉ làm việc cho n < 480. Đối với n >= 480, chúng tôi cần dấu ngoặc đơn : (n/240^n/5)&1.
— Arnauld
8

Bong bóng , 30 byte

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

Câu trả lời bắt buộc Bubblegum.

— LegionMammal978
nguồn
Ôi trời ơi ngôn ngữ này thật tuyệt!
— Pedro A
7

Haskell, 77 70 57 byte

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

Chán concats và replicates thay vì chơi với sin. Cũ là:

unlines[["\\/"!!(ceiling$sin(pi*x/5)*sin(pi*y/4))|x<-[0.5..59]]|y<-[0.5..23]]
— Thiên thần
nguồn
6

Brainfuck, 140 byte

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

:-CƯỜI MỞ MIỆNG

— 0WJYxW9FMN
nguồn
3
Ôi nhìn kìa! Giải pháp brainfuck ngắn hơn tám byte so với giải pháp Java. Thời gian để các lập trình viên Java chuyển sang brainfuck ...
— 0WJYxW9FMN
Java tấn công trở lại
— cliffroot
6

Python 2, 86 80 76 74 73 byte

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

Có thể chơi golf thêm một vài lần nữa nhưng đó là một sự khởi đầu.

Biên tập

Đã lưu 6 bằng cách xóa một số dấu ngoặc không cần thiết

4 khác bằng cách sử dụng một chuỗi duy nhất và sau đó đảo ngược nó

Cảm ơn @Ad Nam. Có một đêm khuya và vẫn chưa hoàn toàn tỉnh táo: p

-1 bằng cách di chuyển *24đến biến thay vì sử dụng hai lần

— ElPedro
nguồn
4
Tôi tin rằng đó *6*4là giống như *24? : p
— Adnan
6

Brainfuck, 149 byte

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

Thông dịch viên tốt nhất EVAR!

Điều này sử dụng 6 ô (không gói, không modulo). Họ đây rồi:

0A 00 2F 00 5C 00

Các 00tế bào được sử dụng cho các bộ đếm vòng lặp. Ở đây, các quầy được điền vào các giá trị ban đầu:

0A 06 2F 04 5C 03

Bộ đếm ngoài cùng bên trái là cho vòng lặp trong cùng (vâng, tôi sử dụng các vòng lặp lồng nhau ở độ sâu 3). Xin lưu ý rằng ô thứ 4 (bộ 04đếm) được sử dụng hai lần, một lần cho /////\\\\\...và một lần cho \\\\\/////...mỗi lần.

0A, 2FVà 5Clà những nhân vật \n, /và \, tương ứng.

— Erik là người vượt trội
nguồn
6

Python 2.7 66 -> 56 -> 55 byte

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

mới chơi golf

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

Cảm ơn Stewie Griffin

Quên một khoảng trắng ngớ ngẩn;)

— Ivar Matstoms
nguồn
2
Chào mừng đến với PPCG! Câu trả lời đầu tiên rất hay :) Bạn có thể bỏ qua một số biến trung gian không? Ít nhất dvà e, có thể nhiều hơn nữa. Tôi đã không kiểm tra điều này, nhưng nó sẽ gần : print(4*c+4*(6*b+"\n"))*3. Nó ít hơn 5 byte.
— Stewie Griffin
3
55 byte:a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3
— Stewie Griffin
6

Brainfuck, 179 byte

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

Tôi biết đây không phải là điểm số tốt nhất trong chủ đề nhưng tôi muốn thử Brainfuck và thử nó.

Chỉnh sửa: Tôi phải mắc lỗi trong khi sao chép. Phiên bản này sẽ hoạt động

— Axel Matstoms
nguồn
Chào mừng đến với trang web!
— DJMcMayhem
Không làm việc cho tôi. Trình duyệt bị treo với trình thông dịch này , và trình duyệt cá nhân hiển thị đầu ra 5 dòng không mong đợi: /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\ bốn lần, sau đó là vô hạn \ .
— aluriak
Vâng, nó hoạt động :)
— aluriak
5

MATL , 18 16 byte

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

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

Giải trình

'\/'   % 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
— Luis Mendo
nguồn
5

Bình thường, 22 byte

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

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

Giải trình:

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)

Xin lỗi nếu lời giải thích hơi khó hiểu, nhưng nó hơi phức tạp.

— RK.
nguồn
5

V , 22 21 byte

Chỉnh sửa Một byte giành được, cảm ơn @DjMcMayhem:

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

Thay đổi là:

  • Y4P-> 4ÄSử dụng dòng V trùng lặp thay vì lệnh tích hợp Vim (điều này sẽ thêm một dòng trống ở cuối đoạn)
  • 3äG-> 3ä}Sao chép đoạn văn thay vì toàn bộ bộ đệm (để tránh dòng trống được tạo bởi thay đổi trước đó)

Bài gốc

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

Dùng thử trực tuyến

Bị phân hủy như thế này:

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
— statox
nguồn
Thật tuyệt khi thấy người khác sử dụng V! Cho đến gần đây, đó chỉ là tôi. Nếu bạn cần trợ giúp với nó, vui lòng ping tôi theo byte thứ mười chín
— DJMcMayhem
@DrMcMoylex Yup ngôn ngữ của bạn có vẻ thú vị để sử dụng :-) Tôi đã có một vấn đề về cái này: ban đầu tôi muốn sử dụng 5á\5á/05ä$5Ä5x$p4Ä3äGtức là thay thế Y4Pbằng 4Änhưng vì một lý do mà tôi không hiểu nó sao chép một dòng trống thêm ... Nếu bạn có thể soi sáng cho tôi về điều này nó sẽ tốt đẹp Ngoài ra nếu tôi tìm thấy thời gian rảnh, tôi sẵn sàng đóng góp cho ngôn ngữ (đặc biệt là vấn đề # 4 )
— statox
Ah, vâng, điều đó đã gây rắc rối cho tôi nhiều lần. Đó là một vấn đề được biết đến. Vấn đề là đó Älà một từ đồng nghĩa với dd, không Y. Điều này thường không phải là một vấn đề, nhưng nó gây ra một số vấn đề nếu bộ đệm chỉ có một dòng hoặc nếu bạn đang ở dòng cuối cùng.
— DJMcMayhem
Thực ra, tôi chỉ nhận ra, cách tiếp cận mà vẫn có thể làm việc nếu bạn thay thế 3äGvới 3ä}vì nó sẽ không yank rằng xuống dòng cuối cùng. v.tryitonline.net/ từ
— DJMcMayhem
Ok tôi nghĩ rằng tôi hiểu tại sao nó không hoạt động bây giờ. Và cách tốt đẹp để giành được 1 byte, cảm ơn!
— statox
4

Trên thực tế , 21 byte

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

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

-1 byte từ Adnan

Giải trình:

"/\"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
— MEGO
nguồn
Bạn có thể làm một cái gì đó như "/\"5*Sđể tạo ra chuỗi dấu gạch chéo?
— Ad Nam
@Ad Nam Ý tưởng tuyệt vời!
— Mego
4

Ruby, 46 byte

Tạo chuỗi sau (70 ký tự, một bộ nhiều hơn mức cần thiết) sau đó xen kẽ giữa các ký tự lấy mẫu 0..59và 5..64từ chuỗi đó.

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

mã và đầu ra

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

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

sai lầm thú vị (7 thay vì 5)

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

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
— Cấp sông St
nguồn
4

APL, 30 byte

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

Tôi còn khá mới với APL, (Tôi đang sử dụng APLX, nhưng điều này sẽ hoạt động trên hầu hết các triển khai APL), vì vậy đây là một giải pháp khá đơn giản.

Giải trình:

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)
— đổi
nguồn
4

C, 66 61 byte

5 byte được lưu nhờ vào orlp.

Nhân vật đơn giản bằng cách in nhân vật. 61 ký tự mỗi hàng, cuối cùng là dòng mới (ASCII 10) và các ký tự khác xen kẽ giữa /47 và \92.

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

//call like this
main(){f();}
— Cấp sông St
nguồn
61 byte : i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}.
— orlp
@orlp cảm ơn, tôi biết phải có một cách tốt hơn với i--nhưng tôi đã không có thời gian để tìm kiếm nó.
— Cấp sông St
3

Python 2, 63 byte

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

Đối với Python 3, hãy làm điều này (65 byte):

a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
— Erik là người vượt trội
nguồn
1
Điều này sử dụng phương pháp tương tự như câu trả lời Jelly của tôi .
— Erik the Outgolfer 6/11/2016
Phương pháp hiệu quả hơn phương pháp của tôi để bắt đầu
— ElPedro 6/11/2016
@ElPedro Về cơ bản, tôi chỉ thực hiện một số thao tác chuỗi / mảng. Bí quyết là tôi đã chuẩn bị một chuỗi lớn hơn: /////\\\\\/////...bốn lần, cách nhau bởi các dòng mới
— Erik the Outgolfer 6/11/2016
3

J, 31 28 19 byte

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

Sử dụng

   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
— dặm
nguồn
3

Octave, 50 48 byte

Hàm ẩn danh:

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

Bạn có thể thử trực tuyến tại đây . Đơn giản chỉ cần chạy lệnh trên và sau đó chạy chức năng với ans().

Về cơ bản, điều này tạo ra một mảng có giá trị 47 cao 4 và rộng 5. Sau đó, nó tạo ra một mảng thứ hai có giá trị 92 có cùng kích thước.

Hai mảng được nối vào một bàn cờ của [A B;B A]. Nó ''cũng được nối để buộc chuyển đổi thành chuỗi ký tự.

Cuối cùng, toàn bộ mảng được sao chép xuống 3 lần và 6 lần để tạo thành kích thước cuối cùng.

  • Đã lưu 2 byte, cảm ơn @StewieGriffin
— Thợ mộc Tom
nguồn
không cần một chức năng ẩn danh; lưu 3 byte.
— Tasos Papastylianou
@TasosPapastylianou có, nếu không nó sẽ in ans=trước gối. Có nó trong hàm sẽ xoay quanh điều này vì nó dự kiến ​​sẽ trả về câu trả lời cho một biến thay vì hiển thị nó.
— Tom Carpenter
Đó chỉ là ngữ nghĩa. Ý tôi là, nếu bạn sẽ trở thành nhà mô phạm, tôi sẽ lo lắng nhiều hơn về các thông báo cảnh báo 3 dòng xuất hiện thay vào đó: p Ngoài ra các quy tắc thông thường nói rằng nó cần phải là đầu ra từ lệnh đầu cuối trực tiếp hoặc có thể gọi được chức năng xử lý. Có nghĩa là bạn nên gán chức năng ẩn danh của mình cho một tay cầm (hoặc thêm 5 byte khác vào tài khoản để phải pring ans()). Đó là vô nghĩa, vì ans() vẫn in anskhi chạy!
— Tasos Papastylianou
@TasosPapastylianou ans()là một hàm xử lý có thể gọi được, vì vậy bạn không cần gán nó cho một cái gì đó, ví dụ a=@..., bởi vì nó được gán ngầm anslàm tay cầm. Ngoài ra, nó không in ans=khi chạy trừ khi bạn yêu cầu cụ thể bằng cách không làm gì với giá trị được trả về và không thêm a ;. Nếu bạn đã làm disp(ans())nó sẽ chỉ in đầu ra chính xác (không ans=). Nhưng vâng, cảnh báo là khó chịu, tuy nhiên điều đó đã không xảy ra trước đây, vì vậy nó không phải là ngôn ngữ cụ thể, mà là cụ thể thông dịch viên.
— Tom Carpenter
Ok, chúng tôi sẽ đồng ý không đồng ý. Theo cách tôi thấy, nếu bạn dựa vào disp(ans())trước khi nhận đầu ra, thì bạn cần thêm 12 byte vào câu trả lời của mình. Ý kiến ​​riêng của tôi là đây chỉ là cách quãng tám trình bày kết quả của nó và điều đó tốt.
— Tasos Papastylianou
3

PHP, 73 69 byte

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

Bản giới thiệu

http://ideone.com/z7N1Md

— chocochaos
nguồn
1
69 byte: for($s='/\\';$i<1440;$i++)echo$i%60<1?'\n':'',$s[($i/5+($i/240|0))%2];(thay thế \nbằng một dòng mới thực sự). echokhông phải là một hàm, vì vậy, nó không cần dấu ngoặc đơn. Ngoài ra, echocó thể nhận nhiều giá trị, được phân tách bằng dấu phẩy. Điều này thực sự loại bỏ sự cần thiết cho những dấu ngoặc đơn. Và sau đó, bên trong bạn $s[...], phép tính ngoài cùng nhất cũng không cần dấu ngoặc đơn, vì nó được chứa []. Sử dụng $s[($i/5+($i/240|0))%2]có tác dụng tương tự và ngắn hơn.
— Ismael Miguel
Cảm ơn bạn, cập nhật! Tôi thậm chí còn không biết về tiếng vang chấp nhận nhiều tham số ^ _ ^
— chocochaos
echovà printchấp nhận nhiều tham số. Nhưng printyêu cầu dấu ngoặc đơn có nhiều tham số khi được sử dụng trên gia số, điều kiện hoặc phép gán của vòng lặp.
— Ismael Miguel
Có thể loại bỏ điều đó <1, bằng cách chuyển đổi các biểu thức, echo$i%60?'':' ',dòng mới dưới dạng biểu thức 3 trong ternary.
— Progrock
3

Java 7, 120 byte

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

Đẩy mọi thứ vào một vòng lặp. Beats Brainfuck, nhiệm vụ đã hoàn thành.

Xem trực tuyến: https://ideone.com/pZjma3

— vách đá
nguồn
3

Vim, 44 27 byte

EDIT Rất nhiều byte giành được nhờ @DrMcMoylex:

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

Câu trả lời gốc:

Tôi không chắc rằng nó thực sự phù hợp với các quy tắc của trang web này nhưng tôi nghĩ rằng thật thú vị khi thử nó:

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

Mà có thể được phân tách như thế này:

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
nguồn
Oh hey statox, chào mừng đến với trang web! Điều này hoàn toàn phù hợp với các quy tắc. Tôi chơi golf chủ yếu ở vim. Để bạn biết, bạn có thể làm 5i/<esc>5a\<esc>0y$5Pngay từ đầu để lưu 9 byte.
— DJMcMayhem
Này DrMcMoylex (tên mới? :-)) rất vui khi gặp bạn ở đây và câu trả lời của tôi phù hợp. Cũng cảm ơn vì gợi ý của bạn, tôi sẽ chỉnh sửa câu trả lời của tôi
— statox 7/11/2016
2
Haha, vâng tôi tạm thời đổi tên vì thử thách này , lol. Tôi sẽ thay đổi lại sau 30 ngày
— DJMcMayhem
3

Brainfuck, 168 byte

++++++[>++++++++<-]>-<+++++++++[>>++++++++++<<-]>>++<<+++++[>>>++<<<-]>>>>+++[>++++[>++++++[<<<<<.....>.....>>>>-]<<<.>>-]++++[>++++++[<<<<.....<.....>>>>>-]<<<.>>-]<-]
— Humphrey
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.