Das ist mein Kissen

66

... Wirst du mir helfen, es zu verewigen?

Bildbeschreibung hier eingeben

Ich habe dieses Kissen jetzt ein paar Jahre gehabt, und anscheinend ist es Zeit, es loszuwerden. Können Sie bitte eine Funktion oder ein Programm schreiben, das ich mitbringen und verwenden kann, um dieses Kissen nachzubauen, wann immer ich mich ein bisschen erinnern möchte?

Es muss ohne Eingabeargumente funktionieren.

Die Ausgabe sollte genau so aussehen (nachgestellte Zeilenumbrüche und Leerzeichen sind in Ordnung).

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

Das ist Code Golf, also gewinnt der kürzeste Code in Bytes!

Bestenliste

Code-Snippet anzeigen

code-golf  ascii-art  kolmogorov-complexity 
— Stewie Griffin
quelle
7
Ich bin etwas enttäuscht, dass das Muster nicht ein bisschen komplexer ist, um die unterschiedlichen Strichstärken des Kissens darzustellen.
— Sparr
4
@Sparr Ich habe es versucht, aber ich habe es nicht geschafft, dass es nur mit ASCII-Zeichen gut aussieht. Ich dachte, das wäre nah genug :)
— Stewie Griffin
3
Ich hätte gerade Leerzeichen hinzugefügt
— Sparr
1
anscheinend: P
— Pysis
7
Jetzt können Sie ein leeres Kissen kaufen und das Gewinner-Snippet darauf drucken.
— Coredump

Antworten:

24

05AB1E , 18 15 Bytes

Code:

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

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

— Adnan
quelle
2
Wow ... zwei verschiedene Einstellungen, die gleiche Anzahl von Bytes ...
— Oliver Ni
30

/// 116 Bytes

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

Probieren Sie es online!

Edit : die \\\\\\\\\\\\\\\/und \\\\\\\\\\\\\\\\sind eigentlich ein einzelnes / und \.

Edit : -3, weil ich daran gedacht habe, es zu entfernen i. Ich denke, das kann nicht weiter golfen werden.

— Erik der Outgolfer
quelle
15

Python 2, 49 Bytes

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

Vielen Dank an Mitch Schwartz für diese saubere Methode, die ein Byte spart. Die Idee ist, vier Zeilen zu drucken ('\\'*5+'/'*5)*6, die Rollen von Schrägstrich und Backslash zu vertauschen und dann den gesamten Vorgang sechsmal durchzuführen. Die beiden Zeichen werden in aund gespeichert bund vertauscht als a,b=b,a. Die Doppelschleife wird doppelt ausgeführt, indem die folgende Code-Zeichenfolge generiert und anschließend ausgeführt wird 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 Bytes:

s='/'*5+'\\'*5;exec("print s*6;"*4+"s=s[::-1];")*6

Erstellt die Zeilenfolge, druckt sie viermal und kehrt sie dann um. Dann macht man das sechsmal. Dazu wird der folgende Code generiert und anschließend ausgeführt:

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]

Hier sind einige der Iterationen meines Golfspiels:

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
— xnor
quelle
12

05AB1E, 15 Bytes

„/\5×{R6×6FR4F=

Probieren Sie es online!

Erläuterung:

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

Verwendet die CP-1252- Codierung.

— Oliver Ni
quelle
8

JavaScript (ES6), 68 60 58 Byte

Eine rekursive Funktion. Mehrere von Chocochaos inspirierte Optimierungen antworten .

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

Demo

Code-Snippet anzeigen

— Arnauld
quelle
Ich denke, Sie können das erste &1
— Henrik Christensen,
@HenrikChristensen Das würde nur funktionieren n < 480. Für n >= 480würden wir Klammern müssen: (n/240^n/5)&1.
— Arnauld
8

Bubblegum , 30 Bytes

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

Obligatorische Bubblegum-Antwort.

— LegionMammal978
quelle
Oh meine Güte, diese Sprache ist großartig!
— Pedro A
7

Haskell, 77 70 57 Bytes

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

Langweiliges concats und replicates statt mit Sinus zu spielen. Alt war:

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

Brainfuck, 140 Bytes

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

:-D

— 0WJYxW9FMN
quelle
3
Oh schau! Die Brainfuck-Lösung ist acht Byte kürzer als die Java-Lösung. Zeit für Java-Codierer, auf Brainfuck
— umzusteigen
Java schlägt zurück
— Cliffroot
6

Python 2, 86 80 76 74 73 Bytes

for z in range(24):a=('/'*5+'\\'*5)*24;print((a+a[::-1])*3)[z*60:z*60+60]

Könnte wahrscheinlich ein paar mehr Golf spielen, aber es ist ein Anfang.

Bearbeiten

Gespeichert 6 durch Entfernen einiger nicht benötigter Klammern

Weitere 4, indem Sie eine einzelne Zeichenfolge verwenden und diese dann umkehren

Vielen Dank @Adnan. Hatte eine späte Nacht letzte Nacht und noch nicht ganz wach: p

-1, indem Sie *24auf die Variable verschieben, anstatt sie zweimal zu verwenden

— ElPedro
quelle
4
Ich glaube das *6*4ist das selbe wie *24? : p
— Adnan
6

Brainfuck, 149 Bytes

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

Der beste Dolmetscher EVAR!

Dies verwendet 6 Zellen (kein Wrapping, kein Modulo). Hier sind sie:

0A 00 2F 00 5C 00

Die 00Zellen werden für die Schleifenzähler verwendet. Hier werden die Zähler mit Anfangswerten gefüllt:

0A 06 2F 04 5C 03

Der Zähler ganz links ist für die innerste Schleife (ja, ich verwende verschachtelte Schleifen der Tiefe 3). Bitte beachten Sie, dass die 4. Zelle ( 04Zähler) zweimal, einmal für /////\\\\\...und einmal für \\\\\/////...jedes Mal verwendet wird.

0A, 2FUnd 5Csind die Zeichen \n, /und \, respectively.

— Erik der Outgolfer
quelle
6

Python 2.7 66 -> 56 -> 55 Bytes

a="/"*5+"\\"*5;b=a[::-1];c=6*a+"\n";d=6*b+"\n";e=4*c+4*d;print e*3

Neu im Code Golf

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

Vielen Dank, Stewie Griffin

Habe ein albernes Leerzeichen vergessen;)

— Ivar Matstoms
quelle
2
Willkommen bei PPCG! Schöne erste Antwort :) Können Sie einige der Zwischenvariablen überspringen? Zumindest dund evielleicht noch mehr. Ich habe nicht getestet, aber es sollte in der Nähe sein: print(4*c+4*(6*b+"\n"))*3. Es sind 5 Bytes weniger.
— Stewie Griffin
3
55 Bytes:a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3
— Stewie Griffin
6

Brainfuck, 179 Bytes

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

Ich weiß, dass dies nicht die beste Punktzahl im Thread ist, aber ich wollte Brainfuck ausprobieren und es versuchen.

Bearbeiten: Ich muss einen Fehler beim Kopieren gemacht haben. Diese Version sollte funktionieren

— Axel Matstoms
quelle
Willkommen auf der Seite!
— DJMcMayhem
Funktioniert bei mir nicht. Der Browser legt mit diesem Interpreter auf , und ein persönlicher zeigt eine nicht erwartete Ausgabe von 5 Zeilen: /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\ viermal, dann unendlich \ .
— Aluriak
Ja, es funktioniert :)
— Aluriak
5

MATL , 18 16 Bytes

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

Probieren Sie es online!

Erläuterung

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

Pyth, 22 Bytes

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

Probieren Sie es hier aus .

Erläuterung:

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)

Tut mir leid, wenn die Erklärung etwas schwer zu verstehen ist, aber es war ein bisschen kompliziert.

— RK.
quelle
5

V , 22-21 Bytes

Edit Ein Byte gewonnen, danke @DjMcMayhem:

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

Änderungen sind:

  • Y4P-> 4ÄVerwenden Sie V duplicate line anstelle von Vim built-in command (dies fügt eine leere Zeile am Ende des Absatzes hinzu)
  • 3äG-> 3ä}Dupliziere den Absatz anstelle des gesamten Puffers (um Leerzeilen zu vermeiden, die durch vorherige Änderungen erzeugt wurden)

Ursprünglicher Beitrag

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

Probieren Sie es online aus

So zerlegt:

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
quelle
Es ist cool, jemanden mit V zu sehen! Bis vor kurzem war ich es nur. Wenn Sie jemals Hilfe benötigen, können Sie mich
— gerne
@DrMcMoylex Yup Ihre Sprache scheint Spaß zu benutzen :-) ich auf diesem ein Problem hatte: zunächst wollte ich verwenden 5á\5á/05ä$5Ä5x$p4Ä3äGdh ersetzen Y4Pdurch , 4Äaber aus einem Grund, ich verstehe nicht , kopiert es eine zusätzliche Leerzeile ... Wenn Sie können Erleuchten Sie mich auf diesem es wäre nett. Auch wenn ich etwas Freizeit finde, würde ich gerne zur Sprache beitragen (insbesondere Ausgabe 4 )
— statox
Ach ja, das hat mich schon oft beunruhigt. Es ist ein bekanntes Problem. Das Problem ist, dass Äes ein Synonym für ist dd, nicht Y. Dies ist normalerweise kein Problem, verursacht jedoch einige Probleme, wenn der Puffer nur eine Zeile enthält oder Sie sich in der letzten Zeile befinden.
— DJMcMayhem
Eigentlich habe ich nur realisiert werden , würde dieser Ansatz noch arbeiten , wenn Sie ersetzt 3äGmit , 3ä}da es wird nicht das letzte Newline zerrt. v.tryitonline.net/…
— DJMcMayhem
Ok, ich glaube ich verstehe, warum es jetzt nicht funktioniert hat. Und schöne Möglichkeit, 1 Byte zu gewinnen, danke!
— Statox
4

Eigentlich 21 Bytes

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

Probieren Sie es online!

-1 Byte von Adnan

Erläuterung:

"/\"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
quelle
Können Sie so etwas tun, "/\"5*Sum eine Reihe von Schrägstrichen zu erstellen?
— Adnan
@Adnan Tolle Idee!
— Mego
4

Ruby, 46 Bytes

Erstellt die folgende Zeichenfolge (70 Zeichen, eine Zeichenfolge mehr als erforderlich) und wechselt dann zwischen den Abtastzeichen 0..59und der entsprechenden Zeichenfolge 5..64.

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

Code und Ausgabe

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

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

interessanter Fehler (eine 7 anstelle einer 5)

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

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
— Level River St
quelle
4

APL, 30 Bytes

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

Ich bin ziemlich neu in APL (ich verwende APLX, aber dies sollte für die meisten Implementierungen von APL funktionieren), daher ist dies eine ziemlich vereinfachte Lösung.

Erläuterung:

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
quelle
4

C, 66 61 Bytes

5 Bytes gespart dank orlp.

Zeichen für Zeichen einfach zu drucken. 61 Zeichen pro Zeile, letzte Zeile ist Newline (ASCII 10) und die anderen wechseln sich zwischen /47 und \92 ab.

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
quelle
61 Bytes i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}.
— Orlp
@orlp danke, ich wusste, dass es einen besseren Weg geben musste, i--aber ich hatte keine Zeit danach zu suchen.
— Level River St
3

Python 2, 63 Bytes

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

Führen Sie dies für Python 3 aus (65 Byte):

a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
— Erik der Outgolfer
quelle
1
Dies verwendet die gleiche Methode wie meine Gelee-Antwort .
— Erik der Outgolfer
Effizientere Methode als meine
— ElPedro
@ElPedro Grundsätzlich habe ich nur einige Zeichenfolgen- / Array-Manipulationen durchgeführt. Der Trick ist, dass ich eine größere Saite vorbereitet habe: /////\\\\\/////...vier Mal, durch Zeilenumbrüche getrennt
— Erik the Outgolfer
3

J, 31 28 19 Bytes

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

Verwendungszweck

   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
— Meilen
quelle
3

Oktave, 50 48 Bytes

Anonyme Funktion:

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

Sie können es hier online versuchen . Führen Sie einfach den obigen Befehl aus und führen Sie dann die Funktion mit aus ans().

Dies erzeugt im Wesentlichen ein Array mit dem Wert 47, das 4 hoch und 5 breit ist. Anschließend wird ein zweites Array mit dem Wert 92 erstellt, das dieselbe Größe hat.

Die beiden Arrays sind zu einem Schachbrett aus zusammengesetzt [A B;B A]. Das'' wird auch verkettet, um die Konvertierung in Zeichenketten zu erzwingen.

Schließlich wird das gesamte Array 3-mal nach unten und 6-mal nach unten repliziert, um die endgültige Größe zu erhalten.

  • 2 Bytes gespeichert, danke @StewieGriffin
— Tom Carpenter
quelle
keine anonyme Funktion erforderlich; 3 Bytes sparen.
— Tasos Papastylianou
@TasosPapastylianou gibt es, sonst wird es ans=vor dem Kissen gedruckt . Wenn Sie es in der Funktion haben, können Sie dies umgehen, da erwartet wird, dass die Antwort auf eine Variable zurückgegeben wird, anstatt sie anzuzeigen.
— Tom Carpenter
Das ist nur Semantik. Ich meine, wenn Sie pedantisch sein wollen, würde ich mich mehr um die 3-zeiligen Warnmeldungen kümmern, die stattdessen angezeigt werden: p Auch die üblichen Regeln besagen, dass es sich entweder um eine Ausgabe eines direkten Terminalbefehls oder um eine aufrufbare Ausgabe handeln muss Funktionsgriff. Das heißt, Sie sollten Ihre anonyme Funktion einem Handle zuweisen (oder weitere 5 Bytes hinzufügen, um zu berücksichtigen, dass Sie ein Pring durchführen müssen ans()). Welches ist sinnlos, da ans() noch druckt ansbei der Ausführung!
— Tasos Papastylianou
@TasosPapastylianou ans()ist ein aufrufbares Funktionshandle, daher müssen Sie es keinem Element mit zuweisen, z. B. a=@...weil es implizit ansals Handle zugewiesen ist. Außerdem wird ans=beim Ausführen nicht gedruckt , es sei denn, Sie fordern ausdrücklich dazu auf, nichts mit dem zurückgegebenen Wert zu tun und kein a hinzuzufügen ;. Wenn Sie dies tun disp(ans()), wird nur die genaue Ausgabe gedruckt (nein ans=). Aber ja, die Warnung ist ärgerlich, aber das ist vorher nicht geschehen, also nicht sprachspezifisch, sondern dolmetscherspezifisch.
— Tom Carpenter
Ok, wir werden zustimmen, nicht zuzustimmen. So wie ich es sehe, müssen Sie disp(ans())Ihrer Antwort 12 Bytes hinzufügen , wenn Sie sich darauf verlassen, bevor Sie Ihre Ausgabe erhalten. Meine eigene Meinung ist, dass dies nur die Art und Weise ist, wie die Oktave ihr Ergebnis präsentiert, und das ist in Ordnung.
— Tasos Papastylianou
3

PHP, 73 69 Bytes

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

Demo

http://ideone.com/z7N1Md

— Chocochaos
quelle
1
69 Bytes: for($s='/\\';$i<1440;$i++)echo$i%60<1?'\n':'',$s[($i/5+($i/240|0))%2];(Ersetzen Sie die \ndurch eine echte Newline). echoist keine Funktion, daher werden keine Klammern benötigt. Auch echokönnen mehrere Werte erhalten, durch ein Komma getrennt. Dadurch werden diese Klammern nicht mehr benötigt. Und dann benötigt auch $s[...]die äußerste Berechnung in Ihrem Inneren keine Klammern, da sie in withing enthalten ist []. Verwenden $s[($i/5+($i/240|0))%2]hat den gleichen Effekt und ist kürzer.
— Ismael Miguel
Vielen Dank, aktualisiert! Ich wusste nicht einmal, dass Echo mehrere Parameter akzeptiert ^ _ ^
— Chocochaos
echound printakzeptieren Sie mehrere Parameter. Aber printerfordert parenthesys mit mehreren Parametern , wenn sie auf einer Schleife der Zuwachs, den Zustand oder Zuweisung verwendet.
— Ismael Miguel
Kann <1durch Umschalten der Ausdrücke die echo$i%60?'':' ',neue Zeile als Ausdruck 3 im Ternär abschneiden .
— Progrock
3

Java 7, 120 Bytes

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

Alles in eine Schleife geschoben. Beats Brainfuck, Mission erfüllt.

Sehen Sie es online: https://ideone.com/pZjma3

— Cliffroot
quelle
3

Vim, 44 27 Bytes

EDIT Lot von Bytes gewann dank @DrMcMoylex:

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

Ursprüngliche Antwort:

Ich bin mir nicht sicher, ob das wirklich den Regeln dieser Seite entspricht, aber ich dachte, es hat Spaß gemacht, es auszuprobieren:

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

Was kann wie folgt zerlegt werden:

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
quelle
Oh hey statox, willkommen auf der Seite! Dies entspricht voll und ganz den Regeln. Ich golfe meistens in vim. Damit Sie wissen, können Sie 5i/<esc>5a\<esc>0y$5Pzu Beginn 9 Bytes einsparen.
— DJMcMayhem
Hey DrMcMoylex (neuer Name? :-)), ich freue mich, dich hier zu sehen und meine Antwort passt. Auch danke für deinen Hinweis, ich bearbeite meine Antwort
— statox
2
Haha, ja, ich habe meinen Namen wegen dieser Herausforderung vorübergehend geändert , lol. Ich werde es in 30 Tagen wieder ändern
— DJMcMayhem
3

Brainfuck, 168 Bytes

++++++[>++++++++<-]>-<+++++++++[>>++++++++++<<-]>>++<<+++++[>>>++<<<-]>>>>+++[>++++[>++++++[<<<<<.....>.....>>>>-]<<<.>>-]++++[>++++++[<<<<.....<.....>>>>>-]<<<.>>-]<-]
— Mitchell Humphrey
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.