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!

code-golf ascii-art Michael Karas
la source

5

Vous dites également qu'il peut s'agir d'une fonction mais qu'elle doit "imprimer sur STDOUT". Est-ce intentionnel?

Post Rock Garf Hunter

5

Oui, une règle de construction générale serait géniale ... par exemple, je ne suis pas sûr des entrées paires, comme N = 4 ...

digEmAll

7

Veuillez ne pas dire "L'algorithme pour produire les étoiles fait partie du défi de programmation." Ce n'est pas quelque chose que la plupart des golfeurs apprécient lorsqu'ils font un défi artistique ASCII, et cela ressemble à une tentative de mettre en gage quelque chose qui est la responsabilité du spécificateur. Cela dit, je suis surpris que les gens ne soient pas clairs sur la construction ici; ce sont deux triangles qui se chevauchent comme le dit le défi. Serait-il utile de dire explicitement la taille et le décalage des triangles?

2019

9

@TimPederick Bonne prise sur N = 1 étant différent. J'ai mis une note pour que les solveurs ne manquent pas cela. Je pense que le défi serait mieux sans ce cas particulier.

xnor

4

@xnor: puisque n = 1 était différent, je ne pouvais pas en déduire une règle générale ... et IMO la règle devrait toujours être spécifiée pour l'art ASCII, sinon je suis bien autorisé à imprimer ce que je veux en dehors de la plage de la définition exemples;)

digEmAll

7

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

Emigna
la source

1

Vos étoiles de sortie semblent correctes.

Michael Karas

1

Je peux trouver plein d'alternatives 3*s≠-L·<comme 6*s≠·-ÅÉou ≠3/-6*ÅÉ, mais malheureusement aucune n'est plus courte .. Belle réponse, comme toujours! :)

Kevin Cruijssen

xs3*<ŸRsLì'*×.º.C.∊pour 19 :). J'ai menti, ça ne marche pas pour 1. Le laisser pour inspiration.

Urne de poulpe magique

7

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!

Post Rock Garf Hunter
la source

Votre sortie est belle maintenant.

Michael Karas

6

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

digEmAll
la source

Ouais, je n'aime pas non plus ces affectations répétées de S [] =, et cela semble fonctionner

Kirill L.

Génial ! Je pensais à quelque chose comme ça ... mais je

dînais

Il semble que vous pouvez enregistrer un octet: i> n-1 peut être réécrit en i> = n

t-clausen.dk

@ t-clausen.dk: oui, merci!

digEmAll

1

117 octets sur la version la plus récente

Giuseppe

5

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}

TFeld
la source

Je suis raisonnablement sûr que vous n'avez pas besoin des parens dans l'expression du sélecteur, i+x>n*6oréconomise donc deux octets.

Lynn

@Lynn Merci :)

TFeld

Vous pouvez même aller i+x>~i/n/2%2*6*nou quelque chose comme i+x>3*n*(~i/n&2)(les deux 96 octets.)

Lynn

5

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)

Arnauld
la source

Juste un aperçu du défi semble exiger que votre sortie soit imprimée directement sur la console. Cela ne répond pas techniquement à cette exigence.

Post Rock Garf Hunter

@ SriotchilismO'Zaic Merci de me le faire savoir. Ceci est désormais «corrigé».

Arnauld

3

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

Jonathan Allan
la source

2

Toile , 25 23 octets

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

Essayez-le ici!

15 octets sans manipulation1

dzaima
la source

Fait de belles étoiles.

Michael Karas

2

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

Nick Kennedy
la source

1

J'apprécie que vous écriviez le début de manière élégante même si ×3’»3la longueur est la même ^ _ ^

Lynn

1

@Lynn au moment où je l'ai fait, je pensais que j'allais utiliser un autre rapide pour fusionner plusieurs liens, et cela signifiait que je pouvais le faire dans le maximum 4 autorisé. Cependant, une fois que j'ai décidé de l'utiliser, ɓcela n'a pas d'importance mais je l'ai gardé parce que je l'aimais toujours!

Nick Kennedy

2

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.

Neil
la source

2

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

Jo King
la source

2

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.

Jonas
la source

Agréable! Voici ma solution - même longueur, approche différente: essayez-la en ligne!

Galen Ivanov

1

Merci. On a vraiment l'impression qu'il pourrait être joué plus, mais j'ai essayé une poignée d'autres approches et je n'ai pas pu le faire.

Jonah

2

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

t-clausen.dk
la source

1

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

Hirsute
la source

Les étoiles font des étoiles

introduction

Paramètres

Exemples

Défi

Notation

Réponses:

05AB1E , 21 octets

Haskell , 114 octets

Explication

Version alternative, 114 octets

$N>1$

$N=1$

R , 125 107 101 octets

R , 150 148 136 135 135 130 128 octets

Python 2 , 101 99 97 octets

JavaScript (V8) , 101 108 octets

Commenté (sans `print`)

Gelée , 21 octets

Comment?

Toile , 25 23 octets

Gelée , 21 octets

Explication

Fusain , 25 octets

Perl 6 , 74 octets

Explication:

J , 53 50 octets

non golfé

Comment

T-SQL, 194 octets

Japt `-R` , 25 octets

Les étoiles font des étoiles

introduction

Paramètres

Exemples

Défi

Notation

Réponses:

05AB1E , 21 octets

Haskell , 114 octets

Explication

Version alternative, 114 octets

N> 1N>1N>1

N= 1N=1N=1

R , 125 107 101 octets

R , 150 148 136 135 135 130 128 octets

Python 2 , 101 99 97 octets

JavaScript (V8) , 101 108 octets

Commenté (sans print)

Gelée , 21 octets

Comment?

Toile , 25 23 octets

Gelée , 21 octets

Explication

Fusain , 25 octets

Perl 6 , 74 octets

Explication:

J , 53 50 octets

non golfé

Comment

T-SQL, 194 octets

Japt -R , 25 octets

$N>1$

$N=1$

Commenté (sans `print`)

Japt `-R` , 25 octets