Étant donné un entier non négatif, imprimez un Xqui est si grand. Xest la sortie pour l'entrée 0, et vous ajouterez des barres obliques égales à l'entrée dans chaque direction pour étendre les Xentrées plus grandes.

Cas de test

0

X

1

\ /
 X
/ \

2

\   /
 \ /
  X
 / \
/   \

...

dix

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

Règles

Vous pouvez soit imprimer la sortie, soit renvoyer une chaîne ou une liste de chaînes à partir d'une fonction. Une nouvelle ligne de fin, ainsi que des espaces intérieurs supplémentaires qui n'affectent pas l'apparence, sont autorisés.

C'est le golf de code , donc la réponse la plus courte en octets gagne!

Canevas , 3 octets

╵＼┼

Essayez-le ici!

la moitié de la taille de la réponse au fusain: 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`

Fusain , 6 octets

ＰX⁺¹ＮX

Vos bêtises ne m'arrêtent pas;)

Essayez-le en ligne!

JavaScript (ES6), 79 octets

Utilise une fonction récursive g qui parcourt une grille et construit le caractère de sortie par caractère.

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)

Comment?

Les variables x et y itèrent de 2n à -1 , où n est l'entrée.

Pour chaque position (x, y) dans la grille, nous choisissons l'un de ces caractères:

• 0: /
• 1: \
• 2: espace
• 3: X
• 4: nouvelle ligne

en utilisant les tests suivants:

• ~x: Faux si x == -1 : nous avons atteint la fin de la ligne.
• x-y: Faux si x == y : nous sommes situés sur l'anti-diagonale.
• x+y-w: Faux si x + y == w : nous sommes situés sur la diagonale.
• x-n: Faux si x == n : parce que ce test n'est effectué que lorsque x == y , cela signifie que nous sommes situés au centre exact de la grille.

et l'arbre de décision suivant:

Démo

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 octets

'\/X 'iEQXytEP+)

Essayez-le en ligne!

Considérez l'entrée 2comme exemple. La pile est montrée ici à l'envers, c'est-à-dire que les éléments inférieurs sont les derniers poussés.

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

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

Essayez-le en ligne!

(−2 golf grâce à MD XF)

Il imprime deux caractères (au début, c = 47qui est une barre oblique et c + 45, qui est une barre oblique inverse, puis ils sont échangés) avec une largeur de champ dynamique.

Les largeurs de champ commencent à 1et 2n, et à chaque itération, la première largeur est incrémentée de 1 et la seconde est décrémentée de 2.

Lorsque la deuxième largeur de champ devient 0, elle génère 'X'une nouvelle ligne au lieu des caractères normaux et inverse la direction des incréments ( i). Une nouvelle ligne est imprimée séparément pour toutes les autres lignes ( puts("")).

shortC , 111 octets

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

Sur la base de ma réponse C . Conversions:

• R -> printf(
• P -> putchar(
• W -> while(
• O -> for(
• Fermeture insérée automatiquement ");}

Cela utilise également des codes ASCII pour \et /.

Essayez-le en ligne!

Python 2 , 81 octets

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

Essayez-le en ligne!

C, 168 155 150 octets

^{-5 grâce à 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");}

Peut certainement être joué au golf; Je le fais. Essayez-le en ligne!

Non 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 octets

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

Essayez-le en ligne!

Hexdump:

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

Explication:

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

Essentiellement, nous avons Insérer un X, n fois étendre les barres obliques .

Mais ce n'est pas aussi simple que cela, car nous devons également ajouter les barres obliques la première fois. Si les barres obliques étaient déjà là, nous pourrions écrire étendre les barres obliques comme suit :

>HÄX2pGÙX2p

Ce qui nous ferait économiser 6 octets.

C #, 157 122 120 octets

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

Version non golfée:

 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 octets

(Partiellement inspiré par la solution de 104 octets de Jenny_mathy)

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

Renvoie une liste de chaînes.

Explication: IdentityMatrix[2#+1]crée une matrice de la bonne taille avec 1s le long de la diagonale et 0s ailleurs. Ensuite, nous le multiplions par "\\"(une barre oblique inversée), ce qui en fait une matrice avec des barres obliques inverses le long de la diagonale et 0s ailleurs, car bien sûr, 1 fois la barre oblique inverse est la barre oblique inverse et 0 fois la barre oblique inverse est 0. Nous ajoutons ceci aux "/"fois son inverse pour faire la forme en X. Nous avons presque terminé, sauf qu'il y a toujours des 0 partout, et le milieu l'est "\\" + "/". Nous corrigeons ces deux choses en remplaçant " "par 0et "X"pour a_+_, ce qui correspond à n'importe quelle somme de deux choses (comme _+_devrait, sauf que Mathematica est trop intelligent pour son propre bien et l'interprète comme 2 fois _). Enfin, ""<>#&/@transforme cela en une liste de chaînes.

Java (OpenJDK 8) , 135 octets

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

Expression lambda qui prend et entier et renvoie un tableau de chaînes

Essayez-le en ligne!

Non 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 octets

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

Formaté:

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'entrée se fait via la colonne a dans le tableau nommé t , selon nos directives .

Rubis , 66 octets

Fonction récursive.

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

Essayez-le en ligne!

Explication

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)

Gelée , 24 17 octets

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

Essayez-le en ligne!

Comment ça marche

Ḥ‘=þ`µḤ+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 octets grâce à @LeakyNun et -1 octet avec une amélioration supplémentaire

Lot, 201 octets

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

Commence par construire la ligne supérieure, puis après avoir imprimé chaque ligne, déplace l' \espace de droite et l' /espace de gauche une fois, en s'assurant qu'ils forment un Xau milieu.

PHP , 115 octets

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;

Essayez-le en ligne!

Rétine , 74 octets

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

Essayez-le en ligne! Explication:

.+
$* X

Placez le X.

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

En commençant par le X, en remontant, placez une \diagonale à gauche à chaque fois. Placez également /deux espaces de plus après la /dernière fois.

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

En commençant par le X, en descendant, placez une /diagonale à gauche à chaque fois. Placez également \deux espaces de plus après la /dernière fois.

m` (\W)$
$1

Le nombre d'espaces entre les deux diagonales doit être impair, donc le dernier espace sur chaque ligne (sauf la Xligne d' origine ) est supprimé.

Mathematica, 131 octets

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

Mathematica, 104 octets

voici une autre approche utilisant 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 octets

Requiert ⎕IO←0ce qui est par défaut sur de nombreux systèmes.

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

Essayez-le en ligne!

' \/'[… ] Indexez la chaîne avec

 ⎕ obtenir une entrée

 2× multiplier par deux

 1+ ajoute un

 ⍳ que de nombreux entiers

 ∘.=⍨ table d'égalité (ie matrice d'identité; diagonale NW-SE)

 (… ) Appliquer la fonction tacite suivante sur ce

  ⊢ l'argument

  + plus

  2× Deux fois

  ⌽ l'argument en miroir horizontal (ie diagonale NE-SW)

Bash , 138 octets

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

Essayez-le en ligne!

Vraiment long, bash chauffe '\ et /'

Moins 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 octets

-10 octets grâce à @FelipeNardiBatista

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

Essayez-le en ligne!

05AB1E , 21 octets

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

Essayez-le en ligne!

Perl 5, 110 + 1 = 111 octets

Utilise le -ndrapeau.

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

QBIC , 90 octets

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

Comment fonctionne cette monstruosité, est laissé comme un exercice pour le lecteur ...

Exemple de sortie:

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

Visual Basic.Net , 454 450 octets

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

Je ne sais pas si faire un func pour writelinesauvera quelques octets grâce à Stephen S pour pointer vers la as ...suppression également changé integeren object dernière édition changé la première en arrière

05AB1E , 22 octets

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

Essayez-le en ligne!

Explication

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

Solution alternative de 22 octets

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

Pyke, 14 octets

\XQV.X \   /\/

Essayez-le ici!

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

démo

Situé nsur la première ligne.

Peut-être que je peux jouer au golf plus en utilisant une approche récursive

R , 75 72 octets

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

Inspiré par cette réponse , génère une matrice implicite et l'écrit sur stdout; lit la taille depuis stdin. Il doit construire une matrice de caractères d'espace et utilise sep=''b / c sinon il a des problèmes d'espacement.

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

Essayez-le en ligne!