pengantar

Idenya adalah menggunakan karakter asterisk (bintang) *untuk menampilkan bintang ascii-art pada dimensi yang ditentukan. Dimensi adalah angka input yang lebih besar dari atau sama dengan yang menentukan ketinggian dalam garis dari titik atas bintang. Bintang-bintang di sini dimaksudkan untuk menjadi bintang berujung enam dengan ukuran lebih besar yang terlihat lebih baik dari perspektif gambar.$1$

Dalam semua kasus, representasi bintang seni ascii muncul sebagai dua segitiga yang tumpang tindih seperti yang ditunjukkan dalam contoh berikut.

Parametrik

Gambar dan tabel data berikut menjelaskan atribut untuk tujuh ukuran pertama bintang. Setiap parameter tumbuh dalam perkembangan aritmatika dengan meningkatnya , kecuali berbeda .$N$$N=1$

Contohnya

Untuk input 1 (kasus degenerasi) output program harus sebagai berikut:

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

Input 2:

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

(3)

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

(5)

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

Tantangan

Tugas Anda adalah membuat fungsi atau program yang akan menerima angka N sebagai input dan kemudian menampilkan bintang berukuran tepat menggunakan hanya karakter dan *karakter.

• Anda dapat mengasumsikan bahwa nilai input selalu berupa bilangan bulat positif.
• Trailing whitespace pada jalur output OK.
• Algoritma program harus cukup umum untuk setiap input $N$ untuk menghasilkan output seni bintang. Keterbatasan praktis ada tentu saja karena ukuran ukuran tampilan.
• Output harus dicetak ke STDOUT.
• Celah standar dilarang.
• Ini adalah kode-golf sehingga semua aturan main golf berlaku.

Mencetak gol

Ini adalah kode-golf sehingga kode dengan jumlah byte terpendek akan menang!

05AB1E , 21 byte

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

Cobalah online! atau sebagai Test Suite

Penjelasan

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 byte

Membangun fungsi gyang mengambil angka dan menghasilkan IOmonad yang mencetak bintang ke STDOUT. Saya pikir ini baik-baik saja.

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

Cobalah online!

Penjelasan

Pertama mari kita bicara tentang lambda.

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

Ini membutuhkan angka n,, untuk digambarkan sebagai bintang. Kami mencetak bintang dua kali lebih banyak dan kemudian 1 lebih banyak dan menempelkannya di kanan ke ukuran gambar. Kami menempelkan ini di kanan dengan aspasi untuk memusatkan garis bintang. Kita bisa menggunakan lambda ini untuk menggambar setiap baris.

Dari lambda ini kita buat (%). (%)dimulai dengan melakukan mapM_dengan lambda kami untuk mengubah profil menjadi bentuk.

Sekarang yang perlu kita lakukan adalah membuat daftar profil untuk bintang. Kita bisa melakukan ini dengan membuat segitiga terlebih dahulu [1..a], lalu melapisinya dengan nol ++replicate b 0. Jika kita mengambil profil segitiga dan membalikkannya, kita akan mendapatkan separuh bintang lainnya. Untuk memaksakan mereka, kami hanya membuat profil baru di mana setiap entri adalah maks dari dua segitiga. Ini zipWith max.

Kami kemudian menyebutnya dalam salah satu dari dua cara: 3%1untuk input dari 1dan dengan (3*a-1)%asebaliknya.

Dari sini kita melakukan sedikit mengutak-atik beberapa nilai untuk mencukur beberapa byte. Karena 3*a-1agak lama kami mengimbangi beberapa nilai kami yang lain dengan 1 sehingga semuanya dibatalkan dan kami mendapatkan perilaku yang diinginkan 3*a. Yaitu kita mulai daftar kami di 2bukannya 1dan melakukan 2*n-3bukan 2*n-1untuk menebus perubahan.

Versi alternatif, 114 byte

Yang ini membangun fungsi point-free (%)<*>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

Cobalah 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

Cobalah 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

Cobalah online!

R , 125 107 101 byte

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)

Cobalah online!

• -24 terima kasih kepada @Giuseppe

Pendekatan sebelumnya (berbeda):

R , 150 148 136 135 130 128 byte

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

Cobalah online!

• -14 terima kasih kepada @ Kirill L.
• -1 berkat @ t-clausen.dk
• -7 terima kasih kepada @Giuseppe

Python 2 , 101 99 97 byte

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)

Cobalah online!

_{-2 byte, terima kasih untuk Lynn}

JavaScript (V8) ,  101  108 byte

EDIT: +7 byte untuk mencetak ke 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):'')``)

Cobalah online!

Berkomentar (tanpa 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)

Jelly , 21 byte

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

Program lengkap yang menerima bilangan bulat positif yang dicetak ke STDOUT.

Cobalah online! Atau lihat test-suite .

Bagaimana?

×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

Kanvas , 25 23 byte

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

Coba di sini!

15 byte tanpa penanganan1

Jelly , 21 byte

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

Cobalah online!

Tautan monadik yang menerima integer tunggal sebagai argumen kirinya dan mengembalikan string Jelly yang dipisahkan dengan baris baru dengan bintang sebagai hasilnya. Saat dijalankan sebagai program lengkap, secara implisit mencetak bintang ke STDOUT.

Penjelasan

   ɗ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

Arang , 25 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

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

Gambarlah segi lima yang tidak beraturan yang mewakili bagian kanan atas bintang, tetapi selubung khusus 1untuk membuat baris kolom tambahan lebih lebar.

‖Ｏ¬

Renungkan untuk melengkapi bintang.

Ｃ⁰¬⊖θ

Casing lebih istimewa membuat bintang untuk 1baris lebih tinggi lebih tinggi.

Solusi alternatif, juga 25 byte:

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

∧¬⊖θ*

Cetak ekstra *untuk kasing 1.

Ｇ↗↓⊖׳Ｎ*

Gambarlah setengah kiri segitiga dengan ukuran yang sesuai.

‖Ｏ

Refleksikan untuk melengkapi segitiga.

‖ＯＯ↓∧⊖θ⊖⊗θ

Tumpang tindih dengan pantulannya, kecuali dalam hal 1, yang hanya mencerminkannya.

14 byte tanpa casing khusus untuk 1:

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｇ<⊖׳Ｎ*

Gambarlah segitiga dengan ukuran yang sesuai.

‖ＯＯ↑⊖⊗θ

Tumpang tindih dengan pantulannya.

Perl 6 , 74 byte

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

Cobalah online!

Secara harfiah membuat segitiga dengan proporsi yang tepat dan tumpang tindih dengan salinan terbalik menggunakan string atau operator (~| ). Output sebagai daftar garis dengan spasi spasi baris terdepan dan tertinggal.

Penjelasan:

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

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

Cobalah online!

ungolfed

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

bagaimana

Gunakan tabel fungsi (seperti tabel waktu kelas 3) untuk membangun setengah segitiga dengan menggunakan >:(lebih besar atau sama) sebagai fungsi. Kemudian balikkan setiap baris, potong kolom terakhir, dan jahit kedua sisi bersamaan untuk mendapatkan segitiga penuh (tetapi terbuat dari 1 dan 0). Tambahkan nbaris nol di bagian bawah. Akhirnya membalikkan semuanya, dan overlay pada yang asli, menggunakan boolean atau +.untuk mendapatkan hasilnya. Kemudian putar 1 ke *dan 0 ke spasi.

T-SQL, 194 byte

@ adalah nilai input

@c menangani lebar segitiga atas

@d menangani lebar segitiga bawah

@eberisi output baik @catau @d- ini menghemat beberapa byte

@fmenangani kasus khusus 1 sebagai input. @c*@=3menentukan kapan harus digunakan @f. 5 byte lebih murah daripada menulis@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

Cobalah online

Japt -R , 25 byte

+5 byte untuk n=1: \

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

Cobalah

õ 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