Aujourd'hui, nous allons créer un hexagone ASCII. Vous devez écrire un programme ou une fonction prenant un entier positif n et générant une grille hexagonale de taille n , composée d'astérisques. Par exemple, un hexagone de taille 2 ressemble à ceci:

 * *
* * *
 * *

Alors qu’un hexagone de taille 3 ressemble à ceci:

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

Vous pouvez utiliser n’importe laquelle des méthodes d’entrée et de sortie par défaut , par exemple STDIO / STDOUT, les arguments de fonction et les valeurs de retour ou lire / écrire un fichier.

Vous pouvez supposer que la saisie est toujours valide, donc si ce n'est pas un entier positif, votre programme peut faire ce que vous voulez. Vous ne devez cependant traiter le cas particulier d'une taille 1 hexagone, qui se trouve être un astérisque:

*

Les espaces de début et de fin sont autorisés tant que la sortie est visuellement identique.

Exemples:

1:
*

2:
 * *
* * *
 * *

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

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

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

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

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

Comme d'habitude, c'est du code-golf , donc les échappatoires standard s'appliquent , et vous devriez essayer d'écrire le programme le plus court possible mesuré en octets. Bien sûr, certaines langues sont intrinsèquement plus courtes ou plus longues que d’autres, rappelez-vous donc que l’objectif n’est pas nécessairement d’avoir le plus petit nombre total d’octets, mais de battre les soumissions dans les mêmes langues ou dans des langues similaires.

Que le meilleur golfeur gagne!

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

Inclut +3 pour le -gdrapeau et +8 pour |tr . \*l'appel non standard (voir cette méta publication )

L'entrée est donnée sous forme d'argument à Hexagony. Lorsque l'interpréteur Hexagony est appelé avec l' -g Noption, il affiche un hexagone de .s. Nous utilisons ensuite tr pour remplacer ceux par *s.

Python 2, 61 octets

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

Imprime un espace de fin à la fin de chaque ligne.

Merci à Erik the Outgolfer pour avoir sauvegardé un octet.

JavaScript (ES6), 77 81 84

@Upvoters: ne manquez pas la réponse de @ETHproductions, soit 76 octets

Modifier Révisé après modification des spécifications, espace de fin autorisé

Juste pour le chapeau ... hé! Pas de chapeau?

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

Tester

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>

Hexagony , 91 87 86 octets

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

Essayez-le en ligne!

Finalement l'a fait.

Initialement (avant de réaliser à quel point les boucles sont coûteuses), je suppose que cela pourra peut-être tenir dans la longueur de côté 5, mais maintenant, il est assez difficile de l’adapter à la longueur de côté 6.

Pour obtenir cela, je dois en fait modifier un peu le code linéaire. En fait, écrire ceci me permet de comprendre comment coder le code linéaire de 1 à 2 octets.

JavaScript (ES6), 77 76 octets

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

Je me suis dit que je ne dormirais pas tant que je n'aurais pas établi un nouvel enregistrement ES6 sans regarder les autres réponses, alors voila ...

Extrait de test

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

C, 91 89 80 74 octets

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

J'ai à peu près tordu pour obtenir les bonnes formules, puis j'ai tout mis en purée.

Appelez favec le numéro n , et l'hexagone sera imprimé sur la sortie standard.

Non golfé et expliqué (version 80 octets):

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
}

Voir en direct sur Coliru

Remarques:

• printfpeut gérer le remplissage négatif, ce qui donne un caractère aligné à gauche avec le remplissage à droite. J'ai donc essayé quelque chose qui aurait pour effet de w = printf("%*c*", y, ' ')prendre en compte la valeur absolue et de la récupérer à partir de sa valeur de retour. Malheureusement, les largeurs de remplissage zéro et une impriment le caractère seul, de sorte que les trois lignes centrales sont identiques.
  Mise à jour: Jasen a trouvé un moyen de faire exactement cela en imprimant une chaîne vide au lieu d'un caractère - 6 octets supprimés!

• Coliru ne gère pas correctement le caractère de retour arrière. L'exécution de ce code sur un terminal local supprime l'espace de début sur chaque ligne.

05AB1E , 14 à 13 octets

Code:

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

Explication:

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

Utilise le codage CP-1252 . Essayez-le en ligne!

Gelée , 24 octets

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

Essayez-le en ligne!

Jelly a honte du fait qu’il n’a pas d’atome de centralisation, c’est donc battu de 05AB1E et V. De 11 et 7 octets respectivement!

Si vous trouvez un moyen de jouer au golf, veuillez commenter. Toute aide est appréciée.

Explication :

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.

Bonus: pour trouver le nombre d'étoiles dans un hexagone, utilisez ceci:

Ḷ×6S‘

Octave, 62 58 octets

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

Réponse précédente:

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

qui peut être appelé comme

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

Essayez-le (coller) sur Octave Online

Par exemple, l'image de base pour n=5est

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

qui peut être créé avec

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

Le dilation morphological operatorappliqué 4 fois sur l'image en utilisant le masque voisin suivant:

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

qui peut être créé avec [k='01010'-48;~k;k]

résultat de la dilatation:

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

puis remplacez 0 et 1 par '' et '*' respectivement

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

postgresql9.6, 290 octets

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 formaté est ici:

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

sortie:

INFO:      * * * *
INFO:     * * * * *
INFO:    * * * * * *
INFO:   * * * * * * *
INFO:    * * * * * *
INFO:     * * * * *
INFO:      * * * *

V , 17 octets

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

Essayez-le en ligne!

Comme d'habitude, voici un hexdump, puisqu'il contient des caractères non imprimables:

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

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

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

Suppose ⎕IO←0, c'est-à-dire une indexation basée sur zéro La sortie contient un espace de début et un espace de fin sur chaque ligne.

Un grand merci à @FrownyFrog et @ngn pour beaucoup de golf.

Essayez-le en ligne!

Comment ça fonctionne

(⍉⊖⍪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

JavaScript (ES6), 83 81 octets

Ceci est ma première réponse (code golf). J'espère que j'ai tout formaté correctement.

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

Contrairement aux 2 réponses ES6 actuelles, je n’appelle pas de manière récursive et j’utilise la console pour la sortie.

Haskell, 99 97 79 octets

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

Explication: Ce programme est basé sur l'observation que chaque ligne d'un n-hexagone contient des espaces (nk) suivis par des astérisques (n + k-1), pour certains k dépendant du numéro de ligne.

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 

Edit: Basculé sur mapM_. Je ne savais pas qu'il était disponible sans l'aide de l'importation

Python 2 , 100 97 89 88 87 81 79 octets

-1 de @ Flp.Tkc

-6 à nouveau de @Flp

-2 avec merci à @ nedla2004. J'essayais de trouver comment me débarrasser de la deuxième tranche mais je n'y pensais pas :)

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

Essayez-le en ligne!

Crée un tableau pour la moitié supérieure puis ajoute le tableau inversé moins la ligne médiane, puis s'imprime. Imprime exactement "en l’état", sauf pour les 1impressions avec un espace de début (je suppose que cela est autorisé car *est visuellement identique au *avec ou sans espace de début).

Lot, 161 octets

@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%%

Remarque: espace de fin sur la ligne 2. Ungolfed:

@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

JavaScript (ES6), 83 octets

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>

Toile , 9 octets

╷⁸＋* ×］／─

Essayez-le ici!

Battre l'intégré: D

Explication:

{╷⁸+* ×]/─  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

_{Je ne sais pas pourquoi il y a un si grand rembourrage, mais c'est autorisé et je répare ce problème bientôt ™. fixé? J'espère que je n'ai pas casser des trucs}

Perl 6 , 49 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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

Powershell, 91 89 78 68 63 52 48 octets

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

Script de test:

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

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

Sortie (espace de début supplémentaire):

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

Explication:

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

PHP, 83 79 octets

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

Exécuter en pipe -nRou essayer en ligne .

C'est proche de la réponse de Kodos ; mais str_padest plus courte que str_repeatmême quand on joue au golf.
Et la ++tête dans la boucle enregistre encore plus.

Ruby, 54 octets

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

La fonction lambda prend n en argument et renvoie une chaîne séparée par des nouvelles lignes. ( $/est une variable contenant le séparateur de ligne par défaut.)

dans le programme de test

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

puts f[gets.to_i]

Charly, 125 octets

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}

Charly GitHub Page: https://github.com/KCreate/charly-lang

SmileBASIC, 74 octets

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

Ajoute un espace de début et de fin.

Ces "hexagones" ont l’air horrible quand les personnages ont la même largeur et la même hauteur ...

raquette / schéma

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

essai:

(f 1)
*

(f 4)
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

Python 2, 111 octets

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

Une mise en œuvre simple et ennuyeuse (et un programme complet). Affiche un espace de fin à chaque ligne.

Cas de test:

1:
*

2:
 * * 
* * * 
 * * 

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

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

Javascript (ES6), 143 octets

C'est enfin la pause de Noël (joyeux Noël!), J'ai donc un peu de temps pour jouer au golf.
Et ça fait un bout de temps, d'où le grand nombre d'octets.
Voici:

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

Java, 157 149 129 127 octets

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 octets supprimés par Jonathan Frech.
• 20 octets supprimés par Kevin Cruijssen.
• 2 octets supprimés par Kevin Cruijssen.

Essayez-le en ligne!

Hexagone (linéaire), 128 127 126 octets

Notez qu'il ne s'agit pas d' Hexagony, mais simplement d'un (méta-) langage Timwi pris en charge dans Esoteric IDE. Ce n'est donc pas éligible à la prime.

Cependant, cela peut être converti en une solution Hexagony (et je pense que ce sera plus petit que cette solution), je pourrai le faire plus tard. Cela prend plus d'effort que je l'ai fait ici .

L'initiale ❢prend 3 octets ( e2 9d a2). Chaque nouvelle ligne prend 1 octet ( 0a).

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

Non Essayez-le en ligne !. Cela ne fonctionne que dans l'IDE Esoteric.

Code annoté:

❢?        # 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
@

Japt -R, 11 à 10 octets

Æ°çSi*Ãû ê

Essayez-le (ou utilisez TIO pour exécuter plusieurs tests)

Explication

               :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