Fammi una coperta!

16

Voglio una coperta che assomigli a questa. Ogni striscia va sopra, sotto, sopra, sotto. Puoi stamparlo?

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

Gli spazi finali alla fine di ogni riga e le nuove righe finali sono accettabili.

Ricorda, questo è code-golf , quindi vince il codice con il minor numero di byte.

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Mostra snippet di codice

code-golf  ascii-art  kolmogorov-complexity 
— Oliver Ni
fonte
Il bordo destro sembra disallineato.
— Magic Octopus Urn
Il bordo sinistro non si sovrappone?
— xnor
@xnor Mi dispiace, mia cattiva.
— Oliver Ni
@carusocomputing Risolto.
— Oliver Ni,
10
Se avessi usato il Sandbox, quei problemi avrebbero potuto essere evitati prima che questo aumentasse.
— Mego

Risposte:

8

Python 2, 84 byte

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

Grazie a Sp3000 per 6 byte, trasformando le operazioni aritmetiche in bit per bit.

— XNOR
fonte
Whoa ... come ????
— Oliver Ni,
1
i+~j>>2&1^i+j>>1&2^i&4, Forse?
— Sp3000,
@ Sp3000 Questa è una bella precedenza bit per bit. Dovrò ricordare che quando si combinano valori booleani derivati ​​aritmeticamente in un indice.
— xnor
5

Pyth, 36 byte

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

Provalo online: dimostrazione

Spiegazione:

Possiamo determinare il simbolo controllando 3 condizioni:

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

Se interpretiamo [A,B,C]come un numero binario, otteniamo il seguente mapping:

01234567
 \// \/\

Possiamo anche interpretare [A,B,C]come numero decimale ed eseguire una ricerca indicizzata modulare nella stringa. Questo non fa differenza perché 10 mod 8 = 2.

Ora al codice:

V24scorre N(id-riga) sopra [0, 1, ..., 23].

sm...48associa i numeri d(column-idx) [0, 1, ..., 47]ai caratteri e stampa la stringa combinata.

++BNdgenera l'elenco [N, N+d], +...t-Ndaggiunge N-d-1. Quindi abbiamo la lista [N, N+d, N-d-1]. m<3%k8controlla ogni numero calcolato k, se 3 < k % 8, quindi questo fornisce l'elenco con le condizioni [A, B, C].

i...Tlo convince con un numero decimale e quindi @" \// \/\\"esegue la ricerca nella stringa.

Più o meno lo stesso codice in Python2: 98 byte :

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
fonte
Sto solo cercando di fare i conti con Pyth, quindi qualsiasi risposta decente con una buona spiegazione ottiene un mio voto. stavo per provare Pyth dopo il mio esperimento di base 3 :)
— ElPedro
Dovresti pubblicare anche la risposta di Python2 ...
— Jerry Jeremiah,
3

Perl, 209 + 17 = 226 byte

Esegui con -mList::Util=max -M5.010(il secondo flag è gratuito). Non sta vincendo alcuna competizione sul conteggio dei byte, ma ecco la mia soluzione.

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

Leggibile:

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

Genera proceduralmente ogni segmento, quindi ripete lo schema 6 volte, quindi emette il risultato totale 3 volte.

— Gabriel Benamy
fonte
Woah, non sono più la risposta più lunga :) +1 per averlo fatto comunque in Perl.
— ElPedro
Avrei potuto farlo allo stesso modo di tutti gli altri (solo stampando un mucchio di righe), ma ho deciso di fare le cose in modo algoritmico invece che esplicitamente perché mi sembrava più freddo.
— Gabriel Benamy,
Fresco per i miei standard. Ho adottato un approccio che non avevo mai provato prima perché era una sfida interessante. Come ho detto, +1. Nessun insulto previsto dal mio commento. Ecco perché ho votato.
— ElPedro
3

Python 3, 174 172 138 byte

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

Ho trovato il modello più piccolo che ho trovato nella coperta (il modello "under" e "over"), l'ho bloccato in un elenco e aggiunto un po 'di comprensione dell'elenco e manipolazione delle stringhe per decomprimere tutto. Sostituito tutte le barre rovesciate di escape con "b" e rimpiazzate più tardi per salvare alcuni byte.

Grazie a Oliver per aver giocato a golf con 2 byte!

Sono stati eliminati 34 byte modificando il modello: l'intero modello per la coperta è ora in un unico elenco, quindi è necessario solo uno per il ciclo per scartare il modello.

— TheCrazyInventor
fonte
1
Benvenuti in PPCG! bel primo post! Puoi radere un byte in Python 2, penso, non hai bisogno delle parends per la stampa.
— Rɪᴋᴇʀ
1
Grazie Easterk Irk, sono in agguato da troppo tempo nel code golf, quindi ho deciso di partecipare. :)
— TheCrazyInventor
1
Puoi salvare due byte rimuovendo lo spazio dopo 0*6eu*6
— Oliver Ni
1
Puoi salvare 4 byte usando la "b" per le doppie barre rovesciate e ovunque hai bisogno di una singola barra rovesciata basta usare l'escaping: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","\\\\"))
— dzaima
dzaima: il tuo codice non sembra generare una coperta valida.
— TheCrazyInventor
3

Python 2, 171 170 168 byte

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)

Non carino e non intelligente. Imposta semplicemente le variabili per i gruppi di stringhe più utilizzate, quindi le combina e stampa il risultato 3 volte. Potrei provare a giocare a golf più tardi se non trovo un approccio migliore.

1 byte salvato utilizzando l'input non elaborato sull'assegnazione a. Grazie @ nedla2004

-2 assegnando un paio di variabili ma non ancora un serio concorrente

— ElPedro
fonte
1
È possibile definire a come r "\\"
— nedla2004
Grazie @ nedla2004 Un buon punto. L'ho messo insieme abbastanza rapidamente e lo vedremo più tardi. È un buon inizio :)
— ElPedro
Più interessato a trovare un modo per aggirare il *6 ogni elemento tupla. Qualche idea?
— ElPedro
1
Non so come potresti farlo, ma l'ultima riga può essere exec r"print'\n'.join(d);"*3.
— nedla2004
Ho appena pubblicato un'alternativa appena per interesse. Darei valore anche ai tuoi commenti.
— ElPedro
2

SOML , 106 byte

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

una versione non competitiva che utilizza una funzione che ho aggiunto solo di recente: ( 83 67 66 byte)

spiegazione:

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

Rubino, 75 byte

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

Meglio giocare a golf, usando una singola ricerca di stringa da 8 byte indicizzata da j & 4 oltre agli altri parametri, piuttosto che una stringa modificabile da 4 byte.

Rubino, 81 byte

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

Stampa le strisce diagonali carattere per carattere. Il carattere corretto viene selezionato da una stringa di 4 caratteri a seconda della presenza / assenza di ciascun filo. Il carattere di sovrapposizione varia a seconda del filo in cima.

Commentate

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
fonte
2

Perl, 132 131 113 byte

@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
fonte
2

05AB1E , 37 byte

Utilizza la codifica CP-1252 .

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

Provalo online!

Spiegazione

Usa il trucco mod-8 spiegato abilmente nella risposta pyth di 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
fonte
2

Python, 245 236 234 233 230 216 212 198 195 byte

OK, più a lungo della mia ultima (e di qualsiasi altra) risposta, ma sarei interessato al feedback sull'approccio.

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

modificare

-9 a causa di @ nedla2004 che è più sulla palla di me

-2 prendendo la lambda fuori dal ciclo e perdendo così 2 spazi di rientro

-1 usando in' '*3invece di in 0,1,2poiché non usoh comunque. è solo un contatore.

-3 Perché, perché, perché ho lasciato una nuova riga e 2 rientri tra il secondo e la stampa ??? È tardi. Torneremo domani.

-14 Può effettivamente perdere completamente la lambda e includere semplicemente il decodificatore di base 3 direttamente dopo l'istruzione print. Sembra disordinato ma dopo tutto, questo è il codice golf :)

-4 Nessun punto imposta una variabile per l'elenco intero. Usalo direttamente nel secondo per loop.

-14 e nessun punto usando l'anello esterno. Basta moltiplicare la tupla intera per 3 (rubata spudoratamente da @ nedla2004 per ottenere meno di 200 :))

-3 Salvato 3 creando \ = 0, / = 1 e spazio = 2. Ciò rende più breve l'elenco di numeri interi poiché tre dei numeri di base 3 ora hanno 0 iniziali

Come funziona (e funziona)

Poiché vengono utilizzati solo 3 caratteri:

  1. l è un elenco degli 8 schemi ripetuti come equivalenti interi della loro rappresentazione di base 3 assumendo che "" = 0, "\" = 1 e "/" = 2

  2. La lambda Il primo codice dopo l'istruzione print è un convertitore leggero da intero a una stringa di base 3

  3. Il primo loop viene ripetuto 3 volte e il secondo stampa ogni riga con i 3 caratteri di base moltiplicati per 6 e sostituiti con /, \ o spazio.

Sono sicuro di poter usare un regex invece di un nidificato repl () ma sono troppo stanco per provare adesso. Questo è stato solo un esperimento e più lungo del mio precedente sforzo di Python, ma ho pubblicato solo per qualsiasi commento sull'approccio (e anche perché non ho mai lavorato in Base 3 prima e mi è piaciuto molto lavorare con il convertitore).

— ElPedro
fonte
1
Puoi semplicemente rimuovere la prima divisione nella conversione base 3.
— nedla2004,
Per qualche motivo che mi stava causando problemi in precedenza, ma ho appena provato e funziona ora. molte grazie per essere più sveglio di me. Modifica nuovamente la mia risposta (e mi hai appena salvato 9 byte :))
— ElPedro
1
Ho riscritto la conversione di base 3, non è più una lambda, dovevo renderla una funzione, ma potrebbe essere possibile riconvertirla in una lambda. Puoi trovare la funzione qui .
— nedla2004,
Grazie. Penso che una combinazione dei due potrebbe funzionare, ma probabilmente è un lavoro per domani sera :) Grazie ancora per i tuoi commenti.
— ElPedro
1
Sono arrivato al 169, qui .
— nedla2004,
2

Rubino, 135 byte

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

La matrice numerica corrisponde a ciascun componente di ciascuna riga, tradotta in base 3: = 0, \= 1, /= 2, quindi convertita in decimale. Le chiamate gsub () sono però troppo grandi.

E, proprio ora, ho visto la risposta di @ ElPedro. :-( Solo una coincidenza.

— jose_castro_arnaud
fonte
e.to_s(3).rjust(8,"0")→ ("%8s"%e.to_s(3)); gsub("0"," ").gsub("1","\\")..gsub("2","/")→ tr("013"," \\/"); "\n"→ $/; .join→ *"". È inoltre possibile salvare un byte dividendo tutti i numeri nell'array per 4 e sostituendoli econ(e*4) .
— Giordania,
Oops, suppongo che dovrebbe essere tr("021"," /\\").
— Giordania,
— Giordania
2

PHP 157 126 byte

Prendendo le modifiche alle liste di @Titus nei commenti ... Sono infastidito dal fatto di aver perso il punto 1 che avrei dovuto prendere, ma non sapevo che esistesse strtr () che è dove arriva la maggior parte dei risparmi - bel lavoro Titus!

NUOVO:

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

VECCHIO:

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

Poiché tutte le barre rovesciate devono essere salvate, si risparmia un po 'di spazio per impacchettarle come carattere diverso e sostituirle per l'output, quindi una volta che chiamo str_replace () ha senso usarlo il più spesso possibile.

— Toxik-YOGURT
fonte
1
Puoi rimuovere il tag aperto se lo usi -r. Utilizzare questi cinque passaggi per salvare altri 30 byte: ideone.com/wt4HGB 1) utilizzare $a[...]direttamente come str_replaceparametro invece di assegnarlo. 2) strtrinvece di str_replace. 3) Utilizzare le cifre anziché le lettere. 4) Includi il compito nell'eco. 5) Non assegnare $a, basta usarlo.
— Tito,
1

Python 2, 169 161 165 160 155 154 152

Basato sulla risposta di @ ElPedro, con piccoli miglioramenti. Per vedere la spiegazione, vedere la loro risposta . Questo è Python 2, anche se sembra che ci sia una parentesi vicino a print.

Salvato 8 byte utilizzando una variabile per replace.Funziona solo per le stringhe e l'utilizzo di una funzione per essa sarebbe più lungo.

Ho salvato 4 byte vedendo che @ElPedro ha capito che non avevano bisogno di l, e nemmeno io.

Hai salvato 5 byte non capovolgendo range(8)e invece di utilizzare +=per aggiungere a r, aggiungendo r alla fine della nuova cifra. Provalo usando repl.it

Hai salvato 5 byte rubando il nuovo elenco di valori di @ ElPedro.

Salvato 1 byte rimuovendo lo spazio tra ine( .

Salvato 2 byte rimuovendo la variabile 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
fonte
Puoi salvare 1 rimuovendo lo spazio tra ine (il primo nel
— ElPedro
Inoltre ho perso tre byte riordinando la sequenza di cui i numeri rappresentano ciascun personaggio nell'elenco di base 3. Vedi la mia risposta per una spiegazione. sentiti libero di copiare. Per quanto mi riguarda questo è uno sforzo congiunto e sono felice di vedere che la mia idea originale aveva almeno un potenziale :)
— ElPedro,
Non hai bisogno a=3**i. Usa for i in range(8):r=x / 3 ** i% 3 +rper salvare un paio. la precedenza dell'operatore si occupa di tutto il resto :)
— ElPedro,
Non sono sicuro di come delimitare i caratteri di conversione delle stringhe. Il parser li ha rimossi nel mio ultimo commento, quindi non
— limitarti
Buon punto, ho capito.
— nedla2004,
1

PHP, 184 byte

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

Produzione:

C:\PHP>php make-me-a-blanket.php
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
— Mario
fonte
0

Lotto, 152 byte

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

L'elaborazione delle stringhe in batch fa schifo, quindi questo è probabilmente l'approccio migliore. Il call-and-fall-through è leggermente più breve di un forloop nidificato . Almeno non devo citare le mie barre rovesciate!

— Neil
fonte
0

APL, 110 byte

Sono nuovo di APL, quindi questa è una soluzione semplicistica.

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

Ecco il mio approccio: nota che dopo le prime 8 righe della coperta, il modello si ripete. Quindi ho solo bisogno di definire le prime 8 righe, e quindi posso ripeterle 3 volte. Si noti inoltre che ogni riga si ripete dopo i primi 8 caratteri. Pertanto, per definire una singola riga, devo solo definire i primi 8 caratteri e quindi ripeterli 8 volte.

Ecco una soluzione non golfata:

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

Ho notato sopra che D è il contrario di B, E è il contrario di A e H è il contrario di F. Nel mio codice attuale, ne approfitto non definendo D, F o H e usando la funzione inversa ⊖:

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

— ren
fonte
0

Rubino, 132 byte

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

risposta molto semplice.

— dkudriavtsev
fonte
0

Haskell, 96 byte

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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.