Sterne machen Sterne

17

Einführung

Die Idee ist, das Sternchen (Stern) *zu verwenden, um einen ASCII-Stern in einer bestimmten Dimension anzuzeigen. Die Bemaßung ist eine Eingabenummer größer oder gleich , die die Höhe in Linien des oberen Punkts des Sterns angibt. Die Sterne hier sollen sechs spitze Sterne mit größeren Größen sein, die aus einer Bildperspektive besser aussehen.1

In allen Fällen soll die ASCII-Darstellung der Sterne als zwei Dreiecke erscheinen, die sich überlappen, wie in den folgenden Beispielen gezeigt.

Parametrics

Das folgende Bild und die Datentabelle beschreiben Attribute für die ersten sieben Größen des Sterns. Jeder der Parameter wächst in einer arithmetischen Folge, wenn zunimmt, mit der Ausnahme, dass unterschiedlich ist .NN=1

Bildbeschreibung hier eingeben

Bildbeschreibung hier eingeben

Beispiele

Für eine Eingabe von 1 (der entartete Fall) sollte die Programmausgabe wie folgt lauten:

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

Eingabe von 2:

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

(3)

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

(5)

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

Herausforderung

Ihre Aufgabe ist es, eine Funktion oder ein Programm zu erstellen, das die Zahl N als Eingabe akzeptiert und dann den Stern mit der entsprechenden Größe nur aus Zeichen und dem *Zeichen ausgibt .

  • Sie können davon ausgehen, dass der Eingabewert immer eine positive ganze Zahl ist.
  • Das nachfolgende Leerzeichen in den Ausgabezeilen ist in Ordnung.
  • Der Programmalgorithmus sollte allgemein genug sein, damit jede Eingabe die Star-Art-Ausgabe erzeugt. Praktische Einschränkungen bestehen natürlich aufgrund der Anzeigeausgabegröße.N
  • Die Ausgabe sollte nach STDOUT erfolgen.
  • Standardlücken sind verboten.
  • Dies ist Code-Golf, daher gelten alle üblichen Golfregeln.

Wertung

Das ist Code-Golf, also gewinnt der Code mit der kürzesten Anzahl von Bytes!

code-golf  ascii-art 
— Michael Karas
quelle
5
Sie sagen auch, es kann eine Funktion sein, aber es muss "auf STDOUT drucken". Ist das beabsichtigt?
— Weizen-Assistent
5
Ja, eine allgemeine Konstruktionsregel wäre großartig ... zum Beispiel bin ich mir nicht sicher, ob Eingaben wie N = 4 ...
— digEmAll
7
Bitte sagen Sie nicht "Der Algorithmus zur Erzeugung der Sterne ist Teil der Programmierherausforderung." Dies ist etwas, das die meisten Golfer bei einer ASCII-Kunstherausforderung nicht mögen, und es klingt nach einem Versuch, etwas zu verpfänden, das in der Verantwortung des Spielers liegt. Das heißt, ich bin überrascht, dass die Leute über den Bau hier nicht klar sind. Es sind zwei Dreiecke, die sich überlappen, wie die Herausforderung sagt. Wäre es hilfreich, die Größe und den Versatz der Dreiecke explizit anzugeben?
— 14.
9
@ TimPederick Guter Fang darüber, dass N = 1 anders ist. Ich habe eine Notiz eingefügt, damit Löser diese nicht verpassen. Ich denke, die Herausforderung wäre jedoch ohne diesen Sonderfall besser.
— 14.
4
@xnor: da n = 1 unterschiedlich war, konnte ich keine allgemeine Regel ableiten ... und IMO sollte die Regel immer für ASCII-Kunst angegeben werden, sonst kann ich gut drucken, was ich will, außerhalb des definierten Bereichs Beispiele;)
— digEmAll

Antworten:

7

05AB1E , 21 Bytes

3*s≠-L·<sÅ0«Âø€à'*×.C

Probieren Sie es online! oder als Testsuite

Erläuterung

3*                     # multiply input by 3
  s≠-                  # subtract 1 if the input isn't 1
     L                 # push range [1 ... (3*n-(n!=1))]
      ·<               # multiply by 2 and subtract 1 to get odd numbers
        sÅ0«           # append n zeroes
            Âø         # zip with a reversed copy
              ۈ       # get the largest number in each pair
                '*×    # repeat "*" for each number in the list
                   .C  # format centered
— Emigna
quelle
1
Ihre Ausgangssterne sehen korrekt aus.
— Michael Karas
1
Ich kann jede Menge Alternativen finden 3*s≠-L·<wie 6*s≠·-ÅÉoder ≠3/-6*ÅÉ, aber leider keine kürzer .. Nizza Antwort, wie immer! :)
— Kevin Cruijssen
xs3*<ŸRsLì'*×.º.C.∊für 19 :). Ich habe gelogen, es funktioniert nicht für 1. Lassen Sie es für Inspiration.
— Magic Octopus Urn
7

Haskell , 114 Bytes

Erstellt eine Funktion, gdie eine Zahl annimmt und eine IOMonade erzeugt , die den Stern nach STDOUT druckt. Ich finde das ok

f=replicate
a%b=mapM_(\n->putStrLn$f(a-n)' '++f(2*n-3)'*')$zipWith max<*>reverse$[2..a]++f b 0
g 1=4%1
g a=(3*a)%a

Probieren Sie es online!

Erläuterung

Lassen Sie uns zuerst über das Lambda sprechen.

\n->putStrLn$f(a-n)' '++f(2*n-1)'*'

Dies braucht eine Zahl, num als Sterne gezeichnet zu werden. Wir drucken doppelt so viele Sterne und dann noch einen und füllen ihn rechts auf die Größe des Bildes auf. Wir füllen dies rechts durch aLeerzeichen auf, um die Sternlinie zu zentrieren. Wir können dieses Lambda verwenden, um jede Linie zu zeichnen.

Aus diesem Lambda erschaffen wir (%). (%)Beginnt damit, mapM_mit unserem Lambda ein Profil in die Form zu bringen.

Jetzt müssen wir nur noch eine Liste des Profils für den Stern erstellen. Wir können dies tun, indem wir zuerst ein Dreieck mit [1..a]und dann mit einigen Nullen auffüllen ++replicate b 0. Wenn wir das Profil des Dreiecks nehmen und es umkehren, erhalten wir die andere Hälfte des Sterns. Um sie zu überlagern, erstellen wir einfach ein neues Profil, in dem jeder Eintrag das Maximum der beiden Dreiecke ist. Das ist zipWith max.

Wir nennen dies dann auf zwei Arten: als 3%1Eingabe von 1und mit dem (3*a-1)%aAnderen.

Ab hier fummeln wir ein bisschen an einigen Werten herum, um ein paar Bytes zu rasieren. Da 3*a-1es ziemlich lang ist, versetzen wir einige unserer anderen Werte um 1, so dass alles abbricht und wir 3*astattdessen das beabsichtigte Verhalten erhalten . Und zwar beginnen wir unsere Liste an 2statt 1und tun 2*n-3statt , 2*n-1die für die Änderung zu bilden.

Alternative Version, 114 Bytes

Dieser baut eine punktfreie Funktion auf (%)<*>min 2

f=replicate
a%b=mapM_(\n->putStrLn$f(3*a-n)' '++f(2*(n-b)+1)'*')$zipWith max<*>reverse$[b..3*a]++f a 0
(%)<*>min 2

Probieren Sie es online!

N>1

f=replicate
g a=mapM_(\n->putStrLn$f(3*a-n)' '++f(2*n-3)'*')$zipWith max<*>reverse$[2..3*a]++f a 0

Probieren Sie es online!

N=1

f=replicate
g a=mapM_(\n->putStrLn$f(3*a-n)' '++f(2*n-1)'*')$zipWith max<*>reverse$[1..3*a]++f a 0

Probieren Sie es online!

— Weizen-Assistent
quelle
Ihre Ausgabe sieht jetzt gut aus.
— Michael Karas
6

R , 125 107 101 Bytes

function(n,S=3*n+!n-1,P=pmax(I<-c(2:S*2-3,!1:n),rev(I)),`~`=strrep)write(paste0(' '~S-1-P/2,'*'~P),1)

Probieren Sie es online!

  • -24 danke an @ Giuseppe

Bisheriger (anderer) Ansatz:

R , 150 148 136 135 130 128 Bytes

function(n,G=n<2,K=4*n-1+G)for(i in 1:K-1)cat(`[<-`(rep(' ',W<-3*n-2+G),1+W+c(-i:i*(i<K-n),-(j=K-i-1):j*(i>=n)),'*'),sep='','
')

Probieren Sie es online!

  • -14 danke an @Kirill L.
  • -1 danke an @ t-clausen.dk
  • -7 danke an @ Giuseppe
— digEmAll
quelle
Ja, ich mag auch diese wiederholten S [] = -Aufträge nicht und es sieht so aus, als würde das funktionieren
— Kirill L.,
Groß ! Ich dachte an so etwas ... aber ich
— aß zu
Anscheinend können Sie ein Byte speichern: i> n-1 kann um
— t-clausen.dk
@ t-clausen.dk: yep, danke!
— digEmAll
1
117 Bytes auf der neueren Version
— Giuseppe
5

Python 2 , 101 99 97 Bytes

n=input()
x=2*(n>1)
for i in range(1,8*n,2):print('*'*[i,8*n-i-x][i+x>n*6or i/n/2%2]).center(6*n)

Probieren Sie es online!

-2 Bytes, danke an Lynn

— TFeld
quelle
Ich bin mir ziemlich sicher, dass Sie die Parens im Selector-Ausdruck nicht benötigen, i+x>n*6orspart also zwei Bytes.
— Lynn
@ Lynn Danke :)
— TFeld
Sie können sogar gehen i+x>~i/n/2%2*6*noder so etwas wie i+x>3*n*(~i/n&2)(beide 96 Bytes.)
— Lynn
5

JavaScript (V8) ,  101  108 Bytes

EDIT: +7 Bytes zum Drucken auf STDOUT

n=>print((k=3*n+!~-n,g=y=>++y<k+n?`
`.padEnd(w=k-Math.max(y>n&&n-y+k,y<k&&y)).padEnd(2*k+~w,'*')+g(y):'')``)

Probieren Sie es online!

Kommentiert (ohne print)

n => (                    // n = input
  k =                     // k is half the maximum width of the star + 1.5
    3 * n + !~-n,         // k = 3n if n > 1 or 4 if n = 1
  g = y =>                // g = recursive function taking y
    ++y < k + n ?         //   increment y; if y is less than k + n:
      `\n`                //     append a line feed
      .padEnd(            //     append w - 1 leading spaces:
        w =               //       where w is defined as
          k -             //       k minus
          Math.max(       //       the maximum of:
            y > n         //         - true (coerced to 1) if y > n
            && n - y + k, //           or n - y + k otherwise (bottom triangle)
            y < k &&      //         - true (coerced to 1) if y < k
            y             //           or y otherwise (top triangle)
          )               //       end of Math.max()
      )                   //     end of padEnd()
      .padEnd(            //     append 2 * (k - w) - 1 stars
        2 * k + ~w,       //       by padding to 2 * k - w - 1
        '*'               // 
      ) +                 //     end of padEnd() 
      g(y)                //     append the result of a recursive call
    :                     //   else:
      ''                  //     stop recursion
)``                       // initial call to g with y = [''] (zero-ish)
— Arnauld
quelle
Nur ein Köpfchen vor der Herausforderung scheint es erforderlich zu sein, dass Ihre Ausgabe direkt auf die Konsole gedruckt wird. Dies entspricht technisch nicht dieser Anforderung.
— Weizen-Assistent
@ SriotchilismO'Zaic Danke, dass du mich informiert hast. Dies ist jetzt 'behoben'.
— Arnauld
3

Jelly , 21 Bytes

×3’+ỊR;Ṭ»Ṛ$”*ẋz⁶ṚZŒBY

Ein vollständiges Programm, das eine positive Ganzzahl akzeptiert, die an STDOUT ausgegeben wird.

Probieren Sie es online! Oder sehen Sie sich eine Testsuite an .

Wie?

×3’+ỊR;Ṭ»Ṛ$”*ẋz⁶ṚZŒBY - Main Link: integer, n   e.g. 3
 3                    - three                        3
×                     - multiply (n by)              9
  ’                   - decrement                    8
    Ị                 - insignificant (abs(n)<=1)?   0
   +                  - add                          8
     R                - range                        [1,2,3,4,5,6,7,8]
       Ṭ              - un-truth (n)                 [0,0,1]
      ;               - concatenate                  [1,2,3,4,5,6,7,8,0,0,1]
          $           - last two links as a monad:
         Ṛ            -   reverse                    [1,0,0,8,7,6,5,4,3,2,1]
        »             -   maximum (vectorises)       [1,2,3,8,7,6,7,8,3,2,1]
           ”*         - an asterisk character        '*' 
             ẋ        - repeat (vectorises)          ["*","**",...]
               ⁶      - a space character            ' '
              z       - transpose with filler        ["***********"," ********* ",...]
                Ṛ     - reverse                      ["   *   *   ","   ** **   ",...]
                 Z    - transpose                    ["       *","      **",...]
                  ŒB  - bounce (vectorises)          ["       *       ","      ***      ",...]
                    Y - join with newline characters "       *       \n      ***      \n..."
                      - implicit print
— Jonathan Allan
quelle
2

Jelly , 21 Bytes

×’»ɗ3”*xⱮz⁶ɓ⁶x;»Ṛ$ŒBY

Probieren Sie es online!

Ein monadischer Link, der eine einzelne Ganzzahl als linkes Argument akzeptiert und eine durch Zeilenumbrüche getrennte Jelly-Zeichenfolge mit dem Stern als Ausgabe zurückgibt. Bei der Ausführung als vollständiges Programm wird der Stern implizit an STDOUT ausgegeben.

Erläuterung

   ɗ3                 | Last three links as a dyad with 3 as right argument:
×                     |   Multiply (by 3)
 ’                    |   Decrease by 1
  »                   |   Maximum of this (and 3)
     ”*xⱮ             | An implicit range from 1 to this many asterisks
         z⁶           | Zip with space as filler
           ɓ          | Start a new dyadic chain with the input as left argument and the list of asterisks as right argument
            ⁶x        | Input many spaces
              ;       | Concatenated to the asterisk list
                 $    | Last two links as a monad:
               »Ṛ     |   Maximum of this list and its reverse
                  ŒB  | Bounce each list (i.e. mirror it without duplicating the middle entry)
                    Y | Join with newlines
— Nick Kennedy
quelle
1
Ich weiß es zu schätzen, dass du den Start auf stilvolle Weise schreibst, obwohl er ×3’»3die gleiche Länge hat ^ _ ^
— Lynn,
1
@Lynn Als ich das tat, dachte ich, ich würde einen anderen Schnellzugriff verwenden, um mehrere Links zusammenzuführen, und das bedeutete, dass ich dies innerhalb der maximal zulässigen 4 tun konnte. Sobald ich mich entschied, ɓes zu benutzen, spielte es keine Rolle, aber ich behielt es, weil es mir immer noch gefiel!
— Nick Kennedy
2

Holzkohle , 25 Bytes

Ｇ↙θ←⁺⊗θ¬⊖θ↑⊗θ↘⊕θ*‖Ｏ¬Ｃ⁰¬⊖θ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｇ↙θ←⁺⊗θ¬⊖θ↑⊗θ↘⊕θ*

Zeichnen Sie ein unregelmäßiges Fünfeck, das das obere rechte Viertel des Sterns darstellt, aber eine spezielle Hülle 1, um die Reihe um eine zusätzliche Spalte zu verbreitern.

‖Ｏ¬

Überlege, um den Stern zu vervollständigen.

Ｃ⁰¬⊖θ

Mehr Spezialgehäuse, um den Stern für 1eine zusätzliche Reihe höher zu machen.

Alternativlösung, auch 25 Bytes:

∧¬⊖θ*Ｇ↗↓⊖׳Ｎ*‖Ｏ‖ＯＯ↓∧⊖θ⊖⊗θ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

∧¬⊖θ*

Drucken Sie ein Extra *für den Fall von 1.

Ｇ↗↓⊖׳Ｎ*

Zeichnen Sie die linke Hälfte eines Dreiecks der entsprechenden Größe.

‖Ｏ

Nachdenken, um das Dreieck zu vervollständigen.

‖ＯＯ↓∧⊖θ⊖⊗θ

Überlappen Sie es mit seinem Spiegelbild, außer im Fall von 1 , in dem es nur reflektiert wird.

14 Bytes ohne Sondergehäuse für 1:

Ｇ<⊖׳Ｎ*‖ＯＯ↑⊖⊗θ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｇ<⊖׳Ｎ*

Zeichnen Sie ein Dreieck der entsprechenden Größe.

‖ＯＯ↑⊖⊗θ

Überlappen Sie es mit seinem Spiegelbild.

— Neil
quelle
2

Perl 6 , 74 Bytes

{$_ Z~|[R,] $_}o{.&{|((' 'x--$+$_*3~'*'x$++*2+1)xx$_*3-($_>1)),|($ xx$_)}}

Probieren Sie es online!

Erstellt buchstäblich ein Dreieck mit den richtigen Proportionen und überlappt es mit einer kopierten Kopie unter Verwendung der Zeichenfolge oder des Operators (~| ). Ausgabe als Liste von Zeilen mit Leerzeichen vor und nach der Zeile.

Erläuterung:

                {.&{                                                     }  # Anonymous code block
                      (                        )xx$_*3-($_>1)   # Repeat n*3-(n!=1) times
                       ' 'x--$+$_*3      # With a decreasing indentation
                                   ~'*'x$++*2+1  # Append an increasing triangle
                                       # This creates the triangle
                                                            ,|($ xx$_)  # And add some padding lines
{             }o   # Pass the triangle to the combining function
    Z~|            # Zip string bitwise or
 $_                # The list
       [R,] $_     # With its reverse
— Scherzen
quelle
2

J , 53 50 Bytes

' *'{~[:(+.|.),.@#&0,~[:(|.,}.)"1*@<:>:/~@i.@-~3*]

Probieren Sie es online!

ungolfed

' *' {~ [: (+. |.) ,.@#&0 ,~ [: (|. , }.)"1 *@<: >:/~@i.@-~ 3 * ]

Wie

Verwenden Sie eine Funktionstabelle (wie eine Zeittabelle der 3. Klasse), um das halbe Dreieck zu konstruieren, indem Sie >:(größer oder gleich) als Funktion verwenden. Kehren Sie dann jede Reihe um, hacken Sie die letzte Spalte und nähen Sie die beiden Seiten zusammen, um das volle Dreieck zu erhalten (jedoch aus 1 und 0). Fügen Sie nam unteren Rand Zeilen mit Nullen hinzu. Kehren Sie schließlich das Ganze um und überlagern Sie es mit dem Booleschen Wert oder +., um das Ergebnis zu erhalten. Dann drehen Sie die 1 auf *und 0 auf Leerzeichen.

— Jona
quelle
Nett! Hier ist meine Lösung - gleiche Länge, anderer Ansatz: Probieren Sie es online aus!
— Galen Ivanov
1
Vielen Dank. Es fühlt sich an, als könnte man mehr Golf spielen, aber ich habe eine Handvoll anderer Ansätze ausprobiert und war nicht in der Lage, dies zu tun.
— Jonah,
2

T-SQL, 194 Bytes

@ ist der Eingabewert

@c regelt die Breite des oberen Dreiecks

@d behandelt das breite untere Dreieck

@eEnthält die Ausgabe entweder @coder @d- dies spart einige Bytes

@fbehandelt den Sonderfall 1 als Eingabe. @c*@=3legt fest, wann verwendet werden soll @f. 5 Bytes billiger als das Schreiben@c=3and @=1

DECLARE @ INT=8

,@c INT=1,@e INT=1,@d INT,@f INT=0SET @d=@*8-3r:PRINT
space(@*3-@e/2+@f/2)+replicate('*',@e-@f)SELECT
@c=nullif(@c,@*6-3)+2,@f=iif(@c*@=3,2,0),@d-=2-@f,@e=iif(@c>@d
or @c/2<@,@c,@d)IF @d>0goto r

Probieren Sie es online aus

— t-clausen.dk
quelle
1

Japt -R , 25 Bytes

+5 Bytes für n=1: \

õ cUon3*U-´UÎ)®ç* êÃê!U û

Versuch es

õ cUon3*U-´UÎ)®ç* êÃê!U û     :Implicit input of integer U
õ                             :Range [1,U]
  c                           :Concatenate
   Uo                         :  Range [0,U)
     n                        :  Subtract each from
      3*U-                    :    Multiply U by 3 and subtract
          ´U                  :      Decrement U
            Î                 :      Get sign
             )                :End concat
              ®               :Map each Z
               ç*             :  Repeat "*" Z times
                  ê           :  Palindromise
                   Ã          :End map
                    ê!U       :If decremented U is 0, append reverse, else, palindromise
                        û     :Centre pad each line with spaces to the length of the longest
                              :Implicitly join with newlines and output
— Zottelig
quelle
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.