Drucken Sie bei einer nicht negativen Ganzzahl eine so Xgroße Zahl aus . Xist die Ausgabe für die Eingabe 0, und Sie fügen Schrägstriche hinzu, die der Eingabe in jeder Richtung entsprechen, um die Xfür größere Eingaben zu erweitern.

Testfälle

0

X

1

\ /
 X
/ \

2

\   /
 \ /
  X
 / \
/   \

...

10

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

Regeln

Sie können entweder die Ausgabe drucken oder eine Zeichenfolge oder eine Liste von Zeichenfolgen aus einer Funktion zurückgeben. Ein abschließender Zeilenumbruch sowie zusätzliche Leerzeichen im Inneren, die sich nicht auswirken, sind zulässig.

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes!

Canvas , 3 Bytes

╵＼┼

Probieren Sie es hier aus!

halb so groß wie die Antwort von Charcoal: 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`

Holzkohle , 6 Bytes

ＰX⁺¹ＮX

Dein Unsinn hält mich nicht auf;)

Probieren Sie es online!

JavaScript (ES6), 79 Byte

Verwendet eine rekursive Funktion g , die ein Raster durchläuft und die Ausgabe zeichenweise erstellt.

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)

Wie?

Beide Variablen x und y iterieren von 2n bis -1 , wobei n die Eingabe ist.

Für jede Position (x, y) im Raster wählen wir eines der folgenden Zeichen aus:

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

unter Verwendung der folgenden Tests:

• ~x: Falsy if x == -1 : Wir haben ein Zeilenende erreicht.
• x-y: Falsy if x == y : Wir befinden uns auf der Anti-Diagonale.
• x+y-w: Falsch, wenn x + y == w : Wir befinden uns auf der Diagonale.
• x-n: Falsy if x == n : da dieser Test nur durchgeführt wird, wenn x == y ist , bedeutet dies, dass wir uns genau in der Mitte des Gitters befinden.

und der folgende Entscheidungsbaum:

Demo

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

Probieren Sie es online!

Betrachten Sie die Eingabe 2als Beispiel. Der Stapel wird hier verkehrt herum dargestellt, dh die unteren Elemente wurden zuletzt verschoben.

'\/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);}

Probieren Sie es online!

(-2 Golfen dank MD XF)

Es werden zwei Zeichen (zuerst c = 47ein Schrägstrich und c + 45dann ein umgekehrter Schrägstrich) mit einer dynamischen Feldbreite gedruckt.

Die Feldbreiten beginnen bei 1und 2nund bei jeder Iteration wird die erste Breite um 1 erhöht und die zweite um 2 verringert.

Wenn die zweite 'X'Feldbreite 0 wird, wird anstelle der regulären Zeichen eine neue Zeile ausgegeben und die Richtung der Inkremente ( i) umgekehrt . Eine neue Zeile wird für alle anderen Zeilen separat gedruckt ( 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

Basierend auf meiner C-Antwort . Conversions:

• R -> printf(
• P -> putchar(
• W -> while(
• O -> for(
• Automatisch eingefügtes Schließen ");}

Dies verwendet auch ASCII-Codes für \und /.

Probieren Sie es online!

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)

Probieren Sie es online!

C 168, 155, 150 Bytes

^{-5 dank 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");}

Kann sicherlich Golf gespielt werden; Mache ich so Probieren Sie es 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 Bytes

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

Probieren Sie es online!

Hexdump:

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

Erläuterung:

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

Grundsätzlich müssen wir ein X einfügen, n-mal die Schrägstriche verlängern .

Ganz so einfach ist es aber nicht, da wir die Schrägstriche auch gleich beim ersten Mal hinzufügen müssen. Wenn die Schrägstriche bereits vorhanden wären, könnten wir die Schrägstriche wie folgt erweitern :

>HÄX2pGÙX2p

Das würde uns 6 Bytes sparen.

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

Ungolfed-Version:

 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

(Teilweise inspiriert von Jenny_mathys 104-Byte-Lösung)

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

Gibt eine Liste von Zeichenfolgen zurück.

Erklärung: IdentityMatrix[2#+1]Erstellt eine Matrix der richtigen Größe mit 1s entlang der Diagonale und 0s an einer anderen Stelle. Als nächst wir mehrfach durch "\\"(einen entflohener Backslash), die an anderer Stelle macht, es ist eine Matrix mit Schrägstrichen entlang der Diagonalen und 0er da natürlich 1 mal Backslash Backslash und 0 mal Backslash 0. Wir fügen diese zu "/"Zeiten seine Rückseite zu machen die X-Form. Wir sind fast fertig, außer es gibt noch überall Nullen und die Mitte ist "\\" + "/". Wir beheben diese beiden Dinge durch Ersetzen " "von 0und "X"für a_+_, was jeder Summe von zwei Dingen entspricht (wie _+_sollte, außer dass Mathematica zu schlau für sich ist und dies als 2-mal interpretiert _). Schließlich ""<>#&/@verwandelt sich dies in eine Liste von Zeichenfolgen.

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

Lambda-Ausdruck, der eine Ganzzahl annimmt und ein Array von Strings zurückgibt

Probieren Sie es 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 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

Formatiert:

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

Die Eingabe erfolgt über Spalte a in benannte Tabelle t , gemäß unseren Richtlinien .

Ruby , 66 Bytes

Rekursive Funktion.

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

Probieren Sie es online!

Erläuterung

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)

Gelee , 24 17 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Ḥ‘=þ`µḤ+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 dank @LeakyNun und -1 Bytes mit einer zusätzlichen Verbesserung

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

Beginnt mit dem Aufbau der obersten Zeile und verschiebt dann nach dem Drucken jeder Zeile die \rechte und die /linke Stelle um jeweils eine Stelle, wobei sichergestellt wird, dass sie Xin der Mitte stehen.

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;

Probieren Sie es online!

Retina , 74 Bytes

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

Probieren Sie es online!Erläuterung:

.+
$* X

Stelle das X .

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

Beginnen Sie mit X, arbeiten Sie nach oben und platzieren Sie jeweils \diagonal nach links. Platziere auch a/ nach dem /letzten Mal noch zwei Leerzeichen .

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

Beginnen Sie mit X, arbeiten Sie nach unten und platzieren Sie jeweils /diagonal nach links. Platziere auch a\ nach dem /letzten Mal noch zwei Leerzeichen .

m` (\W)$
$1

Die Anzahl der Leerzeichen zwischen den beiden Diagonalen muss ungerade sein, damit das letzte Leerzeichen in jeder Zeile (mit Ausnahme der ursprünglichen XZeile) gelöscht wird.

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

Hier ist ein anderer Ansatz mit 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

Benötigt, ⎕IO←0was auf vielen Systemen Standard ist.

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

Probieren Sie es online!

' \/'[… ] Indexiere den String mit

 ⎕ Eingabe abrufen

 2× multiplizieren mit zwei

 1+ füge eins hinzu

 ⍳ als viele ganze Zahlen

 ∘.=⍨ Gleichheitstabelle (dh Identitätsmatrix; NW-SE-Diagonale)

 (… ) Wenden darauf die folgende implizite Funktion an

  ⊢ das Argument

  + Plus

  2× zweimal

  ⌽ das horizontal gespiegelte Argument (dh NE-SW-Diagonale)

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

Probieren Sie es online!

Wirklich lange, heftige Erhitzungen '\ und /'

Weniger golfen

 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 dank @FelipeNardiBatista

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

Probieren Sie es online!

05AB1E , 21 Bytes

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

Probieren Sie es online!

Perl 5, 110 + 1 = 111 Bytes

Verwendet -nFlagge.

$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

Wie diese Monstrosität funktioniert, bleibt als Übung für den Leser ...

Beispielausgabe:

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

nicht sicher , ob eine func dafür , ob machen writelinewird für den Hinweis auf einige Bytes dank Stephen S speichern as ...Entfernung auch geändert integerin object zuletzt geändert , um die erste zurück

05AB1E , 22 Bytes

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

Probieren Sie es online!

Erläuterung

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

Alternative 22-Byte-Lösung

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

Pyke, 14 Bytes

\XQV.X \   /\/

Probieren Sie es hier aus!

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

Demo

einstellen n die erste Zeile setzen.

Vielleicht kann ich mit einem rekursiven Ansatz mehr Golf spielen

R , 75 72 Bytes

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

Inspiriert von dieser Antwort , generiert sie eine implizite Matrix und schreibt sie in stdout. liest die größe von stdin. Es muss eine Matrix aus Leerzeichen erstellen und verwendet sep=''B / C, ansonsten treten Abstandsprobleme auf.

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

Probieren Sie es online!