Giới thiệu

Ý tưởng là sử dụng ký tự dấu sao (ngôi sao) *để hiển thị một ngôi sao nghệ thuật ascii ở một kích thước xác định. Thứ nguyên là số đầu vào lớn hơn hoặc bằng chỉ định chiều cao theo dòng của điểm trên của ngôi sao. Các ngôi sao ở đây được dự định là sáu ngôi sao nhọn với kích thước lớn hơn nhìn tốt hơn từ góc độ hình ảnh.$1$

Trong mọi trường hợp, đại diện nghệ thuật ascii của các ngôi sao sẽ xuất hiện dưới dạng hai hình tam giác chồng lên nhau như trong các ví dụ sau.

Thông số

Hình ảnh và bảng dữ liệu sau đây mô tả các thuộc tính cho bảy kích thước đầu tiên của ngôi sao. Mỗi tham số tăng theo một tiến trình số học khi tăng, ngoại trừ là khác nhau .$N$$N=1$

Ví dụ

Đối với đầu vào là 1 (trường hợp suy biến), đầu ra chương trình phải như sau:

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

Đầu vào của 2:

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

(3)

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

(5)

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

Thử thách

Nhiệm vụ của bạn là tạo ra một hàm hoặc chương trình sẽ chấp nhận số N làm đầu vào và sau đó xuất ra ngôi sao có kích thước phù hợp chỉ bằng các ký tự và *ký tự.

• Bạn có thể giả sử rằng giá trị đầu vào luôn là số nguyên dương.
• Trailing khoảng trắng trên các dòng đầu ra là OK.
• Thuật toán chương trình phải đủ chung cho bất kỳ đầu vào nào để tạo đầu ra nghệ thuật sao. Tất nhiên, những hạn chế thực tế tồn tại do kích thước đầu ra hiển thị.$N$
• Đầu ra nên in ra STDOUT.
• Sơ hở tiêu chuẩn bị cấm.
• Đây là mã golf nên tất cả các quy tắc chơi golf thông thường được áp dụng.

Chấm điểm

Đây là môn đánh gôn, vì vậy mã có số byte ngắn nhất sẽ thắng!

05AB1E , 21 byte

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

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

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

Xây dựng một hàm glấy một số và tạo ra một IOđơn vị in sao thành STDOUT. Tôi nghĩ rằng điều này là 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

Hãy thử trực tuyến!

Giải trình

Đầu tiên hãy nói về lambda.

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

Điều này cần một số n, để được vẽ như những ngôi sao. Chúng tôi in hai lần nhiều ngôi sao và sau đó thêm 1 ngôi sao và đặt nó ở bên phải theo kích thước của hình ảnh. Chúng ta đặt cái này ở bên phải bằng akhoảng trắng để căn giữa dòng sao. Chúng ta có thể sử dụng lambda này để vẽ từng dòng.

Từ lambda này, chúng tôi tạo ra (%). (%)bắt đầu với việc làm mapM_với lambda của chúng tôi để biến một hồ sơ thành hình dạng.

Bây giờ tất cả những gì chúng ta cần làm là lập danh sách hồ sơ cho ngôi sao. Chúng ta có thể làm điều này bằng cách tạo một hình tam giác trước [1..a], sau đó đệm nó bằng một số không ++replicate b 0. Nếu chúng ta lấy hồ sơ của tam giác và đảo ngược nó, chúng ta sẽ có được nửa kia của ngôi sao. Để siêu áp đặt chúng, chúng ta chỉ cần tạo một hồ sơ mới trong đó mỗi mục nhập là tối đa của hai hình tam giác. Đây là zipWith max.

Sau đó, chúng tôi gọi điều này theo một trong hai cách: như 3%1đối với đầu vào 1và với (3*a-1)%acách khác.

Từ đây, chúng ta thực hiện một chút thay đổi với một số giá trị để cạo một số byte. Vì 3*a-1khá dài, chúng tôi bù một số giá trị khác của chúng tôi bằng 1 để mọi thứ hủy bỏ và 3*athay vào đó chúng tôi có hành vi dự định . Cụ thể, chúng tôi bắt đầu danh sách của chúng tôi 2thay vì 1và làm 2*n-3thay vì 2*n-1để bù đắp cho sự thay đổi.

Phiên bản thay thế, 114 byte

Điều này xây dựng một chức năng điểm miễn phí (%)<*>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

Hãy thử trực tuyến!

$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

Hãy thử trực tuyến!

$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

Hãy thử trực tuyến!

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)

Hãy thử trực tuyến!

• -24 cảm ơn @Giuseppe

Cách tiếp cận trước (khác nhau):

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

Hãy thử trực tuyến!

• -14 cảm ơn @Kirill L.
• -1 cảm ơn @ t-clausen.dk
• -7 cảm ơn @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)

Hãy thử trực tuyến!

_{-2 byte, nhờ Lynn}

JavaScript (V8) ,  101  108 byte

EDIT: +7 byte để in sang 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):'')``)

Hãy thử trực tuyến!

Nhận xét (không có 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)

Thạch , 21 byte

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

Một chương trình đầy đủ chấp nhận một số nguyên dương in ra STDOUT.

Hãy thử trực tuyến! Hoặc xem một bộ thử nghiệm .

Làm sao?

×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 byte

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

Hãy thử nó ở đây!

15 byte mà không cần xử lý1

Thạch , 21 byte

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

Hãy thử trực tuyến!

Một liên kết đơn âm chấp nhận một số nguyên duy nhất làm đối số bên trái của nó và trả về chuỗi Jelly được phân tách bằng dòng mới với ngôi sao làm đầu ra. Khi chạy dưới dạng một chương trình đầy đủ, in sao vào STDOUT.

Giải trình

   ɗ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

Than , 25 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

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

Vẽ một hình ngũ giác không đều đại diện cho phần trên cùng bên phải của ngôi sao, nhưng vỏ đặc biệt 1để làm cho hàng thêm một cột rộng hơn.

‖Ｏ¬

Phản ánh để hoàn thành ngôi sao.

Ｃ⁰¬⊖θ

Vỏ bọc đặc biệt hơn để làm cho ngôi sao cho 1một hàng cao hơn.

Giải pháp thay thế, cũng 25 byte:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

∧¬⊖θ*

In thêm *cho trường hợp 1.

Ｇ↗↓⊖׳Ｎ*

Vẽ nửa bên trái của một hình tam giác có kích thước phù hợp.

‖Ｏ

Phản xạ để hoàn thành tam giác.

‖ＯＯ↓∧⊖θ⊖⊗θ

Chồng chéo nó với sự phản chiếu của nó, ngoại trừ trong trường hợp 1, trong trường hợp đó chỉ phản ánh nó.

14 byte không có vỏ đặc biệt cho 1:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｇ<⊖׳Ｎ*

Vẽ một hình tam giác có kích thước phù hợp.

‖ＯＯ↑⊖⊗θ

Chồng chéo nó với sự phản ánh của nó.

Perl 6 , 74 byte

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

Hãy thử trực tuyến!

Nghĩa đen tạo ra một hình tam giác với tỷ lệ đúng và chồng nó với một bản sao lộn ngược bằng cách sử dụng chuỗi hoặc toán tử ( ~|). Đầu ra dưới dạng một danh sách các dòng có khoảng trắng dòng đầu và cuối.

Giải trình:

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

Hãy thử trực tuyến!

vô dụng

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

làm sao

Sử dụng bảng chức năng (như bảng lần thứ 3) để xây dựng một nửa tam giác bằng cách sử dụng >:(lớn hơn hoặc bằng) làm hàm. Sau đó đảo ngược từng hàng, cắt cột cuối cùng và khâu hai cạnh lại với nhau để có được hình tam giác đầy đủ (nhưng được làm bằng 1 và 0). Thêm ncác hàng số không ở phía dưới. Cuối cùng đảo ngược toàn bộ, và phủ nó lên bản gốc, sử dụng boolean hoặc +.để có kết quả. Sau đó biến 1 thành *0 và khoảng trắng.

T-SQL, 194 byte

@ là giá trị đầu vào

@c xử lý chiều rộng của tam giác trên cùng

@d xử lý tam giác đáy rộng

@echứa đầu ra @choặc @d- điều này sẽ tiết kiệm một vài byte

@fxử lý trường hợp đặc biệt của 1 làm đầu vào. @c*@=3xác định khi nào sử dụng @f. 5 byte rẻ hơn so với viết@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

Dùng thử trực tuyến

Japt -R , 25 byte

+5 byte cho n=1: \

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

Thử nó

õ 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