Ini bantalku

66

... Maukah Anda membantu saya mengabadikannya?

masukkan deskripsi gambar di sini

Saya sudah memiliki bantal ini beberapa tahun sekarang, dan tampaknya sudah waktunya untuk menyingkirkannya. Bisakah Anda menulis fungsi atau program, yang dapat saya bawa dan gunakan untuk membuat ulang bantal ini setiap kali saya ingin bernostalgia sedikit.

Itu harus bekerja tanpa argumen masukan.

Outputnya akan terlihat persis seperti ini (trailing newlines dan spasi OK).

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

Ini kode golf, jadi kode terpendek dalam byte menang!

Papan peringkat

Tampilkan cuplikan kode

code-golf  ascii-art  kolmogorov-complexity 
— Stewie Griffin
sumber
7
Saya agak kecewa karena polanya tidak sedikit lebih rumit, untuk mewakili ketebalan garis bantal yang berbeda.
— Sparr
4
@Sparr saya mencoba, tetapi saya tidak berhasil membuatnya terlihat bagus hanya menggunakan karakter ASCII. Mengira ini cukup dekat :)
— Stewie Griffin
3
Saya baru saja menambahkan spasi
— Sparr
1
'rupanya': P
— Pysis
7
Sekarang Anda dapat membeli bantal kosong dan mencetak potongan pemenang di atasnya.
— coredump

Jawaban:

24

05AB1E , 18 15 byte

Kode:

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

Penjelasan:

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

Menggunakan pengkodean CP-1252 . Cobalah online!

— Adnan
sumber
2
Wow ... dua pengambilan berbeda, hitungan byte yang sama ...
— Oliver Ni
30

/// , 116 byte

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

Cobalah online!

Sunting : \\\\\\\\\\\\\\\/dan \\\\\\\\\\\\\\\\masing - masing sebenarnya adalah satu / dan \.

Sunting : -3 karena saya berpikir untuk menghapus i. Saya pikir ini tidak bisa golf lebih lanjut.

— Erik the Outgolfer
sumber
15

Python 2, 49 byte

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

Terima kasih kepada Mitch Schwartz untuk metode bersih ini yang menghemat satu byte. Idenya adalah untuk mencetak empat baris ('\\'*5+'/'*5)*6, menukar peran garis miring dan garis miring terbalik, dan kemudian lakukan seluruh proses itu 6 kali. Dua karakter disimpan di adan b, dan ditukar sebagai a,b=b,a. Double-loop ganda dengan menghasilkan string kode berikut, kemudian mengeksekusi dengan 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

Membuat string baris, mencetaknya empat kali dan kemudian membaliknya, lalu melakukannya 6 kali. Lakukan dengan membuat kode berikut, kemudian jalankan:

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]

Berikut adalah beberapa iterasi golf saya:

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
— Tidak
sumber
12

05AB1E, 15 byte

„/\5×{R6×6FR4F=

Cobalah online!

Penjelasan:

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

Menggunakan pengkodean CP-1252 .

— Oliver Ni
sumber
8

JavaScript (ES6), 68 60 58 byte

Fungsi rekursif. Beberapa optimasi diinspirasi dari jawaban chocochaos .

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

Demo

Tampilkan cuplikan kode

— Arnauld
sumber
Saya pikir Anda dapat meninggalkan yang pertama &1dan menyimpan dua byte
— Henrik Christensen
@ HenrikChristensen Itu hanya akan berfungsi untuk n < 480. Untuk n >= 480, kami perlu kurung: (n/240^n/5)&1.
— Arnauld
8

Bubblegum , 30 byte

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

Jawaban Bubblegum wajib.

— LegionMammal978
sumber
Ya ampun, bahasa ini luar biasa!
— Pedro A
7

Haskell, 77 70 57 byte

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

Membosankan concatdan dan replicatebukannya bermain dengan sinus. Lama adalah:

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

Brainfuck, 140 byte

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

:-D

— 0WJYxW9FMN
sumber
3
Oh lihat! Solusi Brainfuck adalah delapan byte lebih pendek dari solusi Java. Saatnya Java coders untuk beralih ke brainfuck ...
— 0WJYxW9FMN
Java menyerang balik
— 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]

Mungkin bisa bermain golf lagi, tapi ini awal.

Sunting

Disimpan 6 dengan menghapus beberapa tanda kurung yang tidak dibutuhkan

Lain 4 dengan menggunakan string tunggal dan kemudian membalikkannya

Terima kasih @ adnan Sudah larut malam tadi malam dan masih belum sepenuhnya bangun: hlm

-1 dengan memindahkannya *24ke variabel alih-alih menggunakannya dua kali

— ElPedro
sumber
4
Saya percaya itu *6*4sama dengan *24? : p
— Adnan
6

Brainfuck, 149 byte

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

Penerjemah terbaik EVAR!

Ini menggunakan 6 sel (tanpa pembungkus, tanpa modulo). Di sini mereka:

0A 00 2F 00 5C 00

The 00sel yang digunakan untuk counter lingkaran. Di sini, penghitung diisi dengan nilai awal:

0A 06 2F 04 5C 03

Penghitung paling kiri adalah untuk loop terdalam (ya, saya menggunakan loop bersarang dari kedalaman 3). Harap dicatat bahwa sel ke-4 ( 04penghitung) digunakan dua kali, sekali untuk /////\\\\\..., dan sekali untuk \\\\\/////...setiap kali.

0A, 2Fdan 5Cadalah karakter \n, /dan \, masing-masing.

— Erik the Outgolfer
sumber
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

baru mengenal kode golf

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

Terima kasih Stewie Griffin

Lupa spasi putih konyol;)

— Ivar Matstoms
sumber
2
Selamat datang di PPCG! Jawaban pertama yang bagus :) Bisakah Anda melewati beberapa variabel perantara? Setidaknya ddan e, mungkin lebih. Saya belum diuji ini, tetapi harus dekat: print(4*c+4*(6*b+"\n"))*3. Kurang dari 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

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

Saya tahu ini bukan skor terbaik di utasnya tetapi saya ingin mencoba brainfuck dan mencobanya.

Sunting: Saya pasti membuat kesalahan saat menyalin. Versi ini seharusnya berfungsi

— Matel Axel
sumber
Selamat datang di situs ini!
— DJMcMayhem
Tidak bekerja untuk saya. Browser menutup telepon dengan juru bahasa ini , dan seorang pribadi menunjukkan output 5 baris yang tidak diharapkan: /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\ empat kali, kemudian tak terbatas \ .
— aluriak
Ya, itu bekerja :)
— aluriak
5

Pyke, 16 byte

"/\"6*5m*n+4*sD3

Setelah pembaruan hari ini yang diizinkan "dalam string literal, 17 byte

"/\\"6*5m*n+4*sD3

Coba di sini!

— Biru
sumber
5

MATL , 18 16 byte

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

Cobalah online!

Penjelasan

'\/'   % 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
sumber
5

Pyth, 22 byte

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

Coba di sini .

Penjelasan:

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)

Maaf jika penjelasannya agak sulit dimengerti, tapi itu agak rumit.

— RK.
sumber
5

V , 22 21 byte

Sunting Satu byte menang, terima kasih @DjMcMayhem:

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

Perubahannya adalah:

  • Y4P-> 4ÄGunakan baris duplikat V bukan perintah bawaan Vim (ini akan menambah baris kosong di akhir paragraf)
  • 3äG-> 3ä}Gandakan paragraf alih-alih seluruh buffer (untuk menghindari baris kosong yang dihasilkan oleh perubahan sebelumnya)

Pos asli

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

Cobalah online

Terurai seperti ini:

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
sumber
Sangat menyenangkan melihat orang lain menggunakan V! Sampai baru-baru ini, hanya aku. Jika Anda memerlukan bantuan untuk itu, silakan ping saya di byte kesembilan belas
— DJMcMayhem
@DrMcMoylex Yup bahasa Anda tampaknya menyenangkan untuk digunakan :-) Saya punya masalah yang satu ini: awalnya saya ingin menggunakan 5á\5á/05ä$5Ä5x$p4Ä3äGyaitu ganti Y4Pdengan 4Ätetapi karena alasan yang saya tidak mengerti itu menyalin baris kosong tambahan ... Jika Anda bisa mencerahkan saya pada yang satu ini akan menyenangkan. Juga jika saya menemukan waktu luang, saya dengan senang hati akan berkontribusi pada bahasa (terutama edisi # 4 )
— statox
Ah, ya itu sudah sering menggangguku. Ini masalah yang diketahui. Masalahnya adalah itu Äadalah sinonim untuk dd, bukan Y. Ini biasanya bukan masalah, tetapi menyebabkan beberapa masalah jika buffer hanya memiliki satu baris atau jika Anda berada di baris terakhir.
— DJMcMayhem
Sebenarnya, saya baru sadar, pendekatan itu masih akan berhasil jika Anda ganti 3äGdengan 3ä}karena tidak akan menarik baris baru terakhir. v.tryitonline.net/…
— DJMcMayhem
Ok saya pikir saya mengerti mengapa itu tidak berhasil sekarang. Dan cara yang bagus untuk memenangkan 1 byte, terima kasih!
— statox
4

Sebenarnya , 21 byte

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

Cobalah online!

-1 byte dari Adnan

Penjelasan:

"/\"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
sumber
Bisakah Anda melakukan sesuatu seperti "/\"5*Suntuk membuat string garis miring?
— Adnan
@ Adnan Ide bagus!
— Mego
4

Ruby, 46 byte

Membuat string berikut (70 karakter, satu set lebih dari yang dibutuhkan) kemudian bergantian antara karakter sampel 0..59dan 5..64darinya.

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

kode dan output

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

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

kesalahan yang menarik (7 bukannya 5)

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

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
— Level River St
sumber
4

APL, 30 byte

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

Saya cukup baru untuk APL, (Saya menggunakan APLX, tetapi ini harus bekerja di sebagian besar implementasi APL), jadi ini adalah solusi yang cukup sederhana.

Penjelasan:

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)
— ren
sumber
4

C, 66 61 byte

5 byte disimpan berkat orlp.

Karakter langsung dengan pencetakan karakter. 61 karakter per baris, terakhir adalah baris baru (ASCII 10) dan yang lainnya bergantian antara /47 dan \92.

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

//call like this
main(){f();}
— Level River St
sumber
61 bytes: i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}.
— orlp
@ Atau terima kasih, saya tahu harus ada cara yang lebih baik dengan i--tetapi saya tidak punya waktu untuk mencarinya.
— Level River St
3

Python 2, 63 byte

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

Untuk Python 3, lakukan ini (65 byte):

a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
— Erik the Outgolfer
sumber
1
Ini menggunakan metode yang sama dengan jawaban Jelly saya .
— Erik the Outgolfer
Metode yang lebih efisien daripada metode saya untuk memulai
— ElPedro
@ ElPedro Pada dasarnya, saya hanya melakukan beberapa manipulasi string / array. Kuncinya adalah bahwa saya telah menyiapkan string yang lebih besar: /////\\\\\/////...empat kali, dipisahkan oleh baris baru
— Erik the Outgolfer
3

J, 31 28 19 byte

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

Pemakaian

   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
— mil
sumber
3

Oktaf, 50 48 byte

Fungsi anonim:

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

Anda dapat mencoba online di sini . Cukup jalankan perintah di atas lalu jalankan fungsinya dengan ans().

Pada dasarnya ini menciptakan array nilai 47 yang 4 tinggi dan 5 lebar. Ini kemudian menciptakan array nilai 92 yang berukuran sama.

Kedua array tersebut digabungkan menjadi kotak-kotak [A B;B A]. The ''concatenated juga untuk memaksa konversi ke string karakter.

Akhirnya seluruh array direplikasi 3 kali turun dan 6 kali melintang untuk membentuk ukuran akhir.

  • Disimpan 2 byte, terima kasih @StewieGriffin
— Tom Carpenter
sumber
tidak perlu untuk fungsi anonim; simpan 3 byte.
— Tasos Papastylianou
@TasosPapastylianou ada, kalau tidak akan mencetak ans=sebelum bantal. Setelah itu dalam fungsi menyiasati ini karena diharapkan untuk mengembalikan jawaban ke variabel daripada menampilkannya.
— Tom Carpenter
Itu hanya semantik. Maksud saya, jika Anda akan bertele-tele saya akan lebih khawatir tentang pesan peringatan 3-baris yang muncul sebagai gantinya: p Juga aturan umum menyatakan bahwa itu harus berupa output dari perintah terminal langsung, atau panggilan fungsi pegangan. Berarti Anda harus menetapkan fungsi anonim Anda ke pegangan (atau menambahkan 5 byte lainnya ke akun karena harus melakukan pring ans()). Tidak ada gunanya, karena ans() masih mencetak ansketika dijalankan!
— Tasos Papastylianou
@TasosPapastylianou ans()adalah pegangan fungsi yang bisa dipanggil, jadi Anda tidak perlu menetapkannya ke sesuatu dengan, misalnya a=@..., karena itu secara implisit ditugaskan anssebagai pegangan. Juga tidak mencetak ans=ketika dijalankan kecuali Anda secara khusus memintanya dengan tidak melakukan apa pun dengan nilai yang dikembalikan dan tidak menambahkan ;. Jika Anda melakukannya disp(ans())hanya akan mencetak output yang tepat (tidak ans=). Tapi ya, peringatan itu menjengkelkan, namun itu tidak terjadi sebelumnya, jadi itu bukan khusus bahasa, tetapi lebih khusus penerjemah.
— Tom Carpenter
Oke, kami akan setuju untuk tidak setuju. Cara saya melihatnya, jika Anda mengandalkan disp(ans())sebelum mendapatkan output Anda, maka Anda perlu menambahkan 12 byte ke jawaban Anda. Pendapat saya sendiri adalah inilah cara oktaf menyajikan hasilnya dan itu bagus.
— Tasos Papastylianou
3

PHP, 73 69 byte

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

Demo

http://ideone.com/z7N1Md

— chocochaos
sumber
1
69 byte: for($s='/\\';$i<1440;$i++)echo$i%60<1?'\n':'',$s[($i/5+($i/240|0))%2];(ganti \ndengan baris baru nyata). echobukan fungsi, jadi, tidak perlu tanda kurung. Juga, echodapat menerima beberapa nilai, dipisahkan dengan koma. Ini benar-benar menghilangkan kebutuhan akan tanda kurung tersebut. Dan kemudian, di dalam Anda $s[...], perhitungan terluar tidak membutuhkan tanda kurung juga, karena itu terkandung dalam layu []. Menggunakan $s[($i/5+($i/240|0))%2]memiliki efek yang sama dan lebih pendek.
— Ismael Miguel
Terima kasih, diperbarui! Saya bahkan tidak tahu tentang gema menerima beberapa parameter ^ _ ^
— chocochaos
echodan printmenerima beberapa parameter. Tetapi printmembutuhkan tanda kurung dengan beberapa parameter ketika digunakan pada kenaikan, kondisi atau penugasan loop.
— Ismael Miguel
Dapat menghilangkan itu <1, dengan mengganti ekspresi,, echo$i%60?'':' ',baris baru sebagai ekspresi 3 di 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;}

Dorong semuanya menjadi satu lingkaran. Beats Brainfuck, misinya tercapai.

Lihat online: https://ideone.com/pZjma3

— cliffroot
sumber
3

Vim, 44 27 byte

EDIT Lot of bytes menang berkat @DrMcMoylex:

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

Jawaban asli:

Saya tidak yakin itu benar-benar cocok dengan aturan situs ini, tetapi saya pikir itu menyenangkan untuk mencobanya:

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

Yang bisa diuraikan seperti ini:

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
sumber
Oh, hei statox, selamat datang di situs ini! Ini sangat sesuai dengan aturan. Saya bermain golf sebagian besar di vim. Asal tahu saja, Anda bisa melakukannya 5i/<esc>5a\<esc>0y$5Pdi awal untuk menghemat 9 byte.
— DJMcMayhem
Hai, DrMcMoylex (nama baru? :-)) senang melihat Anda di sini dan jawaban saya cocok. Juga terima kasih atas petunjuk Anda, saya akan mengedit jawaban saya
— statox
2
Haha, ya saya untuk sementara mengubah nama saya karena tantangan ini , lol. Saya akan mengubahnya kembali dalam 30 hari
— DJMcMayhem
3

Brainfuck, 168 byte

++++++[>++++++++<-]>-<+++++++++[>>++++++++++<<-]>>++<<+++++[>>>++<<<-]>>>>+++[>++++[>++++++[<<<<<.....>.....>>>>-]<<<.>>-]++++[>++++++[<<<<.....<.....>>>>>-]<<<.>>-]<-]
— Mitchell Humphrey
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.