Dessinez ce motif de diamant

24

Le schéma ci-dessous constituera la base de ce défi.

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

Étant donné une largeur et une hauteur d'entrée, chacune >=1génère le motif d'art ASCII ci-dessus répété autant de fois, se rejoignant (et se chevauchant) au niveau des petits diamants.

Par exemple, voici une entrée avec width = 2et height = 1:

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

Voici une entrée width = 3et height = 2:

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

Règles et E / S

  • L'entrée et la sortie peuvent être fournies par n'importe quelle méthode pratique .
  • Vous pouvez l'imprimer sur STDOUT ou le renvoyer en tant que résultat de fonction.
  • Un programme complet ou une fonction sont acceptables.
  • N'importe quelle quantité d'espace blanc étranger est acceptable, tant que les caractères s'alignent correctement.
  • Les failles standard sont interdites.
  • Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.
code-golf  ascii-art 
— AdmBorkBork
source
1
— Luis Mendo

Réponses:

10

Toile , 26 25 24 21 18 octets

４／╬/╬⁰ｒ：⤢ｎ↷⁸｛Ａ×├ｍ↷

Essayez-le ici!

-3 octets en fixant le ｍcanevas non répété

Explication:

4/╬                 quad-palindromize a 4-long diagonal - big inner diamond
   /╬               quad-palindromize "/" - small diamond
     ⁰r             join the two vertically, centered
       :⤢n          overlap with transpose
           ↷        and rotate the thing clockwise
            ⁸{      for each input
              A×      times 10
                ├     plus 2
                 m    mold the canvas to that width
                  ↷   and rotate clockwise, setting up for the next iteration
— dzaima
source
wow O_o canvas est trop court
— ASCII uniquement
6

JavaScript (ES8), 167 161 159 octets

NB: Ceci encode le motif. Voir mon autre réponse pour une approche mathématique plus courte.

Prend l'entrée comme (width)(height).

w=>h=>(g=h=>h?g(--h)+`
`+([4106,4016,31305,21504,17010]['0102344320'[h%=10]]+'').replace(/./g,c=>'\\/'[c^h>5]||''.padEnd(c-1)).repeat(w+1).slice(8):'')(h*10+2)

Essayez-le en ligne!

Comment?

Nous encodons la moitié supérieure du motif avec des chiffres:

  • 0 signifie\
  • 1 signifie/
  • n=2 à7 signifien−1 espaces

Cela donne:

0  ···/\·····  -->  [3 spaces] [/] [\] [5 spaces]             -->  4106
1  ···\/·····  -->  [3 spaces] [\] [/] [5 spaces]             -->  4016
0  ···/\·····  -->  [3 spaces] [/] [\] [5 spaces]             -->  4106
2  ··/··\····  -->  [2 spaces] [/] [2 spaces] [\] [4 spaces]  -->  31305
3  ·/····\···  -->  [1 space] [/] [4 spaces] [\] [3 spaces]   -->  21504
4  /······\/\  -->  [/] [6 spaces] [\] [/] [\]                -->  17010

Pour la moitié inférieure, nous utilisons les lignes 4,3,2,0 avec /et \inversé.

— Arnauld
source
6

JavaScript (ES6), 139 octets

Cela utilise une approche assez différente de ma réponse initiale, donc je poste ceci séparément.

Prend l'entrée comme (width)(height).

w=>h=>(g=x=>y>8?` /\\
`[a=(x+y*9)%10,d=(x+y)%10,x?(y%10>3&&2*(a==8)|d==5)|(y%10<6&&2*(a==6)|d==7):3]+g(x--?x:--y&&w):'')(w=w*10+2,y=-~h*10)

Essayez-le en ligne!

Comment?

Compte tenu de la largeur w et de la hauteur h , nous dessinons la sortie caractère par caractère sur une grille qui est:

  • 10w+3 caractères de large
  • 10h+2 caractères de haut

avec x allant de 10w+2 à 0 (de gauche à droite) et y allant de 10h+10 à 9 (de haut en bas).

Exemple pour w=3 et h=2 :

(32,30)(31,30)…(0,30)(32,29)(31,29)(0,29)⋮⋱⋮(32,9)(31,9)…(0,9)

x=0 ) sont simplement remplies de sauts de ligne.

Pour toutes les autres cellules, nous calculons:

  • a=(x−y)mod10
  • d=(x+y)mod10

Nous dessinons un "/"si:

((ymod10)>3 and d=5) or ((ymod10)<6 and d=7)

 y  | y % 10 | output (w = 3, h = 1)
----+--------+----------------------------------
 20 |    0   | ...../........./........./......
 19 |    9   | ....../........./........./.....
 18 |    8   | ...../........./........./......
 17 |    7   | ..../........./........./.......
 16 |    6   | .../........./........./........
 15 |    5   | /./......././......././......./.
 14 |    4   | ./......././......././......././
 13 |    3   | ......../........./........./...
 12 |    2   | ......./........./........./....
 11 |    1   | ....../........./........./.....
 10 |    0   | ...../........./........./......
  9 |    9   | ....../........./........./.....

Nous dessinons un "\"si:

((ymod10)>3 and a=8) or ((ymod10)<6 and a=6)

 y  | y % 10 | output (w = 3, h = 1)
----+--------+----------------------------------
 20 |    0   | ......\.........\.........\.....
 19 |    9   | .....\.........\.........\......
 18 |    8   | ......\.........\.........\.....
 17 |    7   | .......\.........\.........\....
 16 |    6   | ........\.........\.........\...
 15 |    5   | .\.......\.\.......\.\.......\.\
 14 |    4   | \.\.......\.\.......\.\.......\.
 13 |    3   | ...\.........\.........\........
 12 |    2   | ....\.........\.........\.......
 11 |    1   | .....\.........\.........\......
 10 |    0   | ......\.........\.........\.....
  9 |    9   | .....\.........\.........\......

Ou nous dessinons un espace si aucune de ces conditions n'est remplie.

— Arnauld
source
C'est vraiment cool.
— AdmBorkBork
— uniquement en ASCII
@Arnauld Je savais que c'était votre réponse en regardant simplement le code: D
— flawr
6

C ++ (gcc) , 137 octets

#include<cstdio>
auto p(int x,int y){int n=10,t=x=++x*n;for(++y*=n;y>8;)t>7?putchar(t<9?y--,n:t%n-y%n+4&7?t%n+y%n-5&7?32:47:92),t--:t=x;}

Essayez-le en ligne!

Explication

_______________________________
   098765432109876.... 
   9    \/    .     factor =y%10 - x10
   8    /\    .     if factor = -4 || 4. Print --> '\'  47
   7   /  \   . 
   6  /    \  .     factor =x%10+y%10;  
   5\/      \/*-.   if factor = 5 || 13 --> /  92
   4/\      /\   `.
   3  \    /       `->  * is 9,5 => \
   2   \  /      
   1    \/   
   0    /\       
   9
— AZTECCO
source
1
Invalide, pas un programme complet ni une fonction
— ASCII uniquement
1
Mais, 10/10 une très belle méthode
— ASCII uniquement
1
Quelles réponses ne sont pas exactement des programmes ou des fonctions complets? (il suffit de le demander, il a peut-être manqué cela)
— ASCII seulement
1
— ASCII uniquement le
1
159 , mais je ne sais pas si la sortie d'une fonction est valide (elle l'est probablement)
— ASCII uniquement
4

Haskell , 179 octets

k '\\'='/'
k '/'='\\'
k x=x
f x=take(10*x+2)
w#h=map(f w.cycle).f h.drop 9.cycle$(++).reverse=<<map(map k)$["\\/\\      /","   \\    / ","    \\  /  ","     \\/   ","     /\\   "]

Essayez-le en ligne!

Haskell , 181 octets

k '\\'='/'
k '/'='\\'
k x=x
f x=take(10*x+2)
w#h=map(f w.cycle).f h.drop 9.cycle$(++).reverse=<<map(map k)$map t[49200,36058,31630,30010,29038]
t 0=""
t n="\\ /"!!mod n 3:t(div n 3)

Essayez-le en ligne!

— ovs
source
1
L'utilisation de reverse.map(map k)<>idover (++).reverse=<<map(map k)vous permet d'économiser 3 octets dans les deux solutions.
— ბიმო
1
Ah, et dans le 2ème on map tpeut devenir t<$>et take$10*x+2enregistrer un autre octet aussi et enfin vous pouvez utiliser cycle"\\ /"!!nplus "\\ /"!!mod n 3- maintenant le deuxième est plus court :) Essayez-le en ligne!
— 2018
3

Charbon de bois , 24 22 20 octets

\/↘²‖Ｍ↘LＦ⊖ＮＣχ⁰Ｆ⊖ＮＣ⁰χ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

´\/↘²

Dessinez un huitième du motif d'origine.

‖Ｍ↘L

Dupliquez-le trois fois pour terminer le motif d'origine.

Ｆ⊖ＮＣχ⁰

Copiez le nombre de fois requis horizontalement.

Ｆ⊖ＮＣ⁰χ

Copiez le nombre de fois requis verticalement.

— Neil
source
3

Powershell, 146 octets

param($w,$h)0..9*$h+0,1|%{$y=$_
-join(0..9*$w+0,1|%{('3  /\33  \/33  /\33 /  \3  /3 \ /\/33\\/\33/3\3 /3  \  /33 \/3'-replace3,'   ')[$y*10+$_]})}

Explication

Le modèle est un tableau de 10 x 10 caractères:

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

Le script:

  • répète le motif;
  • ajoute des colonnes [0,1] à la fin de chaque ligne;
  • ajoute les lignes [0,1] à la fin de la sortie.

Deux choses pour le golf:

  1. Le tableau de motifs mappé sur une chaîne de 100 octets de longueur;
  2. La chaîne réduite par simple replace.
— mazzy
source
2

Perl 5 -p , 148 octets

$_='3A3'x$_.$/.'3B3
3A3
2/2\\2
1/4\\1
A6A
B6B
1\\4/1
2\\2/2
3B3
3A3
'=~s/^.*$/$&x$_/mger x<>.'3B3'x$_;s|A+|/\\|g;s|B+|\\/|g;s/\d/$"x$&/ge;s|^ |  |gm

Essayez-le en ligne!

— Xcali
source
1

PHP, 159 octets

motif tiré de mazzy; traduit en 1-2-3, converti en base26 -> décodé par le programme

while($y<$argv[2]*10+2)echo str_pad("",$argv[1]*10+2,strtr(base_convert([jng1,jnnb,jng1,jofn,k333,"1h4p5",23814,k94d,k02h,jnnb][$y++%10],26,4),312,"\ /")),"
";

nécessite PHP 5.5 ou version ultérieure. Courez avec -nrou essayez-le en ligne .

le calcul peut être plus court (comme c'était le cas pour Arnauld). Je peux examiner cela.

— Titus
source
1

Kotlin , 196 135 octets

Économie de 61 octets grâce à la suggestion ASCII uniquement d'utiliser l'algorithme C ++ d'AZTECCO.

{h,w->var r=""
for(l in 9..h*10+10){for(c in 9..w*10+10){r+=when{(l%10+c%10)%8==5->'/'
(l%10-c%10+8)%8==4->'\\'
else->' '}}
r+='\n'}
r}

Essayez-le en ligne!

— JohnWells
source
1
136 , vol de la nouvelle réponse C ++
— ASCII uniquement
1

Python 3 , 194 192 192 187 127 octets

@ Solution ASCII uniquement:

lambda w,h,n=10:"\n".join("".join([" /","\\"][(j%n-i%n)%8==4][(j%n+i%n)%8==5]for i in range(-1,w*n+1))for j in range(-1,h*n+1))

Essayez-le en ligne!

Solution originale

n="\n"
def f(w,h):a=[r"     /\   "*w,r"     \/   "*w,r"    \  /  "*w,r"   \    / "*w,r"\/\      /"*w+r"\/"];return a[0]+n+n.join(([i.translate({47:92,92:47})for i in a]+a[::-1])*h)+n+a[1]

Essayez-le en ligne!

-2 octets grâce à @Black Owl Kai montrant que les hauts et les bas sont accessibles à partir du tableau généré plutôt que dans des variables distinctes.

-5 octets de plus grâce à @Black Owl Kai utilisant une manière plus créative de stocker les diamants

Génère cette portion de chaque diamant:

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

Un /\ajout à la fin de chaque ligne pour le compléter. Ensuite, les /s et les \s sont échangés pour former le haut de chaque diamant, et l'ordre des lignes est inversé pour former la moitié inférieure. Enfin, il ajoute la toute dernière rangée de /\s et la toute dernière rangée de \/s pour compléter l'image.

— Neil A.
source
192 octets en n'utilisant pas les variables b et c
— Black Owl Kai
187 octets en supprimant deux +=/*= affectations et en retournant le diamant entier à l'envers, ce qui rend la dernière chaîne plus facile à stocker
— Black Owl Kai
181
— uniquement en ASCII
147 , utilise une solution c ++
— ASCII uniquement
127
— ASCII uniquement
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.