To jest moja poduszka

66

... pomożesz mi go uwiecznić?

wprowadź opis zdjęcia tutaj

Mam tę poduszkę już od kilku lat i najwyraźniej czas się jej pozbyć. Czy możesz napisać funkcję lub program, który mogę zabrać ze sobą i użyć, aby odtworzyć tę poduszkę, gdy chcę trochę wspomnieć.

Musi działać bez argumentów wejściowych.

Wynik powinien wyglądać dokładnie tak (końcowe znaki nowej linii i spacje są w porządku).

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

To jest kod golfowy, więc wygrywa najkrótszy kod w bajtach!

Tabela liderów

Pokaż fragment kodu

code-golf  ascii-art  kolmogorov-complexity 
— Stewie Griffin
źródło
7
Jestem nieco rozczarowany, że wzór nie jest trochę bardziej złożony, aby reprezentować różne grubości linii poduszki.
— Sparr
4
@Sparr Próbowałem, ale nie udało mi się sprawić, aby wyglądał dobrze, używając tylko znaków ASCII. Stwierdziłem, że było wystarczająco blisko :)
— Stewie Griffin
3
Właśnie
— dodałbym
1
„pozornie”: P
— Pysis
7
Teraz możesz kupić pustą poduszkę i wydrukować na niej fragment zwycięzcy.
— coredump

Odpowiedzi:

24

05AB1E , 18 15 bajtów

Kod:

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

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

— Adnan
źródło
2
Wow ... dwa różne ujęcia, ta sama liczba bajtów ...
— Oliver Ni
30

/// , 116 bajtów

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

Wypróbuj online!

Edycja : \\\\\\\\\\\\\\\/i \\\\\\\\\\\\\\\\są właściwie odpowiednio pojedynczym / i \.

Edycja : -3, ponieważ myślałem o usunięciu i. Myślę, że nie można tego dalej grać w golfa.

— Erik the Outgolfer
źródło
15

Python 2, 49 bajtów

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

Podziękowania dla Mitcha Schwartza za tę czystą metodę, która oszczędza bajt. Chodzi o to, aby wydrukować cztery linie ('\\'*5+'/'*5)*6, zamienić role slash i backslash, a następnie wykonać cały ten proces 6 razy. Te dwa znaki są przechowywane w ai b, i zamieniane jako a,b=b,a. Podwójna pętla jest podwójna, generując następujący ciąg kodu, a następnie wykonując go za pomocą 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 bajtów:

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

Tworzy ciąg linii, drukuje go cztery razy, a następnie odwraca, a następnie robi to 6 razy. Czyni to, generując następujący kod, a następnie wykonując go:

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]

Oto kilka iteracji mojego golfa:

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
źródło
12

05AB1E, 15 bajtów

„/\5×{R6×6FR4F=

Wypróbuj online!

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252 .

— Oliver Ni
źródło
8

JavaScript (ES6), 68 60 58 bajtów

Funkcja rekurencyjna. Kilka optymalizacji inspirowanych odpowiedzią chocochaos .

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

Próbny

Pokaż fragment kodu

— Arnauld
źródło
Myślę, że możesz pominąć pierwszy &1i zapisać dwa bajty
— Henrik Christensen
@HenrikChristensen To działałoby tylko dla n < 480. Dla n >= 480, to musimy nawiasów: (n/240^n/5)&1.
— Arnauld,
8

Bubblegum , 30 bajtów

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

Obowiązkowa odpowiedź gumy do żucia.

— LegionMammal978
źródło
O mój Boże, ten język jest niesamowity!
— Pedro A,
7

Haskell, 77 70 57 bajtów

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

Nudne concatsi replicatezamiast gry z sinusami. Stary był:

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

Brainfuck, 140 bajtów

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

:-RE

— 0WJYxW9FMN
źródło
3
O popatrz! Rozwiązanie typu „brainfuck” jest osiem bajtów krótsze niż rozwiązanie Java. Czas, aby koderzy Java
— przeszli na pieprzenie mózgów
Java kontratakuje
— Cliffroot
6

Python 2, 86 80 76 74 73 bajty

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

Mógłby grać w golfa jeszcze kilka, ale to dopiero początek.

Edytować

Zapisano 6, usuwając niepotrzebne nawiasy klamrowe

Kolejne 4 za pomocą pojedynczego ciągu, a następnie odwracając go

Dzięki @Adnan. Miałem późną noc zeszłej nocy i jeszcze nie do końca obudzony: str

-1, przenosząc *24zmienną zamiast używać jej dwukrotnie

— ElPedro
źródło
4
Wierzę, że *6*4to to samo co *24? : p
— Adnan
6

Brainfuck, 149 bajtów

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

Najlepszy tłumacz EVAR!

Wykorzystuje 6 komórek (bez zawijania, bez modulo). Tutaj są:

0A 00 2F 00 5C 00

Te 00komórki są wykorzystywane do liczników w pętlach. Tutaj liczniki są wypełnione wartościami początkowymi:

0A 06 2F 04 5C 03

Najbardziej lewy licznik jest dla najbardziej wewnętrznej pętli (tak, używam zagnieżdżonych pętli o głębokości 3). Należy pamiętać, że 4. komórka ( 04licznik) jest używana dwa razy, raz /////\\\\\...i raz za \\\\\/////...każdym razem.

0A, 2FI 5Cto znaki \n, /i \, odpowiednio.

— Erik the Outgolfer
źródło
6

Python 2.7 66 -> 56 -> 55 bajtów

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

nowość w grze w golfa

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

Dzięki Stewie Griffin

Zapomniałem głupiego białego znaku;)

— Ivar Matstoms
źródło
2
Witamy w PPCG! Dobra pierwsza odpowiedź :) Czy możesz pominąć niektóre zmienne pośrednie? Przynajmniej di emoże więcej. Nie testowałem, ale powinno to być blisko: print(4*c+4*(6*b+"\n"))*3. To 5 bajtów mniej.
— Stewie Griffin
3
55 bajtów:a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3
— Stewie Griffin
6

Brainfuck, 179 bajtów

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

Wiem, że to nie jest najlepszy wynik w tym wątku, ale chciałem spróbować pieprzyć mózg i spróbować.

Edycja: Podczas kopiowania musiałem popełnić błąd. Ta wersja powinna działać

— Axel Matstoms
źródło
Witamy na stronie!
— DJMcMayhem
Nie działa dla mnie. Przeglądarka rozłącza się przy pomocy tego interpretera , a osobista wyświetla nieoczekiwany 5-liniowy wynik: /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\ cztery razy, a następnie nieskończony \ .
— aluriak
Tak, działa :)
— aluriak
5

Pyke, 16 bajtów

"/\"6*5m*n+4*sD3

Po dzisiejszej aktualizacji, która dozwolona "w literałach łańcuchowych, 17 bajtów

"/\\"6*5m*n+4*sD3

Wypróbuj tutaj!

— niebieski
źródło
5

MATL , 18 16 bajtów

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

Wypróbuj online!

Wyjaśnienie

'\/'   % 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
źródło
5

Pyth, 22 bajty

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

Wypróbuj tutaj .

Wyjaśnienie:

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)

Przepraszam, jeśli wyjaśnienie jest trochę trudne do zrozumienia, ale było trochę skomplikowane.

— RK.
źródło
5

V , 22 21 bajtów

Edytuj Jeden bajt wygrany, dzięki @DjMcMayhem:

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

Zmiany to:

  • Y4P-> 4ÄUżyj V-powielonej linii zamiast wbudowanego polecenia Vima (spowoduje to dodanie pustej linii na końcu akapitu)
  • 3äG-> 3ä}Duplikuj akapit zamiast całego bufora (aby uniknąć pustej linii wygenerowanej przez poprzednią zmianę)

Oryginalny post

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

Wypróbuj online

Rozkłada się tak:

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
źródło
Fajnie jest widzieć kogoś innego używającego V! Do niedawna byłem tylko ja. Jeśli kiedykolwiek potrzebujesz pomocy, możesz
— pingować
@DrMcMoylex Tak, twój język wydaje się przyjemny w użyciu :-) Miałem problem z tym: początkowo chciałem użyć, 5á\5á/05ä$5Ä5x$p4Ä3äGtj. Zastąpić Y4P, 4Äale z powodu, którego nie rozumiem, kopiuje dodatkową pustą linię ... Jeśli możesz oświeć mnie na tym, byłoby miło. Również jeśli znajdę trochę wolnego czasu, chętnie przyczynię się do tego języka (zwłaszcza numer 4 )
— statox,
Ach, tak, niepokoiło mnie to wiele razy. To znany problem. Problemem jest to, że Äjest synonimem ddnie Y. Zwykle nie stanowi to problemu, ale powoduje pewne problemy, jeśli bufor ma tylko jedną linię lub jeśli znajdujesz się w ostatniej linii.
— DJMcMayhem
Faktycznie, zdałem sobie sprawę, że takie podejście będzie nadal działać, jeśli otrzymuje 3äGsię 3ä}, ponieważ nie będzie szarpać że ostatni znak nowej linii. v.tryitonline.net/…
— DJMcMayhem
Ok, myślę, że rozumiem, dlaczego to teraz nie działało. I dobry sposób na wygranie 1 bajtu, dzięki!
— statox
4

Właściwie 21 bajtów

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

Wypróbuj online!

-1 bajt od Adnana

Wyjaśnienie:

"/\"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
źródło
Czy możesz zrobić coś takiego jak "/\"5*Stworzenie ciągu ukośników?
— Adnan,
@Adnan Świetny pomysł!
— Mego
4

Rubinowy, 46 bajtów

Tworzy następujący ciąg (70 znaków, jeden zestaw więcej niż potrzeba), a następnie na przemian między próbkowanymi znakami 0..59a 5..64nim.

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

kod i dane wyjściowe

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

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

ciekawy błąd (7 zamiast 5)

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

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
— Level River St
źródło
4

APL, 30 bajtów

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

Jestem całkiem nowy w APL (używam APLX, ale powinno to działać w większości implementacji APL), więc jest to dość uproszczone rozwiązanie.

Wyjaśnienie:

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
źródło
4

C, 66 61 bajtów

5 bajtów zapisanych dzięki orlp.

Prosty druk znak po znaku. 61 znaków na wiersz, ostatni to znak nowej linii (ASCII 10), a pozostałe na przemian między /47 a \92.

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
źródło
61 bajtów: i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}.
— orlp
@orlp dzięki, wiedziałem, że musi być lepszy sposób, i--ale nie miałem czasu na to.
— Level River St
3

Python 2, 63 bajty

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

W przypadku Python 3 wykonaj następujące czynności (65 bajtów):

a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
— Erik the Outgolfer
źródło
1
To używa tej samej metody, co moja odpowiedź Jelly .
— Erik the Outgolfer,
Na początek bardziej wydajna metoda niż moja
— ElPedro,
@ElPedro Zasadniczo po prostu wykonałem kilka operacji na łańcuchach / tablicach. Sztuczka polega na tym, że przygotowałem większy ciąg: /////\\\\\/////...cztery razy, oddzielone
— znakiem
3

J, 31 28 19 bajtów

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

Stosowanie

   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
— mile
źródło
3

Oktawa, 50 48 bajtów

Funkcja anonimowa:

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

Możesz spróbować online tutaj . Po prostu uruchom powyższe polecenie, a następnie uruchom funkcję za pomocą ans().

Zasadniczo tworzy to tablicę o wartości 47, która ma 4 wysokie i 5 szerokich. Następnie tworzy drugą tablicę o wartości 92, która jest tego samego rozmiaru.

Dwie tablice są połączone w szachownicę [A B;B A]. ''Jest łączony także zmusić do konwersji ciągów znaków.

Na koniec cała tablica jest replikowana 3 razy w dół i 6 razy w poprzek, aby uzyskać ostateczny rozmiar.

  • Zapisano 2 bajty, dzięki @StewieGriffin
— Tom Carpenter
źródło
nie ma potrzeby anonimowej funkcji; zapisz 3 bajty.
— Tasos Papastylianou
@TasosPapastylianou jest, inaczej wydrukuje się ans=przed poduszką. Posiadanie tego w funkcji pozwala obejść ten problem, ponieważ oczekuje się, że zwróci odpowiedź do zmiennej, a nie ją wyświetli.
— Tom Carpenter,
To tylko semantyka. Chodzi mi o to, że jeśli będziesz pedantyczny, martwię się bardziej o 3-liniowe komunikaty ostrzegawcze, które pojawiają się w zamian: p Również zwykłe reguły mówią, że musi to być albo wynik bezpośredniego polecenia terminalu, albo wywołanie uchwyt funkcyjny. Oznacza to, że powinieneś przypisać swoją anonimową funkcję do uchwytu (lub dodać kolejne 5 bajtów, aby uwzględnić konieczność wykonywania polecenia pring ans()). Co jest bez sensu, ponieważ ans() nadal drukuje ansgdy prowadzony!
— Tasos Papastylianou
@TasosPapastylianou ans()jest uchwytem funkcji, który można wywoływać, więc nie trzeba przypisywać go do czegoś za pomocą, np. a=@...Ponieważ jest domyślnie przypisany ansjako uchwyt. Również nie jest drukowany ans=po uruchomieniu, chyba że wyraźnie o to poprosisz, nie robiąc nic ze zwróconą wartością i nie dodając ;. Jeśli to zrobisz disp(ans()), wydrukuje tylko dokładne dane wyjściowe (nie ans=). Ale tak, ostrzeżenie jest denerwujące, jednak nie zdarzyło się to wcześniej, więc nie jest specyficzne dla języka, ale raczej dla tłumacza.
— Tom Carpenter,
Ok, zgodzimy się nie zgodzić. Z mojego punktu widzenia, jeśli polegasz na disp(ans())uzyskaniu danych wyjściowych, musisz dodać 12 bajtów do swojej odpowiedzi. Moim zdaniem jest to sposób, w jaki oktawa przedstawia swój wynik i jest w porządku.
— Tasos Papastylianou
3

PHP, 73 69 bajtów

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

Próbny

http://ideone.com/z7N1Md

— chocochaos
źródło
1
69 bajtów: for($s='/\\';$i<1440;$i++)echo$i%60<1?'\n':'',$s[($i/5+($i/240|0))%2];(zamień na \nprawdziwy nowy wiersz). echonie jest funkcją, więc nie potrzebuje nawiasów. Ponadto echomoże odbierać wiele wartości oddzielonych przecinkiem. To naprawdę eliminuje potrzebę tych nawiasów. A następnie, w twoim $s[...]zewnętrznym obliczeniu nie trzeba też nawiasów, ponieważ jest ono zawarte w []. Korzystanie $s[($i/5+($i/240|0))%2]ma ten sam efekt i jest krótsze.
— Ismael Miguel
Dziękuję, zaktualizowano! Nawet nie wiedziałem, że echo akceptuje wiele parametrów ^ _ ^
— chocochaos
echoi printzaakceptuj wiele parametrów. Ale printwymaga nawiasów z wieloma parametrami, jeśli są używane do przyrostu, stanu lub przypisania pętli.
— Ismael Miguel
Może się ogolić <1, zmieniając wyrażenia echo$i%60?'':' ',, nową linię jako wyrażenie 3 w trójce.
— Progrock,
3

Java 7, 120 bajtów

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

Zepchnął wszystko w jedną pętlę. Beats Brainfuck, misja wykonana.

Zobacz online: https://ideone.com/pZjma3

— Cliffroot
źródło
3

Vim, 44 27 bajtów

EDYCJA Wiele bajtów wygranych dzięki @DrMcMoylex:

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

Oryginalna odpowiedź:

Nie jestem pewien, czy to naprawdę pasuje do zasad tej witryny, ale pomyślałem, że fajnie było spróbować:

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

Które można rozłożyć w następujący sposób:

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
źródło
Och, hej statox, witamy na stronie! To całkowicie pasuje do zasad. Gram głównie w vima. Po prostu wiesz, że możesz 5i/<esc>5a\<esc>0y$5Pna początku zaoszczędzić 9 bajtów.
— DJMcMayhem
Hej DrMcMoylex (nowa nazwa? :-)) Cieszę się, że cię tu widzę i że moja odpowiedź pasuje. Dziękuję również za podpowiedź,
— zredaguję
2
Haha, tak, chwilowo zmieniłem nazwisko z powodu tego wyzwania , lol. Zmienię to za 30 dni
— DJMcMayhem
3

Brainfuck, 168 bajtów

++++++[>++++++++<-]>-<+++++++++[>>++++++++++<<-]>>++<<+++++[>>>++<<<-]>>>>+++[>++++[>++++++[<<<<<.....>.....>>>>-]<<<.>>-]++++[>++++++[<<<<.....<.....>>>>>-]<<<.>>-]<-]
— Mitchell Humphrey
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.