Mach mir eine Decke!

16

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

Code-Snippet anzeigen

code-golf ascii-art kolmogorov-complexity Oliver Ni
quelle
Die rechte Kante scheint falsch ausgerichtet zu sein.
Magic Octopus Urn
Soll sich die linke Kante nicht überlappen?
8.
@ xnor Entschuldigung, meine schlechte.
Oliver Ni
@carusocomputing Behoben.
Oliver Ni
10
Wenn Sie die Sandbox verwendet hätten, hätten diese Probleme vermieden werden können, bevor dies zur Hauptsache wurde.
Mego

Antworten:

8

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.

xnor
quelle
Whoa ... wie ????
Oliver Ni
1
i+~j>>2&1^i+j>>1&2^i&4, vielleicht?
Sp3000,
@ Sp3000 Das ist ein netter bitweiser Vorrang. Ich muss daran denken, wenn ich arithmetisch abgeleitete Boolesche Werte zu einem Index kombiniere.
xnor
5

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)
Jakube
quelle
Nur zu versuchen, Pyth in den Griff zu bekommen, damit jede anständige Antwort mit einer guten Erklärung von mir positiv bewertet wird. wollte Pyth nach meinem Base-3-Experiment
ausprobieren
Sie sollten auch die Antwort von Python2 posten ...
Jerry Jeremiah,
3

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.

Gabriel Benamy
quelle
Woah, ich bin nicht mehr die längste Answe :) +1 dafür, dass ich es trotzdem in Perl mache.
ElPedro
Ich hätte es genauso machen können wie alle anderen (nur ein paar Zeilen drucken), aber ich habe mich entschieden, die Dinge algorithmisch anstatt explizit zu machen, weil ich es cooler fand.
Gabriel Benamy
Nach meinen Maßstäben cool. Ich habe einen Ansatz gewählt, den ich noch nie ausprobiert habe, da es eine interessante Herausforderung war. Wie gesagt, +1. Keine durch meinen Kommentar beabsichtigte Beleidigung. Deshalb habe ich mich aufgestimmt.
ElPedro
3

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.

TheCrazyInventor
quelle
1
Willkommen bei PPCG! schöner erster Beitrag! Sie können ein Byte in Python 2 rasieren. Ich denke, Sie brauchen die Übergänge nicht zum Drucken.
9.
1
Vielen Dank an Easterly Irk, ich habe mich schon zu lange im Code-Golf herumgetrieben, also habe ich beschlossen, daran teilzunehmen. :)
TheCrazyInventor
1
Sie können zwei Byte sparen, indem Sie das Leerzeichen nach 0*6und entfernenu*6
Oliver Ni
1
Sie könnten 4 Bytes einsparen, indem Sie das "b" für doppelte Backslashes verwenden, und überall, wo Sie einen einzelnen Backslash benötigen, verwenden Sie einfach das 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","\\\\"))
Escapezeichen
dzaima: Ihr Code scheint keine gültige Decke zu generieren.
TheCrazyInventor
3

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

ElPedro
quelle
1
Sie könnten ein als r "\\" definieren
nedla2004
Danke @ nedla2004 Guter Punkt. Wirf das ziemlich schnell zusammen und werde es später anschauen. Das ist ein guter Anfang :)
ElPedro
Die meisten sind jedoch daran interessiert, einen Weg zu finden, um das *6Tupelelement zu umgehen. Irgendwelche Ideen?
ElPedro
1
Ich weiß nicht, wie Sie das tun könnten, aber die letzte Zeile kann sein exec r"print'\n'.join(d);"*3.
nedla2004
Ich habe gerade aus Interesse eine Alternative gepostet. Würde deine Kommentare dazu auch schätzen.
ElPedro
2

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)
dzaima
quelle
2

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.
}
Level River St
quelle
2

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
}
Denis Ibaev
quelle
2

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
Emigna
quelle
2

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

ElPedro
quelle
1
Sie können einfach die erste Unterteilung in der Basis 3-Konvertierung entfernen.
nedla2004
Aus irgendeinem Grund hatte ich früher Probleme, aber ich habe es gerade versucht und es funktioniert jetzt. Vielen Dank, dass du wacher bist als ich. Ich bearbeite meine Antwort erneut (und du hast mir gerade 9 Bytes gespart :))
ElPedro
1
Ich habe die Basis 3-Konvertierung umgeschrieben, es ist kein Lambda mehr, ich musste es zu einer Funktion machen, aber es könnte möglich sein, es wieder in ein Lambda umzuwandeln. Die Funktion finden Sie hier .
Nedla2004
Vielen Dank. Ich denke, eine Kombination der beiden könnte funktionieren, aber das ist wahrscheinlich ein Job für morgen Abend :) Nochmals vielen Dank für Ihre Kommentare.
ElPedro
1
Ich habe es auf 169 nach unten, hier .
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

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.

jose_castro_arnaud
quelle
e.to_s(3).rjust(8,"0")→ ("%8s"%e.to_s(3)); gsub("0"," ").gsub("1","\\")..gsub("2","/")→ tr("013"," \\/"); "\n"→ $/; .join→ *"". Sie können auch ein Byte speichern , indem alle Zahlen in der Anordnung von 4 und ersetzt Dividieren emit (e*4).
Jordanien
Ups, ich denke das sollte sein tr("021"," /\\").
Jordanien
90 Bytes: tio.run/##DcjNDkUwEEDhV5FJJG0zl6mhauG@CHJDws5PlMUNnr26Ol/Ofg5/…
Jordan
2

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.

ToXik-Joghurt
quelle
1
Sie können das offene Tag entfernen, wenn Sie verwenden -r. Verwenden Sie diese fünf Schritte, um weitere 30 Byte zu sparen: ideone.com/wt4HGB 1) Verwenden Sie $a[...]direkt als str_replaceParameter, anstatt ihn zuzuweisen . 2) strtrstatt str_replace. 3) Verwenden Sie Ziffern anstelle von Buchstaben. 4) Nehmen Sie die Zuordnung in das Echo auf. 5) Nicht zuweisen $a, nur benutzen.
Titus
1

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',' ')
nedla2004
quelle
Sie können 1 sparen, indem Sie das Leerzeichen zwischen inund (im ersten für
ElPedro
Außerdem habe ich drei Bytes verloren, indem ich die Reihenfolge geändert habe, in der die Zahlen die einzelnen Zeichen in der Liste der Basis 3 darstellen. Siehe meine Antwort zur Erklärung. Fühlen Sie sich frei zu kopieren. Für mich ist dies eine gemeinsame Anstrengung und ich bin froh zu sehen, dass meine ursprüngliche Idee zumindest ein gewisses Potenzial hatte :)
ElPedro
Das brauchst du nicht a=3**i. Verwenden Sie einfach for i in range(8):r=x / 3 ** i% 3 +r, um ein Paar zu retten. Operator Vorrang kümmert sich um den Rest :)
ElPedro
Nicht sicher, wie die Zeichenfolge-Konvertierungszeichen abgegrenzt werden sollen. Der Parser hat sie in meinem letzten Kommentar entfernt, also kopiere und
füge
Guter Punkt, ich habe verstanden.
nedla2004,
1

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
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
Mario
quelle
0

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!

Neil
quelle
0

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

ren
quelle
0

Ruby, 132 Bytes

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

sehr einfache Antwort.

dkudriavtsev
quelle
0

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