24

El siguiente patrón formará la base de este desafío.

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

Dado un ancho y una altura de entrada, cada uno >=1, genera el patrón de arte ASCII anterior repetido tantas veces, uniéndose (y superponiéndose) en los diamantes pequeños.

Por ejemplo, aquí hay una entrada con width = 2y height = 1:

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

Aquí hay una entrada width = 3y height = 2:

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

Reglas y E / S

La entrada y salida se pueden dar por cualquier método conveniente .
Puede imprimirlo en STDOUT o devolverlo como resultado de una función.
Un programa completo o una función son aceptables.
Cualquier cantidad de espacios en blanco extraños es aceptable, siempre y cuando los caracteres se alineen apropiadamente.
Las lagunas estándar están prohibidas.
Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

code-golf ascii-art AdmBorkBork
fuente

1

Relacionado libremente

Luis Mendo

10

Lienzo , 26 25 24 21 18 bytes

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

Pruébalo aquí!

-3 bytes arreglando el ｍlienzo no repetido

Explicación:

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
fuente

wow O_o canvas es demasiado corto

solo ASCII

6

JavaScript (ES8), 167 161 159 bytes

^{NB: Esto codifica el patrón. Vea mi otra respuesta para un enfoque matemático más corto.}

Toma entrada como (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)

Pruébalo en línea!

¿Cómo?

Codificamos la mitad superior del patrón con dígitos:

$0$ significa\
$1$ significa/
$n=2$ a $7$ significa $n-1$ espacios

Esto da:

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

Para la mitad inferior, usamos las filas $4,3,2,0$ con /e \invertidas.

Arnauld
fuente

6

JavaScript (ES6), 139 bytes

Esto está usando un enfoque bastante diferente de mi respuesta inicial, así que estoy publicando esto por separado.

Toma entrada como (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)

Pruébalo en línea!

¿Cómo?

Dado el ancho $w$ la altura $h$ , dibujamos el carácter de salida por carácter sobre una cuadrícula que es:

$10w+3$ caracteres de ancho
$10h+2$ caracteres de altura

$x$ $10w+2$ $0$ $y$ $10h+10$ $9$

$w=3$ $h=2$

\begin{matrix} (32, 30) & (31, 30) & ... & (0 0, 30) \\ (32, 29) & (31, 29) & (0 0, 29) \\ ⋮ & ⋱ & ⋮ \\ (32, 9 9) & (31, 9 9) & ... & (0 0, 9 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$

Para todas las demás celdas, calculamos:

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

Dibujamos un "/"if:

((y mod 10) > 3 y re = 5 5) o ((y mod 10) < 6 6 y re = 7 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   | ....../........./........./.....

Dibujamos un "\"if:

((y mod 10) > 3 y una = 8) o ((y mod 10) < 6 6 y una = 6 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   | .....\.........\.........\......

O dibujamos un espacio si ninguna de estas condiciones se cumple.

Arnauld
fuente

Esto es realmente genial.

AdmBorkBork

111 usando la respuesta C ++?

Solo ASCII el

@Arnauld Sabía que esta era tu respuesta con solo mirar el código: D

falla

6

C ++ (gcc) , 137 bytes

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

Pruébalo en línea!

Explicación

_______________________________
   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
fuente

1

No es válido, no es un programa completo ni una función

solo ASCII el

1

Pero 10/10 es un método muy bueno

solo ASCII el

1

¿Qué respuestas exactamente no son programas o funciones completos? (solo preguntando, puede haberlo pasado por alto) Tenga en cuenta que algunos idiomas (p. ej., lenguajes de secuencias de comandos) no necesitan repeticiones para los programas completos

solo ASCII el

1

Creo que es necesario incluir el#include

ASCII de sólo

1

159 , pero no estoy seguro si la salida de una función es válida (probablemente lo sea)

solo ASCII el

4

Haskell , 179 bytes

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)$["\\/\\      /","   \\    / ","    \\  /  ","     \\/   ","     /\\   "]

Pruébalo en línea!

Haskell , 181 bytes

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)

Pruébalo en línea!

ovs
fuente

1

Usar reverse.map(map k)<>idover le (++).reverse=<<map(map k)ahorra 3 bytes en ambas soluciones.

ბიმო

1

Ah, y en el segundo uno map tpuede llegar a ser t<$>y take$10*x+2ahorra otro byte demasiado y, finalmente, se puede utilizar cycle"\\ /"!!nsobre "\\ /"!!mod n 3- ahora el segundo es más corto :) Pruébelo en línea!

ბიმო

3

Carbón , 24 22 20 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

´\/↘²

Dibuja una octava parte del patrón original.

‖Ｍ↘L

Duplícalo tres veces para completar el patrón original.

Ｆ⊖ＮＣχ⁰

Copie el número requerido de veces horizontalmente.

Ｆ⊖ＮＣ⁰χ

Copie el número requerido de veces verticalmente.

Neil
fuente

3

Powershell, 146 bytes

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+$_]})}

Explicación

El patrón es una matriz de 10x10 caracteres:

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

La secuencia de comandos:

repite el patrón;
agrega columnas [0,1] al final de cada línea;
agrega líneas [0,1] al final de la salida.

Dos cosas para el golf:

La matriz de patrones asignada a una cadena con una longitud de 100 bytes;
La cadena reducida por simple replace.

mazzy
fuente

2

Perl 5 `-p` , 148 bytes

$_='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

Pruébalo en línea!

Xcali
fuente

1

PHP, 159 bytes

patrón tomado de mazzy; traducido a 1-2-3, convertido a base26 -> decodificado por el programa

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,"\ /")),"
";

requiere PHP 5.5 o posterior. Ejecutar -nro probarlo en línea .

el cálculo puede ser más corto (como lo fue para Arnauld). Puedo investigar eso.

Titus
fuente

1

Kotlin , 196 135 bytes

Ahorró 61 bytes gracias a la sugerencia de ASCII-only de usar el algoritmo C ++ de 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}

Pruébalo en línea!

JohnWells
fuente

1

136 , robando de la nueva respuesta de C ++

solo ASCII el

1

Pitón 3 , 194 192 187 127 bytes

La solución de @ ASCII-only:

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

Pruébalo en línea!

Solución original

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]

Pruébalo en línea!

-2 bytes gracias a @Black Owl Kai que muestra que se puede acceder a las partes superior e inferior desde la matriz generada en lugar de hacerlo en variables separadas.

-5 bytes más gracias a @Black Owl Kai usando una forma más creativa para almacenar los diamantes

Genera esta porción de cada diamante:

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

A /\agregado al final de cada fila para completarlo. A continuación, las /s y \s se intercambian para formar la parte superior de cada diamante, y el orden de las líneas se invierte para formar la mitad inferior. Finalmente, agrega en la fila superior de /\sy la fila inferior de\/ s para completar la imagen.

Neil A.
fuente

192 bytes al no usar las variables byc

Black Owl Kai

187 bytes eliminando dos +=/ *=asignaciones y volteando todo el diamante al revés, haciendo que la última cadena sea más fácil de almacenar

Black Owl Kai

181

Solo ASCII el

147 , usa solución c ++

solo ASCII

127

ASCII solo el

Dibuja este patrón de diamantes

Reglas y E / S

Respuestas:

Lienzo , 26 25 24 21 18 bytes

JavaScript (ES8), 167 161 159 bytes

¿Cómo?

JavaScript (ES6), 139 bytes

¿Cómo?

C ++ (gcc) , 137 bytes

Haskell , 179 bytes

Haskell , 181 bytes

Carbón , 24 22 20 bytes

Powershell, 146 bytes

Explicación

Perl 5 `-p` , 148 bytes

PHP, 159 bytes

Kotlin , 196 135 bytes

Pitón 3 , 194 192 187 127 bytes

Dibuja este patrón de diamantes

Reglas y E / S

Respuestas:

Lienzo , 26 25 24 21 18 bytes

JavaScript (ES8), 167 161 159 bytes

¿Cómo?

JavaScript (ES6), 139 bytes

¿Cómo?

C ++ (gcc) , 137 bytes

Haskell , 179 bytes

Haskell , 181 bytes

Carbón , 24 22 20 bytes

Powershell, 146 bytes

Explicación

Perl 5 -p , 148 bytes

PHP, 159 bytes

Kotlin , 196 135 bytes

Pitón 3 , 194 192 187 127 bytes

Perl 5 `-p` , 148 bytes