Dessinez une grosse barre oblique X

21

É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!

code-golf  ascii-art 
— Stephen
source
— Stephen
6
... Je vais juste attendre la solution de charbon de bois à 1 octet.
— Leaky Nun
@LeakyNun Je serais surpris si Charcoal peut facilement gérer Xle milieu (une partie de la raison pour laquelle je l'ai ajouté) mais qui sait: D
— Stephen
— Value Ink
— Xnor

Réponses:

6

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`
— dzaima
source
Dang c'est court.
— dylnan
: |||||||| +1 pour golfiness
— ASCII uniquement
Je me demande également si les langues basées sur la pile dépassent toujours les autres langues?
— ASCII uniquement
@ Gelée ASCII uniquement
— Okx
@Okx * stack-based / tacit
— ASCII uniquement
22

Fusain , 6 octets

ＰX⁺¹ＮX

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

Essayez-le en ligne!

— Okx
source
2
Le TIO a l'air ... intéressant quand vous y mettez un très gros chiffre
— Stephen
@StephenS Uniquement à cause de l'habillage.
— Okx
Je sais, c'est juste intuitif que tous les `` wrappés '' soient alignés à gauche (parce que les espaces ne sont pas enveloppés)
— Stephen
5 caractères (défi postdates) juste pour se rapprocher un peu de Canvas
— ASCII uniquement
16

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:

decision tree

Démo

Afficher l'extrait de code

— Arnauld
source
4
C'est ... JavaScript? Qu'est-ce qui vous est arrivé, vieil ami.
— roberrrt-s
13

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
— Luis Mendo
source
Je voulais faire quelque chose de similaire dans Octave, mais tu m'as battu et en MATL c'est encore plus court que Octave, donc super travail!
— Michthan
@Michthan Merci! Une version Octave vaut également la peine d'être publiée. Ma tentative est à 38 octets, quelle est la vôtre?
— Luis Mendo
J'y ai pensé tout le week-end et je n'ai pas pu trouver un moyen plus efficace que celui que vous utilisez ici. Donc, tous les crédits devraient vous être remis pour une version octave.
— Michthan
6

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

— anatolyg
source
106 octets: 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);} essayez-le en ligne!
— MD XF
Merci pour l'idée! Je n'en ai utilisé qu'une partie pour m'assurer que le code peut être appelé deux fois.
— anatolyg
5

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!

— MD XF
source
5

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");
    }
}
— MD XF
source
2
Vous pouvez perdre 5 caractères en définissant p comme "printf (" au lieu de "printf".
— Computronium
3

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.

— DJMcMayhem
source
3

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;
        };
— LiefdeWen
source
1
Vous pouvez déplacer l'autre fonction anonyme hors de la première, puis l'inclure comme _=d=>new string(' ',d);(notez que vous n'avez pas besoin des accolades d). Vous pouvez supprimer les accolades autour de la boucle for. Utilisez une chaîne textuelle avec pour ne pas avoir à échapper à toutes les barres obliques inverses. Si vous définissez, i=0vous pouvez le faire ++i<a+1et le supprimer i++.
— TheLethalCoder
De plus, avec les chaînes textuelles, vous n'avez pas besoin d'inclure \nun saut de ligne réel, même si je ne sais pas si vous pourrez ensuite supprimer les accolades autour de la boucle for, vous devrez essayer.
— TheLethalCoder
1
Après avoir appliqué la première suggestion de TheLethalCoder , vous pouvez également remplacer le ++i<a+1pour ++i<=a EDIT. Vous pouvez également enregistrer 4 octets supplémentaires en changeant le Funcde new string(' ',d)au"".PadLeft(d)
— auhmaan
Merci pour les suggestions, @TheLethalCoder suis-je autorisé à déclarer 2 fonctions comme ça, cela ne raccourcirait-il pas beaucoup le golf C # si nous pouvions le faire?
— LiefdeWen
1
@StefanDelport Il y a une méta-discussion à ce sujet quelque part, mais en l'état, je crois que vous pouvez aussi longtemps que vous montrez le nom des fonctions. Dans ce cas _.
— TheLethalCoder
3

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.

— Pas un arbre
source
3

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

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 .

— BradC
source
3

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)
— Encre de valeur
source
3

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

— fireflame241
source
— Leaky Nun
2

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.

— Neil
source
2

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é.

— Neil
source
2

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

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)

— Adam
source
2

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

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

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

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

— polyglotrealIknow
source
Vous êtes courageux :) Je pense que vous pouvez supprimer tout cela as Types, car si vous l'avez Option Strict Off, VB.NET agit comme un langage vaguement tapé.
— Stephen
Actuellement sous Linux mono est ennuyeux
— polyglotrealIknow
mono ne se soucie pas d'Option Strict, ou du moins c'est ce que je pense
— polyglotrealIknow
Oh, il semblait functions ! = for loops Merci pour le golf
— polyglotrealIknow
N'est pas Option Strictdésactivé par défaut? C'est au moins dans Visual Studio
— Stephen
1

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

Pyke, 14 octets

\XQV.X \   /\/

Essayez-le ici!

\X             - "X"
  QV           - repeat input times:
    .X \   /\/ -  surround(^, all=" ", 
                              tl="\", 
                              left=" ",  
                              right=" ",  
                              lower=" ",  
                              tr="/",  
                              br="\",  
                              bl="/")
— Bleu
source
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 / \\

démo

Situé nsur la première ligne.

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

— sergiol
source
1

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!

— Giuseppe
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.