Ich möchte eine Decke, die so aussieht. Jeder Streifen geht über, unter, über, unter. Kannst du es drucken?

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

Leerzeichen am Ende jeder Zeile und Zeilenumbrüche sind zulässig.

Denken Sie daran, das ist Code-Golf , also gewinnt der Code mit den wenigsten Bytes.

Bestenlisten

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

# [><>](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 Bytes

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

Dank Sp3000 für 6 Bytes von der Umwandlung der arithmetischen Operationen in bitweise.

Pyth, 36 Bytes

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

Probieren Sie es online aus: Demonstration

Erläuterung:

Wir können das Symbol bestimmen, indem wir 3 Bedingungen überprüfen:

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

Wenn wir [A,B,C]als Binärzahl interpretieren , erhalten wir die folgende Zuordnung:

01234567
 \// \/\

Wir können auch [A,B,C]als Dezimalzahl interpretieren und eine modulare indizierte Suche in der Zeichenfolge durchführen. Das macht keinen Unterschied, weil 10 mod 8 = 2.

Nun zum Code:

V24iteriert N(row-idx) über [0, 1, ..., 23].

sm...48dOrdnet die Zahlen (column-idx) [0, 1, ..., 47]den Zeichen zu und gibt die kombinierte Zeichenfolge aus.

++BNderzeugt die Liste [N, N+d], +...t-Ndhängt an N-d-1. Wir haben also die Liste [N, N+d, N-d-1]. m<3%k8prüft für jede berechnete Zahl k, ob 3 < k % 8, also ergibt dies die Liste mit den Bedingungen [A, B, C].

i...TKonvertiert dies in eine Dezimalzahl und führt dann @" \// \/\\"die Suche in der Zeichenfolge durch.

Mehr oder weniger derselbe Code in Python2: 98 Bytes :

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 Bytes

Laufen Sie mit -mList::Util=max -M5.010(die zweite Flagge ist frei). Es gewinnt keine Bytezahl-Wettbewerbe, aber hier ist meine Lösung.

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

Lesbar:

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

Erzeugt prozedural jedes Segment, wiederholt dann das Muster 6 Mal und gibt dann das Gesamtergebnis 3 Mal aus.

Python 3, 174 172 138 Bytes

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

Fand das kleinste Muster, das ich in der Decke finden konnte (das "Unter" - und "Über" -Muster), steckte es in eine Liste und fügte etwas Listenverständnis und Zeichenkettenmanipulation hinzu, um alles zu entpacken. Ersetzte alle ausgeblendeten Backslashes durch "b" und ersetzte sie später wieder, um ein paar Bytes zu sparen.

Danke an Oliver für die 2 Bytes!

34 Bytes wurden durch Ändern des Musters entfernt - das gesamte Muster für die Decke befindet sich jetzt in einer einzigen Liste, sodass nur eine for-Schleife zum Auspacken des Musters erforderlich ist.

Python 2, 171 170 168 Bytes

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)

Nicht hübsch und nicht schlau. Setzt einfach Variablen für die am häufigsten verwendeten Zeichenfolgengruppen, kombiniert sie und gibt das Ergebnis dreimal aus. Versuchen Sie es später noch einmal, wenn ich keinen besseren Ansatz finde.

1 Byte, das durch Verwendung der unformatierten Eingabe für die Zuweisung gespeichert wurde. Vielen Dank @ nedla2004

-2 durch Zuweisung einiger Variablen, aber immer noch kein ernsthafter Konkurrent

SOML , 106 Bytes

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

eine nicht konkurrierende Version mit einer Funktion, die ich erst kürzlich hinzugefügt habe: ( 83 67 66 Bytes)

Erläuterung:

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

Ruby, 75 Bytes

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

Besser Golf spielen, wenn ein einzelner 8-Byte-String-Lookup verwendet wird, der von j & 4 zusätzlich zu den anderen Parametern indiziert wird, als ein modifizierbarer 4-Byte-String.

Ruby, 81 Bytes

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

Druckt die diagonalen Streifen zeichenweise. Das richtige Zeichen wird aus einer Folge von 4 Zeichen ausgewählt, abhängig vom Vorhandensein / Fehlen jedes Strangs. Der Überlappungscharakter variiert je nachdem, welcher Strang oben liegt.

Kommentiert

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 Bytes

@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

Ungolfed:

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 Bytes

Verwendet die CP-1252- Codierung.

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

Probieren Sie es online!

Erläuterung

Verwendet den Mod-8-Trick, der in Jakubes Pyth-Antwort fachmännisch erklärt wurde .

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 Bytes

OK, länger als meine letzte (und jede andere) Antwort, wäre aber an Rückmeldungen zum Ansatz interessiert.

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

Bearbeiten

-9, weil @ nedla2004 mehr am Ball ist als ich

-2, indem Sie das Lambda außerhalb der Schleife nehmen und so 2 Einrückungsfelder verlieren

-1 durch Verwenden von in' '*3anstelle von, in 0,1,2da ich hsowieso nicht verwende . Es ist nur ein Zähler.

-3 Warum, warum, warum habe ich zwischen dem zweiten für und dem Druck eine neue Zeile und zwei Einzüge gelassen ??? Es ist spät. Werde morgen wiederkommen.

-14 Kann tatsächlich das Lambda vollständig verlieren und den Basis-3-Decoder direkt nach der Druckanweisung einschließen. Sieht chaotisch aus, aber das ist doch Codegolf :)

-4 Es macht keinen Sinn, eine Variable für die Ganzzahlliste festzulegen. Verwenden Sie es einfach direkt in der zweiten for-Schleife.

-14 und kein Punkt mit der äußeren Schleife. Multipliziere einfach das ganzzahlige Tupel mit 3 (schamlos von @ nedla2004 gestohlen, um unter 200 zu kommen :))

-3 3 gespeichert, indem \ = 0, / = 1 und Leerzeichen = 2 gesetzt werden. Dadurch wird die Ganzzahlliste kürzer, da drei der Basis-3-Zahlen jetzt führende Nullen haben

Wie es funktioniert

Da nur 3 Zeichen verwendet werden:

1. 1 ist eine Liste der 8 sich wiederholenden Muster als ganzzahlige Äquivalente ihrer Basis-3-Darstellung unter der Annahme, dass "" = 0, "\" = 1 und "/" = 2

2. Das Lambda Der erste Code nach der print-Anweisung ist ein einfacher Konverter von einer Ganzzahl in eine Zeichenfolge zur Basis 3

3. Die erste Schleife wird dreimal wiederholt, und die zweite Schleife gibt jede Zeile mit den Basiszeichen 3 multipliziert mit 6 aus und wird durch /, \ oder Leerzeichen ersetzt.

Ich bin sicher, ich könnte einen regulären Ausdruck anstelle des verschachtelten Ersatzes () verwenden, aber ich bin zu müde, um es jetzt zu versuchen. Dies war nur ein Experiment und länger als meine vorherigen Python-Versuche, aber ich habe nur Kommentare zu diesem Ansatz veröffentlicht (und auch, weil ich noch nie in Base 3 gearbeitet habe und den Konverter sehr genossen habe).

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

Das Zahlenarray entspricht jeder Komponente jeder Zeile, wird in Basis 3 übersetzt: = 0, \= 1, /= 2 und dann in Dezimalzahl konvertiert. Die Aufrufe von gsub () sind jedoch zu groß.

Und gerade jetzt habe ich die Antwort von @ ElPedro gesehen. :-( Nur Zufall.

PHP 157 126 Bytes

Die Änderungen in @ Titus-Listen in den Kommentaren übernehmen ... Ich bin verärgert, dass ich Punkt 1 verpasst habe, den ich hätte fangen sollen, aber ich wusste nicht, dass strtr () existiert, wo die meisten Einsparungen anfallen - gute Arbeit, Titus!

NEU:

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

ALT:

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

Da alle Backslashes maskiert werden müssen, wird viel Platz gespart, um sie als andere Zeichen zu packen und für die Ausgabe zu ersetzen. Wenn ich dann str_replace () aufrufe, ist es sinnvoll, sie so oft wie möglich zu verwenden.

Python 2, 169 161 165 160 155 154 152

Basierend auf der Antwort von @ ElPedro mit kleinen Verbesserungen. Die Erklärung finden Sie in der Antwort . Dies ist Python 2, obwohl es in der Nähe von anscheinend Klammern gibtprint .

8 Bytes mit einer Variablen für gespeichert replace . Das funktioniert nur für Strings und die Verwendung einer Funktion dafür wäre länger.

4 Bytes gespart, als @ElPedro merkte, dass sie l nicht brauchten, und ich auch nicht.

5 Bytes gespart, indem das Symbol nicht umgedreht range(8)wird und anstatt +=an r anzuhängen, r am Ende der neuen Ziffer hinzugefügt wird. Versuchen Sie es mit repl.it

5 Bytes durch Stehlen der neuen Werteliste von @ ElPedro gespart.

1 Byte durch Entfernen des Leerzeichens zwischen inund gespart (.

2 Bytes gespart durch Entfernen der Variablen 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 Bytes

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

Ausgabe:

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

Batch, 152 Bytes

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

Die String-Verarbeitung in Batch ist zum Kotzen, daher ist dies wahrscheinlich der beste Ansatz. Call-and-Fall-Through ist etwas kürzer als eine verschachtelte forSchleife. Zumindest muss ich meine Backslashes nicht zitieren!

APL, 110 Bytes

Ich bin neu in APL, das ist also eine vereinfachte Lösung.

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

Hier ist mein Ansatz: Beachten Sie, dass sich das Muster nach den ersten 8 Zeilen der Decke wiederholt. Daher muss ich nur die ersten 8 Zeilen definieren und kann sie dann 3 Mal wiederholen. Beachten Sie auch, dass sich jede Zeile nach den ersten 8 Zeichen wiederholt. Um eine einzelne Zeile zu definieren, muss ich daher nur die ersten 8 Zeichen definieren und diese dann 8 Mal wiederholen.

Hier ist eine ungolfed Lösung:

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

Ich habe oben bemerkt, dass D die Umkehrung von B ist, E die Umkehrung von A ist und H die Umkehrung von F. In meinem tatsächlichen Code nutze ich dies, indem ich D, F oder H nicht definiere und die Umkehrungsfunktion verwende ⊖:

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

Ruby, 132 Bytes

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

sehr einfache Antwort.

Haskell, 96 Bytes

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