Zrób mi koc!

16

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

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

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

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

Liderów

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

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

# Language Name, N bytes

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

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

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

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

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

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

Pokaż fragment kodu

code-golf ascii-art kolmogorov-complexity Oliver Ni
źródło
Prawa krawędź wydaje się nierównomierna.
Magic Octopus Urn
Czy lewa krawędź nie zachodzi na siebie?
xnor
@xnor Przepraszam, mój zły.
Oliver Ni
@carusocomputing Naprawiono.
Oliver Ni
10
Gdybyś użył piaskownicy, można by uniknąć tych problemów, zanim to się stanie.
Mego

Odpowiedzi:

8

Python 2, 84 bajtów

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

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

xnor
źródło
Whoa ... jak ????
Oliver Ni
1
i+~j>>2&1^i+j>>1&2^i&4, być może?
Sp3000,
@ Sp3000 To niezły precedens bitowy. Muszę pamiętać o tym, łącząc arytmetycznie logiczne logiki w indeks.
xnor
5

Pyth, 36 bajtów

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

Wypróbuj online: demonstracja

Wyjaśnienie:

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

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

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

01234567
 \// \/\

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

Teraz do kodu:

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

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

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

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

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

R=range(8)
for r in R*3:print''.join(" \// \/\\"[4*(r>3)+2*((r+c)%8>3)+((r-c-1)%8>3)]for c in R*6)
Jakube
źródło
Po prostu próbuję poradzić sobie z Pythem, aby każda przyzwoita odpowiedź z dobrym wyjaśnieniem otrzymała ode mnie opinię. zamierzałem wypróbować Pytha po moim podstawowym eksperymencie 3 :)
ElPedro,
Powinieneś również opublikować odpowiedź na Python2 ...
Jerry Jeremiah
3

Perl, 209 + 17 = 226 bajtów

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

for(0..7){@b=(1)x8;@b[$_+3..$_+7]=(3)x4;@b[7-$_..10-$_]=(2)x4;for$c(0..2){$b[$c+8]=max$b[$c+8],$b[$c];$b[5-$c]=max$b[5-$c],$b[13-$c];}push@a,sprintf("%-8s",join("",@b[3..10])=~tr[123][ /\\]r)x6;}say for@a,@a,@a

Czytelny:

for(0..7){
    @b=(1)x8;
    @b[$_+3..$_+7]=(3)x4;
    @b[7-$_..10-$_]=(2)x4;
    for$c(0..2){
        $b[$c+8]=max$b[$c+8],$b[$c];
        $b[5-$c]=max$b[5-$c],$b[13-$c];
    }
    push@a,sprintf("%-8s",join("",@b[3..10])=~tr[123][ /\\]r)x6
}
say for@a,@a,@a

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

Gabriel Benamy
źródło
Woah, nie jestem już najdłuższą odpowiedzią :) +1 za zrobienie tego w Perlu.
ElPedro,
Mógłbym to zrobić tak samo jak wszyscy inni (po prostu drukując kilka linii), ale zdecydowałem się robić rzeczy algorytmicznie zamiast jawnie, ponieważ czułem, że było fajniej.
Gabriel Benamy,
Cool według moich standardów. Podjąłem podejście, którego nigdy wcześniej nie próbowałem, ponieważ było to interesujące wyzwanie. Jak powiedziałem +1. Żadna zniewaga zamierzona przez mój komentarz. Właśnie dlatego głosowałem.
ElPedro,
3

Python 3, 174 172 138 bajtów

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

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

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

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

TheCrazyInventor
źródło
1
Witamy w PPCG! fajny pierwszy post! Możesz ogolić bajt w pythonie 2 Myślę, że nie potrzebujesz parendów do drukowania.
Rɪᴋᴇʀ
1
Dziękuję Easterly Irk, zbyt długo kręciłem się w golfa kodowym, więc postanowiłem wziąć udział. :)
TheCrazyInventor
1
Możesz zaoszczędzić dwa bajty, usuwając spację po 0*6iu*6
Oliver Ni
1
Możesz zapisać 4 bajty, używając „b” dla podwójnych odwrotnych ukośników i wszędzie tam, gdzie potrzebujesz pojedynczego odwrotnego ukośnika, po prostu użyj 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","\\\\"))
klawisza Escape
dzaima: twój kod nie generuje prawidłowego koca.
TheCrazyInventor,
3

Python 2, 171 170 168 bajtów

a,b,c=r"\\","/"*4," "
f,g=c*2,c+a+b+c
d=(a*2+b)*6,g*6,(f+b+f)*6,g[::-1]*6,(b+a*2)*6,('\\//'+f+a+"\\")*6,(a+f*2+a)*6,(a+"\\"+f+'//\\')*6
for e in 0,1,2:print'\n'.join(d)

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

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

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

ElPedro
źródło
1
Można zdefiniować jako r "\\"
nedla2004
Dzięki @ nedla2004 Dobry punkt. Złożyłem to dość szybko i zamierzałem to później obejrzeć. To dobry początek :)
ElPedro,
Najbardziej zainteresowani jest jednak *6obejściem każdego elementu krotki. Jakieś pomysły?
ElPedro
1
Nie wiem, jak możesz to zrobić, ale ostatnia linijka może być exec r"print'\n'.join(d);"*3.
nedla2004
Właśnie zamieściłem alternatywę zupełnie poza zainteresowaniem. Doceniłbym również twoje komentarze na ten temat.
ElPedro,
2

SOML , 106 bajtów

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

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

wyjaśnienie:

  →$\\→#////→@”6*p"→~3{"##@~ #@ ~$@$~ @# ~@##~\//$#\~#$$#~#\$//\~”
  →$                                                                in the further code replace "$" with "  "
    \\→#                                                            replace "#" with "\\"
        ////→@                                                      replace "@" with "////"
              ”6*p"→~3{"##@~ #@ ~$@$~ @# ~@##~\//$#\~#$$#~#\$//\~” the code to exchange stuff in

so that results in:
”6*p"→~3{"\\\\////~ \\//// ~  ////  ~ ////\\ ~////\\\\~\//  \\\~\\    \\~\\\  //\~”
”6*p"→~3{"A~B~C~D~E~F~G~H~”  modified version of the program (removing "/","\" and " " and replaced with A,B,C,ect.)
”6*p"→~                      replace in the further program "~" with ”6*p" which is:
”                            end string
 6*                          repeat the last thing in stack 6 times
   p                         output the result
    "                        start a string
resulting program: 
3{"A”6*p"B”6*p"C”6*p"D”6*p"E”6*p"F”6*p"G”6*p"H”6*p"”
shortened example:
3{"A”6*p"B”6*p"H”6*p"”
3{                      repeat 3 times
  "A”                   push "A" (original: "\\\\////")
     6*p                output it multiplied by 6
        "B”             push "B" (original: " \\//// ")
           6*p          output it multiplied by 6
              "H”       push "H" (original: "\\\  //\")
                 6*p    output it multiplied by 6
                    "”  push an empty string (shorter to do ~” than ”6*p)
dzaima
źródło
2

Rubinowy, 75 bajtów

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

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

Ruby, 81 bajtów

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

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

Skomentował

1152.times{|i|j=i/48%8;        #Iterate through all printable chars. j is line number.
  $><<"\\#{'/\\'[j/4]} /"[     #Print a char from "\/ /" if j/4 even or "\\ /" if odd. character changes depending which strand on top.
   (i+j)/4&1|(i-j)/2&2]+       #Print \ if (i+j)/4==0, / if (i-j)/2&2 >0, space if both false. As above if both true. 
   $/*(i%48/47)                #If on column 47, print a newline.
}
Level River St
źródło
2

Perl, 132 131 113 bajtów

@a=((0)x4,1..4);map{say+(map$a[7-$_]?$a[$_]*$r?'/':'\\':$a[$_]?'/':$",0..7)x6;push@a,shift@a;$_%4||($r=!$r)}0..23

Nie golfowany:

use strict;
use warnings;
use feature 'say';

my @a = ((1) x 4, (0) x 4);  # print '\' if true
my @b = ((0) x 4, (1) x 4);  # print '/' if true
my $r = 0;                   # print '\' over '/' if true

for (0 .. 23) {
    say((map { $a[$_] ? ($b[$_] * $r ? '/' : '\\') : ($b[$_] ? '/' : ' ') } 0 .. 7) x 6);
    unshift(@a, pop(@a));    # circular shift to left
    push(@b, shift(@b));     # circular shift to right
    $r = !$r if !($_ % 4);   # change print priority
}
Denis Ibaev
źródło
2

05AB1E , 37 bajtów

Wykorzystuje kodowanie CP-1252 .

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

Wypróbuj online!

Wyjaśnienie

Wykorzystuje sztuczkę mod-8 fachowo wyjaśnioną w pythowej odpowiedzi Jakube .

24F                                    # for N in [0 ... 23] do:
   NU                                  # save N in X
     48F                               # for N in [0 ... 48] do:
        XXN+XN-<)                      # push [X,X+N,X-N-1]
                 8%                    # mod each by 8
                   3›                  # compare with 3
                     J                 # join
                      " \// \/\"è?     # index into string and print
                                  }    # end inner loop
                                   ¶?  # print newline
Emigna
źródło
2

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

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

for a in(40,4496,6200,5456,3240,1188,720,228)*3:print((`a%6561/2178`+`a%2178/729`+`a%729/243`+`a%243/81`+`a%81/27`+`a%27/9`+`a%9/3`+`a%3/1`)*6).replace('0','\\').replace('1','/').replace('2',' ')

Edytować

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

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

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

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

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

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

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

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

Jak to działa (i działa)

Ponieważ używane są tylko 3 znaki:

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

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

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

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

ElPedro
źródło
1
Możesz po prostu usunąć pierwszy podział w konwersji podstawowej 3.
nedla2004
Z jakiegoś powodu sprawiało mi to problemy wcześniej, ale właśnie próbowałem i teraz działa. wielkie dzięki za bycie bardziej rozbudzonym niż ja.
Przeredaguję
1
Przepisałem konwersję podstawy 3, nie jest to już lambda, musiałem uczynić ją funkcją, ale może być w stanie przekonwertować ją z powrotem na lambda. Możesz znaleźć tę funkcję tutaj .
nedla2004,
Dzięki. Myślę, że połączenie dwóch może działać, ale to chyba praca na jutrzejszy wieczór :) Jeszcze raz dziękuję za komentarze.
ElPedro,
1
Sprowadziłem to do 169 tutaj .
nedla2004
2

Rubin, 135 bajtów

puts [3320,1212,720,2172,6520,4144,2920,3184].map{|e|(e.to_s(3).rjust(8,"0").gsub("0"," ").gsub("1","\\").gsub("2","/"))*6+"\n"}.join*3

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

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

jose_castro_arnaud
źródło
e.to_s(3).rjust(8,"0")→ ("%8s"%e.to_s(3)); gsub("0"," ").gsub("1","\\")..gsub("2","/")→ tr("013"," \\/"); "\n"→ $/; .join→ *"". Możesz także zapisać bajt, dzieląc wszystkie liczby w tablicy przez 4 i zastępując eje (e*4).
Jordan
Ups, chyba tak powinno być tr("021"," /\\").
Jordan
90 bajtów: tio.run/##DcjNDkUwEEDhV5FJJG0zl6mhauG@CHJDws5PlMUNnr26Ol/Ofg5/…
Jordan
2

PHP 157 126 bajtów

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

NOWY:

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

STARY:

<?$a=[zzyy,' zyy ',syys,' yyz ',yyzz,xysxz,zssz,xzsyx];while($i<32){$b=$a[$i++%8];$b=str_replace([z,x,y,s],['\\\\','\\','//','  '],$b);echo"$b$b$b$b$b$b
";}

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

ToXik-jogurt
źródło
1
Jeśli chcesz, możesz usunąć otwarty tag -r. Skorzystaj z tych pięciu kroków, aby zapisać kolejne 30 bajtów: ideone.com/wt4HGB 1) użyj $a[...]bezpośrednio jako str_replaceparametru zamiast przypisywać go. 2) strtrzamiast str_replace. 3) Użyj cyfr zamiast liter. 4) Dołącz przypisanie do echa. 5) Nie przydzielaj $a, po prostu go używaj.
Tytus
1

Python 2, 169 161 165 160 155 154 152

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

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

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

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

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

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

Zapisano 2 bajty, usuwając zmienną a.

for x in(40,4496,6200,5456,3240,1188,720,228)*3:
 r=''
 for i in range(8):r=`x/3**i%3`+r
 print(r*6).replace('0','\\').replace('1','/').replace('2',' ')
nedla2004
źródło
Można zapisać 1 usuwając przestrzeń pomiędzy in, a (w pierwszym za
ElPedro
Straciłem również trzy bajty, zmieniając kolejność, w której liczby reprezentują każdy znak na liście podstawowej 3. Zobacz moją odpowiedź w celu wyjaśnienia. kopiuj. Jeśli o mnie chodzi, jest to wspólny wysiłek i cieszę się, że mój oryginalny pomysł miał przynajmniej pewien potencjał :)
ElPedro,
Nie trzeba a=3**i. Wystarczy użyć for i in range(8):r=x / 3 ** i% 3, +raby zapisać parę. pierwszeństwo operatora dba o resztę :)
ElPedro
Nie wiesz, jak rozgraniczać znaki konwersji ciągów. Parser usunął je w moim ostatnim komentarzu, więc nie kopiuj i wklej z mojej sugestii, bo się
zepsuje
Dobra uwaga, zrozumiałem.
nedla2004
1

PHP, 184 bajty

<?$p=['1111////',' 11//// ','  ////  ',' ////11 ','////1111','1//  111','11    11','111  //1'];for($j=0;$j<3;$j++)for($i=0;$i<8;$i++)echo str_replace(1,'\\',str_repeat($p[$i],6))."\n";

Wynik:

C:\PHP>php make-me-a-blanket.php
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
Mario
źródło
0

Partia, 152 bajty

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

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

Neil
źródło
0

APL, 110 bajtów

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

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

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

Oto rozwiązanie bez golfa:

A←48⍴'\\\\////'⋄ ⍝ set A to a 48 element vector (48⍴) of repeated '\\\\////'s
B←48⍴' \\//// '⋄ ⍝ set B to a 48 element vector (48⍴) of repeated ' \\//// 's
C←48⍴'  ////  '⋄ ⍝ ...
D←48⍴' ////\\ '⋄ ⍝ Note that this is actually the reverse of vector B
E←48⍴'////\\\\'⋄ ⍝ Note that this is actually the reverse of vector A
F←48⍴'\//  \\\'⋄
G←48⍴'\\    \\'⋄
H←48⍴'\\\  //\'⋄ ⍝ Note that this is actually the reverse of vector F

24 48 ⍴ A,B,C,D,E,F,G,H ⍝ Make a 24 by 48 character matrix (24 48⍴) by concatenating A,B...H
                        ⍝ and repeating the string until the matrix is full

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

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

ren
źródło
0

Rubin, 132 bajty

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

bardzo prosta odpowiedź.

dkudriavtsev
źródło
0

Haskell, 96 bajtów

f n=n`mod`8`div`4
putStr$unlines[["\\ //\\ \\/"!!(f(x-y)+2*f(x+y)+4*f y)|x<-[0..47]]|y<-[0..23]]
Angs
źródło