Problème

Inspiré par un défi précédent faisant quelque chose de similaire

Étant donné la nsortie d' entrée entière positive, une forme qui suit ce modèle:

entrée n=1:

* *
 *
* *

entrée n=2:

**  **
 ****
  **
 ****
**  **

entrée n=3:

***   ***
 *** ***
  *****
   ***
  *****
 *** ***
***   ***

etc...

Il a ces propriétés:

n*2+1 lignes hautes

les "bras" sont nlarges sauf lorsqu'ils fusionnent

la ligne médiane est nlarge

si nmême les lignes au-dessus et en dessous du centre sont n*2larges

si nest impair, les lignes au-dessus et en dessous du centre sont n*2-1larges

Règles

• Nouvelles lignes de fin acceptées
• Des échappatoires standard s'appliquent
• Octets les plus courts gagnent
• La sortie peut être imprimée ou une chaîne ou un tableau de chaînes

Modifications

• n=0 n'a pas besoin d'être manipulé
• Espaces de fin autorisés

Fusain , 13 12 octets

Merci à @ErikTheOutgolfer pour un octet

ＦＮ«ＰX⁺*×*Ｉθ→

Essayez-le en ligne!

C'est ma toute première réponse au fusain, et je suis presque sûr que ce n'est pas le golf aussi bien qu'il pourrait l'être, mais j'ai pensé que je commencerais quelque part.

 ＦＮ«            # For input() (i in range(0,input()))
     Ｐ           # Print
       X          # In an 'X' shape
        ⁺*×*Ｉθ   # '*'+'*'*int(first_input)
               →  # Move the cursor right one

MATL , 16 octets

EQXyG:Y+tP+g42*c

Essayez-le en ligne!

Explication

Considérez l'entrée 2comme exemple. Le contenu de la pile est affiché avec les plus récents ci-dessous.

EQ    % Implicitly input n. Push 2*n+1
      %   STACK: 5
Xy    % Identity matrix of that size
      %   STACK: [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]
G:    % Push [1 2 ... n]
      %   STACK: [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],
                 [1 2]
Y+    % 2D convolution, extending size
      %   STACK: [1 2 0 0 0 0;
                  0 1 2 0 0 0;
                  0 0 1 2 0 0;
                  0 0 0 1 2 0;
                  0 0 0 0 1 2]
tP+   % Duplicate, flip vertically, add
      %   STACK: [1 2 0 0 2 1;
                  0 1 2 1 2 0;
                  0 0 1 4 0 0;
                  0 1 2 1 2 0;
                  1 2 0 0 1 2]
g     % Convert to logical
      %   STACK: [1 1 0 0 1 1;
                  0 1 1 1 1 0;
                  0 0 1 1 0 0;
                  0 1 1 1 1 0;
                  1 1 0 0 1 1]
42*   % Multiply by 42.
      %   STACK: [42 42  0  0 42 42;
                   0 42 42 42 42  0;
                   0  0 42 42  0  0;
                   0 42 42 42 42  0;
                  42 42  0  0 42 42]
c     % Convert to char. Char 42 is '*'. Char 0 is displayed as space
      %   STACK: ['**  **';
                  ' **** ';
                  '  **  ';
                  ' **** ';
                  '**  **']

Gelée , 15 octets

Ḥ‘Ḷ⁶ẋ;€”*ẋ$»Ṛ$Y

Essayez-le en ligne!

V , 18 17 octets

Sauvegardé un octet grâce à l'astuce d'entrée de @ DJMcMayhem.

Àé*ÄJÀälÀñ2ÙÀl2x>

Essayez-le en ligne!

Explication

Àé*ÄJÀäl

Cela insère [n]*'*'+[n]*' '+[n]*'*'

        Àñ        ' [arg] times
          2Ù      ' Duplicate the current line down twice
            Àl    ' Move right [arg] times
              2x  ' Delete two characters
                > ' Indent this line one space

À chaque itération de la boucle à partir de laquelle le tampon passe

|**   ***

À

***   ***
 |** ***
***   ***

Où |est le curseur avec un *dessous

05AB1E , 18 octets

Å4bS{I·ƒDÂ~„ *èJ,À

Essayez-le en ligne!

Explication

Exemple pour n=2

Å4                   # push a list of 4s with length as the input
                     # STACK: [4,4]
  b                  # convert each to binary
                     # STACK: [100, 100]
   S{                # split into digit list and sort
                     # STACK: [0, 0, 0, 0, 1, 1]
     I·ƒ             # input*2+1 times do
        D            # duplicate top of stack
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 0, 0, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
         Â~          # or each item in the duplicate with its reverse
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [1, 1, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 1, 1, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
           „ *èJ     # use the resulting binary list to index into the string " *"
                     # 1st iteration: [0, 0, 0, 0, 1, 1], "**  **"
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], " **** "
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], "  **  "
                ,    # print
                 À   # rotate list left

V , 23 octets

Àé*ÄJÀälÀñÙãlxx>ñyHæGVp

Essayez-le en ligne!

Hexdump:

00000000: c0e9 2ac4 4ac0 e46c c0f1 d9e3 6c78 783e  ..*.J..l....lxx>
00000010: f179 48e6 4756 70                        .yH.GVp

Pour une raison quelconque, ce défi est beaucoup plus difficile en V que le précédent. Depuis notre approche générale de n fois, grandissons un «x» ne fonctionnera pas ici, nous allons plutôt construire le haut du X, le copier et le retourner, puis attacher les deux parties ensemble.

Explication:

Àé*ÄJÀäl                " Insert ('*' * n) + (' ' * n) + ('*' * n) 
                        " The obvious way would be 'Àé*ÀÁ ÀÁ*', but this 
                        " non-obvious way saves us a byte
        Àñ      ñ       " 'n' times:
          Ù             "   Duplicate this line (below us)
           ãl           "   Move to the center of this line
             xx         "   Delete two characters
               >        "   And indent this line with one space.

Faire le retrait à la fin de la boucle, nous permet de profiter des terminaisons implicites . Cela crée également commodément n + 1 lignes, ce qui est exactement la moitié supérieure du «X». Disons que l'entrée était 4. Puis à ce stade, le tampon ressemble à ceci:

****    ****
 ****  ****
  ********
   ******
    ****

Et nous sommes sur la dernière ligne. Alors nous:

                yH      " Copy the whole buffer and move to the first line
                  æG    " Reverse every line
                    Vp  " And paste what we just copied *over* the current
                        " line, deleting it in the process

C #, 139 130 115 octets

-1 octet en créant une chaîne et en appelant WriteLine, sauvegardant ainsi la vérification de la nouvelle ligne.
-6 octets grâce à Kevin et ses maîtres techniques du golf!
-2 octets en remplaçantn*3-n par n*2.
-15 octets après que Kevin m'a gentiment pointé dans la bonne direction: je peux simplement retourner la chaîne au lieu de l'imprimer, sauvegardant ainsi l'appel à System.Console.WriteLine(). Et quelques autres astuces aussi ...

n=>{var s="";for(int i,j=0;j<=n*2;j++,s+='\n')for(i=0;i<n*3;)s+=i>=j&i<j+n|i<=n*3-j-1&i++>=n*2-j?'*':' ';return s;}

Essayez-le en ligne!

Non golfé:

class Program
{
    static void Main(string[] args)
    {
        System.Func<int, string> g = n =>
        {
            var s = "";
            for (int i, j = 0; j <= n*2; j++, s += '\n')
                for (i = 0; i < n*3;)
                    s += i >= j & i < j+n | i <= n*3-j-1 & i++ >= n*2-j ? '*' : ' ';
            return s;
        };

        System.Console.Write(f(1));
        System.Console.Write(f(2));
        System.Console.Write(f(3));
        System.Console.Write(f(5));
        System.Console.Write(f(8));

        System.Console.ReadKey();
    }
}

Il itère simplement le long des lignes et des colonnes de l'espace nécessaire pour imprimer le grand X et imprime un '*'ou un ' 'selon la condition.

Haskell , 88 87 86 octets

-1 grâce à @Laikoni

(!)=replicate
x n=[zipWith max(reverse m)m|m<-[i!' '++n!'*'++(n*2-i)!' '|i<-[0..n*2]]]

Essayez-le en ligne!

Gelée , 24 23 16 octets

Ḥ‘Ḷ⁸+þṬ+Ṛ$a”*o⁶Y

Essayez-le en ligne!

MATLAB, 153126 octets (17,6% ↓)

Grâce au commentaire de @ LuisMendo, la fonction disp()peut sortir des caractères sans guillemets simples, donc je pourrais empêcher d'utiliser fprintfavec formatset omettre quelques octets. D'ailleurs, son commentaire me rappelle que j'ai besoin d'utiliser char(32)pour présenter un espace plutôt que char(0)(nul).

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=10
disp([a+32 ''])

Essayez-le en ligne!

MATLAB, 153 octets

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1 
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=42
fprintf([repmat('%c',1,c),'\n'],char(a)')

Exemple de résultat: n = 10

**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********

Python 2 , 93 90 89 83 octets

^{-3 octets grâce à Leaky Nun
-1 octet grâce à Zachary T
-6 octets grâce à xnor}

n=input()
x=n*'*'+n*'  '
exec"print`map(max,x,x[::-1])`[2::5];x=' '+x[:-1];"*(n-~n)

[Essayez-le en ligne!] [TIO-j3xwsktf]

Commence par une chaîne comme '*** 'pour n=3, en appliquant map/maxpour sélectionner les *espaces pour chaque position, puis ajoutez un espace et supprimez le dernier caractère de la chaîne et recommencez.

Haskell , 70 octets

f n=[[last$' ':['*'|y<-[1..n],(c-n-y)^2==r^2]|c<-[1..3*n]]|r<-[-n..n]]

Essayez-le en ligne!

Génère une liste de chaînes.

Pour chaque position de ligne r, colonne c, utilise une formule pour déterminer si elle tombe dans l'une des deux bandes diagonales et est donc *.

Java 8, 119 118 octets

n->{String r="";for(int i=0,j;i<=n*2;i++,r+="\n")for(j=0;j<n*3;r+=j>=i&j<i+n|j<=n*3-i-1&j++>=n*2-i?"*":" ");return r;}

Port de la réponse C # étonnante de @CarlosAlejo , après l'avoir aidé à jouer au golf. Alors assurez-vous de le voter également!

Essayez-le ici.

Javascript (ES2017), 155 157 octets

n=>[...e=[...Array(n+1)].map((a,i)=>[...d=((b=''.padEnd(n))[c='slice'](i)+'*'.repeat(n)+b[c](0,i))[c](n/2)].reverse().join``+d[c](n%1)),...e.reverse()[c](1)]

Renvoie un tableau de chaînes. J'exécute des opérations sur des tableaux puis je les mets en miroir. Cela pourrait probablement être optimisé avec des matrices comme les autres réponses, mais je voulais être unique.

Edit: Comme l'a souligné Neil, pour les valeurs paires de n, la ligne centrale n'était pas nlarge, j'ai donc ajouté un module pour détecter les paires / impaires lors du découpage de la colonne.

n=5
['*****     *****',
 ' *****   ***** ',
 '  ***** *****  ',
 '   *********   ',
 '    *******    ',
 '     *****     ',
 '    *******    ',
 '   *********   ',
 '  ***** *****  ',
 ' *****   ***** ',
 '*****     *****']

Non golfé

n => {
  e = [...Array(n+1)].map((a, i) => {   // Create and iterate over array with n+1 elements
    b = ''.padEnd(n)                    // String of n spaces
    d = (b.slice(i) + '*'.repeat(n) + b.slice(0, i)).slice(n/2) // Create row string
    return [...d].reverse().join`` + d.slice(1) // Mirror and combine row horizontally
  })
  return [...e,...e.reverse().slice(1)] // Mirror and combine vertically
}

Quadrant

n=5
   *****
  ***** 
 *****  
*****   
****    
***     

Miroir horizontalement

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     

Miroir verticalement

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     
    *******    
   *********   
  ***** *****  
 *****   ***** 
*****     *****

Mathematica, 148 octets

T=Table;(a=Join[T[T["*",i],{i,(n=#)+2,2n,2}],T[Join[t=T["*",n],T[" ",y],t],{y,1,n,2}]];Column[Row/@Join[Reverse@a,{T["*",n]},a],Alignment->Center])&

R, 102 octets

Code:

n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)

Tester:

> n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)
1: 10
2: 
Read 1 item
**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********

CJam, 24 octets

{:T2*){S*T'**+}%_W%..e>}

Il s'agit d'un bloc qui prend un nombre dans la pile et génère une liste de lignes dans la pile.

Explication:

{                        e# Stack:           | 2
 :T                      e# Store in T:      | 2, T=2
   2*                    e# Multiply by 2:   | 4
     )                   e# Increment:       | 5
      {                  e# Map over range:  | [0
       S                 e#   Push space:    | [0 " "
        *                e#   Repeat string: | [""
         T               e#   Push T:        | ["" 2
          '*             e#   Push char '*': | ["" 2 '*
            *            e#   Repeat char:   | ["" "**"
             +           e#   Concatenate:   | ["**"
              }%         e# End:             | ["**" " **" "  **" "   **" "    **"]
                _        e# Duplicate:       | ["**" " **" "  **" "   **" "    **"] ["**" " **" "  **" "   **" "    **"]
                 W%      e# Reverse:         | ["**" " **" "  **" "   **" "    **"] ["    **" "   **" "  **" " **" "**"]
                   ..e>  e# Overlay:         | ["**  **" " ****" "  **" " ****" "**  **"]
                       } e# End

Python 2 , 110 octets

x=a=0
n=c=input()
while x<2*n+1:
    print ' '*a+'*'*n+' '*c+'*'*(2*n-2*a-c)
    x+=1
    a=n-abs(n-x)
    c=max(0, n-2*a)

Ce programme divise chaque ligne en 4 parties, les premiers espaces, les premières étoiles, les seconds espaces et ensuite les secondes étoiles. Pour chaque ligne horizontale du X, il calcule le nombre d'étoiles ou d'espaces nécessaires pour chacune des 4 sections de la ligne, puis construit et imprime cette chaîne.

Rétine , 144 octets

.+
 $&$* $&$* $&
 
$`#$'¶
¶\d+$

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1
( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3
+` (# +#)
$1 
+` #...
#
##

Essayez-le en ligne! Explication:

.+
 $&$* $&$* $&

Ajoutez 2n + 1 espaces avant la valeur d'entrée (un pour chaque ligne de sortie).

$`#$'¶

Remplacez chaque espace par un #et recueillez les résultats. Cela donne une ligne diagonale de #s, espace rembourré des deux côtés, avec la valeur d'entrée suffixée.

¶\d+$

Supprimez la valeur d'entrée d'origine, car nous avons maintenant une copie sur chaque ligne.

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1

Construisez deux lignes diagonales de n *s, avec une colonne de séparation d' nespaces enveloppée dans une paire de #s.

( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3

Sur les lignes où les *s sont plus proches du milieu, échangez les deux moitiés autour. Cela donne une apparence ressemblante > | | <.

+` (# +#)
$1 

Déplacez les | |s aussi loin que possible à gauche, donnant une sorte d' >> > <apparence.

+` #...
#

Pour chaque espace entre les #s, supprimez les trois caractères suivants. Cela rejoint le > <dans un X.

##

Supprimer le maintenant inutile #.