Hôm nay, chúng ta sẽ tạo ra một hình lục giác ASCII. Bạn phải viết một chương trình hoặc hàm lấy số nguyên dương n và xuất ra một hình lục giác có kích thước n , được tạo thành từ các dấu sao. Ví dụ: một hình lục giác có kích thước 2 trông như thế này:

 * *
* * *
 * *

Trong khi một hình lục giác có kích thước 3 trông như thế này:

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

Bạn có thể sử dụng bất kỳ phương thức nhập và xuất mặc định nào , ví dụ STDIO / STDOUT, đối số hàm và trả về giá trị hoặc đọc / ghi tệp.

Bạn có thể cho rằng đầu vào luôn hợp lệ, vì vậy nếu đó không phải là số nguyên dương, chương trình của bạn có thể làm bất cứ điều gì bạn muốn. Bạn làm tuy nhiên phải xử lý các trường hợp đặc biệt của một hình lục giác có kích thước 1, mà sẽ xảy ra là một dấu duy nhất:

*

Khoảng trắng hàng đầu và dấu được cho phép miễn là đầu ra giống nhau.

Ví dụ:

1:
*

2:
 * *
* * *
 * *

3:
  * * *
 * * * *
* * * * *
 * * * *
  * * *

4:
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

5:
    * * * * *
   * * * * * *
  * * * * * * *
 * * * * * * * *
* * * * * * * * *
 * * * * * * * *
  * * * * * * *
   * * * * * *
    * * * * *

6:
     * * * * * *
    * * * * * * *
   * * * * * * * *
  * * * * * * * * *
 * * * * * * * * * *
* * * * * * * * * * *
 * * * * * * * * * *
  * * * * * * * * *
   * * * * * * * *
    * * * * * * *
     * * * * * *

12:
           * * * * * * * * * * * *
          * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
          * * * * * * * * * * * * *
           * * * * * * * * * * * *

Như thường lệ, đây là môn đánh gôn , vì vậy các sơ hở tiêu chuẩn được áp dụng và bạn nên cố gắng viết chương trình ngắn nhất có thể được đo bằng byte. Tất nhiên, một số ngôn ngữ vốn đã ngắn hơn hoặc dài hơn các ngôn ngữ khác, vì vậy hãy nhớ rằng mục tiêu không nhất thiết phải có số byte tổng thể ngắn nhất, mà là để đánh bại các bài nộp trong cùng ngôn ngữ hoặc tương tự.

Có thể người chơi golf tốt nhất giành chiến thắng!

Hexagony + Bash Coreutils, 0 + 3 + 8 = 11 byte

Bao gồm +3 cho -gcờ và +8 cho lệnh gọi |tr . \*không chuẩn (xem bài đăng meta này )

Đầu vào được đưa ra như là một đối số cho Hexagony. Khi trình thông dịch Hexagony được gọi với -g Ntùy chọn, nó sẽ in ra một hình lục giác .s. Sau đó chúng tôi sử dụng tr để thay thế những người bằng *s.

Python 2, 61 byte

i=n=input()
while~-n+i:i-=1;j=abs(i);print' '*j+'* '*(2*n+~j)

In một dấu cách ở cuối mỗi dòng.

Cảm ơn Erik, Outgolfer đã lưu một byte.

JavaScript (ES6), 77 81 84

@Upvoters: đừng bỏ lỡ câu trả lời của @ETHproductions, đó là 76 byte

Chỉnh sửa Sửa đổi sau khi thay đổi thông số kỹ thuật, dấu cách cho phép

Chỉ cho cái mũ ... này! Không có mũ?

f=(n,b='* '.repeat(n+n-1),o=b)=>--n?f(n,b=` ${b}`.slice(0,-2),b+`
${o}
`+b):o

Kiểm tra

f=(n,b='* '.repeat(n+n-1),o=b)=>--n?f(n,b=` ${b}`.slice(0,-2),b+`
${o}
`+b):o


function update()
{
  O.textContent=f(+I.value)
}

update()

<input id=I type=number min=1 value=3 oninput='update()'>
<pre id=O></pre>

Lục giác , 91 87 86 byte

?{2'*=&~}=&}='P0</0P}|@..;>;'.\};0Q/..\&(<>"-_"&}=\?_&\/8.=-\<><;{M/.(.(/.-{><.{&'/_.\

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

Cuối cùng đã làm được.

Ban đầu (trước khi nhận ra các vòng lặp đắt tiền như thế nào) Tôi hy vọng điều này có thể phù hợp với chiều dài bên 5, nhưng bây giờ nó đủ khó để lắp nó vào chiều dài bên 6.

Để có được điều này tôi thực sự phải sửa đổi mã tuyến tính một chút. Trong thực tế, viết điều này làm cho tôi nhận ra một cách để đánh golf mã tuyến tính xuống 1 2 byte.

JavaScript (ES6), 77 76 byte

g=(n,s=`
*`+' *'.repeat(n*2-2),c=s,q=c.replace('*',''))=>--n?g(n,q+s+q,q):s

Tôi tự nhủ mình sẽ không ngủ cho đến khi tôi lập kỷ lục ES6 mới mà không cần nhìn vào các câu trả lời khác, vì vậy đây là ...

Kiểm tra đoạn

g=(n,s=`
*`+' *'.repeat(n*2-2),c=s,q=c.replace('*',''))=>--n?g(n,q+s+q,q):s

for(var i = 1; i < 7; i++) console.log(g(i)) // joe

C, 91 89 80 74 byte

w,y;f(s){for(y=-s;++y<s;)for(w=printf("\n%*s",y,"");++w<s*printf(" *"););}

Tôi đã điều chỉnh khá nhiều để có được các công thức chính xác, sau đó trộn tất cả lại với nhau.

Gọi fvới số n , và nó sẽ in hình lục giác ra thiết bị xuất chuẩn.

Ungolfed và giải thích (phiên bản 80 byte):

w,y;
f(s) {
    // y iterates over [-s + 1 ; s - 1] (the number of rows)
    for(y = -s; ++y < s;)
        // w iterates over [abs(y) + 2 ; s * 2 - 1] (the number of stars on the row)
        for(
            // This prints a backspace character (ASCII 8)
            // padded with abs(y) + 2 spaces, effectively
            // printing abs(y) spaces to offset the row.
            // Also initializes w with abs(y) + 2.
            printf("\n%*c", w = abs(y) + 2, 8);

            // This is the for's condition. Makes use
            // of the 2 returned by printf, since we coïncidentally
            // need to double the upper bound for w.
            w++ < s * printf("* ");

            // Empty for increment
        )
            ; // Empty for body
}

Xem nó trực tiếp trên Coliru

Ghi chú:

• printfcó thể xử lý phần đệm âm, dẫn đến ký tự căn trái với phần đệm bên phải. Vì vậy, tôi đã thử một cái gì đó cho hiệu quả của w = printf("%*c*", y, ' ')nó để nó sẽ quan tâm đến giá trị tuyệt đối và tôi có thể lấy nó từ giá trị trả về của nó. Thật không may, cả hai chiều rộng không và một phần đệm đều tự in ký tự, vì vậy ba đường trung tâm giống hệt nhau.
  Cập nhật: Jasen đã tìm ra cách để thực hiện chính xác điều này bằng cách in một chuỗi rỗng thay vì một ký tự - 6 byte bị loại bỏ!

• Ký tự backspace được Coliru xử lý không chính xác - thực thi mã này trên thiết bị đầu cuối cục bộ sẽ loại bỏ không gian hàng đầu trên mỗi dòng.

05AB1E , 14 13 byte

Mã số:

F¹N+„ *×})û.c

Giải trình:

F       }        # Input times do (N = iteration number)
 ¹N+             #   Calculate input + N
    „ *×         #   Multiply by the string " *"
         )       # Wrap everything into an array
          û      # Palindromize the array
           .c    # Centralize

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

Thạch , 24 byte

R+’µạṀx@€⁶żx@K¥€”*$F€ŒḄY

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

Jelly xấu hổ vì thực tế là nó không có nguyên tử tập trung, do đó, nó bị đánh bại bởi 05AB1E và V. lần lượt là 11 và 7 byte!

Nếu bạn tìm thấy bất kỳ cách nào để chơi golf này, xin vui lòng bình luận. Bất kỳ trợ giúp được đánh giá cao.

Giải thích :

R+’µạṀx@€⁶żx@K¥€”*$F€ŒḄY Main link. Arguments: z.
R+’                      The sizes of the hexagon's rows. (implicit argument)
   µ                     Start a new monadic chain with the above argument.
    ȧṀx@€⁶               The spaces you must prepend to each row. (implicit argument)
           x@K¥€”*$      The stars (points) of each row, space-joined, as a single link. (implicit argument)
          ż        F€    Conjoin and merge the leading spaces with the stars appropriately.
                     ŒḄ  Create the second half of the hexagon without the middle row.
                       Y Join the rows with newlines. This makes the shape look like a hexagon.

Phần thưởng: Để tìm xem có bao nhiêu ngôi sao trong một hình lục giác, hãy sử dụng:

Ḷ×6S‘

Octave, 62 58 byte

@(n)' *'(dilate(impad(1,2*--n,n),[k='01010'-48;~k;k],n)+1)

Câu trả lời trước:

@(n)' *'(dilate(impad(1,2*(m=n-1),m),[k='01010'-48;~k;k],m)+1)

có thể được gọi là

(@(n)' *'(dilate(impad(1,2*(m=n-1),m),[k='01010'-48;~k;k],m)+1))(5)

Hãy thử (dán) nó trên Octave Online

Ví dụ: hình ảnh cơ sở cho n=5là

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

có thể được tạo ra với

impad(1,2*(n-1),n-1)

Các dilation morphological operatoráp dụng 4 lần vào hình ảnh bằng cách sử dụng mặt nạ hàng xóm sau:

0 1 0 1 0
1 0 1 0 1
0 1 0 1 0

có thể được tạo ra với [k='01010'-48;~k;k]

kết quả của sự giãn nở:

0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0
0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0
0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0
0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0
0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0

sau đó thay thế 0 và 1 bằng '' và '*' tương ứng

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

postgresql9.6, 290 byte

do language plpgsql $$ declare s constant smallint:=4;declare n smallint;declare a constant int[]:=array(select generate_series(1,s));begin foreach n in array a||array(select unnest(a)t order by t desc offset 1)loop raise info'%',concat(repeat(' ',s-n),repeat(' *',s+(n-1)));end loop;end;$$

sql định dạng là ở đây:

do language plpgsql $$
declare s constant smallint := 4;
declare n smallint;
declare a constant int[] := array(select generate_series(1, s));
begin
foreach n in array a || array(select unnest(a)t order by t desc offset 1) loop
    raise info '%', concat(repeat(' ', s - n), repeat(' *', s + (n - 1)));
end loop;
end;
$$;

đầu ra:

INFO:      * * * *
INFO:     * * * * *
INFO:    * * * * * *
INFO:   * * * * * * *
INFO:    * * * * * *
INFO:     * * * * *
INFO:      * * * *

V , 17 byte

é*À­ñ>{MÄpXA *Î.

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

Như thường lệ, đây là một hexdump, vì cái này chứa các ký tự không thể in được:

00000000: e92a c0ad f13e 7b4d c470 5841 202a 1bce  .*...>{M.pXA *..
00000010: 2e                                       .

APL (Dyalog Unicode) , 40 36 35 33 27 25 byte

(⍉⊖⍪1↓⊢)⍣2∘↑⍳↓¨∘⊂'* '⍴⍨+⍨

Giả sử ⎕IO←0, tức là lập chỉ mục dựa trên không. Đầu ra chứa một khoảng trắng hàng đầu và một dấu cách trên mỗi dòng.

Rất cám ơn @FrownyFrog và @ngn đã chơi golf rất nhiều.

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

Làm thế nào nó hoạt động

(⍉⊖⍪1↓⊢)⍣2∘↑⍳↓¨∘⊂'* '⍴⍨+⍨  ⍝ Main function train
                 '* '⍴⍨+⍨  ⍝   Repeat '* ' up to length 2×⍵
            ⍳↓¨∘⊂          ⍝   Generate lower-right corner of the hexagon
          ∘↑               ⍝   Convert to matrix
(⍉⊖⍪1↓⊢)                   ⍝   Palindromize vertically and transpose
        ⍣2                 ⍝   ... twice

JavaScript (ES6), 83 81 byte

Đây là câu trả lời đầu tiên (mã golf) của tôi. Tôi hy vọng tôi định dạng chính xác mọi thứ.

a=>{for(b=c=2*a-1;c;)console.log(" ".repeat(d=Math.abs(a-c--))+"* ".repeat(b-d))}

Không giống như 2 câu trả lời ES6 hiện tại, tôi không gọi đệ quy một hàm và tôi đang sử dụng bàn điều khiển để xuất ra.

Haskell, 99 97 79 byte

h n=mapM_(putStrLn.(\k->([k..n]>>" ")++([2..n+k]>>"* ")))([1..n-1]++[n,n-1..1])

Giải thích: Chương trình này dựa trên quan sát rằng mỗi dòng của n-Hexagon chứa (nk) khoảng trắng theo sau là dấu hoa thị (n + k-1), đối với một số k phụ thuộc vào số dòng.

h n=                                             h is a function of type Int -> IO ()
  mapM_                                          mapM_ executes a function returning 
                                                 monadic actions on all objects 
                                                 in a list, in order. Then it executes 
                                                 these actions, in order. For this code, it 
                                                 transforms each value in the list into a 
                                                 monadic action that prints 
                                                 the corresponding line

      (                                          the function consists of two components
        putStrLn                                 the second part is printing the result of 
                                                 the first part to stdout 

        .                                        concatenating both components

        (\k->                                    the first parts first prints (n-k) spaces 
                                                 and then (n+k-1) asterisks

          ([k..n]>>" ")                          create the list of the integers from 
                                                 k to n (That is actually one more entry
                                                 than necessary, but just results in a
                                                 leading whitespace per line, while
                                                 saving 2 bytes compared to [1..n-k]).
                                                 Then create a new list where 
                                                 each element of that first list is 
                                                 replaced with the string " " and 
                                                 concatenate that result into one string

          ++                                     concatenate both lists

          ([2..n+k]>>"* ")                       create the list of the integers 
                                                 from 2 to n+k (of length n+k-1). 
                                                 Then create a new list where each 
                                                 element of that first list is replaced 
                                                 with the string "* " and concatenate 
                                                 that result into one big string
        ) 

      )         
      ([1..n-1]++[n,n-1..1])                     the list simply goes from 1 to n and 
                                                 back, supplying the k 

Chỉnh sửa: Đã chuyển sang mapM_. Tôi đã không biết rằng đã có sẵn mà không cần sử dụng nhập khẩu

Python 2 , 100 97 89 88 87 81 79 byte

-1 từ @ Flp.Tkc

-6 một lần nữa từ @Flp

-2 với lời cảm ơn đến @ nedla2004. Tôi đã cố gắng tìm cách thoát khỏi lát thứ hai nhưng không nghĩ đến cái đó :)

i=input()
a=[" "*(i-x)+"* "*(i+x)for x in range(i)]
print'\n'.join(a+a[-2::-1])

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

Tạo một mảng cho nửa trên cùng sau đó thêm mảng đảo ngược trừ đi đường giữa sau đó in. In chính xác "như là" ngoài việc 1in với không gian hàng đầu (tôi đoán rằng được phép như *là trực quan giống như *có hoặc không có không gian hàng đầu).

Hàng loạt, 161 byte

@echo off
set s=*
set l=for /l %%i in (2,1,%1)do call 
%l%set s= %%s%% *
%l%echo %%s%%&call set s=%%s:~1%% *
echo %s%
%l%set s= %%s:~0,-2%%&call echo %%s%%

Lưu ý: Trailing space trên dòng 2. Ungolfed:

@echo off
set s=*
rem build up the leading spaces and stars for the first row
for /l %%i in (2,1,%1) do call :s
rem output the top half of the hexagon
for /l %%i in (2,1,%1) do call :t
rem middle (or only) row
echo %s%
rem output the bottom half of the hexagon
for /l %%i in (2,1,%1) do call :b
exit/b
:s
set s= %s% *
exit/b
:t
echo %s%
rem for the top half remove a space and add a star to each row
set s=%s:~1% *
exit/b
:b
rem for the bottom half add a space and remove a star from each row
set s= %s:~0,-2%
echo %s%
exit/b

JavaScript (ES6), 83 byte

f=
n=>[...Array(n+--n)].map((_,i,a)=>a.map((_,j)=>j<n-i|j<i-n?``:`*`).join` `).join`
`

<input type=number min=1 oninput=o.textContent=f(+this.value)><pre id=o>

Canvas , 9 byte

╷⁸＋* ×］／─

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

Đánh bại tích hợp: D

Giải trình:

{╷⁸+* ×]/─  implicit "{"
{      ]    map over 1..input
 ╷            decrement: 0..input-1
  ⁸+          add the input: input..(input*2-1)
    * ×       repeat "* " that many times
        /   diagonalify that - pad each line with 1 less space than the previous
         ─  palindromize vertically

_{Không biết tại sao lại có phần đệm lớn, nhưng nó được cho phép và tôi sẽ sớm sửa nó. đã sửa? Hy vọng tôi không phá vỡ mọi thứ}

Perl 6 , 49 byte

->\n{say " "x n*2-1-$_~"*"xx$_ for n...n*2-1...n}

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

Làm thế nào nó hoạt động

->\n{                                           }  # Lambda accepting edge size (e.g. 3)
                               for n...n*2-1...n   # For each row-size (e.g. 3,4,5,4,3):
                       "*"xx$_                     # List of stars     (e.g. "*","*","*")
         " "x n*2-1-$_                             # Spaces to prepend (e.g. "  ")
                      ~                            # Concatenate.      (e.g. "  * * *")
     say                                           # Print

Powershell, 91 89 78 68 63 52 48 byte

param($n)$n..1+1..$n|gu|%{' '*$_+'* '*(2*$n-$_)}

Kịch bản thử nghiệm:

$script = {
param($n)$n..1+1..$n|gu|%{' '*$_+'* '*(2*$n-$_)}
}

12,6,5,4,3,2,1 |%{
    $_
    . $script $_
}

Đầu ra (không gian hàng đầu thêm):

12
            * * * * * * * * * * * *
           * * * * * * * * * * * * *
          * * * * * * * * * * * * * *
         * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * * *
          * * * * * * * * * * * * * *
           * * * * * * * * * * * * *
            * * * * * * * * * * * *
6
      * * * * * *
     * * * * * * *
    * * * * * * * *
   * * * * * * * * *
  * * * * * * * * * *
 * * * * * * * * * * *
  * * * * * * * * * *
   * * * * * * * * *
    * * * * * * * *
     * * * * * * *
      * * * * * *
5
     * * * * *
    * * * * * *
   * * * * * * *
  * * * * * * * *
 * * * * * * * * *
  * * * * * * * *
   * * * * * * *
    * * * * * *
     * * * * *
4
    * * * *
   * * * * *
  * * * * * *
 * * * * * * *
  * * * * * *
   * * * * *
    * * * *
3
   * * *
  * * * *
 * * * * *
  * * * *
   * * *
2
  * *
 * * *
  * *
1
 *

Giải trình:

param($n)           # define script parameter
$n..1+              # int range from n to 1 step -1; append
1..$n|              # int range from 1 to n
gu|                 # alias for Get-unique eliminates equal neighbors - here is 1,1 -> 1
%{                  # for each int from [n, n-1, n-2, ... 2, 1, 2, ... n-2, n-1, n]
    ' '*$_+         # string (' ' have repeated $_ times) append
    '* '*(2*$n-$_)  # string ('* ' have repeated 2*n-$_ times)
}

PHP, 83 79 byte

for($p=str_pad;++$y<2*$n=$argn;)echo$p($p("
",1+$k=abs($n-$y)),4*$n-$k-2,"* ");

Chạy như ống với -nRhoặc thử trực tuyến .

Điều này gần với câu trả lời của Kodos ; nhưng str_padngắn hơn str_repeatngay cả khi chơi golf.
Và ++trong vòng lặp đầu tiết kiệm một số chi tiết.

Ruby, 54 byte

->n{(1-n..n-1).map{|j|i=j.abs;' '*i+'* '*(n*2+~i)}*$/}

Hàm lambda lấy n làm đối số và trả về một chuỗi được phân tách bằng dòng mới. ( $/là một biến chứa dấu phân cách dòng mặc định.)

trong chương trình thử nghiệm

f=->n{(1-n..n-1).map{|j|i=j.abs;' '*i+'* '*(n*2+~i)}*$/}

puts f[gets.to_i]

Charly, 125 byte

let i="".promptn()let o=0let j=0let w=write loop{w(" "*(i-1-o),"* "*(i+o))w("
")if j<i-1{o+=1}else{o-=1}if o<0{break}j+=1}

Trang Charit GitHub: https://github.com/KCreate/charly-lang

SmileBASIC, 74 byte

FOR I=0TO N-1P
NEXT
FOR I=N-2TO.STEP-1P
NEXT
DEF P?" "*(N-I);"* "*(N+I)END

Thêm một không gian hàng đầu và dấu.

Những "hình lục giác" này trông thật kinh khủng khi các nhân vật có cùng chiều rộng và chiều cao ...

vợt / sơ đồ

(define (f n)
  (define (s t n)
    (if (= n 0) t (s (~a t "* ") (- n 1))))
  (define (h t p a i)
    (if (= i 0)
        (display t)
        (let ((x (~a t (make-string p #\space) (s "" a) "\n"))
              (q (if (> i n) (- p 1) (+ p 1)))
              (b (if (> i n) (+ a 1) (- a 1))))
          (h x q b (- i 1)))))
  (h "" (- n 1) n (- (* 2 n) 1)))

thử nghiệm:

(f 1)
*

(f 4)
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

Python 2, 111 byte

n=input()
l=range(n,2*n-1)
S=l+[2*n-1]+l[::-1]
W=range(1,n)
for w in W[::-1]+[0]+W:print" "*w+"* "*S[0];S=S[1:]

Một triển khai nhàm chán, đơn giản (và một chương trình đầy đủ). Xuất ra một khoảng trắng ở mỗi dòng.

Testcase:

1:
*

2:
 * * 
* * * 
 * * 

3:
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 

4:
   * * * * 
  * * * * * 
 * * * * * * 
* * * * * * * 
 * * * * * * 
  * * * * * 
   * * * * 

Javascript (ES6), 143 byte

Cuối cùng cũng đến kỳ nghỉ Giáng sinh (Giáng sinh vui vẻ!), Vì vậy tôi có một chút thời gian để chơi gôn.
Và cậu bé đã được một lúc - do đó số lượng byte lớn.
Đây là:

c=[];a=a=>{for(i=0;i<a;i++){c.push(" ".repeat(a-i-1)+"* ".repeat(i+a-1)+"*")}for(j=c.length-2;j>-1;j--)c.push(c[j]);return a==1?"*":c.join`\n`}
console.log(a(3));

Java, 157 149 129 127 byte

s->{for(int j=~--s,t;++j<=s;p(s-~s-t,"* "),p(1,"\n"))p(t=j<0?-j:j," ");};<T>void p(int j,T s){for(;j-->0;)System.out.print(s);}

• 8 byte bị xóa bởi Jonathan Frech.
• 20 byte bị xóa bởi Kevin Cruijssen.
• 2 byte bị xóa bởi Kevin Cruijssen.

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

Hexagony (tuyến tính), 128 127 126 byte

Lưu ý rằng đây không phải là Hexagony, chỉ là một ngôn ngữ (meta-) Timwi được hỗ trợ trong IDE bí truyền, vì vậy điều này không đủ điều kiện để nhận tiền thưởng.

Tuy nhiên, điều này có thể được chuyển đổi thành một giải pháp Hexagony (và tôi nghĩ rằng nó sẽ nhỏ hơn giải pháp này) Tôi có thể làm điều đó sau. Phải mất nhiều nỗ lực hơn tôi đã làm nó ở đây .

Ban đầu ❢mất 3 byte ( e2 9d a2). Mỗi dòng mới mất 1 byte ( 0a).

❢?{2'*=(
A
if > 0
 "-"&}=&~}=&}=?&
 B
 if > 0
  }P0;'(
  goto B
 &{&'-{=-(
 C
 if > 0
  'P0;Q0;}(
  goto C
 {M8;{(
 goto A
@

Không Hãy thử trực tuyến!. Điều này chỉ hoạt động trong IDE bí truyền.

Mã chú thích:

❢?        # read input n
[n]
{2'*=(     # x = 2n-1
[x]
A
if > 0    # loop (x) from 2n-1 to 1
 "-      # a = x - n
 [a]
 "&}=&~}=&    # a = abs(a). Let K be this amount
 }=?&
 B
 if > 0       # print ' ' (a) times
  }P0;'(
  goto B
 &        # current cell = a (= K)
 {&       # a = n if K>0 else x
          # Note that K=abs(x-n). So if K==0 then x==n.
          # Therefore after this step a is always equal to n.
 '-{=-    # compute n-(K-n) = 2n+K
 (        # decrement, get 2n+K-1
 C
 if > 0   # print ' *' this many times
  'P0;Q0;}(
  goto C
 {M8;{    # print a newline, goto x
 (        # x -= 1
 goto A
@

Japt -R, 11 10 byte

Æ°çSi*Ãû ê

Hãy thử nó (hoặc sử dụng TIO để chạy nhiều thử nghiệm)

Giải trình

               :Implicit input of integer U
Æ              :Map the range [0,U)
 °             :  Postfix increment U
  ç            :  Repeat
   S           :    Space
    i*         :    Prepend asterisk
      Ã        :End map
       û       :Centre pad each string with spaces to the length of the longest string
         ê     :Palindromise
               :Implicitly join with newlines and output