Heute machen wir ein ASCII-Sechseck. Sie müssen ein Programm oder eine Funktion schreiben, die eine positive Ganzzahl n annimmt und ein aus Sternchen bestehendes Sechseckgitter der Größe n ausgibt . Ein Sechseck der Größe 2 sieht beispielsweise so aus:

 * *
* * *
 * *

Während ein Sechseck der Größe 3 so aussieht:

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

Sie können eine der Standardeingabe- und -ausgabemethoden verwenden , z. B. STDIO / STDOUT, Funktionsargumente und Rückgabewerte oder das Lesen / Schreiben einer Datei.

Sie können davon ausgehen, dass die Eingabe immer gültig ist. Wenn es sich also nicht um eine positive Ganzzahl handelt, kann Ihr Programm tun, was Sie wollen. Sie müssen jedoch den Sonderfall eines Sechsecks der Größe 1 behandeln, bei dem es sich zufällig um ein einzelnes Sternchen handelt:

*

Führende und nachfolgende Leerzeichen sind zulässig, solange die Ausgabe visuell identisch ist.

Beispiele:

1:
*

2:
 * *
* * *
 * *

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

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

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

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

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

Wie üblich ist dies Codegolf , daher gelten Standardlücken , und Sie sollten versuchen, das kürzestmögliche Programm in Bytes zu schreiben. Natürlich sind einige Sprachen von Natur aus kürzer oder länger als andere. Denken Sie also daran, dass das Ziel nicht notwendigerweise die kürzeste Gesamtbyteanzahl ist, sondern die Übermittlung in derselben oder einer ähnlichen Sprache zu unterbinden.

Möge der beste Golfer gewinnen!

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

Beinhaltet +3 für -gFlag und +8 für |tr . \*nicht standardmäßigen Aufruf (siehe diesen Metapost )

Die Eingabe wird Hexagony als Argument übergeben. Wenn der Hexagony-Interpreter mit der -g NOption aufgerufen wird, wird ein Sechseck von .s ausgegeben . Wir verwenden dann tr, um diese durch *s zu ersetzen .

Python 2, 61 Bytes

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

Gibt am Ende jeder Zeile ein Leerzeichen aus.

Vielen Dank an Erik den Outgolfer für das Speichern eines Bytes.

JavaScript (ES6), 77 81 84

@Upvoters: Verpassen Sie nicht die Antwort von @ETHproductions, das sind 76 Bytes

Bearbeiten Nach Änderung der Spezifikation überarbeitet, nachfolgendes Leerzeichen zulässig

Nur für den Hut ... hey! Kein Hut?

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

Prüfung

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 Bytes

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

Probieren Sie es online!

Endlich geschafft.

Zunächst (bevor mir klar wird, wie teuer die Schlaufen sind) erwarte ich, dass dies möglicherweise in die Seitenlänge 5 passt, aber jetzt ist es schwierig genug, es in die Seitenlänge 6 zu passen.

Um das zu bekommen, muss ich den linearen Code ein wenig modifizieren. Wenn ich das schreibe, merke ich sogar, wie ich den linearen Code um 1 bis 2 Byte verkleinern kann .

JavaScript (ES6), 77 bis 76 Byte

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

Ich sagte mir, ich würde nicht schlafen, bis ich einen neuen ES6-Rekord aufgestellt hätte, ohne auf die anderen Antworten zu achten, also hier ist es ...

Testschnipsel

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 Bytes

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

Ich habe ziemlich viel herumgepfiffen, um die richtigen Formeln zu finden, und dann alles zusammengepresst.

Rufen Sie fmit der Nummer n an , und es wird das Sechseck auf stdout gedruckt.

Ungolfed und erklärt (80-Byte-Version):

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
}

Sehen Sie es live auf Coliru

Anmerkungen:

• printfKann negative Auffüllungen verarbeiten, was zu einem linksbündigen Zeichen mit der Auffüllung auf der rechten Seite führt. Ich habe also versucht, etwas zu bewirken, w = printf("%*c*", y, ' ')damit der absolute Wert erhalten bleibt, und ich konnte ihn von seinem Rückgabewert abrufen. Leider wird das Zeichen sowohl mit einer als auch mit einer Auffüllbreite gedruckt, sodass die drei Mittellinien identisch waren.
  Update: Jasen hat eine Möglichkeit gefunden, genau dies zu tun, indem er eine leere Zeichenfolge anstelle eines Zeichens druckt - 6 Bytes sind abgeschnitten!

• Das Backspace-Zeichen wird von Coliru falsch behandelt. Wenn Sie diesen Code auf einem lokalen Terminal ausführen, wird das führende Leerzeichen in jeder Zeile entfernt.

05AB1E , 14 13 Bytes

Code:

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

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Gelee , 24 Bytes

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

Probieren Sie es online!

Jelly schämt sich für die Tatsache, dass es kein Zentralisierungsatom hat. Deshalb wird es von 05AB1E und V geschlagen. Mit 11 bzw. 7 Bytes!

Wenn Sie einen Weg finden, Golf zu spielen, kommentieren Sie bitte. Jede Hilfe wird geschätzt.

Erklärung :

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: Um herauszufinden, wie viele Sterne sich in einem Sechseck befinden, verwenden Sie Folgendes:

Ḷ×6S‘

Oktave, 62 58 Bytes

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

Vorherige Antwort:

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

das kann man nennen als

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

Versuchen Sie es auf Octave Online

Zum Beispiel für das Basisbild n=5ist

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

das kann mit erstellt werden

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

Die dilation morphological operator4 mal auf das Bild mit der folgenden Nachbarmaske angewendet:

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

das kann mit erstellt werden [k='01010'-48;~k;k]

Ergebnis der 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

Ersetzen Sie dann 0 und 1 durch '' bzw. '*'

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

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

formatiertes SQL ist hier:

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

Ausgabe:

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

V , 17 Bytes

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

Probieren Sie es online!

Wie üblich ist hier ein Hexdump, da dieser nicht druckbare Zeichen enthält:

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

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

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

Angenommen ⎕IO←0, dh nullbasierte Indizierung. Die Ausgabe enthält in jeder Zeile ein vorangestelltes und ein nachgestelltes Leerzeichen.

Vielen Dank an @FrownyFrog und @ngn für viel Golf.

Probieren Sie es online!

Wie es funktioniert

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

Dies ist meine erste Antwort (Code Golf). Ich hoffe ich habe alles richtig formatiert.

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

Im Gegensatz zu den 2 aktuellen ES6-Antworten rufe ich keine Funktion rekursiv auf und verwende die Konsole für die Ausgabe.

Haskell, 99 97 79 Bytes

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

Erläuterung: Dieses Programm basiert auf der Beobachtung, dass jede Zeile eines n-Hexagons (nk) Leerzeichen gefolgt von (n + k-1) Sternchen enthält, wobei einige k von der Zeilennummer abhängen.

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 

Bearbeiten: Auf mapM_ umgestellt. Mir war nicht bewusst, dass ohne Import verfügbar war

Python 2 , 100 97 89 88 87 81 79 Bytes

-1 von @ Flp.Tkc

-6 nochmal von @Flp

-2 mit Dank an @ nedla2004. Ich habe versucht herauszufinden, wie ich das zweite Stück loswerden kann, aber ich habe nicht daran gedacht :)

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

Probieren Sie es online!

Erstellt ein Array für die obere Hälfte und fügt dann das umgekehrte Array abzüglich der Mittellinie hinzu und druckt dann. Druckt genau so, wie es ist, abgesehen davon, 1welche Abzüge mit einem führenden Leerzeichen versehen sind (ich denke, dass a *visuell genauso zulässig ist wie a *mit oder ohne führendem Leerzeichen).

Batch, 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%%

Hinweis: Leerzeichen in Zeile 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 Byte

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 Bytes

╷⁸＋* ×］／─

Probieren Sie es hier aus!

Das eingebaute schlagen: D

Erläuterung:

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

_{Keine Ahnung, warum es die riesige Polsterung gibt, aber es ist erlaubt und ich repariere das bald ™. Fest? Hoffe, ich habe nichts kaputt gemacht}

Perl 6 , 49 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

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

Testskript:

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

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

Ausgabe (zusätzliches Leerzeichen):

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

Erläuterung:

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 Bytes

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

Laufen Sie als Pipe mit -nRoder versuchen Sie es online .

Dies kommt der Antwort von Kodos sehr nahe . Ist aber str_padkürzer als str_repeatselbst beim Golfen.
Und der ++in der Schleife Kopf spart noch etwas mehr.

Ruby, 54 Bytes

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

Die Lambda-Funktion nimmt n als Argument und gibt eine durch Zeilenumbrüche getrennte Zeichenfolge zurück. ( $/ist eine Variable, die das standardmäßige Zeilentrennzeichen enthält.)

im Testprogramm

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

puts f[gets.to_i]

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}

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

SmileBASIC, 74 Bytes

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

Fügt ein führendes und ein nachfolgendes Leerzeichen hinzu.

Diese "Sechsecke" sehen schrecklich aus, wenn die Zeichen die gleiche Breite und Höhe haben ...

Schläger / Schema

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

testen:

(f 1)
*

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

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

Eine langweilige, unkomplizierte Implementierung (und ein vollständiges Programm). Gibt in jeder Zeile ein nachgestelltes Leerzeichen aus.

Testfälle:

1:
*

2:
 * * 
* * * 
 * * 

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

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

Javascript (ES6), 143 Byte

Es ist endlich Weihnachtsferien (Frohe Weihnachten!), Also habe ich etwas Zeit zum Golfen.
Und Junge, es ist schon eine Weile her - daher die große Anzahl von Bytes.
Hier geht:

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 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 entfernt von Jonathan Frech.
• 20 Bytes entfernt von Kevin Cruijssen.
• 2 Bytes entfernt von Kevin Cruijssen.

Probieren Sie es online!

Hexagony (linear), 128 127 126 Bytes

Beachten Sie, dass dies nicht Hexagony ist, sondern nur eine (Meta-) Sprache, die Timwi in der esoterischen IDE unterstützt. Daher ist dies nicht für die Prämie berechtigt.

Dies kann jedoch in eine Hexagony-Lösung umgewandelt werden (und ich denke, es wird kleiner als diese Lösung sein). Ich kann das später tun. Ich muss mich mehr anstrengen, um es hier zu tun .

Der Initial ❢dauert 3 Bytes ( e2 9d a2). Jede neue Zeile benötigt 1 Byte ( 0a).

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

Nein, versuchen Sie es online !. Dies funktioniert nur in Esoteric IDE.

Kommentierter Code:

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

Æ°çSi*Ãû ê

Probieren Sie es aus (oder verwenden Sie TIO , um mehrere Tests durchzuführen)

Erläuterung

               :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