Problema

Inspirado en un desafío anterior haciendo algo similar

Dada una nsalida de entrada entera positiva, una forma que sigue este patrón:

entrada n=1:

* *
 *
* *

entrada n=2:

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

entrada n=3:

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

y así...

Tiene estas propiedades:

n*2+1 líneas altas

los "brazos" son nanchos excepto cuando se fusionan

la línea central es nancha

si nes incluso las líneas arriba y abajo del centro son n*2anchas

si nes impar, las líneas arriba y abajo del centro son n*2-1anchas

Reglas

• Nuevas líneas finales aceptadas
• Se aplican lagunas estándar
• Los bytes más cortos ganan
• La salida puede imprimirse o una cadena o conjunto de cadenas

Ediciones

• n=0 no necesita ser manejado
• Espacios finales permitidos

Carbón , 13 12 bytes

Gracias a @ErikTheOutgolfer por un byte

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

Pruébalo en línea!

Esta es mi primera respuesta al carbón, y estoy bastante seguro de que no está tan bien como podría ser, pero pensé que comenzaría en algún lado.

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

MATL , 16 bytes

EQXyG:Y+tP+g42*c

Pruébalo en línea!

Explicación

Considere la entrada 2como un ejemplo. El contenido de la pila se muestra con los más recientes a continuación.

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

Jalea , 15 bytes

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

Pruébalo en línea!

V , 18 17 bytes

Guardado un byte gracias al truco de entrada de @ DJMcMayhem.

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

Pruébalo en línea!

Explicación

Àé*ÄJÀäl

Esto inserta [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

Cada iteración del bucle del búfer va

|**   ***

A

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

¿Dónde |está el cursor con un *debajo?

05AB1E , 18 bytes

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

Pruébalo en línea!

Explicación

Ejemplo para 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 bytes

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

Pruébalo en línea!

Hexdump:

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

Por alguna razón, este desafío es significativamente más difícil en V que el anterior. Dado que nuestro enfoque general de n veces, crecer una 'x' no funcionará aquí, en su lugar construiremos la parte superior de la X, la copiaremos y voltearemos, luego uniremos las dos partes.

Explicación:

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

Hacer la sangría al final del ciclo, nos permite aprovechar las terminaciones implícitas . Esto también crea convenientemente n + 1 líneas, que es exactamente la mitad superior de la 'X'. Digamos que la entrada fue 4. Entonces, en este punto, el búfer se ve así:

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

Y estamos en la última línea. Entonces, nosotros:

                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 bytes

-1 byte creando una cadena y llamando WriteLine, guardando así el cheque para la nueva línea.
-6 bytes gracias a Kevin y sus técnicas de golf maestro!
-2 bytes reemplazando n*3-ncon n*2.
-15 bytes después de que Kevin me indicó amablemente en la dirección correcta: puedo devolver la cadena en lugar de imprimirla, guardando así la llamada a System.Console.WriteLine(). Y algunos otros consejos también ...

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

Pruébalo en línea!

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

Simplemente itera a lo largo de las filas y columnas del espacio necesario para imprimir la X grande e imprime una '*'o una ' 'según la condición.

Haskell , 88 87 86 bytes

-1 gracias a @Laikoni

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

Pruébalo en línea!

Jalea , 24 23 16 bytes

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

Pruébalo en línea!

MATLAB, 153126 bytes (17.6% ↓)

Gracias a @ comentario de LuisMendo, la función de disp()caracteres de salida puede sin comillas simples, por lo que podría evitar el uso fprintfcon formatsy omitir unos pocos bytes. Además, su comentario me recuerda que necesito usar char(32)para presentar un espacio en lugar de char(0)(nulo).

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

Pruébalo en línea!

MATLAB, 153 bytes

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

Ejemplo de resultado: n = 10

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

Python 2 , 93 90 89 83 bytes

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

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

[¡Pruébalo en línea!] [TIO-j3xwsktf]

Comienza con una cadena como '*** 'for n=3, aplicando map/maxpara seleccionar los *espacios para cada posición, luego agrega un espacio y elimina el último carácter de la cadena y vuelve a hacer todo esto.

Haskell , 70 bytes

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

Pruébalo en línea!

Emite una lista de cadenas.

Para cada posición de fila r, columna c, utiliza una fórmula para determinar si cae en una de las dos bandas diagonales y así es *.

Java 8, 119 118 bytes

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 sorprendente respuesta C # de @CarlosAlejo , después de que lo ayudé a jugar al golf algunas cosas. ¡Así que asegúrate de votarlo también!

Pruébalo aquí

Javascript (ES2017), 155 157 bytes

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

Devuelve una matriz de cadenas. Realizo operaciones en matrices y luego lo reflejo. Esto probablemente podría optimizarse con matrices como las otras respuestas, pero quería ser único.

Editar: como señaló Neil, para los valores pares de n, la línea central no era nancha, por lo que agregué un módulo para detectar pares / impares al cortar la columna.

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

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

Cuadrante

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

Reflejado horizontalmente

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

Reflejado verticalmente

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

Mathematica, 148 bytes

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 bytes

Código:

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)

Prueba:

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

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

Este es un bloque que toma un número de la pila y genera una lista de líneas en la pila.

Explicación:

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

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)

Este programa divide cada línea en 4 partes, primeros espacios, primeras estrellas, segundos espacios y luego segundas estrellas. Para cada línea horizontal de la X, calcula cuántas estrellas o espacios se necesitan para cada una de las 4 secciones de la línea, luego construye e imprime esa cadena.

Retina , 144 bytes

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

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

Pruébalo en línea! Explicación:

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

Agregue 2n + 1 espacios antes del valor de entrada (uno para cada línea de salida).

$`#$'¶

Reemplaza cada espacio con a #y recoge los resultados. Esto proporciona una línea diagonal de #s, espacio acolchado en ambos lados, con el valor de entrada con sufijo.

¶\d+$

Elimine el valor de entrada original, ya que ahora tenemos una copia en cada línea.

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

Construya dos líneas diagonales de n *s, con una columna separadora de nespacios envueltos en un par de #s.

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

En esas líneas donde las *s están más cerca del medio, intercambia las dos mitades. Esto le da un aspecto parecido > | | <.

+` (# +#)
$1 

Mueva los | |s tan a la izquierda como sea posible, dando una especie de >> > <apariencia.

+` #...
#

Para cada espacio entre los #s, elimine los tres caracteres siguientes. Esto une el > <en un X.

##

Eliminar el ahora innecesario #s.