Сьогодні ми збираємося зробити шестикутник ASCII. Ви повинні написати програму або функцію, яка приймає натуральне ціле n , і виводить шестикутну сітку розміром n , складену зірочками. Наприклад, шестикутник розміром 2 виглядає так:

 * *
* * *
 * *

Хоча шестикутник розміром 3 виглядає так:

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

Ви можете використовувати будь-який із методів вводу та виводу за замовчуванням , наприклад, STDIO / STDOUT, аргументи функцій та значення повернення або читання / запис файлу.

Ви можете припустити, що введення завжди дійсне, тому якщо це не додатне ціле число, ваша програма може робити все, що завгодно. Ви дійсно однак повинні обробляти особливий випадок розміру 1 шестикутник, який буває один зірочка:

*

Простір провідних та кінцевих пробілів дозволений до тих пір, поки вихід візуально однаковий.

Приклади:

1:
*

2:
 * *
* * *
 * *

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

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

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

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

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

Як завжди, це код-гольф , тому застосовуються стандартні лазівки , і вам слід спробувати написати найкоротші можливі програми, виміряні в байтах. Звичайно, деякі мови за своєю суттю коротші або довші, ніж інші, тому пам’ятайте, що мета не обов’язково мати найкоротший загальний підрахунок байтів, а перемогти подання в одній і тій же схожій мові.

Нехай переможе найкращий гольфіст!

Шестикутник + Баш-коріутіли, 0 + 3 + 8 = 11 байт

Включає +3 для -gпрапора та +8 для |tr . \*нестандартного виклику (див. Цей мета-пост )

Введення подано як аргумент Гексагонії. Коли викликається перекладач "Шестикутник" з -g Nопцією, він друкує шестикутник .s. Потім ми використовуємо tr, щоб замінити їх на *s.

Python 2, 61 байт

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

Виводить пробіл у кінці кожного рядка.

Дякуємо Еріку Аутгольферу за збереження байта.

JavaScript (ES6), 77 81 84

@Upvoters: не пропустіть відповідь від @ETHproductions, тобто 76 байт

Редагувати Переглянуто після зміни специфікації, дозволений пробіл

Тільки для капелюха ... ей! Без шапки?

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

Тест

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>

Гексагонія , 91 87 86 байт

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

Спробуйте в Інтернеті!

Нарешті зробив це.

Спочатку (перш ніж усвідомити, наскільки дорогі петлі), я думаю, що це може бути в змозі поміститися в бічну довжину 5, але тепер досить важко вписати її в бічну довжину 6.

Для цього мені насправді треба трохи змінити лінійний код. Насправді, написавши це, я змушує реалізувати спосіб перенесення лінійного коду на 1 байт.

JavaScript (ES6), 77 76 байт

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

Я сказав собі, що не спатиму, поки не встановлю новий рекорд ES6, не дивлячись на інші відповіді, тож ось це ...

Фрагмент тесту

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 байт

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

Я досить крутився навколо, щоб отримати правильні формули, потім пюре це все разом.

Зателефонуйте fз номером n , і він надрукує шестикутник у stdout.

Недоліковані та пояснені (80-байтна версія):

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
}

Побачити його наживо на Коліру

Примітки:

• printfможе обробляти негативні прокладки, що призводить до вирівнювання ліворуч символом із підкладкою праворуч. Таким чином, я спробував щось в результаті, w = printf("%*c*", y, ' ')щоб воно піклувалося про абсолютне значення, і я могла отримати це з його поверненого значення. На жаль, як нульова, так і одна ширина прокладки друкують персонаж самостійно, тому три центральні лінії були однаковими.
  Оновлення: Jasen знайшов спосіб зробити саме це, надрукувавши порожній рядок замість символу - 6 байтів вибриті!

• Коліру неправильно обробляється символом зворотної області - виконання цього коду на локальному терміналі видаляє провідний пробіл у кожному рядку.

05AB1E , 14 13 байт

Код:

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

Пояснення:

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

Використовує кодування CP-1252 . Спробуйте в Інтернеті!

Желе , 24 байти

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

Спробуйте в Інтернеті!

Джелі соромиться того, що у нього немає атома централізації, тому його б'ють по 05AB1E і V. На 11 і 7 байт відповідно!

Якщо ви знайдете будь-який спосіб пограти в гольф, будь ласка, прокоментуйте. Будь-яка допомога вдячна.

Пояснення :

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.

Бонус: Щоб знайти скільки зірок у шестикутнику, скористайтеся цим:

Ḷ×6S‘

Октава, 62 58 байт

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

Попередня відповідь:

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

що можна назвати як

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

Спробуйте (вставте) його на Octave Online

Наприклад, базове зображення для n=5є

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

які можна створити за допомогою

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

У dilation morphological operatorзастосованому в 4 рази по зображенню , використовуючи наступну сусідню маску:

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

які можна створити за допомогою [k='01010'-48;~k;k]

результат розширення:

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

потім замініть 0 і 1 на "" і "*" відповідно

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

postgresql9.6, 290 байт

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 тут:

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

вихід:

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

V , 17 байт

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

Спробуйте в Інтернеті!

Як завжди, тут є шістнадцятковий, оскільки він містить недруковані символи:

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

APL (Dyalog Unicode) , 40 36 35 33 27 25 байт

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

Припускає ⎕IO←0, тобто нульове індексування. Вихід містить один провідний та один пробіли у кожному рядку.

Велике спасибі @FrownyFrog та @ngn за багато гольфу.

Спробуйте в Інтернеті!

Як це працює

(⍉⊖⍪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 байт

Це моя перша (кодова гольф) відповідь. Сподіваюся, я все правильно відформатував.

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

На відміну від 2 поточних відповідей ES6, я не рекурсивно викликаю функцію, і я використовую консоль для виводу.

Haskell, 99 97 79 байт

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

Пояснення: Ця програма заснована на спостереженні, що кожен рядок n-шестикутника містить (nk) пробіли, за якими слідують зірки (n + k-1), для деяких k, залежних від номера рядка.

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 

Редагувати: переключився на картуM_. Мені не було відомо, що це доступно без використання імпорту

Пітон 2 , 100 97 89 88 87 81 79 байт

-1 від @ Flp.Tkc

-6 знову від @Flp

-2 завдяки @ nedla2004. Я намагався знайти, як позбутися другого шматочка, але не думав про це :)

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

Спробуйте в Інтернеті!

Створює масив для верхньої половини, після чого додає перевернутий масив мінус середня лінія, а потім друкує. Друкується точно "як є", крім того, 1що друкує з провідним пробілом (я думаю, що дозволено як a *, візуально збігається *з провідним простором або без нього).

Пакетна, 161 байт

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

Примітка: пробіл на лінії 2. Недозволений:

@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 байти

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>

Полотно , 9 байт

╷⁸＋* ×］／─

Спробуйте тут!

Побиття вбудованого: D

Пояснення:

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

_{Не маю уявлення, чому існує величезна накладка, але це дозволено, і я скоро це виправляю ™. виправлено? Сподіваюся, я не зламав речі}

Perl 6 , 49 байт

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

Спробуйте в Інтернеті!

Як це працює

->\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 байт

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

Тестовий сценарій:

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

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

Вихід (додатковий провідний простір):

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

Пояснення:

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 байт

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

Запустіть як трубу -nRабо спробуйте в Інтернеті .

Це близько до відповіді Кодоса ; але str_padкоротше, ніж str_repeatнавіть при гольфі.
А ++голова в петлі економить ще трохи.

Рубін, 54 байти

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

лямбда-функція приймає n як аргумент і повертає рядок, розділену новими рядками. ($/ є змінною, що містить роздільник рядків за замовчуванням.)

в тестовій програмі

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

puts f[gets.to_i]

Чарлі, 125 байт

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: https://github.com/KCreate/charly-lang

SmileBASIC, 74 байти

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

Додає провідний та кінцевий простір.

Ці "шестикутники" виглядають жахливо, коли персонажі мають однакову ширину і висоту ...

ракетка / схема

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

тестування:

(f 1)
*

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

Пітон 2, 111 байт

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

Нудна, прямолінійна реалізація (і повна програма). Виводить пробіли пробілів у кожному рядку.

Тести:

1:
*

2:
 * * 
* * * 
 * * 

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

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

Javascript (ES6), 143 байти

Це нарешті різдвяна перерва (з Різдвом Христовим!), Тож у мене є час для гольфу.
І хлопчик минув деякий час - звідси велика кількість байтів.
Ось:

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 байт

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 байт видалено Джонатаном Фрехом.
• 20 байтів вилучив Кевін Крейссен.
• 2 байти вилучив Кевін Крейссен.

Спробуйте в Інтернеті!

Шестикутник (лінійний), 128 127 126 байт

Зауважте, що це не Гексагонія, а лише (мета-) мова Тімві, підтримувана в Ezoteric IDE, тому це не підходить для винагороди.

Однак це може бути перетворене на розчин шестикутника (і я думаю, що він буде меншим, ніж це рішення), я можу це зробити пізніше. Треба більше зусиль, я це зробив тут .

Початковий ❢займає 3 байти ( e2 9d a2). Кожен новий рядок займає 1 байт ( 0a).

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

Ні Спробуйте в Інтернеті !. Це працює лише в Ezoteric IDE.

Код з примітками:

❢?        # 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 байт

Æ°çSi*Ãû ê

Спробуйте (або використовуйте TIO для запуску декількох тестів)

Пояснення

               :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