introduction

L'idée est d'utiliser le caractère astérisque (étoile) *pour afficher une étoile ascii-art à une dimension spécifiée. La dimension est un nombre d'entrée supérieur ou égal à $1$ qui spécifie la hauteur en lignes du point supérieur de l'étoile. Les étoiles ici sont destinées à être des étoiles à six pointes de plus grandes tailles, plus belles du point de vue de l'image.

Dans tous les cas, la représentation ascii des étoiles doit apparaître sous la forme de deux triangles qui se chevauchent, comme indiqué dans les exemples suivants.

Paramètres

L'image et le tableau de données suivants décrivent les attributs des sept premières tailles de l'étoile. Chacun des paramètres croît dans une progression arithmétique à mesure que $N$ augmente, sauf que $N=1$ est différent .

Exemples

Pour une entrée de 1 (le cas dégénéré), la sortie du programme doit être la suivante:

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

Entrée de 2:

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

(3)

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

(5)

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

Défi

Votre tâche consiste à créer une fonction ou un programme qui acceptera le nombre N comme entrée, puis affichera l'étoile de taille appropriée en utilisant uniquement des caractères et le *caractère.

• Vous pouvez supposer que la valeur d'entrée est toujours un entier positif.
• La fin des espaces blancs sur les lignes de sortie est OK.
• L'algorithme du programme doit être suffisamment général pour que toute entrée $N$ produise la sortie en étoile. Des limitations pratiques existent bien sûr en raison de la taille de sortie de l'affichage.
• La sortie doit imprimer sur STDOUT.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent.

Notation

C'est du code-golf donc le code avec le plus petit nombre d'octets gagne!

05AB1E , 21 octets

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

Essayez-le en ligne! ou comme suite de tests

Explication

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

Haskell , 114 octets

Construit une fonction gqui prend un nombre et produit une IOmonade qui imprime l'étoile sur STDOUT. Je pense que c'est 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

Essayez-le en ligne!

Explication

Parlons d'abord de la lambda.

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

Cela prend un nombre, npour être dessiné sous forme d'étoiles. Nous imprimons deux fois plus d'étoiles, puis 1 de plus et le garnissons à droite de la taille de l'image. Nous remplissons ceci à droite par des aespaces pour centrer la ligne des étoiles. Nous pouvons utiliser ce lambda pour tracer chaque ligne.

À partir de cette lambda, nous créons (%). (%)commence par faire mapM_avec notre lambda pour transformer un profil en forme.

Maintenant, tout ce que nous devons faire est de faire une liste du profil de l'étoile. Nous pouvons le faire en créant d'abord un triangle avec [1..a], puis en le remplissant de quelques zéros++replicate b 0 . Si nous prenons le profil du triangle et l'inversons, nous obtenons l'autre moitié de l'étoile. Pour les imposer super, nous faisons juste un nouveau profil où chaque entrée est le maximum des deux triangles. C'est ça zipWith max.

Nous appelons ensuite cela de deux manières: comme 3%1pour la saisie de 1et avec(3*a-1)%a contraire.

À partir de là, nous faisons un peu de bricolage avec certaines des valeurs pour raser certains octets. Puisque 3*a-1c'est assez long, nous compensons certaines de nos autres valeurs par 1 afin que tout s'annule et que nous obtenions le comportement souhaité à la 3*aplace. À savoir, nous commençons notre liste à la 2place de 1et faisons 2*n-3au lieu de 2*n-1compenser le changement.

Version alternative, 114 octets

Celui-ci construit une fonction sans point (%)<*>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

Essayez-le en ligne!

$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

Essayez-le en ligne!

$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

Essayez-le en ligne!

R , 125 107 101 octets

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)

Essayez-le en ligne!

• -24 grâce à @Giuseppe

Approche précédente (différente):

R , 150 148 136 135 135 130 128 octets

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='','
')

Essayez-le en ligne!

• -14 grâce à @Kirill L.
• -1 grâce à @ t-clausen.dk
• -7 grâce à @Giuseppe

Python 2 , 101 99 97 octets

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)

Essayez-le en ligne!

_{-2 octets, merci à Lynn}

JavaScript (V8) ,  101  108 octets

EDIT: +7 octets pour imprimer sur 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):'')``)

Essayez-le en ligne!

Commenté (sans 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)

Gelée , 21 octets

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

Un programme complet acceptant un entier positif qui s'imprime sur STDOUT.

Essayez-le en ligne! Ou consultez une suite de tests .

Comment?

×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

Toile , 25 23 octets

Ｒ：｛⁸３×４Ｍ∔］∔｛*×］↔⁸１≡？╪］┼

Essayez-le ici!

15 octets sans manipulation1

Gelée , 21 octets

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

Essayez-le en ligne!

Un lien monadique acceptant un seul entier comme argument de gauche et renvoyant une chaîne Jelly séparée par des sauts de ligne avec l'étoile en sortie. Lorsqu'il est exécuté en tant que programme complet, il imprime implicitement l'étoile sur STDOUT.

Explication

   ɗ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

Fusain , 25 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

Dessinez un pentagone irrégulier représentant le quart supérieur droit de l'étoile, mais un boîtier spécial 1pour élargir la rangée d'une colonne supplémentaire.

‖Ｏ¬

Réfléchissez pour terminer l'étoile.

Ｃ⁰¬⊖θ

Plus de boîtier spécial pour rendre l'étoile 1plus haute.

Solution alternative, également 25 octets:

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

∧¬⊖θ*

Imprimez un supplément *pour le cas de 1.

Ｇ↗↓⊖׳Ｎ*

Dessinez la moitié gauche d'un triangle de la taille appropriée.

‖Ｏ

Réfléchissez pour compléter le triangle.

‖ＯＯ↓∧⊖θ⊖⊗θ

Le chevaucher avec son reflet, sauf dans le cas de 1 , auquel cas il suffit de le refléter.

14 octets sans boîtier spécial pour 1:

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｇ<⊖׳Ｎ*

Tracez un triangle de la taille appropriée.

‖ＯＯ↑⊖⊗θ

Superposez-le avec son reflet.

Perl 6 , 74 octets

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

Essayez-le en ligne!

Crée littéralement un triangle avec les bonnes proportions et le chevauche avec une copie à l'envers à l'aide de la chaîne ou de l'opérateur (~| ). Sorties sous forme de liste de lignes avec un espace de ligne de début et de fin.

Explication:

                {.&{                                                     }  # 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

J , 53 50 octets

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

Essayez-le en ligne!

non golfé

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

Comment

Utilisez une table de fonctions (comme une table de multiplication de 3e année) pour construire la moitié du triangle en utilisant >:(supérieur ou égal) comme fonction. Inversez ensuite chaque ligne, coupez la dernière colonne et cousez les deux côtés ensemble pour obtenir le triangle complet (mais composé de 1 et 0). Ajoutez des nrangées de zéros en bas. Enfin, inversez le tout et superposez-le sur l'original, en utilisant booléen ou +.pour obtenir le résultat. Tournez ensuite le 1 vers *et le 0 vers les espaces.

T-SQL, 194 octets

@ est la valeur d'entrée

@c gère la largeur du triangle supérieur

@d gère le triangle inférieur de largeur

@econtient la sortie soit @cou @d- cela économise quelques octets

@fgère le cas spécial de 1 en entrée. @c*@=3détermine quand utiliser @f. 5 octets moins cher que l'écriture@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

Essayez-le en ligne

Japt -R , 25 octets

+5 octets pour n=1 : \

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

Essayez-le

õ 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