今日は、ASCII六角形を作成します。正の整数nを取り、アスタリスクで構成されるサイズnの六角形グリッドを出力するプログラムまたは関数を作成する必要があります。たとえば、サイズ2の六角形は次のようになります。

 * *
* * *
 * *

サイズ3の六角形は次のようになります。

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

あなたは、任意の使用することができ、デフォルトの入力および出力のメソッドをファイルの書き込み/、たとえばSTDIO / STDOUTのために、関数の引数と戻り値や読書を。

入力は常に有効であると仮定することができます。そのため、正の整数でない場合、プログラムは必要な処理を実行できます。ただし、サイズ1の六角形の特殊なケースを処理する必要があります。これはたまたま単一のアスタリスクです。

*

出力が視覚的に同じである限り、先頭と末尾の空白は許可されます。

例：

1:
*

2:
 * *
* * *
 * *

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

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

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

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

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

いつものように、これはcode-golfであるため、標準の抜け穴が適用されます。バイト単位で可能な限り最短のプログラムを書くようにしてください。もちろん、一部の言語は他の言語よりも本質的に短いか長いため、目標は必ずしも全体のバイト数を最短にすることではなく、同じまたは類似の言語で提出することです。

最高のゴルファーが勝つように！

六角形 + Bash Coreutils、0 + 3 + 8 = 11バイト

-gフラグに+3、|tr . \*非標準の呼び出しに+8が含まれます（このメタ投稿を参照）

入力は、Hexagonyの引数として与えられます。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)

各行の末尾にスペースを出力します。

バイトを保存してくれたOutgolferのErikに感謝します。

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, ' ')、絶対値を処理するために、何らかの効果を試みましたが、戻り値から取得することができました。残念ながら、0と1の両方のパディング幅は、それ自体で文字を印刷するため、3つの中心線は同一でした。
  更新： 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

オンラインでお試しください！

Jellyは、中央化アトムを持たないという事実を恥ずかしく思います。そのため、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、つまりゼロベースのインデックス付けを想定しています。出力には、各行に1つの先行スペースと1つの後続スペースが含まれます。

たくさんのゴルフをしてくれた@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 

編集：mapM_に切り替えました。インポートを使用せずに利用できることを知りませんでした

パイソン2、100 97 89 88 87の 81の 79バイト

-1 @ Flp.Tkcから

再び@Flpから-6

-2、@ nedla2004に感謝します。私は2番目のスライスを取り除く方法を見つけようとしていましたが、それを考えていませんでした:)

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>

Canvas、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]

Charly、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)
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

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

退屈で簡単な実装（および完全なプログラム）。各行に末尾の空白を出力します。

テストケース：

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

• Jonathan Frechによって8バイトが削除されました。
• Kevin Cruijssenによって20バイトが削除されました。
• Kevin Cruijssenによって2バイトが削除されました。

オンラインでお試しください！

六角形（線形）、128 127 126バイト

これがあることに注意していない Hexagony、単に（メタ）言語Timwiは密教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
@

いいえ、オンラインでお試しください！これは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