C'est mon oreiller

66

... m'aideras-tu à l'immortaliser?

entrez la description de l'image ici

J'ai cet oreiller depuis quelques années maintenant, et apparemment, il est temps de s'en débarrasser. Pouvez-vous s'il vous plaît écrire une fonction ou un programme, que je peux emporter avec moi et que je peux utiliser pour recréer cet oreiller chaque fois que je veux me rappeler un peu.

Cela doit fonctionner sans argument d'entrée.

La sortie devrait ressembler à ceci (les retours à la ligne et les espaces sont OK).

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

C'est le code de golf, donc le code le plus court en octets gagne!

Classement

Afficher l'extrait de code

code-golf  ascii-art  kolmogorov-complexity 
— Stewie Griffin
source
7
Je suis un peu déçu que le motif ne soit pas un peu plus complexe, pour représenter les différentes épaisseurs de lignes de l'oreiller.
— Sparr
4
@Sparr J'ai essayé, mais je n'ai pas réussi à lui donner une belle apparence en utilisant uniquement des caractères ASCII. Je me suis dit que c'était assez proche :)
— Stewie Griffin
3
J'aurais juste ajouté des espaces
— Sparr
1
«apparemment»: P
— Pysis
7
Maintenant, vous pouvez acheter un oreiller vierge et imprimer l’extrait du vainqueur dessus.
— Coredump

Réponses:

24

05AB1E , 18 15 octets

Code:

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

Explication:

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

Utilise le codage CP-1252 . Essayez-le en ligne!

— Adnan
source
2
Wow ... deux prises différentes, même nombre d'octets ...
— Oliver Ni
30

/// , 116 octets

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

Essayez-le en ligne!

Edit : le \\\\\\\\\\\\\\\/et \\\\\\\\\\\\\\\\sont en réalité un simple / et \, respectivement.

Edit : -3 parce que j'ai pensé à enlever i. Je pense que cela ne peut plus être joué au golf.

— Erik l'Outgolfeur
source
15

Python 2, 49 octets

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

Merci à Mitch Schwartz pour cette méthode propre qui enregistre un octet. L’idée est d’imprimer quatre lignes ('\\'*5+'/'*5)*6, d’échanger les rôles de barre oblique et de barre oblique inverse, puis d’effectuer ce processus 6 fois. Les deux caractères sont stockés dans aet b, et échangés en tant que a,b=b,a. La double boucle est double en générant la chaîne de code suivante, puis en l'exécutant avec 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 octets:

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

Crée la chaîne de caractères, l’imprime quatre fois, puis l’inverse, puis 6 fois. Le fait en générant le code suivant, puis en l'exécutant:

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]

Voici quelques unes des itérations de mon parcours de 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
source
12

05AB1E, 15 octets

„/\5×{R6×6FR4F=

Essayez-le en ligne!

Explication:

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

Utilise le codage CP-1252 .

— Oliver Ni
source
8

JavaScript (ES6), 68 60 58 octets

Une fonction récursive. Plusieurs optimisations inspirées de chocochaos répondent .

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

Démo

Afficher l'extrait de code

— Arnauld
source
Je pense que vous pouvez omettre le premier &1et économiser deux octets
— Henrik Christensen
@ HenrikChristensen Cela ne fonctionnerait que pour n < 480. Pour n >= 480, nous avions besoin entre parenthèses: (n/240^n/5)&1.
— Arnauld
8

Bubblegum , 30 octets

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

Réponse Bubblegum obligatoire.

— LegionMammal978
source
Oh mon Dieu, cette langue est géniale!
— Pedro A
7

Haskell, 77 70 57 octets

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

Ennuyeux concats et replicates au lieu de jouer avec des sinus. Vieux était:

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

Brainfuck, 140 octets

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

:-RÉ

— 0WJYxW9FMN
source
3
Oh regarde! La solution brainfuck est huit octets plus courte que la solution Java. Il est temps que les codeurs Java basculent dans le brainfuck ...
— 0WJYxW9FMN
Java frappe
— cliffroot
6

Python 2, 86 80 76 74 73 octets

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

Pourrait probablement jouer un peu plus au golf mais c’est un début.

Modifier

Enregistré 6 en supprimant certains crochets inutiles

4 autres en utilisant une seule chaîne puis en l'inversant

Merci @Adnan. Eu une nuit tardive la nuit dernière et toujours pas encore complètement réveillé: p

-1 en déplaçant le *24à la variable au lieu de l'utiliser deux fois

— ElPedro
source
4
Je crois que *6*4c'est la même chose que *24? : p
— Adnan
6

Brainfuck, 149 octets

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

Le meilleur interprète EVAR!

Cela utilise 6 cellules (pas d'emballage, pas de modulo). Les voici:

0A 00 2F 00 5C 00

Les 00cellules sont utilisées pour les compteurs de boucles. Ici, les compteurs sont remplis avec les valeurs initiales:

0A 06 2F 04 5C 03

Le compteur le plus à gauche est celui de la boucle la plus à l'intérieur (oui, j'utilise des boucles imbriquées de profondeur 3). Veuillez noter que la 4ème cellule ( 04compteur) est utilisée deux fois, une /////\\\\\...fois pour \\\\\/////...toutes et une fois pour toutes.

0A, 2Fet 5Csont les caractères \n, /et \, respectivement.

— Erik l'Outgolfeur
source
6

Python 2.7 66 -> 56 -> 55 octets

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

nouveau au code de golf

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

Merci Stewie Griffin

J'ai oublié un espace idiot;)

— Ivar Matstoms
source
2
Bienvenue chez PPCG! Bonne première réponse :) Pouvez-vous sauter certaines des variables intermédiaires? Au moins det epeut-être plus. Je ne l' ai pas testé, mais il devrait être proche: print(4*c+4*(6*b+"\n"))*3. C'est 5 octets de moins.
— Stewie Griffin
3
55 octets:a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3
— Stewie Griffin
6

Brainfuck, 179 octets

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

Je sais que ce n'est pas le meilleur score du fil, mais je voulais essayer le brainfuck et l'essayer.

Edit: J'ai dû faire une erreur en copypasting. Cette version devrait fonctionner

— Axel Matstoms
source
Bienvenue sur le site!
— DJMcMayhem
Ca ne marche pas pour moi Le navigateur raccroche avec cet interprète , et le premier affiche une sortie non attendue sur 5 lignes: /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\ quatre fois, puis infinie \ .
— Aluriak
Oui, ça marche :)
— aluriak
5

Pyke, 16 octets

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

Après la mise à jour de ce jour ", 17 octets autorisés dans les littéraux de chaîne

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

Essayez-le ici!

— Bleu
source
5

MATL , 18 16 octets

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

Essayez-le en ligne!

Explication

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

Pyth, 22 octets

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

Essayez ici .

Explication:

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)

Désolé si l'explication est un peu difficile à comprendre, mais c'était un peu compliqué.

— RK.
source
5

V , 22 21 octets

Edit Un octet gagné, merci @DjMcMayhem:

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

Les changements sont:

  • Y4P-> 4ÄUtiliser V la ligne en double au lieu de la commande intégrée de Vim (cela ajoutera une ligne vierge à la fin du paragraphe)
  • 3äG-> 3ä}dupliquer le paragraphe au lieu de la totalité du tampon (pour éviter les lignes vierges générées par les modifications précédentes)

Original post

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

Essayez-le en ligne

Décomposé comme ça:

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
source
C'est cool de voir quelqu'un d'autre utiliser V! Jusqu'à récemment, ce n'était que moi. Si jamais vous avez besoin d'aide, n'hésitez pas à me
— contacter
@DrMcMoylex Yup, votre langue semble amusante à utiliser :-) J'ai eu un problème avec celui-ci: au départ, je voulais utiliser 5á\5á/05ä$5Ä5x$p4Ä3äGc'est- à- dire remplacer Y4Ppar 4Ämais pour une raison que je ne comprends pas, copie une ligne vierge supplémentaire ... Si vous le pouvez m'éclairer sur celui-ci ce serait bien. Aussi, si je trouve un peu de temps libre, je contribuerais volontiers à la langue (en particulier le numéro 4 )
— statox
Ah, oui, cela m'a souvent troublé. C'est un problème connu. Le problème est que Äc'est un synonyme de dd, pas Y. Ce n'est généralement pas un problème, mais cela peut poser problème si le tampon n'a qu'une seule ligne ou si vous êtes sur la dernière ligne.
— DJMcMayhem
En fait, je viens de me rendre compte que cette approche fonctionnerait toujours si vous remplaciez 3äGavec, 3ä}car elle ne retirera pas la dernière ligne. v.tryitonline.net/…
— DJMcMayhem
Ok, je pense que je comprends pourquoi ça n'a pas marché maintenant. Et belle façon de gagner 1 octet, merci!
— statox
4

Gelée , 17 à 16 octets

⁾/\ẋ6Wẋ4;U$ẋ3x5Y

Essayez-le en ligne!

Merci à 6710 (miles) pour -1 octet.

— Erik l'Outgolfeur
source
1
Je pense que vous pouvez économiser un octet avec⁾/\ẋ6Wẋ4;U$ẋ3x5Y
— miles
@miles Merci, il semble que je ne puisse pas encore utiliser efficacement quicks :) Et je savais que je n'avais pas besoin de deux secondes Y!
— Erik the Outgolfer
4

En fait , 21 octets

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

Essayez-le en ligne!

-1 octet d'Adnan

Explication:

"/\"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
source
Pouvez-vous faire quelque chose comme "/\"5*Spour créer la chaîne de barres obliques?
— Adnan
@Adnan Excellente idée!
— Mego
4

Ruby, 46 octets

Crée la chaîne suivante (70 caractères, un jeu de plus que nécessaire), puis alterne entre les caractères d'échantillonnage 0..59et ceux- 5..64ci.

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

code et sortie

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

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

erreur intéressante (un 7 au lieu d'un 5)

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

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
— Level River St
source
4

APL, 30 octets

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

Je connais assez bien APL (j'utilise APLX, mais cela devrait fonctionner dans la plupart des implémentations d'APL). Il s'agit donc d'une solution assez simpliste.

Explication:

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

C, 66 61 octets

5 octets sauvegardés grâce à orlp.

Impression directe caractère par caractère. 61 caractères par ligne, le dernier est Newline (ASCII 10) et les autres alternent entre /47 et \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
source
61 Octets i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}.
— Orlp
@ orlp merci, je savais qu'il devait y avoir un meilleur moyen avec le i--mais je n'ai pas eu le temps de le chercher.
— Level River St
3

Python 2, 63 octets

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

Pour Python 3, procédez comme suit (65 octets):

a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
— Erik l'Outgolfeur
source
1
Cela utilise la même méthode que ma réponse à la gelée .
— Erik l'Outgolfer
Méthode plus efficace que la mienne pour commencer
— ElPedro
@ElPedro En gros, je viens de manipuler des chaînes / des tableaux. Le truc, c'est que j'ai préparé une chaîne plus grosse: /////\\\\\/////...quatre fois, séparées par des nouvelles lignes
— Erik the Outgolfer
3

J, 31 28 19 octets

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

Usage

   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
— milles
source
3

Octave, 50 48 octets

Fonction anonyme:

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

Vous pouvez essayer en ligne ici . Exécutez simplement la commande ci-dessus, puis exécutez la fonction avec ans().

Cela crée essentiellement un tableau de la valeur 47 qui est 4 haut et 5 large. Il crée ensuite un deuxième tableau de valeur 92 de même taille.

Les deux tableaux sont concaténés dans un damier de [A B;B A]. Le ''est également concaténé pour forcer la conversion en chaînes de caractères.

Finalement, tout le tableau est répliqué 3 fois vers le bas et 6 fois pour former la taille finale.

  • Sauvegardé 2 octets, merci @StewieGriffin
— Tom Carpenter
source
pas besoin d'une fonction anonyme; économiser 3 octets.
— Tasos Papastylianou
@TasosPapastylianou il y a, sinon il imprimera ans=avant l'oreiller. Le fait de l’avoir dans la fonction permet de contourner ce problème car il est prévu de renvoyer la réponse à une variable plutôt que de l’afficher.
— Tom Carpenter
C'est juste la sémantique. Je veux dire, si vous voulez être pédant, je m'inquiéterais davantage des messages d'avertissement de 3 lignes qui apparaissent à la place: p De plus, les règles habituelles stipulent qu'il doit s'agir soit d'une sortie d'une commande directe du terminal, soit d'un appelable. poignée de fonction. Cela signifie que vous devez affecter votre fonction anonyme à un descripteur (ou ajouter 5 octets supplémentaires pour tenir compte de la nécessité de pring ans()). Ce qui est inutile, car imprime ans() toujoursans quand exécuté!
— Tasos Papastylianou
@TasosPapastylianou ans()est un handle de fonction appelable, vous n'avez donc pas besoin de l'assigner à quelque chose avec, par exemple a=@..., parce qu'il est implicitement assigné à ansun handle. De plus, il ne s’imprime pas ans=lorsqu’il est exécuté à moins que vous ne le lui demandiez spécifiquement en ne faisant rien avec la valeur renvoyée et en n’ajoutant pas a ;. Si vous le faites, disp(ans())cela n’imprimera que la sortie exacte (non ans=). Mais oui, l'avertissement est agaçant, mais cela ne s'est pas produit auparavant. Ce n'est donc pas spécifique à la langue, mais à l'interpréteur.
— Tom Carpenter
Ok, nous serons d'accord pour être en désaccord. D'après ce que je vois, si vous comptez disp(ans())avant d'obtenir votre sortie, vous devez ajouter 12 octets à votre réponse. Mon opinion personnelle est que c’est comme ça que Octave présente son résultat et c’est bien.
— Tasos Papastylianou
3

PHP, 73 69 octets

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

Démo

http://ideone.com/z7N1Md

— chocochaos
source
1
69 octets: for($s='/\\';$i<1440;$i++)echo$i%60<1?'\n':'',$s[($i/5+($i/240|0))%2];(remplacez le \npar une vraie ligne). echon'est pas une fonction, donc, il n'a pas besoin de parenthèses. En outre, echopeut recevoir plusieurs valeurs, séparées par une virgule. Cela supprime vraiment le besoin de ces parenthèses. Et puis, à l'intérieur de votre $s[...]calcul, le calcul le plus externe n'a pas non plus besoin de parenthèses, puisqu'il est contenu dans []. L'utilisation $s[($i/5+($i/240|0))%2]a le même effet et est plus courte.
— Ismael Miguel
Merci, mis à jour! Je ne savais même pas que l'écho acceptait plusieurs paramètres ^ _ ^
— chocochaos
echoet printaccepter plusieurs paramètres. Mais printnécessite des parenthèses avec plusieurs paramètres lorsqu'il est utilisé sur l'incrément, la condition ou l'affectation d'une boucle.
— Ismael Miguel
Peut <1changer cela , en changeant les expressions echo$i%60?'':' ',, nouvelle ligne en tant qu’expression 3 dans le ternaire.
— Progrock
3

Java 7, 120 octets

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

Poussé tout dans une boucle. Beats Brainfuck, mission accomplie.

Voir en ligne: https://ideone.com/pZjma3

— cliffroot
source
3

Vim, 44 à 27 octets

EDIT Beaucoup d'octets gagnés grâce à @DrMcMoylex:

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

Réponse originale:

Je ne suis pas sûr que cela corresponde vraiment aux règles de ce site, mais j'ai pensé que c'était amusant de l'essayer:

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

Ce qui peut être décomposé comme ceci:

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
source
Oh hey statox, bienvenue sur le site! Cela correspond totalement aux règles. Je joue principalement à Vim. Juste pour que vous sachiez, vous pourriez faire 5i/<esc>5a\<esc>0y$5Pau début pour économiser 9 octets.
— DJMcMayhem
Hey DrMcMoylex (nouveau nom? :-)) content de te voir ici et que ma réponse me convient. Merci également pour votre suggestion, je vais modifier ma réponse
— statox
2
Haha, oui j'ai temporairement changé de nom à cause de ce défi , lol. Je le changerai dans 30 jours
— DJMcMayhem
3

Brainfuck, 168 octets

++++++[>++++++++<-]>-<+++++++++[>>++++++++++<<-]>>++<<+++++[>>>++<<<-]>>>>+++[>++++[>++++++[<<<<<.....>.....>>>>-]<<<.>>-]++++[>++++++[<<<<.....<.....>>>>>-]<<<.>>-]<-]
— Mitchell Humphrey
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.