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

 * *
* * *
 * *

В то время как шестиугольник размера 3 выглядит так:

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

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

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

*

Допускаются начальные и конечные пробелы, если результат визуально одинаков.

Примеры:

1:
*

2:
 * *
* * *
 * *

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

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

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

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

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

Как обычно, это код-гольф , поэтому применяются стандартные лазейки , и вы должны попытаться написать максимально короткую программу, измеряемую в байтах. Конечно, некоторые языки по своей природе короче или длиннее других, поэтому помните, что цель состоит не в том, чтобы иметь самое короткое общее число байтов, а в том, чтобы превзойти представления на тех же или похожих языках.

Пусть победит лучший гольфист!

Hexagony + Bash Coreutils, 0 + 3 + 8 = 11 байт

Включает +3 для -gфлага и +8 для |tr . \*нестандартного вызова (см. Этот мета-пост )

Входные данные приведены в качестве аргумента в гексагонии. Когда интерпретатор Hexagony вызывается с -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 2 байта.

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 , и он выведет шестиугольник на стандартный вывод.

Разоблаченный и объясненный (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
}

Посмотрите это в прямом эфире на Coliru

Примечания:

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

• Coliru неправильно обрабатывает символ возврата на одну позицию - выполнение этого кода на локальном терминале приводит к удалению начального пробела в каждой строке.

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 *Î.

Попробуйте онлайн!

Как обычно, здесь есть hexdump, поскольку он содержит непечатаемые символы:

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

В отличие от двух текущих ответов 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 

Редактировать: переключено на mapM_. Я не знал, что было доступно без использования импорта

Python 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что печатает с начальным пробелом (я полагаю, что допускается как *визуально то же самое, что и *с начальным пробелом или без него).

Пакет, 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. 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 байта

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}

Страница Чарли 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)
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

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

Скучная, простая реализация (и полная программа). Выводит пробел в каждой строке.

Testcases:

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

Обратите внимание, что это не гексагония, а только (мета) язык, поддерживаемый Тимви в Esoteric IDE, поэтому он не подходит для получения награды.

Однако это может быть преобразовано в решение Hexagony (и я думаю, что оно будет меньше, чем это решение), я могу сделать это позже. Требуется больше усилий, я сделал это здесь .

Начальный ❢ занимает 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
@

Нет Попробуйте онлайн! Это работает только в Esoteric 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