Problema

Ispirato da una precedente sfida facendo qualcosa di simile

Dato input di input intero positivo nuna forma che segue questo modello:

input n=1:

* *
 *
* *

input n=2:

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

input n=3:

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

e così via...

Ha queste proprietà:

n*2+1 linee alte

le "braccia" sono nlarghe tranne quando si fondono

la linea centrale è nampia

se nanche le linee sopra e sotto il centro sono n*2larghe

se nè dispari le linee sopra e sotto il centro sono n*2-1larghe

Regole

• Trailing newline accettate
• Si applicano scappatoie standard
• Vincono i byte più brevi
• L'output può essere stampato o una stringa o una matrice di stringhe

Le modifiche

• n=0 non ha bisogno di essere gestito
• Spazi di trascinamento consentiti

Carbone , 13 12 byte

Grazie a @ErikTheOutgolfer per un byte

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

Provalo online!

Questa è la mia prima risposta in assoluto di carbone, e sono abbastanza sicuro che non sia golfato come potrebbe essere, ma ho pensato che avrei iniziato da qualche parte.

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

MATL , 16 byte

EQXyG:Y+tP+g42*c

Provalo online!

Spiegazione

Considera l'input 2come esempio. I contenuti dello stack sono mostrati di seguito con quelli più recenti.

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: ['**  **';
                  ' **** ';
                  '  **  ';
                  ' **** ';
                  '**  **']

Gelatina , 15 byte

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

Provalo online!

V , 18 17 byte

Salvataggio di un byte grazie al trucco di input di @ DJMcMayhem.

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

Provalo online!

Spiegazione

Àé*ÄJÀäl

Questo inserisce [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

Ogni iterazione del loop da cui proviene il buffer

|**   ***

Per

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

Dov'è |il cursore con un *sotto

05AB1E , 18 byte

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

Provalo online!

Spiegazione

Esempio per 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 byte

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

Provalo online!

hexdump:

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

Per qualsiasi motivo, questa sfida è significativamente più difficile in V rispetto all'ultima. Poiché il nostro approccio generale di n volte, crescere una 'x' non funzionerà qui, costruiremo invece la parte superiore della X, la copieremo e la capovolgeremo, quindi unendo le due parti insieme.

Spiegazione:

Àé*Ä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.

Fare il rientro alla fine del ciclo ci consente di trarre vantaggio da finali impliciti . Ciò crea anche n + 1 linee, che è esattamente la metà superiore della "X". Diciamo che l'input era 4. Quindi a questo punto, il buffer si presenta così:

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

E siamo sull'ultima riga. Quindi noi:

                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 byte

-1 byte creando una stringa e chiamando WriteLine, salvando così il controllo per la nuova linea.
-6 byte grazie a Kevin e alle sue tecniche di golf principali!
-2 byte sostituendo n*3-ncon n*2.
-15 byte dopo che Kevin mi ha gentilmente indicato la giusta direzione: posso solo restituire la stringa invece di stamparla, salvando così la chiamata System.Console.WriteLine(). E alcuni altri consigli anche ...

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

Provalo online!

Ungolfed:

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

Iterera semplicemente lungo le righe e le colonne dello spazio necessario per stampare la grande X e stampa una '*'o una a ' 'seconda della condizione.

Haskell , 88 87 86 byte

-1 grazie a @Laikoni

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

Provalo online!

Gelatina , 24 23 16 byte

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

Provalo online!

MATLAB, 153 126 byte (17,6% ↓)

Grazie al commento di @ LuisMendo, la funzione disp()può generare caratteri senza virgolette singole, quindi potrei impedire l'uso fprintfcon formatse omettere alcuni byte. Inoltre, il suo commento mi ricorda che ho bisogno di usare char(32)per presentare uno spazio piuttosto che char(0)(null).

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

Provalo online!

MATLAB, 153 byte

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

Esempio di risultato: n = 10

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

Python 2 , 93 90 89 83 byte

^{-3 byte grazie a Leaky Nun
-1 byte grazie a Zachary T
-6 byte grazie a xnor}

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

[Provalo online!] [TIO-j3xwsktf]

Inizia con una stringa come '*** ' per n=3, applicando map/maxper selezionare gli *spazi per ciascuna posizione, quindi aggiungere uno spazio e rimuovere l'ultimo carattere dalla stringa e ripetere tutto.

Haskell , 70 byte

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

Provalo online!

Emette un elenco di stringhe.

Per ogni posizione di riga r, colonna c, utilizza una formula per determinare se rientra in una delle due bande diagonali e così è *.

Java 8, 119 118 byte

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

Porta dalla sorprendente risposta C # di @CarlosAlejo , dopo averlo aiutato a giocare a golf alcune cose.Quindi assicurati di votare anche lui!

Provalo qui.

Javascript (ES2017), 155 157 byte

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

Restituisce una matrice di stringhe. Eseguo operazioni su array, quindi rispondo. Questo potrebbe probabilmente essere ottimizzato con matrici come le altre risposte, ma volevo essere unico.

Modifica: Come sottolineato da Neil, per i valori pari di n, la linea centrale non era nampia, quindi ho aggiunto un modulo per rilevare pari / dispari durante il taglio della colonna.

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

Ungolfed

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
}

Quadrante

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

Specchiato orizzontalmente

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

Specchiato verticalmente

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

Mathematica, 148 byte

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 byte

Codice:

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)

Test:

> 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 byte

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

Questo è un blocco che prende un numero dallo stack e genera un elenco di righe nello stack.

Spiegazione:

{                        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 byte

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)

Questo programma suddivide ogni riga in 4 parti, primi spazi, prime stelle, secondi spazi e quindi seconde stelle. Per ogni linea orizzontale della X calcola quante stelle o spazi sono necessari per ciascuna delle 4 sezioni della linea, quindi costruisce e stampa quella stringa.

Retina , 144 byte

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

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

Provalo online! Spiegazione:

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

Aggiungi 2n + 1 spazi prima del valore di input (uno per ogni riga di output).

$`#$'¶

Sostituisci ogni spazio con a #e raccogli i risultati. Questo dà una linea diagonale di #s, spazio riempito su entrambi i lati, con il valore di input suffisso.

¶\d+$

Elimina il valore di input originale, poiché ora ne abbiamo una copia su ogni riga.

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

Costruisci due linee diagonali di n *s, con una colonna separatrice di nspazi racchiusa in una coppia di #s.

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

Su quelle linee in cui le *s sono più vicine al centro, scambia le due metà. Questo dà un aspetto simile > | | <.

+` (# +#)
$1 

Sposta la | |s fino a sinistra, dando una sorta di >> > <aspetto.

+` #...
#

Per ogni spazio tra le #s, elimina i tre seguenti caratteri. Questo si unisce a > <in un X.

##

Elimina i messaggi ora non necessari #.