Questo è il mio cuscino

66

... mi aiuterai a immortalarlo?

inserisci qui la descrizione dell'immagine

Ho avuto questo cuscino da alcuni anni e, a quanto pare, è ora di liberarsene. Puoi per favore scrivere una funzione o un programma, che posso portare con me e usare per ricreare questo cuscino ogni volta che voglio ricordare un po '.

Deve funzionare senza argomenti di input.

L'output dovrebbe assomigliare esattamente a questo (le nuove righe e gli spazi finali sono OK).

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

Questo è il codice golf, quindi vince il codice più breve in byte!

Classifica

Mostra snippet di codice

code-golf  ascii-art  kolmogorov-complexity 
— Stewie Griffin
fonte
7
Sono un po 'deluso dal fatto che il motivo non sia un po' più complesso, per rappresentare i diversi spessori di linea del cuscino.
— Sparr,
4
@Sparr Ci ho provato, ma non sono riuscito a farlo sembrare bello usando solo caratteri ASCII. Ho pensato che fosse abbastanza vicino :)
— Stewie Griffin,
3
Avrei appena aggiunto spazi
— Sparr il
1
'apparentemente': P
— Pysis
7
Ora puoi acquistare un cuscino bianco e stamparci sopra lo snippet del vincitore.
— coredump,

Risposte:

24

05AB1E , 18 15 byte

Codice:

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

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online!

— Adnan
fonte
2
Wow ... due take diversi, lo stesso numero di byte ...
— Oliver Ni
30

/// , 116 byte

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

Provalo online!

Modifica : \\\\\\\\\\\\\\\/e \\\\\\\\\\\\\\\\sono in realtà un singolo / e \, rispettivamente.

Modifica : -3 perché pensavo di rimuoverlo i. Penso che questo non possa essere ulteriormente golfato.

— Erik the Outgolfer
fonte
15

Python 2, 49 byte

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

Grazie a Mitch Schwartz per questo metodo pulito che consente di risparmiare un byte. L'idea è di stampare quattro righe di ('\\'*5+'/'*5)*6, scambiare i ruoli di barra e barra rovesciata e quindi eseguire l'intero processo 6 volte. I due personaggi sono memorizzati in ae b, e scambiati come a,b=b,a. Il doppio loop è doppio generando la seguente stringa di codice, quindi eseguendola con 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 byte:

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

Crea la stringa di linea, la stampa quattro volte e poi la inverte, quindi lo fa 6 volte. Lo fa generando il seguente codice, quindi eseguendolo:

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]

Ecco alcune delle iterazioni del mio golf:

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

05AB1E, 15 byte

„/\5×{R6×6FR4F=

Provalo online!

Spiegazione:

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

Utilizza la codifica CP-1252 .

— Oliver Ni
fonte
8

JavaScript (ES6), 68 60 58 byte

Una funzione ricorsiva. Diverse ottimizzazioni ispirate alla risposta del cioccolato .

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

dimostrazione

Mostra snippet di codice

— Arnauld
fonte
Penso che tu possa tralasciare il primo &1e salvare due byte
— Henrik Christensen il
@HenrikChristensen Funzionerebbe solo per n < 480. Per n >= 480, avremmo bisogno parentesi: (n/240^n/5)&1.
— Arnauld,
8

Bubblegum , 30 byte

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

Risposta obbligatoria Bubblegum.

— LegionMammal978
fonte
Oh mio Dio, questa lingua è fantastica!
— Pedro A
7

Haskell, 77 70 57 byte

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

Noioso concats e replicates invece di giocare con i seni. Il vecchio era:

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

Brainfuck, 140 byte

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

:-D

— 0WJYxW9FMN
fonte
3
Oh guarda! La soluzione brainfuck è più corta di otto byte rispetto alla soluzione Java. È ora che i programmatori Java passino a Brainfuck ...
— 0WJYxW9FMN
Java colpisce ancora
— cliffroot il
6

Python 2, 86 80 76 74 73 byte

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

Probabilmente potrebbe giocare a golf un po 'di più ma è un inizio.

modificare

Salvato 6 rimuovendo alcune parentesi non necessarie

Altri 4 utilizzando una singola stringa e quindi invertendola

Grazie @Adnan. Ieri sera ho fatto tardi e non sono ancora del tutto sveglio: p

-1 spostando la *24sulla variabile invece di usarla due volte

— ElPedro
fonte
4
Credo che *6*4sia lo stesso di *24? : p
— Adnan,
6

Brainfuck, 149 byte

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

Il miglior interprete EVAR!

Questo utilizza 6 celle (nessun avvolgimento, nessun modulo). Eccoli:

0A 00 2F 00 5C 00

Le 00celle vengono utilizzate per i contatori di loop. Qui, i contatori vengono compilati con i valori iniziali:

0A 06 2F 04 5C 03

Il contatore più a sinistra è per il ciclo più interno (sì, io uso loop nidificati di profondità 3). Si noti che la quarta cella ( 04contatore) viene utilizzata due volte, una volta per /////\\\\\...e una volta per \\\\\/////...ogni volta.

0A, 2FE 5Csono i personaggi \n, /e \, rispettivamente.

— Erik the Outgolfer
fonte
6

Python 2.7 66 -> 56 -> 55 byte

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

nuovo al golf del codice

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

Grazie Stewie Griffin

Hai dimenticato uno spazio bianco sciocco;)

— Ivar Matstoms
fonte
2
Benvenuti in PPCG! Bella prima risposta :) Puoi saltare alcune delle variabili intermedie? Almeno de eforse di più. Non ho ancora testato questo, ma dovrebbe essere vicino: print(4*c+4*(6*b+"\n"))*3. Sono 5 byte in meno.
— Stewie Griffin,
3
55 byte:a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3
— Stewie Griffin,
6

Brainfuck, 179 byte

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

So che questo non è il miglior punteggio nel thread, ma volevo provare Brainfuck e provarlo.

Modifica: devo aver fatto un errore durante il copypasting. Questa versione dovrebbe funzionare

— Axel Matstoms
fonte
Benvenuti nel sito!
— DJMcMayhem
Non funziona per me. Il browser si blocca con questo interprete e uno personale mostra un output a 5 righe non previsto: /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\ quattro volte, quindi infinito \ .
— aluriak,
Sì, funziona :)
— aluriak,
5

Pyke, 16 byte

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

Dopo l'aggiornamento oggi che ha consentito "in string letterali, 17 byte

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

Provalo qui!

— Blu
fonte
5

MATL , 18 16 byte

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

Provalo online!

Spiegazione

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

Pyth, 22 byte

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

Provalo qui .

Spiegazione:

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)

Scusate se la spiegazione è un po 'difficile da capire, ma è stata un po' complicata.

— RK.
fonte
5

V , 22 21 byte

Modifica Un byte vinto, grazie @DjMcMayhem:

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

Le modifiche sono:

  • Y4P-> 4ÄUsa la riga duplicata V invece del comando integrato Vim (questo aggiungerà una riga vuota alla fine del paragrafo)
  • 3äG-> 3ä}Duplica il paragrafo anziché l'intero buffer (per evitare la riga vuota generata dalla modifica precedente)

Posta originale

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

Provalo online

Scomposto in questo modo:

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
fonte
È bello vedere qualcun altro che usa V! Fino a poco tempo fa, sono stato solo io. Se hai mai bisogno di aiuto, sentiti libero di chiamarmi nel diciannovesimo byte
— DJMcMayhem
@DrMcMoylex Sì, la tua lingua sembra divertente da usare :-) Ho avuto un problema su questo: inizialmente volevo usare 5á\5á/05ä$5Ä5x$p4Ä3äGcioè sostituire Y4Pcon 4Äma per un motivo che non capisco copia una riga vuota aggiuntiva ... Se puoi mi illumini su questo sarebbe bello. Inoltre, se trovo un po 'di tempo libero, contribuirei volentieri alla lingua (in particolare il numero 4 )
— statox
Ah, sì, mi ha turbato molte volte. È un problema noto. Il problema è che Äè sinonimo di ddno Y. Questo di solito non è un problema, ma causa alcuni problemi se il buffer ha solo una riga o se sei sull'ultima riga.
— DJMcMayhem
A dire il vero, ho appena realizzato, questo approccio potrebbe funzionare se è stato sostituito 3äGcon il 3ä}dato che non sarà uno strattone che lo scorso fine riga. v.tryitonline.net/…
— DJMcMayhem
Ok, penso di capire perché non ha funzionato ora. E un bel modo per vincere 1 byte, grazie!
— statox,
4

In realtà , 21 byte

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

Provalo online!

-1 byte da Adnan

Spiegazione:

"/\"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
fonte
Puoi fare qualcosa di simile "/\"5*Sper creare la serie di barre?
— Adnan,
@Adnan Ottima idea!
— Mego
4

Rubino, 46 ​​byte

Crea la seguente stringa (70 caratteri, uno impostato in più del necessario) quindi si alterna tra i caratteri di campionamento 0..59e 5..64da esso.

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

codice e output

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

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

errore interessante (un 7 anziché un 5)

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

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
— Level River St
fonte
4

APL, 30 byte

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

Sono abbastanza nuovo di APL (sto usando APLX, ma dovrebbe funzionare su quasi tutte le implementazioni di APL), quindi questa è una soluzione abbastanza semplicistica.

Spiegazione:

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

C, 66 61 byte

5 byte salvati grazie a orlp.

Carattere semplice per stampa caratteri. 61 caratteri per riga, l'ultimo è newline (ASCII 10) e gli altri si alternano tra /47 e \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
fonte
61 byte: i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}.
— orlp
@orlp grazie, sapevo che doveva esserci un modo migliore con il i--ma non avevo tempo di cercarlo.
— Level River St,
3

Python 2, 63 byte

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

Per Python 3, procedere come segue (65 byte):

a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
— Erik the Outgolfer
fonte
1
Questo utilizza lo stesso metodo della mia risposta Jelly .
— Erik the Outgolfer,
Metodo più efficiente del mio per cominciare
— ElPedro
@ElPedro Fondamentalmente, ho appena fatto qualche manipolazione di stringhe / array. Il trucco è che ho preparato una stringa più grande: /////\\\\\/////...quattro volte, separate da nuove righe
— Erik the Outgolfer
3

J, 31 28 19 byte

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

uso

   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
— miglia
fonte
3

Ottava, 50 48 byte

Funzione anonima:

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

Puoi provare online qui . Basta eseguire il comando sopra e quindi eseguire la funzione con ans().

In sostanza, questo crea un array del valore 47 che è 4 alto e 5 largo. Crea quindi una seconda matrice di valore 92 che ha le stesse dimensioni.

I due array sono concatenati in una scacchiera di [A B;B A]. Il ''è concatenato anche per forzare la conversione di stringhe di caratteri.

Alla fine l'intero array viene replicato 3 volte in giù e 6 volte in larghezza per formare la dimensione finale.

  • Salvato 2 byte, grazie @StewieGriffin
— Tom Carpenter
fonte
nessuna necessità di una funzione anonima; salva 3 byte.
— Tasos Papastylianou,
@TasosPapastylianou c'è, altrimenti verrà stampato ans=davanti al cuscino. Avendolo nella funzione si aggira questo dato che si prevede che restituisca la risposta a una variabile anziché visualizzarla.
— Tom Carpenter,
Questa è solo semantica. Voglio dire, se diventerai pedante, mi preoccuperei di più dei messaggi di avvertimento a 3 righe che appaiono invece: p Anche le solite regole affermano che deve essere un output da un comando terminale diretto, o un callable maniglia di funzione. Significa che dovresti assegnare la tua funzione anonima a un handle (o aggiungere altri 5 byte all'account per dover premere ans()). Il che è inutile, dal momento ans() che stampa ancoraans quando eseguito!
— Tasos Papastylianou,
@TasosPapastylianou ans()è un handle di funzione richiamabile, quindi non è necessario assegnarlo a qualcosa con, ad esempio a=@..., perché è implicitamente assegnato a anscome handle. Inoltre non viene stampato ans=quando eseguito a meno che non lo si richieda specificamente non facendo nulla con il valore restituito e non aggiungendo a ;. Se lo facessi disp(ans()), stampa solo l'output esatto (no ans=). Ma sì, l'avvertimento è fastidioso, tuttavia ciò non è accaduto in precedenza, quindi non è specifico della lingua, ma piuttosto dell'interprete.
— Tom Carpenter,
Ok, accetteremo di non essere d'accordo. Per come la vedo io, se ti affidi disp(ans())prima di ottenere il tuo output, allora devi aggiungere 12 byte alla tua risposta. La mia opinione è che questo è solo il modo in cui l'ottava presenta il suo risultato e va bene.
— Tasos Papastylianou,
3

PHP, 73 69 byte

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

dimostrazione

http://ideone.com/z7N1Md

— chocochaos
fonte
1
69 byte: for($s='/\\';$i<1440;$i++)echo$i%60<1?'\n':'',$s[($i/5+($i/240|0))%2];(sostituisci \ncon una nuova riga reale). echonon è una funzione, quindi non ha bisogno di parentesi. Inoltre, echopuò ricevere più valori, separati da una virgola. Questo elimina davvero la necessità di quelle parentesi. E poi, all'interno del tuo $s[...], il calcolo più esterno non ha bisogno nemmeno delle parentesi, poiché è contenuto all'interno []. L'uso $s[($i/5+($i/240|0))%2]ha lo stesso effetto ed è più breve.
— Ismael Miguel,
Grazie aggiornato! Non sapevo nemmeno di aver accettato più parametri ^ _ ^
— chocochaos il
echoe printaccetta più parametri. Ma printrichiede parentesi con più parametri quando utilizzato sull'incremento, condizione o assegnazione di un ciclo.
— Ismael Miguel,
Può radere ciò <1, cambiando le espressioni echo$i%60?'':' ',, nuova riga come espressione 3 nel ternario.
— Progrock,
3

Java 7, 120 byte

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

Inserito tutto in un loop. Batte Brainfuck, missione compiuta.

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

— cliffroot
fonte
3

Vim, 44 27 byte

EDIT Molti byte vinti grazie a @DrMcMoylex:

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

Risposta originale:

Non sono sicuro che si adatti davvero alle regole di questo sito, ma ho pensato che fosse divertente provarlo:

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

Che può essere decomposto in questo modo:

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
fonte
Oh hey statox, benvenuto nel sito! Questo si adatta perfettamente alle regole. Gioco principalmente a golf a Vim. Solo così sai, potresti fare 5i/<esc>5a\<esc>0y$5Pall'inizio per salvare 9 byte.
— DJMcMayhem
Ehi DrMcMoylex (nuovo nome? :-)) felice di vederti qui e che la mia risposta si adatta. Anche grazie per il tuo suggerimento, modificherò la mia risposta
— statox
2
Haha, sì, ho temporaneamente cambiato il mio nome a causa di questa sfida , lol. Lo cambierò tra 30 giorni
— DJMcMayhem
3

Brainfuck, 168 byte

++++++[>++++++++<-]>-<+++++++++[>>++++++++++<<-]>>++<<+++++[>>>++<<<-]>>>>+++[>++++[>++++++[<<<<<.....>.....>>>>-]<<<.>>-]++++[>++++++[<<<<.....<.....>>>>>-]<<<.>>-]<-]
— Mitchell Humphrey
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.