Introducción

La idea es utilizar el asterisco (estrella) *para mostrar una estrella de arte ascii en una dimensión específica. La dimensión es un número de entrada mayor o igual a $1$ que especifica la altura en líneas del punto superior de la estrella. Las estrellas aquí están destinadas a ser estrellas de seis puntas con tamaños más grandes que se ven mejor desde una perspectiva de imagen.

En todos los casos, la representación ascii-art de las estrellas debe aparecer como dos triángulos que se superponen como se muestra en los siguientes ejemplos.

Paramétricos

La siguiente imagen y tabla de datos describe los atributos para los primeros siete tamaños de la estrella. Cada uno de los parámetros crece en una progresión aritmética a medida que $N$ aumenta, excepto que $N=1$ es diferente .

Ejemplos

Para una entrada de 1 (el caso degenerado), la salida del programa debe ser la siguiente:

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

Entrada de 2:

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

(3)

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

(5)

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

Desafío

Su tarea es crear una función o programa que acepte el número N como entrada y luego la estrella del tamaño apropiado usando solo los caracteres y el *carácter.

• Puede suponer que el valor de entrada es siempre un entero positivo.
• El espacio en blanco al final de las líneas de salida está bien.
• El algoritmo del programa debe ser lo suficientemente general como para que cualquier entrada de $N$ produzca la salida del arte estelar. Existen limitaciones prácticas, por supuesto, debido al tamaño de salida de la pantalla.
• La salida debe imprimirse en STDOUT.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf.

Puntuación

Este es el código de golf, por lo que gana el código con el menor número de bytes.

05AB1E , 21 bytes

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

Pruébalo en línea! o como un conjunto de pruebas

Explicación

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 bytes

Construye una función gque toma un número y produce unIO mónada que imprime la estrella en STDOUT. Creo que esto esta bien.

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

Pruébalo en línea!

Explicación

Primero hablemos de la lambda.

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

Esto requiere un número, npara ser dibujado como estrellas. Imprimimos el doble de estrellas y luego 1 más y las rellenamos a la derecha hasta el tamaño de la imagen. Relleno esto a la derecha pora espacios para centrar la línea de estrellas. Podemos usar esta lambda para dibujar cada línea.

De esta lambda que creamos (%). (%)comienza haciendomapM_ con nuestra lambda para convertir un perfil en la forma.

Ahora todo lo que tenemos que hacer es hacer una lista del perfil de la estrella. Podemos hacer esto haciendo primero un triángulo [1..a]y luego rellenándolo con algunos ceros ++replicate b 0. Si tomamos el perfil del triángulo y lo invertimos, obtenemos la otra mitad de la estrella. Para superponerlos, simplemente hacemos un nuevo perfil donde cada entrada es el máximo de los dos triángulos. Esto eszipWith max .

Luego llamamos a esto de una de dos maneras: en cuanto 3%1a la entrada de 1y con lo (3*a-1)%acontrario.

A partir de aquí, hacemos algunos retoques con algunos de los valores para reducir algunos bytes. Como 3*a-1es bastante largo, compensamos algunos de nuestros otros valores en 1 para que todo se cancele y obtengamos el comportamiento deseado 3*a. Es decir, comenzamos nuestra lista en 2lugar de 1y hacemos en 2*n-3lugar de 2*n-1compensar el cambio.

Versión alternativa, 114 bytes.

Este construye una función sin puntos (%)<*>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

Pruébalo en línea!

$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

Pruébalo en línea!

$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

Pruébalo en línea!

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)

Pruébalo en línea!

• -24 gracias a @Giuseppe

Enfoque anterior (diferente):

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

Pruébalo en línea!

• -14 gracias a @Kirill L.
• -1 gracias a @ t-clausen.dk
• -7 gracias a @Giuseppe

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)

Pruébalo en línea!

_{-2 bytes, gracias a Lynn}

JavaScript (V8) ,  101  108 bytes

EDITAR: +7 bytes para imprimir en 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):'')``)

Pruébalo en línea!

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

Jalea , 21 bytes

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

Un programa completo que acepta un número entero positivo que se imprime en STDOUT.

Pruébalo en línea! O ver un conjunto de pruebas .

¿Cómo?

×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

Lienzo , 25 23 bytes

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

Pruébalo aquí!

15 bytes sin manejo1

Jalea , 21 bytes

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

Pruébalo en línea!

Un enlace monádico que acepta un solo entero como argumento izquierdo y devuelve una cadena Jelly separada por una nueva línea con la estrella como su salida. Cuando se ejecuta como un programa completo, imprime implícitamente la estrella en STDOUT.

Explicación

   ɗ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

Carbón de leña , 25 bytes

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

Pruébalo en línea!El enlace es a la versión detallada del código. Explicación:

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

Dibuja un pentágono irregular que represente el cuarto superior derecho de la estrella, pero con una carcasa especial 1para hacer que la fila sea una columna extra más ancha.

‖Ｏ¬

Reflexiona para completar la estrella.

Ｃ⁰¬⊖θ

Más carcasa especial para hacer la estrella para 1una fila extra más alta.

Solución alternativa, también 25 bytes:

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

∧¬⊖θ*

Imprima un extra *para el caso de1 .

Ｇ↗↓⊖׳Ｎ*

Dibuja la mitad izquierda de un triángulo del tamaño apropiado.

‖Ｏ

Reflexiona para completar el triángulo.

‖ＯＯ↓∧⊖θ⊖⊗θ

Superponerlo con su reflejo, excepto en el caso de 1 , en cuyo caso solo reflejalo.

14 bytes sin carcasa especial para 1:

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｇ<⊖׳Ｎ*

Dibuja un triángulo del tamaño apropiado.

‖ＯＯ↑⊖⊗θ

Superponerlo con su reflejo.

Perl 6 , 74 bytes

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

Pruébalo en línea!

Literalmente crea un triángulo con las proporciones correctas y lo superpone con una copia invertida utilizando la cadena o el operador (~| ). Salidas como una lista de líneas con un espacio en blanco de línea inicial y final.

Explicación:

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

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

Pruébalo en línea!

sin golf

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

cómo

Use una tabla de funciones (como una tabla de tiempos de 3er grado) para construir la mitad del triángulo usando >:(mayor o igual) como la función. Luego invierte cada fila, corta la última columna y une los dos lados para obtener el triángulo completo (pero hecho de 1 y 0). Agregue nfilas de ceros en la parte inferior. Finalmente, invierta todo y superponga el original, usando booleano o +.para obtener el resultado. Luego gire el 1 hacia *y 0 hacia espacios.

T-SQL, 194 bytes

@ es el valor de entrada

@c maneja el ancho del triángulo superior

@d maneja el triángulo inferior ancho

@econtiene la salida @co bien@d , esto ahorra algunos bytes

@fmaneja el caso especial de 1 como entrada. @c*@=3determina cuándo usar @f. 5 bytes más barato que escribir@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

Pruébalo en línea

Japt -R , 25 bytes

+5 bytes para n=1: \

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

Intentalo

õ 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