บทนำ

แนวคิดคือการใช้อักขระเครื่องหมายดอกจัน (ดาว) *เพื่อแสดงดาว ascii-art ในมิติที่ระบุ มิติคือหมายเลขอินพุตที่มากกว่าหรือเท่ากับ$1$ซึ่งระบุความสูงเป็นเส้นของจุดบนของดาว ดาวที่นี่มีจุดประสงค์เพื่อเป็นดาวหกแฉกที่มีขนาดใหญ่ขึ้นดูดีขึ้นจากมุมมองของภาพ

ในทุกกรณีการเป็นตัวแทน ASCII-art ของดาวจะปรากฏเป็นรูปสามเหลี่ยมสองรูปที่ซ้อนทับกันดังที่แสดงในตัวอย่างต่อไปนี้

parametrics

รูปภาพและตารางข้อมูลต่อไปนี้อธิบายคุณสมบัติสำหรับเจ็ดขนาดแรกของดาว แต่ละพารามิเตอร์เติบโตในการก้าวหน้าเลขคณิตเป็น$N$เพิ่มขึ้นยกเว้น$N=1$จะแตกต่างกัน

ตัวอย่าง

สำหรับอินพุต 1 (ตัวพิมพ์เล็ก) ผลลัพธ์ของโปรแกรมควรเป็นดังนี้:

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

อินพุต 2:

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

(3)

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

(5)

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

ท้าทาย

งานของคุณคือการสร้างฟังก์ชั่นหรือโปรแกรมที่จะรับหมายเลข N เป็นอินพุทแล้วออกดาวขนาดที่เหมาะสมโดยใช้แค่ตัวอักษรและ*ตัวอักษร

• คุณอาจคิดว่าค่าที่ป้อนเป็นจำนวนเต็มบวกเสมอ
• ช่องว่างต่อท้ายบนบรรทัดเอาต์พุตนั้นตกลง
• อัลกอริทึมของโปรแกรมควรทั่วไปพอสำหรับอินพุต$N$ใด ๆเพื่อสร้างเอาท์พุตของสตาร์อาร์ต มีข้อ จำกัด ในทางปฏิบัติเนื่องจากขนาดหน้าจอแสดงผล
• เอาต์พุตควรพิมพ์ไปที่ STDOUT
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัส - กอล์ฟดังนั้นจึงใช้กฎการตีกอล์ฟตามปกติทั้งหมด

เกณฑ์การให้คะแนน

นี่คือโค้ดกอล์ฟดังนั้นโค้ดที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ!

05AB1E , 21 ไบต์

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

ลองออนไลน์! หรือเป็นชุดทดสอบ

คำอธิบาย

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 ไบต์

สร้างฟังก์ชั่นgที่ใช้ตัวเลขและสร้างIOmonad ที่พิมพ์ดาวไปยัง STDOUT ฉันคิดว่ามันโอเค

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

ลองออนไลน์!

คำอธิบาย

ก่อนอื่นให้พูดคุยเกี่ยวกับแลมบ์ดา

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

การดำเนินการนี้ใช้ตัวเลขnเพื่อวาดเป็นดาว เราพิมพ์ดาวจำนวนมากเป็นสองเท่าจากนั้นเพิ่มอีก 1 แผ่นแล้ววางลงบนด้านขวาตามขนาดของภาพ เราวางสิ่งนี้ไว้ทางขวาโดยaช่องว่างเพื่อจัดกึ่งกลางของดวงดาว เราสามารถใช้แลมบ์ดานี้เพื่อวาดเส้นแต่ละเส้น

(%)จากแลมบ์ดานี้เราสร้าง (%)เริ่มต้นด้วยการทำmapM_แลมบ์ดาของเราเพื่อเปลี่ยนโปรไฟล์ให้เป็นรูปร่าง

ตอนนี้สิ่งที่เราต้องทำคือทำรายการของโปรไฟล์สำหรับดาว เราสามารถทำเช่นนี้โดยการทำให้รูปสามเหลี่ยมแรกที่มี[1..a]แล้ว padding ++replicate b 0กับศูนย์บาง ถ้าเรานำโพรไฟล์ของรูปสามเหลี่ยมกลับด้านเราจะได้อีกครึ่งหนึ่งของดาว หากต้องการกำหนดพวกเขาเป็นพิเศษเราเพียงสร้างโปรไฟล์ใหม่โดยที่แต่ละรายการมีรูปสามเหลี่ยมสูงสุดสองรูป zipWith maxนี่คือ

จากนั้นเราจะเรียกสิ่งนี้ในหนึ่งในสองวิธี: 3%1สำหรับอินพุต1และด้วยวิธี(3*a-1)%aอื่น

จากที่นี่เราเล่นซอนิด ๆ หน่อย ๆ กับค่าบางส่วนเพื่อโกนหนวดไบท์ เนื่องจาก3*a-1ค่อนข้างนานเราจึงชดเชยค่าอื่น ๆ ของเราด้วย 1 เพื่อให้ทุกอย่างถูกยกเลิกและเราได้รับพฤติกรรมตามที่ตั้งใจไว้3*aแทน คือเราเริ่มรายการของเราที่2แทนที่จะ1ทำและทำ2*n-3แทน2*n-1การเปลี่ยนแปลง

รุ่นทางเลือก 114 ไบต์

หนึ่งนี้สร้างฟังก์ชั่นจุดฟรี (%)<*>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

ลองออนไลน์!

$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

ลองออนไลน์!

$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

ลองออนไลน์!

R , 125 107 101 101 ไบต์

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)

ลองออนไลน์!

• -24 ขอบคุณ @Giuseppe

วิธีก่อนหน้า (แตกต่าง):

R , 150 148 136 135 130 128 ไบต์

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

ลองออนไลน์!

• -14 ขอบคุณ @Kirill L.
• -1 ต้องขอบคุณ @ t-clausen.dk
• -7 ขอบคุณ @Giuseppe

Python 2 , 101 99 97 ไบต์

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)

ลองออนไลน์!

_{-2 ไบต์ขอบคุณ Lynn}

JavaScript (V8) ,  101  108 ไบต์

แก้ไข: +7 ไบต์เพื่อพิมพ์ไปยัง 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):'')``)

ลองออนไลน์!

แสดงความคิดเห็น (โดยไม่ต้อง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)

เยลลี่ 21 ไบต์

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

โปรแกรมเต็มรูปแบบที่รับจำนวนเต็มบวกซึ่งพิมพ์ไปยัง STDOUT

ลองออนไลน์! หรือดูการทดสอบในตัว

อย่างไร?

×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

Canvas , 25 23 ไบต์

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

ลองที่นี่!

15 ไบต์โดยไม่ต้องจัดการ1

เยลลี่ 21 ไบต์

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

ลองออนไลน์!

ลิงก์ monadic ยอมรับจำนวนเต็มเดียวเป็นอาร์กิวเมนต์ด้านซ้ายและส่งคืนสตริงวุ้นที่คั่นด้วยการขึ้นบรรทัดใหม่โดยมีดาวเป็นเอาต์พุต เมื่อรันเป็นโปรแกรมเต็มรูปแบบโดยปริยายพิมพ์ดาวไปยัง STDOUT

คำอธิบาย

   ɗ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

ถ่าน 25 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

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

วาดรูปห้าเหลี่ยมที่ผิดปกติซึ่งเป็นมุมขวาบนของดาว แต่มีปลอกพิเศษ1เพื่อให้แถวกว้างเป็นพิเศษ

‖Ｏ¬

สะท้อนเพื่อทำให้ดาวสมบูรณ์

Ｃ⁰¬⊖θ

ปลอกพิเศษอื่น ๆ ที่จะทำให้ดาวเด่น1ขึ้นสูงเป็นพิเศษ

ทางเลือกอื่น ๆ เช่น 25 ไบต์:

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

∧¬⊖θ*

พิมพ์พิเศษ *1สำหรับกรณีของ

Ｇ↗↓⊖׳Ｎ*

วาดครึ่งซ้ายของสามเหลี่ยมที่มีขนาดที่เหมาะสม

‖Ｏ

สะท้อนให้เห็นถึงความสมบูรณ์ของรูปสามเหลี่ยม

‖ＯＯ↓∧⊖θ⊖⊗θ

ทับซ้อนกับการสะท้อนของมันยกเว้นในกรณีของ1ซึ่งในกรณีนี้เพียงแค่สะท้อน

14 ไบต์โดยไม่มีปลอกพิเศษสำหรับ1:

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

Ｇ<⊖׳Ｎ*

วาดสามเหลี่ยมขนาดที่เหมาะสม

‖ＯＯ↑⊖⊗θ

ทับซ้อนกับการสะท้อนของมัน

Perl 6 , 74 ไบต์

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

ลองออนไลน์!

สร้างสามเหลี่ยมอย่างแท้จริงด้วยสัดส่วนที่ถูกต้องและทับซ้อนกับสำเนาคว่ำโดยใช้สตริงหรือโอเปอเรเตอร์ ( ~|) เอาต์พุตเป็นรายการของบรรทัดที่มีช่องว่างนำหน้าและต่อท้ายบรรทัด

คำอธิบาย:

                {.&{                                                     }  # 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 ไบต์

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

ลองออนไลน์!

ungolfed

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

อย่างไร

ใช้ตารางฟังก์ชั่น (เช่นตารางเกรด 3) เพื่อสร้างครึ่งสามเหลี่ยมโดยใช้>:(มากกว่าหรือเท่ากับ) เป็นฟังก์ชัน จากนั้นย้อนกลับแต่ละแถวสับของคอลัมน์สุดท้ายแล้วต่อสองด้านเข้าด้วยกันเพื่อให้ได้สามเหลี่ยมเต็ม (แต่ทำจาก 1 และ 0) เพิ่มnเลขศูนย์ที่ด้านล่าง ในที่สุดก็ย้อนกลับสิ่งทั้งหมดและวางทับมันบนต้นฉบับโดยใช้บูลีนหรือ+.เพื่อให้ได้ผลลัพธ์ จากนั้นให้หมุน 1 ถึง*และ 0 เป็นช่องว่าง

T-SQL, 194 ไบต์

@ คือค่าอินพุต

@c จัดการความกว้างของรูปสามเหลี่ยมด้านบน

@d จัดการสามเหลี่ยมด้านล่างความกว้าง

@eมีเอาต์พุตอย่างใดอย่างหนึ่ง@cหรือ@d- ซึ่งช่วยประหยัดสองสามไบต์

@fจัดการกรณีพิเศษ 1 เป็นอินพุต กำหนดเวลาที่จะใช้@c*@=3 @f5 ไบต์ราคาถูกกว่าการเขียน@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

ลองออนไลน์

Japt -R 25 ไบต์

+5 ไบต์สำหรับn=1: \

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

ลองมัน

õ 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