Buatkan aku selimut!

16

Saya ingin selimut yang terlihat seperti ini. Setiap strip melewati, di bawah, melewati, di bawah. Bisakah Anda mencetaknya?

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

Mengejar spasi di akhir setiap baris dan mengikuti baris baru dapat diterima.

Ingat, ini adalah kode-golf , jadi kode dengan byte paling sedikit menang.

Papan peringkat

Berikut ini adalah Stack Snippet untuk menghasilkan leaderboard biasa dan gambaran umum pemenang berdasarkan bahasa.

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

# Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda dapat menyimpan skor lama di headline, dengan mencoretnya. Contohnya:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Jika ada yang ingin Anda sertakan beberapa nomor di header (misalnya karena skor Anda adalah jumlah dari dua file atau Anda ingin daftar juru hukuman bendera secara terpisah), memastikan bahwa skor aktual adalah terakhir nomor dalam header:

# Perl, 43 + 2 (-p flag) = 45 bytes

Anda juga dapat membuat tautan nama bahasa yang kemudian akan muncul di cuplikan papan peringkat:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Tampilkan cuplikan kode

code-golf  ascii-art  kolmogorov-complexity 
— Oliver Ni
sumber
Tepi kanan tampaknya tidak selaras.
— Magic Octopus Urn
Apakah tepi kiri tidak tumpang tindih?
— xnor
@ xnor Maaf, salahku.
— Oliver Ni
@computer Tetap.
— Oliver Ni
10
Seandainya Anda menggunakan Sandbox, masalah-masalah itu bisa dihindari sebelum ini menjadi utama.
— Mego

Jawaban:

8

Python 2, 84 byte

R=range(24)
for i in R:print''.join(" \// \/\\"[i+~j>>2&1^i+j>>1&2^i&4]for j in R*2)

Berkat Sp3000 untuk 6 byte dari mengubah operasi aritmatika menjadi operasi bitwise.

— Tidak
sumber
Whoa ... bagaimana ????
— Oliver Ni
1
i+~j>>2&1^i+j>>1&2^i&4mungkin?
— Sp3000
@ Sp3000 Itu beberapa diutamakan bitwise yang bagus. Saya harus ingat bahwa ketika menggabungkan boolean yang diturunkan secara aritmetika ke dalam indeks.
— xnor
5

Pyth, 36 byte

V24sm@" \// \/\\"im<3%k8++BNdt-NdT48

Cobalah online: Peragaan

Penjelasan:

Kami dapat menentukan simbol dengan memeriksa 3 kondisi:

A := row % 8 > 3
B := (row + column) % 8 > 3
C := (row - column - 1) % 8 > 3

Jika kita mengartikannya [A,B,C]sebagai angka biner, kita mendapatkan pemetaan berikut:

01234567
 \// \/\

Kita juga bisa menginterpretasikan [A,B,C]sebagai angka desimal dan melakukan pencarian indeks modular dalam string. Ini tidak membuat perbedaan karena 10 mod 8 = 2.

Sekarang ke kode:

V24iterates N(row-idx) berakhir [0, 1, ..., 23].

sm...48memetakan angka d(kolom-idx) [0, 1, ..., 47]ke karakter dan mencetak string gabungan.

++BNdmenghasilkan daftar [N, N+d], +...t-Ndtambahkan N-d-1. Jadi kita sudah mendapatkan daftarnya [N, N+d, N-d-1]. m<3%k8memeriksa setiap nomor yang dihitung k, jika 3 < k % 8, jadi ini memberikan daftar dengan ketentuan [A, B, C].

i...Tmengubahnya menjadi angka desimal dan kemudian @" \// \/\\"melakukan pencarian dalam string.

Kode kurang lebih sama di Python2: 98 byte :

R=range(8)
for r in R*3:print''.join(" \// \/\\"[4*(r>3)+2*((r+c)%8>3)+((r-c-1)%8>3)]for c in R*6)
— Jakube
sumber
Hanya mencoba memahami Pyth sehingga jawaban yang layak dengan penjelasan yang bagus mendapat dukungan dari saya. akan mencoba Pyth setelah percobaan base 3 saya :)
— ElPedro
Anda harus memposting jawaban Python2 juga ...
— Jerry Jeremiah
3

Perl, 209 + 17 = 226 byte

Jalankan dengan -mList::Util=max -M5.010(bendera kedua gratis). Ini tidak memenangkan kompetisi jumlah byte, tetapi inilah solusi saya.

for(0..7){@b=(1)x8;@b[$_+3..$_+7]=(3)x4;@b[7-$_..10-$_]=(2)x4;for$c(0..2){$b[$c+8]=max$b[$c+8],$b[$c];$b[5-$c]=max$b[5-$c],$b[13-$c];}push@a,sprintf("%-8s",join("",@b[3..10])=~tr[123][ /\\]r)x6;}say for@a,@a,@a

Dapat dibaca:

for(0..7){
    @b=(1)x8;
    @b[$_+3..$_+7]=(3)x4;
    @b[7-$_..10-$_]=(2)x4;
    for$c(0..2){
        $b[$c+8]=max$b[$c+8],$b[$c];
        $b[5-$c]=max$b[5-$c],$b[13-$c];
    }
    push@a,sprintf("%-8s",join("",@b[3..10])=~tr[123][ /\\]r)x6
}
say for@a,@a,@a

Secara prosedural menghasilkan setiap segmen, kemudian mengulangi pola 6 kali, lalu mengeluarkan total hasil 3 kali.

— Gabriel Benamy
sumber
Woah, saya bukan lagi yang terlama :) +1 untuk melakukannya di Perl.
— ElPedro
Saya bisa melakukannya dengan cara yang sama seperti orang lain (hanya mencetak banyak baris), tetapi saya memutuskan untuk melakukan hal-hal secara algoritmik alih-alih secara eksplisit karena saya merasa itu lebih keren.
— Gabriel Benamy
Keren dengan standar saya. Saya telah mengambil pendekatan yang belum pernah saya coba sebelumnya karena ini merupakan tantangan yang menarik. Seperti yang saya katakan, +1. Tidak ada penghinaan yang dimaksudkan oleh komentar saya. Itu sebabnya saya terbalik.
— ElPedro
3

Python 3, 174 172 138 byte

print("\n".join(o*6for o in("bbbb////"," bb//// ","  ////  "," ////bb ","////bbbb","b//  bbb","bb    bb","bbb  //b")*3).replace("b","\\"))

Menemukan pola terkecil yang dapat saya temukan di selimut (pola "di bawah" dan "di atas"), memasukkannya ke dalam daftar dan menambahkan beberapa pemahaman daftar dan manipulasi string untuk membongkar semuanya. Mengganti semua backslash yang lolos dengan "b" dan menggantinya kembali nanti untuk menghemat beberapa byte.

Terima kasih kepada Oliver untuk bermain golf 2 byte!

Mengambil 34 byte off dengan mengubah pola - seluruh pola untuk selimut sekarang dalam satu daftar, jadi hanya satu untuk loop diperlukan untuk membuka pola.

— TheCrazyInventor
sumber
1
Selamat datang di PPCG! posting pertama yang bagus! Anda dapat mencukur byte dalam python 2 Saya pikir, Anda tidak perlu parends untuk dicetak.
— R
1
Terima kasih Easterly Irk, saya sudah lama bersembunyi di golf kode, jadi saya memutuskan untuk berpartisipasi. :)
— TheCrazyInventor
1
Anda dapat menghemat dua byte dengan menghapus spasi setelah 0*6danu*6
— Oliver Ni
1
Anda dapat menyimpan 4 byte dengan menggunakan "b" untuk backslash ganda dan di mana pun Anda membutuhkan backslash tunggal cukup gunakan melarikan diri:print((("\n".join(o*6 for o in("bb////"," b//// "," //// "," ////b ",""))+"\n".join(u*6 for u in("////bb","\\// b\\","b b","b\\ //\\","")))*3).replace("b","\\\\"))
— dzaima
dzaima: kode Anda sepertinya tidak menghasilkan selimut yang valid.
— TheCrazyInventor
3

Python 2, 171 170 168 byte

a,b,c=r"\\","/"*4," "
f,g=c*2,c+a+b+c
d=(a*2+b)*6,g*6,(f+b+f)*6,g[::-1]*6,(b+a*2)*6,('\\//'+f+a+"\\")*6,(a+f*2+a)*6,(a+"\\"+f+'//\\')*6
for e in 0,1,2:print'\n'.join(d)

Tidak cantik dan tidak pintar. Cukup tetapkan variabel untuk grup string yang paling sering digunakan lalu gabungkan dan cetak hasilnya 3 kali. Dapat mencoba dan bermain golf lebih lama jika saya tidak menemukan pendekatan yang lebih baik.

1 byte disimpan dengan menggunakan input mentah pada tugas. Terima kasih @ nedla2004

-2 dengan menetapkan beberapa variabel tetapi masih bukan pesaing serius

— ElPedro
sumber
1
Anda dapat mendefinisikan sebagai r "\\"
— nedla2004
Terima kasih @ nedla2004 Poin bagus. Lemparkan ini bersama dengan cepat dan akan melihatnya nanti. Itu awal yang baik :)
— ElPedro
Paling tertarik untuk menemukan jalan *6di setiap elemen tuple. Ada ide?
— ElPedro
1
Saya tidak tahu bagaimana Anda bisa melakukan itu, tetapi baris terakhir bisa exec r"print'\n'.join(d);"*3.
— nedla2004
Saya baru saja memasang alternatif hanya karena ketertarikan. Akan menghargai komentar Anda tentang itu juga.
— ElPedro
2

SOML , 106 byte

3{"\\\\////”6*p" \\//// ”6*p"  ////  ”6*p" ////\\ ”6*p"////\\\\”6*p"\//  \\\”6*p"\\    \\”6*p"\\\  //\”6*p

versi yang tidak bersaing menggunakan fungsi yang baru saja saya tambahkan: ( 83 67 66 byte)

penjelasan:

  →$\\→#////→@”6*p"→~3{"##@~ #@ ~$@$~ @# ~@##~\//$#\~#$$#~#\$//\~”
  →$                                                                in the further code replace "$" with "  "
    \\→#                                                            replace "#" with "\\"
        ////→@                                                      replace "@" with "////"
              ”6*p"→~3{"##@~ #@ ~$@$~ @# ~@##~\//$#\~#$$#~#\$//\~” the code to exchange stuff in

so that results in:
”6*p"→~3{"\\\\////~ \\//// ~  ////  ~ ////\\ ~////\\\\~\//  \\\~\\    \\~\\\  //\~”
”6*p"→~3{"A~B~C~D~E~F~G~H~”  modified version of the program (removing "/","\" and " " and replaced with A,B,C,ect.)
”6*p"→~                      replace in the further program "~" with ”6*p" which is:
”                            end string
 6*                          repeat the last thing in stack 6 times
   p                         output the result
    "                        start a string
resulting program: 
3{"A”6*p"B”6*p"C”6*p"D”6*p"E”6*p"F”6*p"G”6*p"H”6*p"”
shortened example:
3{"A”6*p"B”6*p"H”6*p"”
3{                      repeat 3 times
  "A”                   push "A" (original: "\\\\////")
     6*p                output it multiplied by 6
        "B”             push "B" (original: " \\//// ")
           6*p          output it multiplied by 6
              "H”       push "H" (original: "\\\  //\")
                 6*p    output it multiplied by 6
                    "”  push an empty string (shorter to do ~” than ”6*p)
— dzaima
sumber
2

Ruby, 75 byte

1152.times{|i|$><<"\\/ /\\\\ /"[(i+j=i/48)/4&1|(i-j)/2&2|j&4]+$/*(i%48/47)}

Lebih baik bermain golf, menggunakan pencarian string 8-byte tunggal yang diindeks oleh j & 4 selain parameter lainnya, daripada string 4-byte yang dapat dimodifikasi.

Ruby, 81 byte

1152.times{|i|j=i/48%8;$><<"\\#{'/\\'[j/4]} /"[(i+j)/4&1|(i-j)/2&2]+$/*(i%48/47)}

Mencetak karakter garis diagonal berdasarkan karakter. Karakter yang benar dipilih dari string 4 karakter tergantung pada ada / tidaknya setiap untai. Karakter tumpang tindih bervariasi tergantung pada untai mana yang di atas.

Berkomentar

1152.times{|i|j=i/48%8;        #Iterate through all printable chars. j is line number.
  $><<"\\#{'/\\'[j/4]} /"[     #Print a char from "\/ /" if j/4 even or "\\ /" if odd. character changes depending which strand on top.
   (i+j)/4&1|(i-j)/2&2]+       #Print \ if (i+j)/4==0, / if (i-j)/2&2 >0, space if both false. As above if both true. 
   $/*(i%48/47)                #If on column 47, print a newline.
}
— Level River St
sumber
2

Perl, 132 131 113 byte

@a=((0)x4,1..4);map{say+(map$a[7-$_]?$a[$_]*$r?'/':'\\':$a[$_]?'/':$",0..7)x6;push@a,shift@a;$_%4||($r=!$r)}0..23

Tidak Disatukan:

use strict;
use warnings;
use feature 'say';

my @a = ((1) x 4, (0) x 4);  # print '\' if true
my @b = ((0) x 4, (1) x 4);  # print '/' if true
my $r = 0;                   # print '\' over '/' if true

for (0 .. 23) {
    say((map { $a[$_] ? ($b[$_] * $r ? '/' : '\\') : ($b[$_] ? '/' : ' ') } 0 .. 7) x 6);
    unshift(@a, pop(@a));    # circular shift to left
    push(@b, shift(@b));     # circular shift to right
    $r = !$r if !($_ % 4);   # change print priority
}
— Denis Ibaev
sumber
2

05AB1E , 37 byte

Menggunakan pengodean CP-1252 .

24FNU48FXXN+XN-<)8%3›J" \// \/\"è?}¶?

Cobalah online!

Penjelasan

Menggunakan trik mod-8 yang secara ahli dijelaskan dalam jawaban kasar Jakube .

24F                                    # for N in [0 ... 23] do:
   NU                                  # save N in X
     48F                               # for N in [0 ... 48] do:
        XXN+XN-<)                      # push [X,X+N,X-N-1]
                 8%                    # mod each by 8
                   3›                  # compare with 3
                     J                 # join
                      " \// \/\"è?     # index into string and print
                                  }    # end inner loop
                                   ¶?  # print newline
— Emigna
sumber
2

Python, 245 236 234 233 230 216 212 198 195 byte

OK, lebih lama dari jawaban terakhir saya (dan yang lainnya) tetapi akan tertarik dengan umpan balik tentang pendekatan ini.

for a in(40,4496,6200,5456,3240,1188,720,228)*3:print((`a%6561/2178`+`a%2178/729`+`a%729/243`+`a%243/81`+`a%81/27`+`a%27/9`+`a%9/3`+`a%3/1`)*6).replace('0','\\').replace('1','/').replace('2',' ')

Edit

-9 karena @ nedla2004 lebih banyak menguasai daripada saya

-2 dengan mengambil lambda di luar loop dan kehilangan 2 spasi indent

-1 dengan menggunakan in' '*3alih-alih in 0,1,2karena saya tidak menggunakanh . itu hanya sebuah penghitung.

-3 Mengapa, mengapa, mengapa saya meninggalkan baris baru dan 2 indentasi antara yang kedua untuk dan hasil cetak ??? Itu terlambat. Akan mengunjungi lagi besok.

-14 Dapat benar-benar kehilangan lambda sepenuhnya dan hanya menyertakan basis 3 decoder langsung setelah pernyataan cetak. Terlihat berantakan tapi bagaimanapun, ini kode golf :)

-4 Tidak ada titik pengaturan variabel untuk daftar integer. Cukup gunakan langsung di loop kedua.

-14 dan tidak ada titik menggunakan loop luar. Cukup gandakan integer tuple dengan 3 (tanpa malu-malu dicuri dari @ nedla2004 hingga di bawah 200 :))

-3 Disimpan 3 dengan membuat \ = 0, / = 1 dan spasi = 2. Ini membuat daftar bilangan bulat lebih pendek karena tiga dari angka 3 basis sekarang memiliki 0 di depan

Bagaimana cara kerjanya (dan itu terjadi)

Karena hanya 3 karakter yang digunakan:

  1. l adalah daftar dari 8 pola berulang sebagai setara bilangan bulat dari representasi basis 3 mereka dengan asumsi bahwa "" = 0, "\" = 1 dan "/" = 2

  2. Lambda Kode pertama setelah pernyataan cetak adalah konverter ringan dari integer ke string 3 basis

  3. Loop pertama loop 3 kali dan yang kedua mencetak setiap baris dengan karakter dasar 3 dikalikan 6 dan diganti dengan /, \ atau spasi.

Saya yakin saya bisa menggunakan regex alih-alih ganti yang bersarang () tapi saya terlalu lelah untuk mencoba sekarang. Ini hanya percobaan dan lebih lama dari upaya Python saya sebelumnya tetapi telah diposting hanya untuk setiap komentar pada pendekatan (dan juga karena saya belum pernah bekerja di basis 3 sebelumnya dan saya sangat menikmati bekerja di konverter).

— ElPedro
sumber
1
Anda bisa menghapus divisi pertama dalam konversi basis 3.
— nedla2004
Untuk beberapa alasan yang menyebabkan saya masalah sebelumnya tetapi hanya mencoba dan berfungsi sekarang. terima kasih banyak karena lebih sadar daripada saya. Saya akan mengedit kembali jawaban saya (dan Anda baru saja menyelamatkan saya 9 byte :))
— ElPedro
1
Saya menulis ulang konversi basis 3, bukan lagi lambda, saya harus membuatnya berfungsi, tetapi mungkin dapat dikonversi kembali menjadi lambda. Anda dapat menemukan fungsinya di sini .
— nedla2004
Thanks. I think a combination of the two may work but that's probably a job for tomorrow evening :) Thanks again for your comments.
— ElPedro
1
I got it down to 169, here.
— nedla2004
2

Ruby, 135 bytes

puts [3320,1212,720,2172,6520,4144,2920,3184].map{|e|(e.to_s(3).rjust(8,"0").gsub("0"," ").gsub("1","\\").gsub("2","/"))*6+"\n"}.join*3

The number array corresponds to each component of each line, translated to base 3: = 0, \ = 1, /= 2, then converted to decimal. The gsub() calls are too big, though.

And, just now, I saw @ElPedro's answer. :-( Just coincidence.

— jose_castro_arnaud
sumber
e.to_s(3).rjust(8,"0")→ ("%8s"%e.to_s(3)); gsub("0"," ").gsub("1","\\")..gsub("2","/")→ tr("013"," \\/"); "\n"→ $/; .join→ *"". Anda juga dapat menyimpan byte dengan membagi semua nomor dalam array oleh 4 dan mengganti edengan (e*4).
— Jordan
Ups, saya rasa seharusnya begitu tr("021"," /\\").
— Jordan
— Jordan
2

PHP 157 126 byte

Taking the changes @Titus lists in the comments... I'm annoyed I missed point 1 which I should have caught, but I didn't know strtr() existed which is where most of the savings come - nice work Titus!

BARU:

while($i<32)echo$b=strtr([3322,' 322 ','0220',' 223 ',2233,12013,3003,13021][$i++%8],['  ','\\','//','\\\\']),"$b$b$b$b$b\n";

TUA:

<?$a=[zzyy,' zyy ',syys,' yyz ',yyzz,xysxz,zssz,xzsyx];while($i<32){$b=$a[$i++%8];$b=str_replace([z,x,y,s],['\\\\','\\','//','  '],$b);echo"$b$b$b$b$b$b
";}

Because all the backslashes need escaping it saves quite a bit of space to pack them up as different character and replace them for output, and then once I'm calling str_replace() it makes sense to use it as often as possible.

— ToXik-yogHurt
sumber
1
Anda dapat menghapus tag terbuka jika Anda menggunakan -r. Gunakan lima langkah ini untuk menyimpan 30 byte lainnya: ideone.com/wt4HGB 1) gunakan $a[...]langsung sebagai str_replaceparameter alih-alih menugaskannya. 2) strtrbukannya str_replace. 3) Gunakan digit alih-alih huruf. 4) Sertakan tugas dalam gema. 5) Jangan ditugaskan $a, gunakan saja.
— Titus
1

Python 2, 169 161 165 160 155 154 152

Berdasarkan jawaban @ ElPedro, dengan sedikit peningkatan. Untuk melihat penjelasannya, lihat jawaban mereka . Ini adalah Python 2, meskipun tampaknya ada tanda kurung di dekat print.

Disimpan 8 byte dengan menggunakan variabel untuk replace.Itu hanya berfungsi untuk string, dan menggunakan fungsi untuk itu akan lebih lama.

Disimpan 4 byte dengan melihat bahwa @ElPedro menyadari bahwa mereka tidak perlu l, dan saya juga tidak.

Disimpan 5 byte dengan tidak membalik range(8), dan bukannya menggunakan +=untuk menambahkan ke r, menambahkan r ke akhir digit baru. Coba gunakan repl.it

Disimpan 5 byte dengan mencuri daftar nilai baru @ ElPedro.

Disimpan 1 byte dengan menghapus ruang antara indan (.

Disimpan 2 byte dengan menghapus variabel a.

for x in(40,4496,6200,5456,3240,1188,720,228)*3:
 r=''
 for i in range(8):r=`x/3**i%3`+r
 print(r*6).replace('0','\\').replace('1','/').replace('2',' ')
— nedla2004
sumber
Anda dapat menghemat 1 dengan menghapus spasi di antara indan (di dalam untuk pertama
— ElPedro
Saya juga telah kehilangan tiga byte dengan menyusun ulang urutan nomor yang mewakili setiap karakter dalam daftar base 3. Lihat jawaban saya untuk penjelasan. jangan ragu untuk menyalin. Sejauh yang saya ketahui, ini adalah upaya bersama dan saya senang melihat bahwa ide awal saya setidaknya memiliki beberapa potensi :)
— ElPedro
Anda tidak perlu a=3**i. Cukup gunakan for i in range(8):r=x / 3 ** i% 3 +runtuk menyimpan pasangan. operator diutamakan mengurus sisanya :)
— ElPedro
Tidak yakin cara membatasi karakter konversi string. Parser menghapusnya di komentar terakhir saya jadi jangan hanya menyalin dan menempelkan saran saya atau itu akan merusak :)
— ElPedro
Poin bagus, saya mengerti.
— nedla2004
1

PHP, 184 byte

<?$p=['1111////',' 11//// ','  ////  ',' ////11 ','////1111','1//  111','11    11','111  //1'];for($j=0;$j<3;$j++)for($i=0;$i<8;$i++)echo str_replace(1,'\\',str_repeat($p[$i],6))."\n";

Keluaran:

C:\PHP>php make-me-a-blanket.php
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
— Mario
sumber
0

Batch, 152 byte

@call:l
@call:l
:l
@for %%s in (\\\\//// " \\//// " "  ////  " " ////\\ " ////\\\\ "\//  \\\" "\\    \\" "\\\  //\")do @echo %%~s%%~s%%~s%%~s%%~s%%~s

Pemrosesan string dalam Batch menyebalkan, jadi ini mungkin pendekatan terbaik. Panggilan-dan-jatuh-melalui sangat sedikit lebih pendek dari forloop bersarang . Setidaknya saya tidak perlu mengutip garis miring terbalik saya!

— Neil
sumber
0

APL, 110 byte

Saya baru mengenal APL, jadi ini solusi sederhana.

A←48⍴'\\\\////'⋄B←48⍴' \\//// '⋄C←48⍴'  ////  '⋄F←48⍴'\//  \\\'⋄G←48⍴'\\    \\'⋄24 48⍴A,B,C,(⊖B),(⊖A),F,G,⊖F

Inilah pendekatan saya: perhatikan bahwa setelah 8 baris pertama selimut, polanya berulang. Karena itu saya hanya perlu mendefinisikan 8 baris pertama, dan kemudian saya bisa mengulanginya 3 kali. Perhatikan juga bahwa setiap baris berulang setelah 8 karakter pertama. Oleh karena itu untuk mendefinisikan satu baris saya hanya perlu mendefinisikan 8 karakter pertama dan kemudian mengulanginya 8 kali.

Inilah solusi yang tidak diserap:

A←48⍴'\\\\////'⋄ ⍝ set A to a 48 element vector (48⍴) of repeated '\\\\////'s
B←48⍴' \\//// '⋄ ⍝ set B to a 48 element vector (48⍴) of repeated ' \\//// 's
C←48⍴'  ////  '⋄ ⍝ ...
D←48⍴' ////\\ '⋄ ⍝ Note that this is actually the reverse of vector B
E←48⍴'////\\\\'⋄ ⍝ Note that this is actually the reverse of vector A
F←48⍴'\//  \\\'⋄
G←48⍴'\\    \\'⋄
H←48⍴'\\\  //\'⋄ ⍝ Note that this is actually the reverse of vector F

24 48 ⍴ A,B,C,D,E,F,G,H ⍝ Make a 24 by 48 character matrix (24 48⍴) by concatenating A,B...H
                        ⍝ and repeating the string until the matrix is full

Saya mencatat di atas bahwa D adalah kebalikan dari B, E adalah kebalikan dari A, dan H adalah kebalikan dari F. Dalam kode aktual saya, saya mengambil keuntungan dari ini dengan tidak mendefinisikan D, F, atau H dan menggunakan fungsi kebalikan ⊖:

24 48⍴A,B,C,(⊖B),(⊖A),F,G,⊖F

— ren
sumber
0

Ruby, 132 byte

puts Zlib.inflate Base64.decode64 "eJzt0bENADAMAsGeKdggC/3+cyQRC+A2ipuT3RgJgHWGUjm6VXb2Vjn/3KpJ/qtIPlp1v+XSKZKPVk3y/x5+D6/3sAEUXQ+Q"

jawaban yang sangat sederhana.

— dkudriavtsev
sumber
0

Haskell, 96 byte

f n=n`mod`8`div`4
putStr$unlines[["\\ //\\ \\/"!!(f(x-y)+2*f(x+y)+4*f y)|x<-[0..47]]|y<-[0..23]]
— Angs
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.