Dado un número entero no negativo, imprima uno Xque sea tan grande. Xes la salida para la entrada 0, y agregará barras diagonales iguales a la entrada en cada dirección para extender las Xentradas más grandes.

Casos de prueba

0 0

X

1

\ /
 X
/ \

2

\   /
 \ /
  X
 / \
/   \

...

10

\                   /
 \                 /
  \               /
   \             /
    \           /
     \         /
      \       /
       \     /
        \   /
         \ /
          X
         / \
        /   \
       /     \
      /       \
     /         \
    /           \
   /             \
  /               \
 /                 \
/                   \

Reglas

Puede imprimir la salida o devolver una cadena o lista de cadenas desde una función. Se permite una nueva línea final, así como un espacio en blanco interior adicional que no afecta la aparición.

Este es el código de golf , ¡así que la respuesta más corta en bytes gana!

Lienzo , 3 bytes.

╵＼┼

Pruébalo aquí!

la mitad del tamaño de la respuesta de carbón: D

╵    increment the input
 \   create a diagonal that long
  ┼  and quad-palindromize, mirroring what's required, with 1 overlap;
     This overlaps the `/` and `\`, resulting in `X`

Carbón de leña , 6 bytes

ＰX⁺¹ＮX

Tu tontería no me detiene;)

Pruébalo en línea!

JavaScript (ES6), 79 bytes

Utiliza una función recursiva g que recorre una cuadrícula y construye la salida carácter por carácter.

n=>(g=x=>`/\\ X
`[~x?x-y?x+y-w&&2:x-n?1:3:4]+(~y?g(~x--?x:y--&&w):''))(y=w=n*2)

¿Cómo?

Ambas variables x e y iteran de 2n a -1 , donde n es la entrada.

Para cada posición (x, y) en la cuadrícula, elegimos uno de estos caracteres:

• 0: /
• 1: \
• 2: espacio
• 3: X
• 4: nueva línea

utilizando las siguientes pruebas:

• ~x: Falsy si x == -1 : hemos llegado al final de la línea.
• x-y: Falsy si x == y : estamos ubicados en la antia diagonal.
• x+y-w: Falsy si x + y == w : estamos ubicados en la diagonal.
• x-n: Falsy si x == n : debido a que esta prueba solo se realiza cuando x == y , esto significa que estamos ubicados en el centro exacto de la cuadrícula.

y el siguiente árbol de decisión:

Manifestación

let f =

n=>(g=x=>`/\\ X
`[~x?x-y?x+y-w&&2:x-n?1:3:4]+(~y?g(~x--?x:y--&&w):''))(y=w=n*2)

console.log(f(0))
console.log(f(1))
console.log(f(4))

MATL , 16 bytes

'\/X 'iEQXytEP+)

Pruébalo en línea!

Considere la entrada 2como un ejemplo. La pila se muestra aquí al revés, es decir, los elementos inferiores son los que se empujaron más recientemente.

'\/X '  % Push this string
        %   STACK: '\/X '
iEQ     % Input a number, n. Multiply by 2, add 1: gives 2*n+1
        %   STACK: '\/X '
                   5
Xy      % Identity matrix of that size
        %   STACK: '\/X '
                   [1 0 0 0 0;
                    0 1 0 0 0;
                    0 0 1 0 0;
                    0 0 0 1 0;
                    0 0 0 0 1]
tEP     % Duplicate, multiply each entry by 2, flip vertically
        %   STACK: '\/X '
                   [1 0 0 0 0;
                    0 1 0 0 0;
                    0 0 1 0 0;
                    0 0 0 1 0;
                    0 0 0 0 1]
                   [0 0 0 0 2;
                    0 0 0 2 0;
                    0 0 2 0 0;
                    0 2 0 0 0;
                    2 0 0 0 0]
+       % Add the two matrices
        %   STACK: '\/X '
                   [1 0 0 0 2;
                    0 1 0 2 0;
                    0 0 3 0 0;
                    0 2 0 1 0;
                    2 0 0 0 1]
)       % Index into the string. Indexing is 1-based and modular, so 1 picks
        % the first character ('\'), ..., 0 picks the last (space)
        %   STACK: ['\   /';
                    ' \ / ';
                    '  X  ';
                    ' / \ ';
                    '/   \']
        % Implicit display

C, 108 106 bytes

a;g(n){for(int b=2*n,i=1,c=47;a+=i;b?puts(""):(i=-i,c=92),b-=2*i)printf("%*c%*c",a,b?c+45*i:88,b,b?c:10);}

Pruébalo en línea!

(−2 golf gracias a MD XF)

Imprime dos caracteres (al principio, c = 47que es una barra diagonal y c + 45una barra invertida; luego se intercambian) con un ancho de campo dinámico.

Los anchos de campo comienzan en 1y 2n, y en cada iteración, el primer ancho se incrementa en 1, y el segundo se reduce en 2.

Cuando el ancho del segundo campo se convierte en 0, genera 'X'una nueva línea en lugar de los caracteres regulares e invierte la dirección de los incrementos ( i). Se imprime una nueva línea para todas las demás líneas por separado ( puts("")).

shortC , 111 bytes

s(x){Wx--)R" ")}j;f(x){O;j<x;j++)s(j),P92),s((x-j)*2-1),R"/\n");s(x);R"X\n");Wj--)s(j),P47),s((x-j)*2-1),R"\\\n

Sobre la base de mi respuesta C . Conversiones:

• R -> printf(
• P -> putchar(
• W -> while(
• O -> for(
• Cierre de inserción automática ");}

Esto también usa códigos ASCII para \y /.

Pruébalo en línea!

Python 2 , 81 bytes

r=range(2*input()+1)
for i in r:print''.join(' \/X'[i==j::2][r[~i]==j]for j in r)

Pruébalo en línea!

C, 168 155 150 bytes

^{-5 gracias a Computronium}

#define p printf(
s(x){while(x--)p" ");}j;f(x){for(;j<x;j++)s(j),p"\\"),s((x-j)*2-1),p"/\n");s(x);p"X\n");while(j--)s(j),p"/"),s((x-j)*2-1),p"\\\n");}

Ciertamente se puede jugar al golf; Lo estoy haciendo Pruébalo en línea!

Sin golf:

int space(int x)
{
    while (x--)
        putchar(' ');
}

int f(int x)
{
    for (int j = 0; j < x; j++) {
        space(j);
        printf("\\");
        space((x-j)*2-1);
        printf("/\n");
    }

    space(x);
    puts("X");

    while (j--) {
        space(j);
        putchar('/');
        space((x-j)*2-1);
        printf("\\\n");
    }
}

V , 21 bytes

éXÀñ>HÄÒ r\Á/YGpr/$r\

Pruébalo en línea!

Hexdump:

00000000: e958 c0f1 3e48 c4d2 2072 5cc1 2f59 4770  .X..>H.. r\./YGp
00000010: 722f 2472 5c                             r/$r\

Explicación:

éX                      " Insert an 'X'
  Àñ                    " Arg1 times:
    >H                  "   Add a space to every line.
                        "   Conveniently, this also puts us on the first line
      Ä                 "   Duplicate this line
       Ò                "   And replace the whole line with spaces
         r\             "   Replace the first char with '\'
           Á/           "   Append a '/' char
             Y          "   Yank this line
              G         "   Move to the last line
               p        "   And paste the line we yanked
                r/      "   Replace the first character with a '/'
                  $     "   Move to the end of the line
                   r\   "   And replace the last character with a '\'

Esencialmente, tenemos Insertar una X, n veces extiende las barras .

Pero no es tan simple porque también tenemos que agregar las barras diagonales la primera vez. Si las barras ya estaban allí, podríamos escribir extender las barras como:

>HÄX2pGÙX2p

Lo que nos ahorraría 6 bytes.

C #, 157 122 120 bytes

_=d=>"".PadLeft(d)
a=>{var s=_(a)+"X\n";for(int i=0;++i<=a;)s=$@"{_(a-i)}\{_(i*2-1)}/
{s+_(a-i)}/{_(i*2-1)}\
";return s;}

Versión sin golf:

 Func<int, string> _ = (d) =>"".PadLeft(d);
        Func<int, string> func = a => {

            var s = _(a) + "X\n";

            for (int i = 0; ++i <= a;) {

                s = $@"{_(a - i)}\{_(i * 2 - 1)}/
{s + _(a - i)}/{_(i * 2 - 1)}\
";

            }
            return s;
        };

Mathematica, 71 bytes

(Parcialmente inspirado por la solución de 104 bytes de Jenny_mathy)

""<>#&/@(#"\\"+Reverse@#"/"&@IdentityMatrix[2#+1]/.{0->" ",a_+_->"X"})&

Devuelve una lista de cadenas.

Explicación: IdentityMatrix[2#+1]forma una matriz del tamaño correcto con 1s a lo largo de la diagonal y 0s en otros lugares. Luego, lo multiplicamos por "\\"(una barra invertida escapada), lo que lo convierte en una matriz con barras invertidas a lo largo de la diagonal y ceros en otra parte, ya que, por supuesto, 1 barra invertida es barra invertida y 0 veces barra invertida es 0. Agregamos esto a "/"veces su reverso para hacer La forma X. Ya casi hemos terminado, excepto que todavía hay ceros en todas partes, y el medio es "\\" + "/". Arreglamos estas dos cosas sustituyendo " "por 0y "X"por a_+_, que coincide con cualquier suma de dos cosas (como _+_debería, excepto que Mathematica es demasiado inteligente para su propio bien y lo interpreta como 2 veces _). Finalmente, ""<>#&/@convierte esto en una lista de cadenas.

Java (OpenJDK 8) , 135 bytes

i->{int k=0,j,l=2*i+1;String[]s=new String[l];for(;k<l;k++)for(s[k]="",j=0;j<l;j++)s[k]+=j==k?j==i?"X":"\\":j==l-1-k?"/":" ";return s;}

Expresión lambda que toma un número entero y devuelve una matriz de cadenas

Pruébalo en línea!

Sin golf:

i->{
    int k=0,j,l=2*i+1;                // Some variables to be used
    String[]s=new String[l];            // Return array (size 2*i+1)
    for(;k<l;k++)                       // For each array entry
        for(s[k]="",j=0;j<l;j++)        // Set each character to 
            s[k]+=j==k?j==i?"X":"\\"    // \ or X if it's the jth character of the jth row
                 :j==l-1-k?"/"          // / if it's the opposite char
                 :" ";                  // else blank
    return s;
}

T-SQL, 201 bytes

DECLARE @ INT SELECT @=a FROM t DECLARE @i INT=@
WHILE @>0BEGIN PRINT SPACE(@i-@)+'\'+SPACE(2*@-1)+'/'SET @-=1 END
PRINT SPACE(@i)+'X'WHILE @<@i BEGIN SET @+=1 PRINT SPACE(@i-@)+'/'+SPACE(2*@-1)+'\'END

Formateado:

DECLARE @ INT 
SELECT @=a FROM t 
DECLARE @i INT=@
WHILE @>0
    BEGIN
        PRINT SPACE(@i-@)+'\'+SPACE(2*@-1)+'/'
        SET @-=1 
    END
PRINT SPACE(@i)+'X'
WHILE @<@i 
    BEGIN 
        SET @+=1 
        PRINT SPACE(@i-@)+'/'+SPACE(2*@-1)+'\'
    END

La entrada es a través de la columna a en la tabla con nombre t , según nuestras pautas .

Rubí , 66 bytes

Función recursiva.

f=->x{?X[x]||"\\#{s=' '*(2*x-1)}/
#{f[x-1].gsub /^/,' '}
/#{s}\\"}

Pruébalo en línea!

Explicación

f=->x{                  # Start of recursive function named `f`
      ?X[x]||           # Return 'X' if x==0, otherwise the following:
"\\#{s=' '*(2x-1)}/     #  Top edge of the cross. Save no. of spaces needed
#{f[x-1]                #  Get result of f[x-1]
        .gsub /^/,' '}  #  Regex sub to left-pad every line w/ a space
/#{s}\\"                #  Bottom edge of cross (insert saved no. of spaces)

Jalea , 24 17 bytes

Ḥ‘=þ`µḤ+Uị“/\x ”Y

Pruébalo en línea!

Cómo funciona

Ḥ‘=þ`µḤ+Uị“/\x ”Y   main link, input a
Ḥ‘                  input doubled and incremented
   þ                Make a table: Apply  
  =                 "equals"/ to      
    `               each element in range(2a+1) cartesian multiplied with itself.
                      eg. For input 1: [1=1,1=2,1=3],[2=1,2=2,2=3],[3=1,3=2,3=3]      
     µ              on this array:
       +            add: 
      Ḥ             double of it to
        U           its reverse (changes south-east to north-west)
         ị“/\x ”    index into the string "/\x " to get the right characters
                Y   join by newlines for the final output.

-6 bytes gracias a @LeakyNun y -1 byte con una mejora adicional

Lote, 201 bytes

@echo off
set s= /
for /l %%i in (2,1,%1)do call set s=  %%s%%
set s=\%s%
for /l %%i in (-%1,1,%1)do call:c
exit/b
:c
echo %s%
set s=%s:\ = \%
set s=%s:X =/\%
set s=%s:\/=X %
set s=%s: /=/ %

Comienza construyendo la línea superior, luego, después de imprimir cada línea, mueve el \espacio derecho una vez y el /espacio izquierdo una vez, asegurándose de que hagan una Xen el medio.

PHP , 115 bytes

for(;$i<$c=1+2*$argn;$b?:$t[$i-1]="\\".!$t[$c-$i]="/",$o.="$t\n")$t=str_pad(" X"[$b=$argn==+$i++],$c," ",2);echo$o;

Pruébalo en línea!

Retina , 74 bytes

.+
$* X
+`^ ( *).( *)
$1\  $2/¶$&
+`¶ ( *).( *).?$
$&¶$1/  $2\
m` (\W)$
$1

Pruébalo en línea! Explicación:

.+
$* X

Coloque el X.

+`^ ( *).( *)
$1\  $2/¶$&

Comenzando en X, trabajando hacia arriba, coloque una \diagonal a la izquierda cada vez. También coloque /dos espacios más después de la /última vez.

+`¶ ( *).( *).?$
$&¶$1/  $2\

Comenzando en X, trabajando hacia abajo, coloque una /diagonal a la izquierda cada vez. También coloque \dos espacios más después de la /última vez.

m` (\W)$
$1

El número de espacios entre las dos diagonales debe ser impar, por lo que Xse elimina el último espacio en cada línea (excepto la línea original ).

Mathematica, 131 bytes

(F[x_,y_]:=Table[x<>StringJoin@Table[" ",i]<>y,{i,1,#*2,2}];Column[Join[Reverse@F["\\","/"],{"X"},F["/","\\"]],Alignment->Center])&

Mathematica, 104 bytes

aquí hay otro enfoque usando Grid

(S=DiagonalMatrix[Table["\\",r=2#+1]];Table[S[[r+1-i,0+i]]="/",{i,r}];S[[#+1,#+1]]="X";Grid@S/. 0->" ")&

APL (Dyalog) , 25 bytes

Requiere ⎕IO←0cuál es el predeterminado en muchos sistemas.

' \/X'[(⊢+2×⌽)∘.=⍨⍳1+2×⎕]

Pruébalo en línea!

' \/'[... ] indexar la cadena con

 ⎕ obtener entrada

 2× multiplicar por dos

 1+ Agrega uno

 ⍳ que muchos enteros

 ∘.=⍨ tabla de igualdad (es decir, matriz de identidad; diagonal NO-SE)

 (... ) aplique la siguiente función tácita en ese

  ⊢ el argumento

  + más

  2× dos veces

  ⌽ el argumento reflejado horizontalmente (es decir, diagonal NE-SW)

Bash , 138 bytes

for i in `seq $1;seq $[$1-1] -1 1`
{ $[a++]
printf "%*c%*s\n" `echo ' '$i $[a>$1?1:2] $[($1-i)*2]' '$[a<$1?1:2]`
}|sed 's/22/X/'|tr 12 /\\

Pruébalo en línea!

Muy largo, bash heates '\ y /'

Menos golf

 for i in {1..10} {9..1};{
   $[a++];                      #argument as padding, prints 1 for \ and 2 for /
   printf "%*c%*s\n" `echo ' '$i $[a>$1?1:2] $[($1-i)*2]' '$[a<$1?1:2]`;
  }|sed 's/22/X/g' | tr 12 /\\

Python 2 , 95 84 bytes

-10 bytes gracias a @FelipeNardiBatista

f=lambda s,i='\n':i+(s and'\\'+'  '*~-s+' /'+f(s-1,i+' ')+i+'/'+'  '*~-s+' \\'or'X')

Pruébalo en línea!

05AB1E , 21 bytes

F'\Nú}'X¹ú).B€.∞ø€.∞»

Pruébalo en línea!

Perl 5, 110 + 1 = 111 bytes

Utiliza -nbandera.

$x=$_;$,="\n";push@x,$"x($x-$_)."\\".$"x(2*--$_+1)."/"while$_>0;say@x,$"x$x."x";for(reverse@x){y!\\/!/\\!;say}

QBIC , 90 bytes

~b=0|?@X`\[0,:-1|X=space$(a)┘Z=Z+X+@\`+space$((b-a)*2-1)+@/`+X+@┘`]Z=Z+space$(b)+A+_fZ

Cómo funciona esta monstruosidad, se deja como ejercicio para el lector ...

Salida de muestra:

Command line: 3
\     /
 \   / 
  \ /  
   X
  / \  
 /   \ 
/     \

Visual Basic.Net , 454 450 Bytes

Option Strict Off
module m
sub main(a As String())
dim v=Convert.toInt32(a(0))
for i as Integer=v to 1 step -1
for j as Object=1 to v-i
w(" ")
next
w("\")
for j as Object=1 to i*2-1
w(" ")
next
console.writeline("/")
next
console.writeline(new String(" ",v)&"X")
for i as Object=1 to v
for j as Object=1 to v-i
w(" ")
next
w("/")
for j as Object=1 to i*2-1
w(" ")
next
console.writeline("\")
next
end sub
sub w(s)
console.write(s)
end Sub
end module

no estoy seguro de si hacer un func para writelineahorrará algunos bytes gracias a Stephen S por apuntar a la as ...eliminación también cambió integera la object última edición cambió la primera atrás

05AB1E , 22 bytes

F'\IN-úR.∞})Âí'Xs)˜.c»

Pruébalo en línea!

Explicación

F                        # for N in [0...input-1] do
 '\                      # push a backslash
   IN-ú                  # prepend input-N spaces
       R                 # reverse
        .∞               # mirror
          }              # end loop
           )             # wrap stack in a list
            Â            # bifurcate
             í           # reverse each item
              'Xs        # push an "X" between the 2 lists on the stack
                 )˜      # wrap in flattened list
                   .c    # pad lines to equal length
                     »   # join on newlines

Solución alternativa de 22 bytes

F'\N·>ú'/ì})Âí'X¸«ì.c»

Pyke, 14 bytes

\XQV.X \   /\/

Pruébalo aquí!

\X             - "X"
  QV           - repeat input times:
    .X \   /\/ -  surround(^, all=" ", 
                              tl="\", 
                              left=" ",  
                              right=" ",  
                              lower=" ",  
                              tr="/",  
                              br="\",  
                              bl="/")

tcl, 134

proc P {x s b} {time {puts [format %[incr ::i $x]s%[expr ($::n-$::i)*2+2]s $s $b]} $::n}
P 1 \\ /
puts [format %[incr i]s X]
P -1 / \\

manifestación

Establecer nen la primera línea.

Puede ser que pueda jugar más golf usando un enfoque recursivo

R , 75 72 bytes

y=diag(b<-2*scan()+1);write(c(" ",'\\','/','X')[y+2*y[,b:1]+1],'',b,,'')

Inspirado por esta respuesta , genera una matriz implícita y la escribe en stdout; lee el tamaño de stdin. Tiene que construir una matriz de caracteres de espacio y usa sep=''b / c; de lo contrario, tiene problemas de espacio.

diag(b)                     # generates a main diagonal of 1, rest 0
2*diag(b)[,b:1]             # the other diagonal is 2
                            # [,b:1] reverses columns
                            # [b:1,] reverses the rows; they're equivalent
diag(b)+2*diag(b)[,b:1]     # sums, so we get 1 for main diagonal
                            # 2 for other diagonal, 3 for center
diag(b)+2*diag(b)[,b:1]+1   # add 1 since R is 1-indexed
                            # the result is indices for the vector
c(' ','\\','/','X')

Pruébalo en línea!