Könnten Sie mir bitte ein Sechseck machen?


53

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 , 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!


15
Warum haben wir überhaupt ein Sechseck-Gitter-Tag?
Pavel

13
Außerdem muss jemand eine Hexagony-Lösung schreiben.
Pavel

Wenn jemand für die Prämie gehen möchte, können Sie wahrscheinlich die Ausgabeschleife meiner Hexagony-Antwort hier wiederverwenden .
Martin Ender

6
"Könnten Sie mir bitte ein Sechseck machen?" - Na
klar

@Pavel, weil sich viele Operationen in einem hexagonalen Raster von denen in einem mehr standardmäßigen quadratischen Raster unterscheiden und zwischen Lösungen für verschiedene Probleme übertragen werden können. Operationen wie Koordinatenmanipulation, Drehung, Ausgabe-Layout usw.
Sparr

Antworten:


37

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 .


2
Wow, das ist genial. Und Sie schlagen alle Golfsprachen!
DJMcMayhem

6
Ich würde das nicht wirklich mit der Hexagony-Sprache bezeichnen, sondern eher mit bash (oder einer anderen Shell) mit dem Hexagony-Interpreter als einem der Befehle. Das wäre zB hexagony -g $1|tr . \*, wenn der Hexagony-Interpreter so heißt.
Paŭlo Ebermann

3
Dies würde von einem tatsächlichen, ausführbaren Befehl profitieren ...
jpmc26

1
@ jpmc26 Für eine Länge von 5 Hex würden Sie ausführenruby ./interpreter.rb -g 5|tr . \*
Riley

3
@OlivierDulac Das "Programm" ist null Bytes. Die ganze Arbeit wird von den "Flags" erledigt.
Riley

20

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.


Ausgehend von diesen leiten Sie einen nicht PEP8 aber gültigen Python 3 - Code mit 69 Bytes, durch int(input())statt input()und den üblichen print(' '*j+'* '*(2*n+~j))ersetzen print' '*j+'* '*(2*n+~j)- cool Code btw ;-)
Dilettant

Das ist echt cooler Code!
Matias Bjarland

13

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>


11

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 .


10

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


10

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.


w=printf("\n%*s",abs(y),"");++w<s*printf(" *");
Jasen

@Jasen Ich kann nicht glauben, dass ich das verpasst habe ... Danke!
Quentin

9

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!


1
Ich verstehe nicht, was der Teil "Zentralisieren" tut. Wenn ich es entferne, erhalte ich ein Array von Zeichenfolgen ohne die entsprechende Anzahl von führenden Leerzeichen.
DJMcMayhem

1
@DJMcMayhem In einem Array können Sie sehen, dass es sich um eine Zeichenfolge handelt, die durch Zeilenumbrüche mit zentriertem Text verbunden ist. Dies geschieht bei der Eingabe.
Adnan

8

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‘

2
Puh, die Erklärung war überwältigend.
Erik der Outgolfer

Was würde ein "Zentralisierungsatom" tun?
DJMcMayhem

@DJMcMayhem Ein Beispiel finden Sie in der Antwort 05AB1E.
Erik der Outgolfer

7

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

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

6

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

lpadVielleicht können Sie ein paar Bytes sparen. Ich würde auch die Sprache pl / pgsql nennen, aber das wirft Fragen auf, ob Sie das do language plpgsql $$und das Closing zählen müssen $$;. Diese werden am besten auf Meta angesprochen, wenn sie noch nicht aufgetaucht sind.
jpmc26

Warum brauchen Sie auch mehrere DECLAREs? Würde nicht ein einziger funktionieren?
jpmc26

6

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                                       .

6

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

5

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.


Könnten Sie verwenden, alertwenn Sie Browser-Js angeben?
FlipTack

@FlipTack, eigentlich nicht, da ich den String nach und nach aufbaue (Zeile für Zeile). Wenn ich alertes bearbeitete, warnte es Zeile für Zeile und nicht die ganze Sache.
Luke

5

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


5

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


1
Dies ergibt eine falsche Lösung für 1 - "*". Ich denke es sollte ein Stern ohne Leerzeichen davor sein?
Андрей Ломакин

@ АндрейЛомакин - From OP: "Führende und nachfolgende Leerzeichen sind zulässig, solange die Ausgabe visuell identisch ist." Ein einzelner Stern ist optisch das gleiche wie ein einzelner Stern mit einem Leerzeichen davor oder zumindest war das meine Interpretation ;-)
ElPedro

Aber Sie haben tatsächlich Recht, dass ich dem widersprochen habe, was ich gerade in meiner Antwort gesagt habe. Ich habe die Antwort zur Klarstellung aktualisiert. Besser jetzt? Übrigens, gute Arbeit beim Finden einer alten Antwort und Erkennen eines möglichen Fehlers. Respekt.
ElPedro

1
Ich habe diese Herausforderung selbst versucht und konnte mir nichts Besseres einfallen lassen. Ich habe mich bei Ihnen um Inspiration bemüht.
Андрей Ломакин

Ich hoffe, meine bescheidene Anstrengung hat dir geholfen. Sicher, wir werden in Zukunft ein bisschen Spaß beim gemeinsamen Golfen haben. Viel Spaß mit PPCG. Ich bin mir sicher ☺
ElPedro

4

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

4

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>


4

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


3

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

3

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

1
Gute Verwendung von gu.
AdmBorkBork

3

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.


2

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]

Sie können 1 Byte speichern, indem Sie (1-n ... n) mit 3 Punkten verwenden
GB

Ein Konsens scheint darin zu bestehen, den Ausgabecode (dh puts) in die Zeichenanzahl aufzunehmen. Aber wenn Sie die Definition noch einmal lesen, heißt es nur, dass Ihre Funktion das Ergebnis "ausgeben" soll, was als "Rückgabe" des Ergebnisses interpretiert werden könnte. Kühle Lösung.
Matias Bjarland



2

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


2

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

3
Willkommen auf der Seite! Dies ist ein Code-Golf-Wettbewerb, daher sollten Sie Ihre Byteanzahl angeben. Sie können auch viele der in dieser Antwort enthaltenen Leerzeichen entfernen, um sie zu verkürzen.
Weizen-Assistent

Vielen Dank für Ihre Eingabe, Cat Wizard. Ich bin neu im Code-Golfen, und ich nehme an, dass Schema nicht die beste Sprache dafür ist, aber ich werde versuchen, es zu verkürzen, Leerzeichen zu entfernen und bei meinem nächsten Eintrag eine Byteanzahl hinzuzufügen.
Kevin

2

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

2

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


2
Einige Verbesserungen: for(j=c.length-2;j>-1;j--)c.push(c[j])kann geschrieben werden for(j=a-1;j;c.push(c[--j]))und for(i=0;i<a;i++){c.push(" ".repeat(a-i-1)+"* ".repeat(i+a-1)+"*")}könnte for(i=0;i<a;c.push(" ".repeat(a-i-1)+"* ".repeat(a-1+i++));. Die return-Anweisung könnte auf return a-1?c.join\ n verkürzt werden. :"*"Insgesamt sparen diese Änderungen 18B (11 + 7 + 1).
Luke

2

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!



1
94 Bytes. HINWEIS: Java 11 hat String#repeat(int), aber TIO ist immer noch JDK 10, daher die emulierte repeat(String,int)Methode (mit der gleichen Byte-Anzahl). Der eigentliche Code in Java 11 wäre:s->{for(int j=~--s,t;++j<=s;System.out.println(" ".repeat(t)+"* ".repeat(s-~s-t)))t=j<0?-j:j;}
Kevin Cruijssen

1
@ Eugene Sicher. :) In diesem Fall einige Dinge zum Golfen in der aktuellen Java-Version (8+) für jetzt: 129 Bytes .
Kevin Cruijssen

1
@KevinCruijssen Das ist ein ziemlich schweres Golfen hier, aktualisiert es, danke.
Eugene

1
Ich wieder. Ich habe eine weitere Sache zum Golfen für -2 Bytes gefunden. 127 Byte Dies kann auch verwendet werden, um 1 Byte in der obigen Java 11-Lösung zu spielen .
Kevin Cruijssen

2

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
@

2

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
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.