¿Podrías hacerme un hexágono por favor?

53

Hoy, vamos a hacer un hexágono ASCII. Debe escribir un programa o función que tome un entero positivo n y genere una cuadrícula hexagonal de tamaño n , compuesta de asteriscos. Por ejemplo, un hexágono de tamaño 2 se ve así:

 * *
* * *
 * *

Mientras que un hexágono de tamaño 3 se ve así:

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

Puede utilizar cualquiera de los métodos de entrada y salida predeterminados , por ejemplo, STDIO / STDOUT, argumentos de función y valores de retorno o leer / escribir un archivo.

Puede suponer que la entrada siempre es válida, por lo que si no es un número entero positivo, su programa puede hacer lo que quiera. Usted no obstante tiene que manejar el caso especial de un hexágono tamaño 1, que pasa a ser un solo asterisco:

*

Los espacios en blanco iniciales y finales están permitidos siempre que la salida sea visualmente la misma.

Ejemplos:

1:
*

2:
 * *
* * *
 * *

3:
  * * *
 * * * *
* * * * *
 * * * *
  * * *

4:
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

5:
    * * * * *
   * * * * * *
  * * * * * * *
 * * * * * * * *
* * * * * * * * *
 * * * * * * * *
  * * * * * * *
   * * * * * *
    * * * * *

6:
     * * * * * *
    * * * * * * *
   * * * * * * * *
  * * * * * * * * *
 * * * * * * * * * *
* * * * * * * * * * *
 * * * * * * * * * *
  * * * * * * * * *
   * * * * * * * *
    * * * * * * *
     * * * * * *

12:
           * * * * * * * * * * * *
          * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
          * * * * * * * * * * * * *
           * * * * * * * * * * * *

Como de costumbre, este es el , por lo que se aplican las lagunas estándar , y debe intentar escribir el programa más corto posible medido en bytes. Por supuesto, algunos idiomas son inherentemente más cortos o más largos que otros, así que recuerde que el objetivo no es necesariamente tener el recuento de bytes general más corto, sino superar las presentaciones en los mismos idiomas o en idiomas similares.

¡Que gane el mejor golfista!

DJMcMayhem
fuente
15
¿Por qué incluso tenemos una etiqueta de cuadrícula hexagonal?
Pavel
13
Además, alguien necesita escribir una solución hexagonal.
Pavel
Si alguien quiere obtener la recompensa, probablemente pueda reutilizar el bucle de salida de mi respuesta de Hexagony aquí .
Martin Ender
66
"¿Podrías hacerme un hexágono por favor?" - claro, aquí tienes: i.imgur.com/1emYIia.png
aditsu
@Pavel porque muchas operaciones en una cuadrícula hexagonal son distintas de las cuadrículas cuadradas más estándar y portátiles entre soluciones a diferentes problemas. Operaciones tales como manipulación de coordenadas, rotación, diseño de salida, etc.
Sparr

Respuestas:

37

Hexagony + Bash Coreutils, 0 + 3 + 8 = 11 Bytes

Incluye +3 para -gbandera y +8 para |tr . \*invocación no estándar (vea esta meta publicación )


La entrada se da como argumento para Hexagony. Cuando se llama al intérprete de Hexagony con la -g Nopción, imprime un hexágono de .s. Luego usamos tr para reemplazar aquellos con *s.

Riley
fuente
2
Wow, eso es genial. ¡Y estás superando todos los idiomas de golf!
DJMcMayhem
66
Realmente no llamaría a esto usando el lenguaje Hexagony, más como usar bash (o algún otro shell) con el intérprete Hexagony como uno de los comandos. Eso sería, por ejemplo hexagony -g $1|tr . \*, suponiendo que el intérprete de hexagonía se llame así.
Paŭlo Ebermann
3
Esto se beneficiaría de un comando ejecutable real ...
jpmc26
1
@ jpmc26 Para un hexágono de longitud 5, correríaruby ./interpreter.rb -g 5|tr . \*
Riley
3
@OlivierDulac El "programa" es cero bytes. Todo el trabajo lo realizan las "banderas".
Riley
20

Python 2, 61 bytes

i=n=input()
while~-n+i:i-=1;j=abs(i);print' '*j+'* '*(2*n+~j)

Imprime un espacio final al final de cada línea.

Gracias a Erik the Outgolfer por guardar un byte.

xnor
fuente
A partir de esto, deriva un código Python 3 no válido pero válido con 69 bytes, en int(input())lugar de input()y el print(' '*j+'* '*(2*n+~j))reemplazo habitual print' '*j+'* '*(2*n+~j)- código genial por cierto ;-)
Dilettant
¡Ese es un código realmente genial!
Matias Bjarland
13

JavaScript (ES6), 77 81 84

@Upvoters: no te pierdas la respuesta de @ETHproductions, es decir 76 bytes

Editar Revisado después de un cambio en las especificaciones, se permite el espacio final

Solo por el sombrero ... hey! ¿Sin sombrero?

f=(n,b='* '.repeat(n+n-1),o=b)=>--n?f(n,b=` ${b}`.slice(0,-2),b+`
${o}
`+b):o

Prueba

f=(n,b='* '.repeat(n+n-1),o=b)=>--n?f(n,b=` ${b}`.slice(0,-2),b+`
${o}
`+b):o


function update()
{
  O.textContent=f(+I.value)
}

update()
<input id=I type=number min=1 value=3 oninput='update()'>
<pre id=O></pre>

edc65
fuente
11

Hexagonía , 91 87 86 bytes

?{2'*=&~}=&}='P0</0P}|@..;>;'.\};0Q/..\&(<>"-_"&}=\?_&\/8.=-\<><;{M/.(.(/.-{><.{&'/_.\

Pruébalo en línea!

Finalmente lo hice.

Inicialmente (antes de darme cuenta de lo caros que son los bucles), espero que esto pueda caber en la longitud lateral 5, pero ahora es bastante difícil ajustarlo en la longitud lateral 6.

Para obtener esto, en realidad tengo que modificar un poco el código lineal. De hecho, escribir esto me hace darme cuenta de una manera de reducir el código lineal en 1 2 byte.

usuario202729
fuente
10

JavaScript (ES6), 77 76 bytes

g=(n,s=`
*`+' *'.repeat(n*2-2),c=s,q=c.replace('*',''))=>--n?g(n,q+s+q,q):s

Me dije que no dormiría hasta haber establecido un nuevo récord ES6 sin mirar las otras respuestas, así que aquí está ...

Fragmento de prueba

g=(n,s=`
*`+' *'.repeat(n*2-2),c=s,q=c.replace('*',''))=>--n?g(n,q+s+q,q):s

for(var i = 1; i < 7; i++) console.log(g(i)) // joe

ETHproducciones
fuente
10

C, 91 89 80 74 bytes

w,y;f(s){for(y=-s;++y<s;)for(w=printf("\n%*s",y,"");++w<s*printf(" *"););}

Prácticamente modifiqué para obtener las fórmulas correctas, luego las mezclé todas juntas.

Llame fcon el número n , e imprimirá el hexágono en stdout.

Ungolfed y explicado (versión de 80 bytes):

w,y;
f(s) {
    // y iterates over [-s + 1 ; s - 1] (the number of rows)
    for(y = -s; ++y < s;)
        // w iterates over [abs(y) + 2 ; s * 2 - 1] (the number of stars on the row)
        for(
            // This prints a backspace character (ASCII 8)
            // padded with abs(y) + 2 spaces, effectively
            // printing abs(y) spaces to offset the row.
            // Also initializes w with abs(y) + 2.
            printf("\n%*c", w = abs(y) + 2, 8);

            // This is the for's condition. Makes use
            // of the 2 returned by printf, since we coïncidentally
            // need to double the upper bound for w.
            w++ < s * printf("* ");

            // Empty for increment
        )
            ; // Empty for body
}

Véalo en vivo en Coliru

Notas:

  • printfpuede manejar el relleno negativo, lo que da como resultado un carácter alineado a la izquierda con el relleno a la derecha. Por lo tanto, probé algo para w = printf("%*c*", y, ' ')que se hiciera cargo del valor absoluto y pudiera recuperarlo de su valor de retorno. Desafortunadamente, los anchos de relleno cero y uno imprimen el carácter por sí mismo, por lo que las tres líneas centrales eran idénticas.
    Actualización: Jasen ha encontrado una manera de hacer exactamente esto imprimiendo una cadena vacía en lugar de un carácter: ¡6 bytes eliminados!

  • Coliru maneja incorrectamente el carácter de retroceso: la ejecución de este código en un terminal local elimina el espacio inicial de cada línea.

Quentin
fuente
w=printf("\n%*s",abs(y),"");++w<s*printf(" *");
Jasen
@Jasen No puedo creer que me perdí eso ... ¡Gracias!
Quentin
9

05AB1E , 14 13 bytes

Código:

F¹N+„ *×})û.c

Explicación:

F       }        # Input times do (N = iteration number)
 ¹N+             #   Calculate input + N
    „ *×         #   Multiply by the string " *"
         )       # Wrap everything into an array
          û      # Palindromize the array
           .c    # Centralize

Utiliza la codificación CP-1252 . Pruébalo en línea!

Adnan
fuente
1
No entiendo lo que hace la parte "centralizar". Cuando lo elimino, obtengo una serie de cadenas sin el número apropiado de espacios iniciales.
DJMcMayhem
1
@DJMcMayhem En una matriz, puede verla como si fuera una cadena unida por nuevas líneas con el texto alineado al centro. Esto es lo que hace en la entrada.
Adnan
8

Jalea , 24 bytes

R+’µạṀx@€⁶żx@K¥€”*$F€ŒḄY

Pruébalo en línea!

Jelly se avergüenza del hecho de que no tiene un átomo de centralización, por lo que es superado por 05AB1E y V. ¡Por 11 y 7 bytes respectivamente!

Si encuentra alguna forma de jugar al golf, por favor comente. Cualquier ayuda es apreciada.

Explicacion :

R+’µạṀx@€⁶żx@K¥€”*$F€ŒḄY Main link. Arguments: z.
R+’                      The sizes of the hexagon's rows. (implicit argument)
   µ                     Start a new monadic chain with the above argument.
    ȧṀx@€⁶               The spaces you must prepend to each row. (implicit argument)
           x@K¥€”*$      The stars (points) of each row, space-joined, as a single link. (implicit argument)
          ż        F€    Conjoin and merge the leading spaces with the stars appropriately.
                     ŒḄ  Create the second half of the hexagon without the middle row.
                       Y Join the rows with newlines. This makes the shape look like a hexagon.

Bonificación: para encontrar cuántas estrellas hay en un hexágono, usa esto:

Ḷ×6S‘
Erik el Outgolfer
fuente
2
Uf, la explicación fue abrumadora.
Erik the Outgolfer
¿Qué haría un "átomo de centralización"?
DJMcMayhem
@DJMcMayhem Vea la respuesta 05AB1E para ver un ejemplo.
Erik the Outgolfer
7

Octava, 62 58 bytes

@(n)' *'(dilate(impad(1,2*--n,n),[k='01010'-48;~k;k],n)+1)

Respuesta anterior:

@(n)' *'(dilate(impad(1,2*(m=n-1),m),[k='01010'-48;~k;k],m)+1)

que se puede llamar como

(@(n)' *'(dilate(impad(1,2*(m=n-1),m),[k='01010'-48;~k;k],m)+1))(5)

Pruébalo (pégalo) en Octave Online

Por ejemplo, la imagen base para n=5es

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

que se puede crear con

impad(1,2*(n-1),n-1)

Se dilation morphological operatoraplica 4 veces en la imagen usando la siguiente máscara vecina:

0 1 0 1 0
1 0 1 0 1
0 1 0 1 0

que se puede crear con [k='01010'-48;~k;k]

resultado de la dilatación:

0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0
0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0
0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0
0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0
0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0

luego reemplace 0 y 1 con '' y '*' respectivamente

    * * * * *
   * * * * * *
  * * * * * * *
 * * * * * * * *
* * * * * * * * *
 * * * * * * * *
  * * * * * * *
   * * * * * *
    * * * * *
rahnema1
fuente
6

postgresql9.6, 290 bytes

do language plpgsql $$ declare s constant smallint:=4;declare n smallint;declare a constant int[]:=array(select generate_series(1,s));begin foreach n in array a||array(select unnest(a)t order by t desc offset 1)loop raise info'%',concat(repeat(' ',s-n),repeat(' *',s+(n-1)));end loop;end;$$

sql formateado está aquí:

do language plpgsql $$
declare s constant smallint := 4;
declare n smallint;
declare a constant int[] := array(select generate_series(1, s));
begin
foreach n in array a || array(select unnest(a)t order by t desc offset 1) loop
    raise info '%', concat(repeat(' ', s - n), repeat(' *', s + (n - 1)));
end loop;
end;
$$;

salida:

INFO:      * * * *
INFO:     * * * * *
INFO:    * * * * * *
INFO:   * * * * * * *
INFO:    * * * * * *
INFO:     * * * * *
INFO:      * * * *
andryk
fuente
lpadEs posible que pueda ahorrarle unos pocos bytes. También llamaría al lenguaje pl / pgsql, pero eso genera preguntas sobre si tiene que contar do language plpgsql $$el cierre y el cierre $$;. Esos se abordarían mejor en meta, si no han aparecido antes.
jpmc26
Además, ¿por qué necesitas múltiples DECLAREs? ¿No funcionaría uno solo?
jpmc26
6

V , 17 bytes

é*À­ñ>{MÄpXA *Î.

Pruébalo en línea!

Como de costumbre, aquí hay un hexdump, ya que contiene caracteres no imprimibles:

00000000: e92a c0ad f13e 7b4d c470 5841 202a 1bce  .*...>{M.pXA *..
00000010: 2e                                       .
DJMcMayhem
fuente
6

APL (Dyalog Unicode) , 40 36 35 33 27 25 bytes

(⍉⊖⍪1↓⊢)⍣2∘↑⍳↓¨∘⊂'* '⍴⍨+⍨

Asume ⎕IO←0, es decir, indexación basada en cero. La salida contiene un espacio inicial y uno posterior en cada línea.

Muchas gracias a @FrownyFrog y @ngn por mucho golf.

Pruébalo en línea!

Cómo funciona

(⍉⊖⍪1↓⊢)⍣2∘↑⍳↓¨∘⊂'* '⍴⍨+⍨   Main function train
                 '* '⍴⍨+⍨     Repeat '* ' up to length 2×⍵
            ⍳↓¨∘⊂             Generate lower-right corner of the hexagon
          ∘↑                  Convert to matrix
(⍉⊖⍪1↓⊢)                      Palindromize vertically and transpose
        2                    ... twice
Bubbler
fuente
5

JavaScript (ES6), 83 81 bytes

Esta es mi primera respuesta (código golf). Espero haber formateado todo correctamente.

a=>{for(b=c=2*a-1;c;)console.log(" ".repeat(d=Math.abs(a-c--))+"* ".repeat(b-d))}

A diferencia de las 2 respuestas actuales de ES6, no estoy llamando recursivamente a una función y estoy usando la consola para la salida.

Luke
fuente
¿Podría usarlo alertsi especifica el navegador js?
FlipTack
@FlipTack, no realmente, ya que gradualmente construyo la cadena (línea por línea). Si lo alerteditara, alertaría línea por línea, y no todo.
Lucas
5

Haskell, 99 97 79 bytes

h n=mapM_(putStrLn.(\k->([k..n]>>" ")++([2..n+k]>>"* ")))([1..n-1]++[n,n-1..1])

Explicación: Este programa se basa en la observación de que cada línea de un n-Hexágono contiene espacios (nk) seguidos de asteriscos (n + k-1), para algunos k dependiendo del número de línea.

h n=                                             h is a function of type Int -> IO ()
  mapM_                                          mapM_ executes a function returning 
                                                 monadic actions on all objects 
                                                 in a list, in order. Then it executes 
                                                 these actions, in order. For this code, it 
                                                 transforms each value in the list into a 
                                                 monadic action that prints 
                                                 the corresponding line

      (                                          the function consists of two components
        putStrLn                                 the second part is printing the result of 
                                                 the first part to stdout 

        .                                        concatenating both components

        (\k->                                    the first parts first prints (n-k) spaces 
                                                 and then (n+k-1) asterisks

          ([k..n]>>" ")                          create the list of the integers from 
                                                 k to n (That is actually one more entry
                                                 than necessary, but just results in a
                                                 leading whitespace per line, while
                                                 saving 2 bytes compared to [1..n-k]).
                                                 Then create a new list where 
                                                 each element of that first list is 
                                                 replaced with the string " " and 
                                                 concatenate that result into one string

          ++                                     concatenate both lists

          ([2..n+k]>>"* ")                       create the list of the integers 
                                                 from 2 to n+k (of length n+k-1). 
                                                 Then create a new list where each 
                                                 element of that first list is replaced 
                                                 with the string "* " and concatenate 
                                                 that result into one big string
        ) 

      )         
      ([1..n-1]++[n,n-1..1])                     the list simply goes from 1 to n and 
                                                 back, supplying the k 

Editar: se cambió a mapM_. No sabía que estaba disponible sin usar importar

Sacchan
fuente
5

Python 2 , 100 97 89 88 87 81 79 bytes

-1 de @ Flp.Tkc

-6 de nuevo desde @Flp

-2 con agradecimiento a @ nedla2004. Estaba tratando de encontrar cómo deshacerme de la segunda porción, pero no pensé en esa :)

i=input()
a=[" "*(i-x)+"* "*(i+x)for x in range(i)]
print'\n'.join(a+a[-2::-1])

Pruébalo en línea!

Crea una matriz para la mitad superior, luego agrega la matriz invertida menos la línea media y luego imprime. Imprime exactamente "tal cual", aparte de lo 1que imprime con un espacio inicial (supongo que eso está permitido ya *que visualmente es lo mismo que *con o sin espacio inicial).

ElPedro
fuente
1
Esto da una solución incorrecta para 1 - "*". Creo que debería ser un asterisco sin espacio delante?
Андрей Ломакин
@ АндрейЛомакин - Desde OP: "Los espacios en blanco iniciales y finales están permitidos siempre que el resultado sea visualmente el mismo". Una sola estrella es visualmente lo mismo que una sola estrella con un espacio delante o al menos esa fue mi interpretación ;-)
ElPedro
Pero en realidad tienes razón en que contradije lo que acabo de decir en mi respuesta. He actualizado la respuesta para aclarar. ¿Mejor ahora? Por cierto, buen trabajo para encontrar una respuesta anterior y detectar un posible error. El respeto.
ElPedro
1
Intenté este desafío yo mismo, y no puedo encontrar nada mejor, estaba estudiando el tuyo en busca de inspiración.
Андрей Ломакин
Espero que mi humilde esfuerzo te haya ayudado. Seguro que nos divertiremos jugando al golf juntos en el futuro. Disfruta PPCG.
Claro
4

Lote, 161 bytes

@echo off
set s=*
set l=for /l %%i in (2,1,%1)do call 
%l%set s= %%s%% *
%l%echo %%s%%&call set s=%%s:~1%% *
echo %s%
%l%set s= %%s:~0,-2%%&call echo %%s%%

Nota: Espacio final en la línea 2. Sin golf:

@echo off
set s=*
rem build up the leading spaces and stars for the first row
for /l %%i in (2,1,%1) do call :s
rem output the top half of the hexagon
for /l %%i in (2,1,%1) do call :t
rem middle (or only) row
echo %s%
rem output the bottom half of the hexagon
for /l %%i in (2,1,%1) do call :b
exit/b
:s
set s= %s% *
exit/b
:t
echo %s%
rem for the top half remove a space and add a star to each row
set s=%s:~1% *
exit/b
:b
rem for the bottom half add a space and remove a star from each row
set s= %s:~0,-2%
echo %s%
exit/b
Neil
fuente
4

JavaScript (ES6), 83 bytes

f=
n=>[...Array(n+--n)].map((_,i,a)=>a.map((_,j)=>j<n-i|j<i-n?``:`*`).join` `).join`
`
<input type=number min=1 oninput=o.textContent=f(+this.value)><pre id=o>

Neil
fuente
4

Lienzo , 9 bytes.

╷⁸+* ×]/─

Pruébalo aquí!

Vencer a la incorporada: D

Explicación:

{╷⁸+* ×]/─  implicit "{"
{      ]    map over 1..input
 ╷            decrement: 0..input-1
  ⁸+          add the input: input..(input*2-1)
    * ×       repeat "* " that many times
        /   diagonalify that - pad each line with 1 less space than the previous
         ─  palindromize vertically

No tengo idea de por qué existe el gran relleno, pero está permitido y lo arreglaré pronto ™. ¿fijo? Espero no haber roto cosas

dzaima
fuente
3

Perl 6 , 49 bytes

->\n{say " "x n*2-1-$_~"*"xx$_ for n...n*2-1...n}

Pruébalo en línea!

Cómo funciona

->\n{                                           }  # Lambda accepting edge size (e.g. 3)
                               for n...n*2-1...n   # For each row-size (e.g. 3,4,5,4,3):
                       "*"xx$_                     # List of stars     (e.g. "*","*","*")
         " "x n*2-1-$_                             # Spaces to prepend (e.g. "  ")
                      ~                            # Concatenate.      (e.g. "  * * *")
     say                                           # Print
smls
fuente
3

Powershell, 91 89 78 68 63 52 48 bytes

param($n)$n..1+1..$n|gu|%{' '*$_+'* '*(2*$n-$_)}

Script de prueba:

$script = {
param($n)$n..1+1..$n|gu|%{' '*$_+'* '*(2*$n-$_)}
}

12,6,5,4,3,2,1 |%{
    $_
    . $script $_
}

Salida (espacio inicial adicional):

12
            * * * * * * * * * * * *
           * * * * * * * * * * * * *
          * * * * * * * * * * * * * *
         * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * * *
          * * * * * * * * * * * * * *
           * * * * * * * * * * * * *
            * * * * * * * * * * * *
6
      * * * * * *
     * * * * * * *
    * * * * * * * *
   * * * * * * * * *
  * * * * * * * * * *
 * * * * * * * * * * *
  * * * * * * * * * *
   * * * * * * * * *
    * * * * * * * *
     * * * * * * *
      * * * * * *
5
     * * * * *
    * * * * * *
   * * * * * * *
  * * * * * * * *
 * * * * * * * * *
  * * * * * * * *
   * * * * * * *
    * * * * * *
     * * * * *
4
    * * * *
   * * * * *
  * * * * * *
 * * * * * * *
  * * * * * *
   * * * * *
    * * * *
3
   * * *
  * * * *
 * * * * *
  * * * *
   * * *
2
  * *
 * * *
  * *
1
 *

Explicación:

param($n)           # define script parameter
$n..1+              # int range from n to 1 step -1; append
1..$n|              # int range from 1 to n
gu|                 # alias for Get-unique eliminates equal neighbors - here is 1,1 -> 1
%{                  # for each int from [n, n-1, n-2, ... 2, 1, 2, ... n-2, n-1, n]
    ' '*$_+         # string (' ' have repeated $_ times) append
    '* '*(2*$n-$_)  # string ('* ' have repeated 2*n-$_ times)
}
mazzy
fuente
1
Buen uso de gu.
AdmBorkBork
3

PHP, 83 79 bytes

for($p=str_pad;++$y<2*$n=$argn;)echo$p($p("
",1+$k=abs($n-$y)),4*$n-$k-2,"* ");

Ejecutar como tubería -nRo probarlo en línea .


Esto está cerca de la respuesta de Kodos ; pero str_pades más corto que str_repeatincluso cuando se juega al golf.
Y la ++cabeza en el bucle ahorra un poco más.

Titus
fuente
2

Ruby, 54 bytes

->n{(1-n..n-1).map{|j|i=j.abs;' '*i+'* '*(n*2+~i)}*$/}

La función lambda toma n como argumento y devuelve una cadena separada por nuevas líneas. ( $/es una variable que contiene el separador de línea predeterminado).

en programa de prueba

f=->n{(1-n..n-1).map{|j|i=j.abs;' '*i+'* '*(n*2+~i)}*$/}

puts f[gets.to_i]
Level River St
fuente
Puede guardar 1 byte usando (1-n ... n) con 3 puntos
GB
Parece consenso es incluir el código de salida (es decir puts) en el recuento de caracteres. Pero releyendo la definición, solo dice que su función debería "generar" el resultado que podría leerse como "devolver" el resultado. Solución genial
Matias Bjarland
@MatiasBjarland meta.codegolf.stackexchange.com/a/2456/15599
Level River St
2

Charly, 125 bytes

let i="".promptn()let o=0let j=0let w=write loop{w(" "*(i-1-o),"* "*(i+o))w("
")if j<i-1{o+=1}else{o-=1}if o<0{break}j+=1}

Página de Charly GitHub: https://github.com/KCreate/charly-lang

Leonard Schuetz
fuente
2

SmileBASIC, 74 bytes

FOR I=0TO N-1P
NEXT
FOR I=N-2TO.STEP-1P
NEXT
DEF P?" "*(N-I);"* "*(N+I)END

Agrega un espacio inicial y final.

Estos "hexágonos" se ven horribles cuando los personajes tienen el mismo ancho y alto ...

12Me21
fuente
2

raqueta / esquema

(define (f n)
  (define (s t n)
    (if (= n 0) t (s (~a t "* ") (- n 1))))
  (define (h t p a i)
    (if (= i 0)
        (display t)
        (let ((x (~a t (make-string p #\space) (s "" a) "\n"))
              (q (if (> i n) (- p 1) (+ p 1)))
              (b (if (> i n) (+ a 1) (- a 1))))
          (h x q b (- i 1)))))
  (h "" (- n 1) n (- (* 2 n) 1)))

pruebas:

(f 1)
*

(f 4)
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *
Kevin
fuente
3
Bienvenido al sitio! Esta es una competencia de código de golf, por lo que debe incluir su número de bytes. También puede eliminar gran parte del espacio en blanco presente en esta respuesta para acortarlo.
Wheat Wizard
Gracias por tu aportación, Cat Wizard. Soy nuevo en el golf de código, y supongo que el esquema no es el mejor lenguaje para él, pero intentaré acortarlo, eliminar espacios en blanco y agregar un conteo de bytes en mi próxima entrada.
Kevin
2

Python 2, 111 bytes

n=input()
l=range(n,2*n-1)
S=l+[2*n-1]+l[::-1]
W=range(1,n)
for w in W[::-1]+[0]+W:print" "*w+"* "*S[0];S=S[1:]

Una implementación aburrida y directa (y un programa completo). Emite un espacio en blanco al final de cada línea.

Casos de prueba:

1:
*

2:
 * * 
* * * 
 * * 

3:
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 

4:
   * * * * 
  * * * * * 
 * * * * * * 
* * * * * * * 
 * * * * * * 
  * * * * * 
   * * * * 
Yytsi
fuente
2

Javascript (ES6), 143 bytes

Finalmente son las vacaciones de Navidad (¡feliz Navidad!), Así que tengo tiempo para jugar al golf.
Y vaya, ha pasado un tiempo, de ahí el gran número de bytes.
Aquí va:

c=[];a=a=>{for(i=0;i<a;i++){c.push(" ".repeat(a-i-1)+"* ".repeat(i+a-1)+"*")}for(j=c.length-2;j>-1;j--)c.push(c[j]);return a==1?"*":c.join`\n`}
console.log(a(3));

Bantha calvo
fuente
2
Algunas mejoras: for(j=c.length-2;j>-1;j--)c.push(c[j])pueden escribirse como for(j=a-1;j;c.push(c[--j]))y for(i=0;i<a;i++){c.push(" ".repeat(a-i-1)+"* ".repeat(i+a-1)+"*")}podrían ser for(i=0;i<a;c.push(" ".repeat(a-i-1)+"* ".repeat(a-1+i++));. La declaración de devolución podría acortarse a return a-1?c.join\ n :"*"En total, estos cambios ahorran 18B (11 + 7 + 1).
Luke
2

Java, 157 149 129 127 bytes

s->{for(int j=~--s,t;++j<=s;p(s-~s-t,"* "),p(1,"\n"))p(t=j<0?-j:j," ");};<T>void p(int j,T s){for(;j-->0;)System.out.print(s);}
  • 8 bytes eliminados por Jonathan Frech.
  • 20 bytes eliminados por Kevin Cruijssen.
  • 2 bytes eliminados por Kevin Cruijssen.

Pruébalo en línea!

Eugene
fuente
1
149 bytes .
Jonathan Frech
1
94 bytes. NOTA: Java 11 tiene String#repeat(int), pero TIO sigue siendo JDK 10, de ahí el repeat(String,int)método emulado (con el mismo número de bytes). El código real en Java 11 sería:s->{for(int j=~--s,t;++j<=s;System.out.println(" ".repeat(t)+"* ".repeat(s-~s-t)))t=j<0?-j:j;}
Kevin Cruijssen
1
@Eugene Claro. :) En ese caso, algunas cosas para jugar golf en la versión Java actual (8+) por ahora: 129 bytes .
Kevin Cruijssen
1
@KevinCruijssen Eso es un golf bastante pesado aquí, lo actualicé, gracias.
Eugene
1
Yo otra vez. Encontré una cosa más para jugar golf por -2 bytes. 127 bytes Esto también se puede usar para jugar 1 byte en la solución Java 11 anterior .
Kevin Cruijssen
2

Hexagonía (lineal), 128 127 126 bytes

Tenga en cuenta que esto no es Hexagony, solo un (meta) lenguaje admitido por Timwi en IDE esotérico, por lo que no es elegible para la recompensa.

Sin embargo, esto se puede convertir en una solución de Hexagony (y creo que será más pequeña que esta solución). Puedo hacerlo más tarde. Se necesita más esfuerzo lo hice aquí .

La inicial toma 3 bytes ( e2 9d a2). Cada línea nueva toma 1 byte ( 0a).

❢?{2'*=(
A
if > 0
 "-"&}=&~}=&}=?&
 B
 if > 0
  }P0;'(
  goto B
 &{&'-{=-(
 C
 if > 0
  'P0;Q0;}(
  goto C
 {M8;{(
 goto A
@

No ¡Pruébelo en línea! Esto solo funciona en IDE esotérico.

Código anotado:

❢?        # read input n
[n]
{2'*=(     # x = 2n-1
[x]
A
if > 0    # loop (x) from 2n-1 to 1
 "-      # a = x - n
 [a]
 "&}=&~}=&    # a = abs(a). Let K be this amount
 }=?&
 B
 if > 0       # print ' ' (a) times
  }P0;'(
  goto B
 &        # current cell = a (= K)
 {&       # a = n if K>0 else x
          # Note that K=abs(x-n). So if K==0 then x==n.
          # Therefore after this step a is always equal to n.
 '-{=-    # compute n-(K-n) = 2n+K
 (        # decrement, get 2n+K-1
 C
 if > 0   # print ' *' this many times
  'P0;Q0;}(
  goto C
 {M8;{    # print a newline, goto x
 (        # x -= 1
 goto A
@
usuario202729
fuente
2

Japt -R, 11 10 bytes

Æ°çSi*Ãû ê

Pruébelo (o use TIO para ejecutar múltiples pruebas)


Explicación

               :Implicit input of integer U
Æ              :Map the range [0,U)
 °             :  Postfix increment U
  ç            :  Repeat
   S           :    Space
    i*         :    Prepend asterisk
      Ã        :End map
       û       :Centre pad each string with spaces to the length of the longest string
         ê     :Palindromise
               :Implicitly join with newlines and output
Lanudo
fuente