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

1

Lâchement lié

Luis Mendo

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
la 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$ signifie $n-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
la 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$ :

\begin{matrix} (32, 30) & (31, 30) & \dots & (0, 30) \\ (32, 29) & (31, 29) & (0, 29) \\ ⋮ & ⋱ & ⋮ \\ (32, 9) & (31, 9) & \dots & (0, 9) \end{matrix}

$\begin{matrix}(32,30)&(31,30)&\dots&(0,30)\\ (32,29)&(31,29)&&(0,29)\\ \vdots&&\ddots&\vdots\\ (32,9)&(31,9)&\dots&(0,9)\end{matrix}$

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

Pour toutes les autres cellules, nous calculons:

$a=(x-y)\bmod 10$
$d=(x+y)\bmod 10$

Nous dessinons un "/"si:

((y mod 10) > 3 and d = 5) or ((y mod 10) < 6 and d = 7)

$((y\bmod 10)>3\text{ and }d=5)\text{ or }((y\bmod 10)<6\text{ 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:

((y mod 10) > 3 and a = 8) or ((y mod 10) < 6 and a = 6)

$((y\bmod 10)>3\text{ and }a=8)\text{ or }((y\bmod 10)<6\text{ 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
la source

C'est vraiment cool.

AdmBorkBork

111 en utilisant la réponse C ++?

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

Je pense que vous devez inclure le#include

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

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

mazzy
la 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
la 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
la 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
la 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.
la 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

Dessinez ce motif de diamant

Règles et E / S

Réponses:

Toile , 26 25 24 21 18 octets

JavaScript (ES8), 167 161 159 octets

Comment?

JavaScript (ES6), 139 octets

Comment?

C ++ (gcc) , 137 octets

Haskell , 179 octets

Haskell , 181 octets

Charbon de bois , 24 22 20 octets

Powershell, 146 octets

Explication

Perl 5 `-p` , 148 octets

PHP, 159 octets

Kotlin , 196 135 octets

Python 3 , 194 192 192 187 127 octets

Dessinez ce motif de diamant

Règles et E / S

Réponses:

Toile , 26 25 24 21 18 octets

JavaScript (ES8), 167 161 159 octets

Comment?

JavaScript (ES6), 139 octets

Comment?

C ++ (gcc) , 137 octets

Haskell , 179 octets

Haskell , 181 octets

Charbon de bois , 24 22 20 octets

Powershell, 146 octets

Explication

Perl 5 -p , 148 octets

PHP, 159 octets

Kotlin , 196 135 octets

Python 3 , 194 192 192 187 127 octets

Perl 5 `-p` , 148 octets