Fais-moi une couverture!

16

Je veux une couverture qui ressemble à ça. Chaque bande va plus, moins, plus, moins. Pouvez-vous l'imprimer?

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

Les espaces de fin à la fin de chaque ligne et les retours à la ligne de fin sont acceptables.

N'oubliez pas qu'il s'agit de code-golf , donc le code avec le moins d'octets gagne.

Classements

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle de démarque suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Afficher l'extrait de code

code-golf ascii-art kolmogorov-complexity Oliver Ni
la source
Le bord droit semble mal aligné.
Urne de poulpe magique
Le bord gauche ne se chevauche-t-il pas?
xnor
@xnor Désolé, ma mauvaise.
Oliver Ni
@carusocomputing Fixed.
Oliver Ni
10
Si vous aviez utilisé le Sandbox, ces problèmes auraient pu être évités avant que cela ne se reproduise.
Mego

Réponses:

8

Python 2, 84 octets

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

Merci à Sp3000 pour 6 octets de transformer les opérations arithmétiques en bits.

xnor
la source
Whoa ... comment ????
Oliver Ni
1
i+~j>>2&1^i+j>>1&2^i&4, peut-être?
Sp3000
@ Sp3000 C'est une belle priorité au niveau du bit. Je dois me rappeler que lors de la combinaison de booléens dérivés arithmétiquement dans un index.
xnor
5

Pyth, 36 octets

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

Essayez-le en ligne: Démonstration

Explication:

On peut déterminer le symbole en vérifiant 3 conditions:

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

Si nous interprétons [A,B,C]comme un nombre binaire, nous obtenons le mappage suivant:

01234567
 \// \/\

Nous pouvons également interpréter [A,B,C]comme un nombre décimal et effectuer une recherche indexée modulaire dans la chaîne. Cela ne fait aucune différence car 10 mod 8 = 2.

Passons maintenant au code:

V24itère N(row-idx) sur [0, 1, ..., 23].

sm...48mappe les nombres d(column-idx) en [0, 1, ..., 47]caractères et imprime la chaîne combinée.

++BNdgénère la liste [N, N+d], +...t-Ndajoute N-d-1. Nous avons donc la liste [N, N+d, N-d-1]. m<3%k8vérifie pour chaque nombre calculé k, si 3 < k % 8, donc cela donne la liste avec les conditions [A, B, C].

i...Tconvertit cela en un nombre décimal, puis @" \// \/\\"effectue la recherche dans la chaîne.

Plus ou moins le même code en Python2: 98 octets :

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
la source
J'essaie juste de me familiariser avec Pyth pour que toute réponse décente avec une bonne explication reçoive un vote positif de moi. allait essayer Pyth après mon expérience de base 3 :)
ElPedro
Vous devriez également publier la réponse Python2 ...
Jerry Jeremiah
3

Perl, 209 + 17 = 226 octets

Courez avec -mList::Util=max -M5.010(le deuxième drapeau est gratuit). Ce n'est pas gagner des concours de comptage d'octets, mais voici ma solution.

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

Lisible:

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

Génère de manière procédurale chaque segment, puis répète le motif 6 fois, puis génère le résultat total 3 fois.

Gabriel Benamy
la source
Woah, je ne suis plus le plus vieux answe :) +1 pour le faire en Perl de toute façon.
ElPedro
J'aurais pu le faire de la même manière que tout le monde (juste en imprimant un tas de lignes), mais j'ai décidé de faire les choses de manière algorithmique plutôt qu'explicite parce que je sentais que c'était plus cool.
Gabriel Benamy
Cool selon mes critères. J'ai adopté une approche que je n'avais jamais essayée auparavant car c'était un défi intéressant. Comme je l'ai dit, +1. Aucune insulte voulue par mon commentaire. C'est pourquoi j'ai voté positivement.
ElPedro
3

Python 3, 174 172 138 138 octets

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

J'ai trouvé le plus petit motif que je pouvais trouver dans la couverture (le motif "sous" et "sur"), l'ai collé dans une liste et ajouté une certaine compréhension de la liste et une manipulation de chaîne pour tout décompresser. Substitue toutes les barres obliques inversées échappées par "b" et les remplace plus tard pour économiser quelques octets.

Merci à Oliver d'avoir joué au golf sur 2 octets!

Pris 34 octets en changeant le modèle - le modèle entier pour la couverture est maintenant dans une seule liste, donc une seule boucle est nécessaire pour dérouler le modèle.

TheCrazyInventor
la source
1
Bienvenue chez PPCG! joli premier post! Vous pouvez raser un octet en python 2 je pense, vous n'avez pas besoin des parends pour l'impression.
Rɪᴋᴇʀ
1
Merci Easterly Irk, je rôde dans le golf de code depuis trop longtemps maintenant, alors j'ai décidé de participer. :)
TheCrazyInventor
1
Vous pouvez enregistrer deux octets en supprimant l'espace après 0*6etu*6
Oliver Ni
1
Vous pouvez économiser 4 octets en utilisant le "b" pour les doubles barres obliques inverses et partout où vous avez besoin d'une seule barre oblique inverse, utilisez simplement l'échappement: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: votre code ne semble pas générer une couverture valide.
TheCrazyInventor
3

Python 2, 171 170 168 octets

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)

Pas joli et pas intelligent. Définit simplement les variables pour les groupes de chaînes les plus utilisés, puis les combine et imprime le résultat 3 fois. Peut essayer de jouer au golf plus tard si je ne trouve pas une meilleure approche.

1 octet enregistré en utilisant l'entrée brute sur une affectation. Merci @ nedla2004

-2 en assignant quelques variables mais toujours pas un concurrent sérieux

ElPedro
la source
1
Vous pouvez définir un comme r "\\"
nedla2004
Merci @ nedla2004 Bon point. Jeté cela assez rapidement et allait le regarder plus tard. C'est un bon début :)
ElPedro
La plupart souhaitent cependant trouver un moyen de contourner *6chaque élément de tuple. Des idées?
ElPedro
1
Je ne sais pas comment vous pourriez faire cela, mais la dernière ligne peut l'être exec r"print'\n'.join(d);"*3.
nedla2004
Je viens de poster une alternative juste par intérêt. J'apprécierais également vos commentaires à ce sujet.
ElPedro
2

SOML , 106 octets

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

une version non concurrente utilisant une fonction que je n'ai que récemment ajoutée: ( 83 67 66 octets)

explication:

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

Rubis, 75 octets

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

Mieux jouer au golf, en utilisant une seule recherche de chaîne de 8 octets indexée par j & 4 en plus des autres paramètres, plutôt qu'une chaîne de 4 octets modifiable.

Rubis, 81 octets

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

Imprime les rayures diagonales caractère par caractère. Le caractère correct est sélectionné dans une chaîne de 4 caractères en fonction de la présence / absence de chaque brin. Le caractère de chevauchement varie en fonction du brin qui se trouve en haut.

Commenté

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
la source
2

Perl, 132 131 113 octets

@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

Non golfé:

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
la source
2

05AB1E , 37 octets

Utilise l' encodage CP-1252 .

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

Essayez-le en ligne!

Explication

Utilise l'astuce mod-8 expliquée de manière experte dans la réponse pyth de 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
la source
2

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

OK, plus longue que ma dernière (et toute autre) réponse, mais je serais intéressé à recevoir des commentaires sur l'approche.

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

Éditer

-9 en raison de @ nedla2004 étant plus sur le ballon que moi

-2 en prenant le lambda en dehors de la boucle et en perdant ainsi 2 espaces en retrait

-1 en utilisant in' '*3au lieu de in 0,1,2puisque je n'utilise pas de htoute façon. c'est juste un compteur.

-3 Pourquoi, pourquoi, pourquoi ai-je laissé un saut de ligne et 2 retraits entre le second pour et l'impression ??? Il est tard. Reviendra demain.

-14 Peut réellement perdre complètement le lambda et inclure simplement le décodeur de base 3 directement après l'instruction d'impression. Ça a l'air malpropre mais après tout, c'est du golf de code :)

-4 Aucun point définissant une variable pour la liste entière. Utilisez-le directement dans la seconde boucle for.

-14 et aucun point en utilisant la boucle externe. Multipliez simplement le tuple entier par 3 (volé sans vergogne à @ nedla2004 pour obtenir moins de 200 :))

-3 Sauvegardé 3 en faisant \ = 0, / = 1 et espace = 2. Cela rend la liste entière plus courte car trois des nombres de base 3 ont maintenant des 0 en tête

Comment ça marche (et ça marche)

Étant donné que seuls 3 caractères sont utilisés:

  1. l est une liste des 8 motifs répétitifs en tant qu'équivalents entiers de leur représentation en base 3 en supposant que "" = 0, "\" = 1 et "/" = 2

  2. Le lambda Le premier code après l'instruction print est un convertisseur léger d'un entier en une chaîne de base 3

  3. La première boucle fait 3 boucles et la seconde imprime chaque ligne avec les 3 caractères de base multipliés par 6 et remplacés par /, \ ou espace.

Je suis sûr que je pourrais utiliser un regex au lieu du replace imbriqué () mais je suis trop fatigué pour essayer maintenant. Ce n'était qu'une expérience et plus longue que mon effort Python précédent, mais j'ai posté juste pour tout commentaire sur l'approche (et aussi parce que je n'ai jamais travaillé en base 3 auparavant et j'ai bien aimé travailler sur le convertisseur).

ElPedro
la source
1
Vous pouvez simplement supprimer la première division de la conversion en base 3.
nedla2004
Pour une raison quelconque, cela m'a causé des problèmes plus tôt, mais j'ai juste essayé et cela fonctionne maintenant. merci d'être plus éveillé que moi. Je vais rééditer ma réponse (et vous venez de me sauver 9 octets :))
ElPedro
1
J'ai réécrit la conversion de base 3, ce n'est plus une lambda, j'ai dû en faire une fonction, mais elle pourrait peut-être être reconvertie en lambda. Vous pouvez trouver la fonction ici .
nedla2004
Merci. Je pense qu'une combinaison des deux peut fonctionner mais c'est probablement un travail pour demain soir :) Merci encore pour vos commentaires.
ElPedro
1
Je suis descendu à 169, ici .
nedla2004
2

Rubis, 135 octets

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

Le tableau de nombres correspond à chaque composant de chaque ligne, traduit en base 3: = 0, \= 1, /= 2, puis converti en décimal. Les appels à gsub () sont cependant trop importants.

Et, tout à l'heure, j'ai vu la réponse de @ ElPedro. :-( Juste une coïncidence.

jose_castro_arnaud
la source
e.to_s(3).rjust(8,"0")→ ("%8s"%e.to_s(3)); gsub("0"," ").gsub("1","\\")..gsub("2","/")→ tr("013"," \\/"); "\n"→ $/; .join→ *"". Vous pouvez également enregistrer un octet en divisant tous les nombres du tableau par 4 et en les remplaçant epar (e*4).
Jordan
Oups, je suppose que ça devrait l'être tr("021"," /\\").
Jordan
90 octets: tio.run/##DcjNDkUwEEDhV5FJJG0zl6mhauG@CHJDws5PlMUNnr26Ol/Ofg5/…
Jordanie
2

PHP 157126 octets

Prendre les modifications des listes @Titus dans les commentaires ... Je suis ennuyé d'avoir raté le point 1 que j'aurais dû attraper, mais je ne savais pas que strtr () existait, c'est là que la plupart des économies viennent - beau travail Titus!

NOUVEAU:

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

VIEUX:

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

Parce que toutes les barres obliques inverses doivent s'échapper, cela économise beaucoup d'espace pour les empaqueter en tant que caractères différents et les remplacer pour la sortie, puis une fois que j'appelle str_replace (), il est logique de l'utiliser aussi souvent que possible.

ToXik-yogHurt
la source
1
Vous pouvez supprimer la balise ouverte si vous utilisez -r. Suivez ces cinq étapes pour enregistrer 30 octets supplémentaires : ideone.com/wt4HGB 1) utilisez $a[...]directement comme str_replaceparamètre au lieu de l'attribuer. 2) strtrau lieu de str_replace. 3) Utilisez des chiffres au lieu de lettres. 4) Inclure l'affectation dans l'écho. 5) Ne pas attribuer $a, utilisez-le.
Titus
1

Python 2, 169 161 165 160 155 154 152

Basé sur la réponse de @ ElPedro, avec de petites améliorations. Pour voir l'explication, voir leur réponse . Il s'agit de Python 2, même s'il semble y avoir des parenthèses près du print.

8 octets enregistrés en utilisant une variable pour replace. Cela ne fonctionne que pour les chaînes, et l'utilisation d'une fonction serait plus longue.

J'ai sauvé 4 octets en voyant que @ElPedro s'est rendu compte qu'ils n'avaient pas besoin de l, et moi non plus.

Enregistré 5 octets en ne retournant pas le range(8), et au lieu d'utiliser +=pour ajouter à r, en ajoutant r à la fin du nouveau chiffre. Essayez-le en utilisant repl.it

Enregistré 5 octets en volant la nouvelle liste de valeurs de @ ElPedro.

1 octet enregistré en supprimant l'espace entre le inet (.

Enregistré 2 octets en supprimant la variable 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
la source
Vous pouvez enregistrer 1 en supprimant l'espace entre inet (le premier pour
ElPedro
J'ai également perdu trois octets en réorganisant la séquence dont les nombres représentent chaque caractère dans la liste de base 3. Voir ma réponse pour l'explication. n'hésitez pas à copier. En ce qui me concerne, celui-ci est un effort commun et je suis heureux de voir que mon idée originale avait au moins un certain potentiel :)
ElPedro
Tu n'as pas besoin a=3**i. Utilisez simplement for i in range(8):r=x / 3 ** i% 3 +rpour enregistrer un couple. la priorité de l'opérateur s'occupe du reste :)
ElPedro
Vous ne savez pas comment délimiter les caractères de conversion de chaîne. L'analyseur les a supprimés dans mon dernier commentaire, ne vous contentez pas de copier-coller de ma suggestion ou cela se cassera :)
ElPedro
Bon point, j'ai compris.
nedla2004
1

PHP, 184 octets

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

Production:

C:\PHP>php make-me-a-blanket.php
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
Mario
la source
0

Lot, 152 octets

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

Le traitement des chaînes dans Batch est nul, c'est donc probablement la meilleure approche. L'appel-et-fall-through est très légèrement plus court qu'une forboucle imbriquée . Au moins, je n'ai pas à citer mes barres obliques inverses!

Neil
la source
0

APL, 110 octets

Je suis nouveau sur APL, c'est donc une solution simpliste.

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

Voici mon approche: notez qu'après les 8 premières lignes de la couverture, le motif se répète. Par conséquent, je n'ai qu'à définir les 8 premières lignes, puis je peux les répéter 3 fois. Notez également que chaque ligne se répète après les 8 premiers caractères. Par conséquent, pour définir une seule ligne, il suffit de définir les 8 premiers caractères, puis de les répéter 8 fois.

Voici une solution non golfée:

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

J'ai noté ci-dessus que D est l'inverse de B, E est l'inverse de A et H est l'inverse de F. Dans mon code actuel, j'en profite en ne définissant pas D, F ou H et en utilisant la fonction inverse ⊖:

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

ren
la source
0

Rubis, 132 octets

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

réponse très simple.

dkudriavtsev
la source
0

Haskell, 96 octets

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