Chcę koc, który wygląda tak. Każdy pasek przechodzi, pod, pod, pod, pod. Czy możesz to wydrukować?

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

Końcowe spacje na końcu każdej linii i końcowe znaki nowej linii są dopuszczalne.

Pamiętaj, to jest kodowanie w golfa , więc wygrywa kod z najmniejszą liczbą bajtów.

Liderów

Oto fragment kodu, który pozwala wygenerować zarówno zwykłą tabelę wyników, jak i przegląd zwycięzców według języka.

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie tabeli wyników:

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

var QUESTION_ID=99023,OVERRIDE_USER=12537;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Python 2, 84 bajtów

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

Dzięki Sp3000 za 6 bajtów z zamiany operacji arytmetycznych na bitowe.

Pyth, 36 bajtów

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

Wypróbuj online: demonstracja

Wyjaśnienie:

Możemy określić symbol, sprawdzając 3 warunki:

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

Jeśli interpretujemy [A,B,C]jako liczbę binarną, otrzymujemy następujące mapowanie:

01234567
 \// \/\

Możemy również interpretować [A,B,C]jako liczbę dziesiętną i wykonywać wyszukiwanie modułowe w indeksie w ciągu. To nie robi różnicy, ponieważ10 mod 8 = 2 .

Teraz do kodu:

V24iteruje N(id-wiersza)[0, 1, ..., 23] .

sm...48odwzorowuje liczby d(id-kolumny) w[0, 1, ..., 47] na znaki i drukuje połączony ciąg.

++BNdgeneruje listę [N, N+d], +...t-Nddołącza N-d-1. Mamy więc listę [N, N+d, N-d-1]. m<3%k8sprawdza każdą obliczoną liczbę k, jeśli 3 < k % 8tak, to daje listę z warunkami[A, B, C] .

i...T konwertuje to do liczby dziesiętnej, a następnie @" \// \/\\" wykonuje wyszukiwanie w ciągu.

Mniej więcej ten sam kod w Python2: 98 bajtów :

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)

Perl, 209 + 17 = 226 bajtów

Uruchom z -mList::Util=max -M5.010(druga flaga jest bezpłatna). Nie wygrywa żadnych konkursów na liczbę bajtów, ale oto moje rozwiązanie.

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

Czytelny:

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

Proceduralnie generuje każdy segment, następnie powtarza wzór 6 razy, a następnie generuje wynik 3 razy.

Python 3, 174 172 138 bajtów

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

Znalazłem najmniejszy wzór, jaki mogłem znaleźć w kocu (wzór „poniżej” i „ponad”), utknąłem na liście i dodałem trochę zrozumienia listy i manipulacji ciągiem, aby rozpakować wszystko. Wszystkie znaki ucieczki odwrócone zamieniono na „b” i zastąpiono je później, aby zaoszczędzić kilka bajtów.

Dzięki Oliver za grę w golfa z 2 bajtów!

Usunięto 34 bajty, zmieniając wzór - cały wzór koca znajduje się teraz na jednej liście, więc do rozpakowania wzoru potrzebny jest tylko jeden dla pętli.

Python 2, 171 170 168 bajtów

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)

Nie ładna i nie sprytna. Po prostu ustawia zmienne dla najczęściej używanych grup ciągów, a następnie łączy je i drukuje wynik 3 razy. Może spróbuję zagrać w golfa później, jeśli nie znajdę lepszego podejścia.

1 bajt zapisany przy użyciu surowego wejścia w przydziale. Dzięki @ nedla2004

-2 przez przypisanie kilku zmiennych, ale nadal nie jest poważnym konkurentem

SOML , 106 bajtów

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

niekonkurencyjna wersja korzystająca z funkcji, którą niedawno dodałem: ( 83 67 66 bajtów)

wyjaśnienie:

  →$\\→#////→@”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)

Rubinowy, 75 bajtów

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

Lepiej gra w golfa, używając pojedynczego 8-bajtowego ciągu znaków indeksowanego przez j & 4 oprócz innych parametrów, zamiast modyfikowalnego ciągu 4-bajtowego.

Ruby, 81 bajtów

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

Drukuje ukośne paski znak po znaku. Właściwy znak jest wybierany z ciągu 4 znaków w zależności od obecności / braku każdej nici. Nakładający się znak jest różny w zależności od tego, która nić jest na górze.

Skomentował

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

Perl, 132 131 113 bajtów

@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

Nie golfowany:

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
}

05AB1E , 37 bajtów

Wykorzystuje kodowanie CP-1252 .

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

Wypróbuj online!

Wyjaśnienie

Wykorzystuje sztuczkę mod-8 fachowo wyjaśnioną w pythowej odpowiedzi 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

Python, 245 236 234 233 230 216 212 198 195 bajtów

OK, dłużej niż moja ostatnia (i jakakolwiek inna) odpowiedź, ale byłbym zainteresowany opiniami na temat tego podejścia.

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',' ')

Edytować

-9 z uwagi na to, że @ nedla2004 jest bardziej na piłce niż ja

-2, biorąc lambda poza pętlę i tracąc w ten sposób 2 wcięcia

-1 używając in' '*3zamiast, in 0,1,2ponieważ nie używamh . to tylko licznik.

-3 Dlaczego, dlaczego, dlaczego zostawiłem znak nowej linii i 2 wcięcia między drugim znakiem a drukiem? Jest późno. Wrócę jutro.

-14 Potrafi całkowicie stracić lambda i po prostu dołączyć dekoder bazowy 3 bezpośrednio po instrukcji print. Wygląda niechlujnie, ale w końcu to kod golfowy :)

-4 Nie ma sensu ustawiać zmiennej dla listy liczb całkowitych. Po prostu użyj go bezpośrednio w drugiej pętli for.

-14 i nie ma sensu używać zewnętrznej pętli. Wystarczy pomnożyć krotkę całkowitą przez 3 (bezwstydnie skradzione z @ nedla2004, aby uzyskać mniej niż 200 :))

-3 Zapisano 3, tworząc \ = 0, / = 1 i spację = 2. To sprawia, że ​​lista liczb całkowitych jest krótsza, ponieważ trzy z podstawowych liczb 3 mają teraz wiodące zera

Jak to działa (i działa)

Ponieważ używane są tylko 3 znaki:

1. l jest listą 8 powtarzających się wzorców jako całkowitych odpowiedników ich podstawowej reprezentacji 3 przy założeniu, że „” = 0, „\” = 1 i „/” = 2

2. The lambda Pierwszym kodem po instrukcji print jest lekki konwerter z liczby całkowitej na ciąg 3 bazowy

3. Pierwsza pętla zapętla się 3 razy, a druga drukuje każdą linię z podstawowymi 3 znakami pomnożonymi przez 6 i zastępowanymi przez /, \ lub spacją.

Jestem pewien, że mógłbym użyć wyrażenia regularnego zamiast zagnieżdżonego replace (), ale jestem zbyt zmęczony, by spróbować teraz. To był tylko eksperyment i dłuższy niż mój poprzedni wysiłek w Pythonie, ale opublikowałem tylko komentarze na temat tego podejścia (a także dlatego, że nigdy wcześniej nie pracowałem w bazie 3 i bardzo podobało mi się opracowanie konwertera).

Rubin, 135 bajtów

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

Tablica liczb odpowiada każdemu składnikowi każdej linii, przetłumaczona na podstawę 3: = 0, \= 1,/ = 2, a następnie przekonwertowana na dziesiętną. Jednak wywołania gsub () są zbyt duże.

I właśnie teraz widziałem odpowiedź @ ElPedro. :-( Tylko zbieg okoliczności.

PHP 157 126 bajtów

Biorąc zmiany w listach @Titus w komentarzach ... Jestem zirytowany, że przegapiłem punkt 1, który powinienem był złapać, ale nie wiedziałem, że istniała strtr (), gdzie jest większość oszczędności - dobra robota Titus!

NOWY:

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

STARY:

<?$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
";}

Ponieważ wszystkie ukośniki odwrotne wymagają ucieczki, oszczędza to sporo miejsca na spakowanie ich jako inny znak i zastąpienie ich danymi wyjściowymi, a następnie, gdy wywołuję str_replace (), warto go używać tak często, jak to możliwe.

Python 2, 169 161 165 160 155 154 152

Na podstawie odpowiedzi @ ElPedro, z niewielkimi ulepszeniami. Aby zobaczyć wyjaśnienie, zobacz ich odpowiedź . To jest Python 2, chociaż wydaje się, że w pobliżu znajdują się nawiasy print.

Zapisano 8 bajtów, używając zmiennej dla replace. Działa to tylko w przypadku ciągów, a użycie funkcji byłoby dłuższe.

Zaoszczędziłem 4 bajty, widząc, że @ElPedro zdał sobie sprawę, że nie potrzebują l, a ja też nie.

Zaoszczędzono 5 bajtów, nie odwracając range(8) , i zamiast używać +=dołączenia do r, dodając r na końcu nowej cyfry. Wypróbuj za pomocą repl.it

Zaoszczędzono 5 bajtów, kradnąc nową listę wartości @ ElPedro.

Zaoszczędzono 1 bajt, usuwając spację między in i( .

Zapisano 2 bajty, usuwając zmienną 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',' ')

PHP, 184 bajty

<?$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";

Wynik:

C:\PHP>php make-me-a-blanket.php
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\

Partia, 152 bajty

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

Przetwarzanie łańcucha w Batch jest do bani, więc jest to prawdopodobnie najlepsze podejście. Połączenie zwrotne jest bardzo nieznacznie krótsze niż forpętla zagnieżdżona . Przynajmniej nie muszę cytować moich ukośników!

APL, 110 bajtów

Jestem nowy w APL, więc jest to uproszczone rozwiązanie.

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

Oto moje podejście: zwróć uwagę, że po pierwszych 8 liniach koca wzór się powtarza. Dlatego muszę tylko zdefiniować pierwsze 8 wierszy, a następnie powtórzyć je 3 razy. Zauważ też, że każdy wiersz powtarza się po pierwszych 8 znakach. Dlatego, aby zdefiniować pojedynczy wiersz, muszę tylko zdefiniować pierwsze 8 znaków, a następnie powtórzyć je 8 razy.

Oto rozwiązanie bez golfa:

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

Zauważyłem powyżej, że D jest odwrotnością B, E jest odwrotnością A, a H jest odwrotnością F. W moim rzeczywistym kodzie korzystam z tego, nie definiując D, F lub H i używając funkcji odwrotnej ⊖:

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

Rubin, 132 bajty

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

bardzo prosta odpowiedź.

Haskell, 96 bajtów

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]]