Zeichne einen großen Schrägstrich X

21

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!

code-golf  ascii-art 
— Stephen
quelle
— Stephen
6
... Ich warte nur auf die 1-Byte-Lösung für Holzkohle.
— Undichte Nonne
@LeakyNun Ich würde mich wundern, wenn Charcoal leicht mit dem Xin der Mitte umgehen kann (ein Teil, warum ich es hinzugefügt habe), aber wer weiß: D
— Stephen
— Value Ink
— xnor

Antworten:

6

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`
— dzaima
quelle
Verdammt, das ist kurz.
— Dylnan
: ||||||| +1 für Golffreundlichkeit
— ASCII
auch frage ich mich, ob stapelbasierte sprachen grundsätzlich immer andere sprachen übertreffen?
— Nur ASCII
@ Nur-ASCII-Gelee
— Okx
@Okx * stapelbasiert / stillschweigend
— ASCII
22

Holzkohle , 6 Bytes

ＰX⁺¹ＮX

Dein Unsinn hält mich nicht auf;)

Probieren Sie es online!

— Okx
quelle
2
Das TIO sieht ... interessant aus, wenn Sie eine wirklich große Zahl
— Stephen
@StephenS Nur wegen Umhüllung.
— Okx
Ich weiß, es ist nur intuitiv, dass alle umbrochenen `\` s linksbündig ausgerichtet werden (weil Leerzeichen nicht umbrochen werden)
— Stephen
5 Zeichen (Herausforderung nach Datum), um Canvas ein Stück näher zu kommen
— ASCII
16

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:

Entscheidungsbaum

Demo

Code-Snippet anzeigen

— Arnauld
quelle
4
Dies ist ... JavaScript? Was ist mit dir passiert, alter Freund?
— roberrrt-s
13

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
— Luis Mendo
quelle
Ich wollte etwas Ähnliches in Octave machen, aber du hast mich geschlagen und in MATL ist es sogar kürzer als Octave, also großartige Arbeit!
— Michthan
@Michthan Danke! Eine Octave-Version wäre auf jeden Fall auch eine Veröffentlichung wert. Mein Versuch ist bei 38 Bytes, was ist deins?
— Luis Mendo
Ich habe das ganze Wochenende darüber nachgedacht und konnte keinen effizienteren Weg finden, als den, den Sie hier verwenden. Also sollten Sie alle Credits für eine Oktavversion haben.
— Michthan
6

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("")).

— anatolyg
quelle
106 Bytes: a,b,i=1,c;g(n){for(b=2*n,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!
— MD XF
Danke für die Idee! Ich habe nur einen Teil davon verwendet, um sicherzustellen, dass der Code zweimal aufgerufen werden kann.
— Anatolyg
5

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!

— MD XF
quelle
5

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");
    }
}
— MD XF
quelle
2
Sie können 5 Zeichen verlieren, indem Sie p als "printf" (anstelle von "printf") definieren.
— Computronium
3

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.

— DJMcMayhem
quelle
3

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;
        };
— LiefdeWen
quelle
1
Sie können die andere anonyme Funktion aus der ersten verschieben und sie dann als _=d=>new string(' ',d);einfügen (beachten Sie, dass keine geschweiften Klammern erforderlich sind d). Sie können die geschweiften Klammern um die for-Schleife entfernen. Verwenden Sie eine wörtliche Zeichenfolge mit, damit Sie nicht alle umgekehrten Schrägstriche umgehen müssen. Wenn Sie i=0dann einstellen , können Sie das tun ++i<a+1und entfernen i++.
— TheLethalCoder
Auch mit wörtlichen Zeichenfolgen, die Sie nicht einschließen müssen, \nfunktioniert ein tatsächlicher Zeilenvorschub, obwohl ich nicht sicher bin, ob Sie dann die geschweiften Klammern um die for-Schleife entfernen können, müssen Sie es versuchen.
— TheLethalCoder
1
Nach dem Auftragen des ersten Vorschlag von TheLethalCoder , können Sie auch die Ersatz ++i<a+1für ++i<=a EDIT Sie können auch speichern 4 weitere Bytes , die durch die Veränderung Funcvon new string(' ',d)zu"".PadLeft(d)
— auhmaan
Danke für die Vorschläge, @TheLethalCoder. Darf ich 2 Funktionen wie diese deklarieren? Würde das nicht viel C # -Golf verkürzen, wenn wir das können?
— LiefdeWen
1
@StefanDelport Irgendwo gibt es eine Metadiskussion darüber, aber so wie es aussieht, können Sie das, solange Sie den Funktionsnamen anzeigen. In diesem Fall _.
— TheLethalCoder
3

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.

— Kein Baum
quelle
3

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;
}
— PunPun1000
quelle
3

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 .

— BradC
quelle
3

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)
— Wert Tinte
quelle
3

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

— fireflame241
quelle
— Undichte Nonne
2

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.

— Neil
quelle
2

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.

— Neil
quelle
2

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->" ")&
— J42161217
quelle
2

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)

— Adam
quelle
2

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 /\\
— marcosm
quelle
1

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}
— Chris
quelle
1

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
  / \  
 /   \ 
/     \
— steenbergh
quelle
1

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

— polyglotrealIknow
quelle
Sie sind mutig :) Ich glaube, Sie können alle entfernen as Types, denn wenn Sie haben Option Strict Off, verhält sich VB.NET wie eine lose getippte Sprache.
— Stephen
Derzeit auf Linux ist Mono nervig
— polyglotrealIknow
Mono kümmert sich nicht um Option Strict, oder zumindest das, was ich denke
— polyglotrealIknow
Oh, es schien functions ! = for loops Danke für den Golf
— polyglotrealIknow
Ist nicht Option Strictstandardmäßig deaktiviert? Es ist in Visual Studio mindestens
— Stephen
1

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»
— Emigna
quelle
1

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="/")
— Blau
quelle
1

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

— Sergiol
quelle
1

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!

— Giuseppe
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.