Dato un numero intero non negativo, stampane uno Xcosì grande. Xè l'output per l'input 0e si aggiungono barre uguali all'input in ciascuna direzione per estendere l' Xinput per input più grandi.

Casi test

0

X

1

\ /
 X
/ \

2

\   /
 \ /
  X
 / \
/   \

...

10

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

Regole

È possibile stampare l'output o restituire una stringa o un elenco di stringhe da una funzione. È consentita una nuova riga finale, oltre a spazi bianchi interni extra che non influiscono.

Questo è code-golf , quindi vince la risposta più breve in byte!

Tela , 3 byte

╵＼┼

Provalo qui!

metà delle dimensioni della risposta al carbone: 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`

Carbone , 6 byte

ＰX⁺¹ＮX

Le tue sciocchezze non mi fermano;)

Provalo online!

JavaScript (ES6), 79 byte

Utilizza una funzione ricorsiva g che attraversa una griglia e crea il carattere di output per carattere.

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)

Come?

Entrambe le variabili x ed y iterare da 2n a -1 , dove n è l'ingresso.

Per ogni posizione (x, y) nella griglia, scegliamo uno di questi caratteri:

• 0: /
• 1: \
• 2: spazio
• 3: X
• 4: newline

utilizzando i seguenti test:

• ~x: Falsy se x == -1 : abbiamo raggiunto la fine della linea.
• x-y: Falsy se x == y : ci troviamo sull'anti-diagonale.
• x+y-w: Falsa se x + y == w : siamo situati sulla diagonale.
• x-n: Falsy se x == n : poiché questo test viene eseguito solo quando x == y , ciò significa che ci troviamo esattamente al centro della griglia.

e il seguente albero decisionale:

dimostrazione

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 byte

'\/X 'iEQXytEP+)

Provalo online!

Considera l'input 2come esempio. La pila è mostrata qui sottosopra, ovvero gli elementi inferiori sono quelli spinti più di recente.

'\/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 byte

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

Provalo online!

(−2 golf grazie a MD XF)

Stampa due caratteri (all'inizio, c = 47che è una barra e c + 45, che è una barra rovesciata; poi vengono scambiati) con una larghezza di campo dinamica.

Le larghezze dei campi iniziano da 1e 2n, e ad ogni iterazione, la prima larghezza viene incrementata di 1 e la seconda viene diminuita di 2.

Quando la larghezza del secondo campo diventa 0, viene emessa 'X'una nuova riga anziché i caratteri normali e inverte la direzione degli incrementi ( i). Viene stampata una nuova riga per tutte le altre righe separatamente ( puts("")).

shortC , 111 byte

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

Sulla base di mia risposta C . conversioni:

• R -> printf(
• P -> putchar(
• W -> while(
• O -> for(
• Chiusura inserita automaticamente ");}

Questo utilizza anche codici ASCII per \e /.

Provalo online!

Python 2 , 81 byte

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

Provalo online!

C, 168 155 150 byte

^{-5 grazie al Computronio}

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

Può certamente essere giocato a golf; Lo sto facendo. Provalo online!

Ungolfed:

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 byte

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

Provalo online!

hexdump:

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

Spiegazione:

é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 '\'

In sostanza, abbiamo inserire una X, n volte estendono le barre .

Ma non è così semplice perché dobbiamo anche aggiungere le barre la prima volta. Se le barre erano già lì, potremmo scrivere estendere le barre come:

>HÄX2pGÙX2p

Il che ci farebbe risparmiare 6 byte.

C #, 157 122 120 byte

_=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;}

Versione non golfata:

 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 byte

(Parzialmente ispirato alla soluzione da 104 byte di Jenny_mathy)

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

Restituisce un elenco di stringhe.

Spiegazione: IdentityMatrix[2#+1]crea una matrice della giusta dimensione con 1s lungo la diagonale e 0s altrove. Successivamente, lo moltiplichiamo per "\\"(una barra rovesciata di escape), che lo rende una matrice con barre rovesciate lungo la diagonale e 0s altrove, poiché ovviamente 1 volte la barra rovesciata è barra rovesciata e 0 volte la barra rovesciata è 0. Aggiungiamo questo a "/"volte il suo rovescio per renderlo la forma a X. Abbiamo quasi finito, tranne che ci sono ancora 0 dappertutto e il centro è "\\" + "/". Risolviamo queste due cose sostituendo " "for 0e "X"for a_+_, che corrisponde a qualsiasi somma di due cose (come _+_dovrebbe, tranne Mathematica è troppo intelligente per il suo bene e lo interpreta come 2 volte _). Infine, ""<>#&/@trasforma questo in un elenco di stringhe.

Java (OpenJDK 8) , 135 byte

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

Espressione lambda che accetta e integer e restituisce una matrice di stringhe

Provalo online!

Ungolfed:

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 byte

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

formattato:

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

L'input avviene tramite la colonna a nella tabella t indicata , secondo le nostre linee guida .

Rubino , 66 byte

Funzione ricorsiva.

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

Provalo online!

Spiegazione

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)

Gelatina , 24 17 byte

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

Provalo online!

Come funziona

Ḥ‘=þ`µḤ+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 byte grazie a @LeakyNun e -1 byte con un ulteriore miglioramento

Lotto, 201 byte

@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: /=/ %

Inizia costruendo la riga superiore, quindi dopo aver stampato ciascuna riga, sposta \uno spazio a destra e uno a /sinistra una volta, assicurandosi che formino una riga Xnel mezzo.

PHP , 115 byte

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;

Provalo online!

Retina , 74 byte

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

Provalo online! Spiegazione:

.+
$* X

Posiziona il X.

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

Partendo da X, lavorando verso l'alto, posiziona una \diagonale a sinistra ogni volta. Posiziona anche /altri due spazi dopo l' /ultima volta.

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

Partendo da X, lavorando verso il basso, posiziona una /diagonale a sinistra ogni volta. Posiziona anche \altri due spazi dopo l' /ultima volta.

m` (\W)$
$1

Il numero di spazi tra le due diagonali deve essere dispari, quindi l'ultimo spazio su ciascuna linea (tranne la Xlinea originale ) viene eliminato.

Mathematica, 131 byte

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

Mathematica, 104 byte

ecco un altro approccio che usa 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 byte

Richiede il ⎕IO←0valore predefinito su molti sistemi.

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

Provalo online!

' \/'[... ] indicizza la stringa con

 ⎕ ottenere input

 2× moltiplicare per due

 1+ Aggiungi uno

 ⍳ di molti numeri interi

 ∘.=⍨ tabella di uguaglianza (cioè matrice di identità; diagonale NW-SE)

 (... ) applica la seguente funzione tacita

  ⊢ l'argomento

  + più

  2× due volte

  ⌽ l'argomento con mirroring orizzontale (ovvero diagonale NE-SW)

Bash , 138 byte

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 /\\

Provalo online!

Davvero lungo, bash riscalda '\ e /'

Meno 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 byte

-10 byte grazie a @FelipeNardiBatista

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

Provalo online!

05AB1E , 21 byte

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

Provalo online!

Perl 5, 110 + 1 = 111 byte

Usa la -nbandiera.

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

QBIC , 90 byte

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

Come funziona questa mostruosità, viene lasciato come un esercizio per il lettore ...

Uscita campione:

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

Visual Basic.Net , 454 450 byte

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

non so se fare un func per writelinesalverà alcuni byte grazie a Stephen S per indicando as ...la rimozione cambiato anche integerin object ultima modifica cambiato il primo uno indietro

05AB1E , 22 byte

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

Provalo online!

Spiegazione

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

Soluzione alternativa a 22 byte

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

Pyke, 14 byte

\XQV.X \   /\/

Provalo qui!

\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 / \\

dimostrazione

Impostato n sulla prima riga.

Forse posso giocare a golf di più usando un approccio ricorsivo

R , 75 72 byte

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

Ispirato da questa risposta , genera una matrice implicita e la scrive su stdout; legge la dimensione da stdin. Deve costruire una matrice di caratteri spaziali e usa il sep=''b / c, altrimenti ha problemi di spaziatura.

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

Provalo online!