Vấn đề

Lấy cảm hứng từ một thử thách trước đó làm một cái gì đó tương tự

Cho đầu nra số nguyên dương có hình dạng theo mẫu này:

đầu vào n=1:

* *
 *
* *

đầu vào n=2:

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

đầu vào n=3:

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

và v.v.

Nó có các tính chất sau:

n*2+1 đường cao

"cánh tay" là n rộng trừ khi chúng hợp nhất

đường trung tâm nrộng

nếu nthậm chí các dòng trên và dưới trung tâm là n*2rộng

nếu nlà lẻ các dòng trên và dưới trung tâm n*2-1rộng

Quy tắc

• Trailing newlines được chấp nhận
• Áp dụng sơ hở tiêu chuẩn
• Chiến thắng byte ngắn nhất
• Đầu ra có thể được in ra hoặc một chuỗi hoặc một chuỗi các chuỗi

Chỉnh sửa

• n=0 không cần phải xử lý
• Không gian lưu trữ cho phép

Than , 13 12 byte

Cảm ơn @ErikTheOutgolfer cho một byte

ＦＮ«ＰX⁺*×*Ｉθ→

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

Đây là câu trả lời đầu tiên của tôi về Than, và tôi khá chắc chắn rằng nó không được chơi golf tốt như nó có thể, nhưng tôi đoán rằng tôi sẽ bắt đầu ở đâu đó.

 ＦＮ«            # For input() (i in range(0,input()))
     Ｐ           # Print
       X          # In an 'X' shape
        ⁺*×*Ｉθ   # '*'+'*'*int(first_input)
               →  # Move the cursor right one

MATL , 16 byte

EQXyG:Y+tP+g42*c

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

Giải trình

Hãy xem xét đầu vào 2là một ví dụ. Nội dung ngăn xếp được hiển thị với những cái gần đây hơn dưới đây.

EQ    % Implicitly input n. Push 2*n+1
      %   STACK: 5
Xy    % Identity matrix of that size
      %   STACK: [1 0 0 0 0;
                  0 1 0 0 0;
                  0 0 1 0 0;
                  0 0 0 1 0;
                  0 0 0 0 1]
G:    % Push [1 2 ... n]
      %   STACK: [1 0 0 0 0;
                  0 1 0 0 0;
                  0 0 1 0 0;
                  0 0 0 1 0;
                  0 0 0 0 1],
                 [1 2]
Y+    % 2D convolution, extending size
      %   STACK: [1 2 0 0 0 0;
                  0 1 2 0 0 0;
                  0 0 1 2 0 0;
                  0 0 0 1 2 0;
                  0 0 0 0 1 2]
tP+   % Duplicate, flip vertically, add
      %   STACK: [1 2 0 0 2 1;
                  0 1 2 1 2 0;
                  0 0 1 4 0 0;
                  0 1 2 1 2 0;
                  1 2 0 0 1 2]
g     % Convert to logical
      %   STACK: [1 1 0 0 1 1;
                  0 1 1 1 1 0;
                  0 0 1 1 0 0;
                  0 1 1 1 1 0;
                  1 1 0 0 1 1]
42*   % Multiply by 42.
      %   STACK: [42 42  0  0 42 42;
                   0 42 42 42 42  0;
                   0  0 42 42  0  0;
                   0 42 42 42 42  0;
                  42 42  0  0 42 42]
c     % Convert to char. Char 42 is '*'. Char 0 is displayed as space
      %   STACK: ['**  **';
                  ' **** ';
                  '  **  ';
                  ' **** ';
                  '**  **']

Thạch , 15 byte

Ḥ‘Ḷ⁶ẋ;€”*ẋ$»Ṛ$Y

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

V , 18 17 byte

Đã lưu một byte nhờ thủ thuật nhập liệu của @ DJMcMayhem.

Àé*ÄJÀälÀñ2ÙÀl2x>

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

Giải trình

Àé*ÄJÀäl

Điều này chèn [n]*'*'+[n]*' '+[n]*'*'

        Àñ        ' [arg] times
          2Ù      ' Duplicate the current line down twice
            Àl    ' Move right [arg] times
              2x  ' Delete two characters
                > ' Indent this line one space

Mỗi lần lặp của vòng lặp bộ đệm đi từ

|**   ***

Đến

***   ***
 |** ***
***   ***

Trong trường hợp |là con trỏ với một *dưới nó

05AB1E , 18 byte

Å4bS{I·ƒDÂ~„ *èJ,À

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

Giải trình

Ví dụ như n=2

Å4                   # push a list of 4s with length as the input
                     # STACK: [4,4]
  b                  # convert each to binary
                     # STACK: [100, 100]
   S{                # split into digit list and sort
                     # STACK: [0, 0, 0, 0, 1, 1]
     I·ƒ             # input*2+1 times do
        D            # duplicate top of stack
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 0, 0, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
         Â~          # or each item in the duplicate with its reverse
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [1, 1, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 1, 1, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
           „ *èJ     # use the resulting binary list to index into the string " *"
                     # 1st iteration: [0, 0, 0, 0, 1, 1], "**  **"
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], " **** "
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], "  **  "
                ,    # print
                 À   # rotate list left

V , 23 byte

Àé*ÄJÀälÀñÙãlxx>ñyHæGVp

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

Hexdump:

00000000: c0e9 2ac4 4ac0 e46c c0f1 d9e3 6c78 783e  ..*.J..l....lxx>
00000010: f179 48e6 4756 70                        .yH.GVp

Vì lý do nào, thử thách này ở V khó hơn đáng kể so với thử thách cuối cùng. Vì cách tiếp cận chung của chúng tôi về n lần, hãy phát triển 'x' sẽ không hoạt động ở đây, thay vào đó, chúng tôi sẽ xây dựng đỉnh X, sao chép và lật nó, sau đó gắn hai phần lại với nhau.

Giải trình:

Àé*ÄJÀäl                " Insert ('*' * n) + (' ' * n) + ('*' * n) 
                        " The obvious way would be 'Àé*ÀÁ ÀÁ*', but this 
                        " non-obvious way saves us a byte
        Àñ      ñ       " 'n' times:
          Ù             "   Duplicate this line (below us)
           ãl           "   Move to the center of this line
             xx         "   Delete two characters
               >        "   And indent this line with one space.

Thực hiện thụt lề ở cuối vòng lặp, cho phép chúng ta tận dụng các kết thúc ngầm . Điều này cũng thuận tiện tạo ra n + 1 dòng, chính xác là nửa trên của 'X'. Giả sử đầu vào là 4. Sau đó, tại thời điểm này, bộ đệm trông như thế này:

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

Và chúng tôi đang ở dòng cuối cùng. Vì vậy, sau đó chúng tôi:

                yH      " Copy the whole buffer and move to the first line
                  æG    " Reverse every line
                    Vp  " And paste what we just copied *over* the current
                        " line, deleting it in the process

C #, 139 130 115 byte

-1 byte bằng cách tạo một chuỗi và gọi WriteLine, do đó lưu kiểm tra cho dòng mới.
-6 byte nhờ Kevin và kỹ thuật chơi gôn bậc thầy của anh ấy!
-2 byte bằng cách thay thế n*3-nbằng n*2.
-15 byte sau khi Kevin vui lòng chỉ cho tôi đi đúng hướng: Tôi chỉ có thể trả về chuỗi thay vì in nó, do đó lưu cuộc gọi đến System.Console.WriteLine(). Và một số lời khuyên khác cũng ...

n=>{var s="";for(int i,j=0;j<=n*2;j++,s+='\n')for(i=0;i<n*3;)s+=i>=j&i<j+n|i<=n*3-j-1&i++>=n*2-j?'*':' ';return s;}

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

Ung dung:

class Program
{
    static void Main(string[] args)
    {
        System.Func<int, string> g = n =>
        {
            var s = "";
            for (int i, j = 0; j <= n*2; j++, s += '\n')
                for (i = 0; i < n*3;)
                    s += i >= j & i < j+n | i <= n*3-j-1 & i++ >= n*2-j ? '*' : ' ';
            return s;
        };

        System.Console.Write(f(1));
        System.Console.Write(f(2));
        System.Console.Write(f(3));
        System.Console.Write(f(5));
        System.Console.Write(f(8));

        System.Console.ReadKey();
    }
}

Nó chỉ lặp đi lặp lại dọc theo các hàng và cột của không gian cần thiết để in chữ X lớn và in a '*'hoặc a ' 'tùy theo điều kiện.

Haskell , 88 87 86 byte

-1 cảm ơn @Laikoni

(!)=replicate
x n=[zipWith max(reverse m)m|m<-[i!' '++n!'*'++(n*2-i)!' '|i<-[0..n*2]]]

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

Thạch , 24 23 16 byte

Ḥ‘Ḷ⁸+þṬ+Ṛ$a”*o⁶Y

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

MATLAB, 153 126 byte (17,6%)

Nhờ @ bình luận LuisMendo của, chức năng disp()can chars đầu ra mà không có dấu ngoặc kép duy nhất, do đó tôi có thể ngăn chặn sử dụng fprintfvới formatsvà bỏ qua một vài byte. Bên cạnh đó, bình luận của anh ấy nhắc nhở tôi rằng tôi cần sử dụng char(32)để trình bày một không gian chứ không phải char(0)(null).

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=10
disp([a+32 ''])

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

MATLAB, 153 byte

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1 
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=42
fprintf([repmat('%c',1,c),'\n'],char(a)')

Ví dụ kết quả: n = 10

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

Python 2 , 93 90 89 83 byte

^{-3 byte nhờ Leaky Nun
-1 byte nhờ Zachary T
-6 byte nhờ xnor}

n=input()
x=n*'*'+n*'  '
exec"print`map(max,x,x[::-1])`[2::5];x=' '+x[:-1];"*(n-~n)

[Dùng thử trực tuyến!] [TIO-j3xwsktf]

Bắt đầu với một chuỗi như '*** 'chon=3 , áp dụng map/maxđể chọn *khoảng trắng cho mỗi vị trí, sau đó nối thêm khoảng trắng và xóa ký tự cuối cùng khỏi chuỗi và thực hiện lại tất cả.

Haskell , 70 byte

f n=[[last$' ':['*'|y<-[1..n],(c-n-y)^2==r^2]|c<-[1..3*n]]|r<-[-n..n]]

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

Xuất ra một danh sách các chuỗi.

Đối với mỗi vị trí của hàng r, cột c, sử dụng một công thức để xác định xem nó có thuộc một trong hai dải chéo hay không *.

Java 8, 119 118 byte

n->{String r="";for(int i=0,j;i<=n*2;i++,r+="\n")for(j=0;j<n*3;r+=j>=i&j<i+n|j<=n*3-i-1&j++>=n*2-i?"*":" ");return r;}

Cổng từ câu trả lời C # tuyệt vời của @CarlosAlejo , sau khi tôi giúp anh ấy chơi golf một vài điều. Vì vậy, hãy chắc chắn để nâng cao anh ấy là tốt!

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

Javascript (ES2017), 155 157 byte

n=>[...e=[...Array(n+1)].map((a,i)=>[...d=((b=''.padEnd(n))[c='slice'](i)+'*'.repeat(n)+b[c](0,i))[c](n/2)].reverse().join``+d[c](n%1)),...e.reverse()[c](1)]

Trả về một chuỗi các chuỗi. Tôi thực hiện các hoạt động trên mảng sau đó phản chiếu nó. Điều này có thể được tối ưu hóa với ma trận như các câu trả lời khác, nhưng tôi muốn là duy nhất.

Chỉnh sửa: Như Neil đã chỉ ra, đối với các giá trị chẵn của n, đường trung tâm không nrộng, vì vậy tôi đã thêm một mô-đun để phát hiện chẵn / lẻ khi cắt cột.

n=5
['*****     *****',
 ' *****   ***** ',
 '  ***** *****  ',
 '   *********   ',
 '    *******    ',
 '     *****     ',
 '    *******    ',
 '   *********   ',
 '  ***** *****  ',
 ' *****   ***** ',
 '*****     *****']

Ung dung

n => {
  e = [...Array(n+1)].map((a, i) => {   // Create and iterate over array with n+1 elements
    b = ''.padEnd(n)                    // String of n spaces
    d = (b.slice(i) + '*'.repeat(n) + b.slice(0, i)).slice(n/2) // Create row string
    return [...d].reverse().join`` + d.slice(1) // Mirror and combine row horizontally
  })
  return [...e,...e.reverse().slice(1)] // Mirror and combine vertically
}

Góc phần tư

n=5
   *****
  ***** 
 *****  
*****   
****    
***     

Nhân đôi theo chiều ngang

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     

Nhân đôi theo chiều dọc

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     
    *******    
   *********   
  ***** *****  
 *****   ***** 
*****     *****

Toán học, 148 byte

T=Table;(a=Join[T[T["*",i],{i,(n=#)+2,2n,2}],T[Join[t=T["*",n],T[" ",y],t],{y,1,n,2}]];Column[Row/@Join[Reverse@a,{T["*",n]},a],Alignment->Center])&

R, 102 byte

Mã số:

n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)

Kiểm tra:

> n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)
1: 10
2: 
Read 1 item
**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********

CJam, 24 byte

{:T2*){S*T'**+}%_W%..e>}

Đây là một khối lấy một số từ ngăn xếp và đưa ra một danh sách các dòng cho ngăn xếp.

Giải trình:

{                        e# Stack:           | 2
 :T                      e# Store in T:      | 2, T=2
   2*                    e# Multiply by 2:   | 4
     )                   e# Increment:       | 5
      {                  e# Map over range:  | [0
       S                 e#   Push space:    | [0 " "
        *                e#   Repeat string: | [""
         T               e#   Push T:        | ["" 2
          '*             e#   Push char '*': | ["" 2 '*
            *            e#   Repeat char:   | ["" "**"
             +           e#   Concatenate:   | ["**"
              }%         e# End:             | ["**" " **" "  **" "   **" "    **"]
                _        e# Duplicate:       | ["**" " **" "  **" "   **" "    **"] ["**" " **" "  **" "   **" "    **"]
                 W%      e# Reverse:         | ["**" " **" "  **" "   **" "    **"] ["    **" "   **" "  **" " **" "**"]
                   ..e>  e# Overlay:         | ["**  **" " ****" "  **" " ****" "**  **"]
                       } e# End

Python 2 , 110 byte

x=a=0
n=c=input()
while x<2*n+1:
    print ' '*a+'*'*n+' '*c+'*'*(2*n-2*a-c)
    x+=1
    a=n-abs(n-x)
    c=max(0, n-2*a)

Chương trình này chia mỗi dòng thành 4 phần, không gian đầu tiên, ngôi sao đầu tiên, không gian thứ hai và sau đó là ngôi sao thứ hai. Đối với mỗi dòng nằm ngang của X, nó tính toán có bao nhiêu ngôi sao hoặc không gian cần thiết cho mỗi trong 4 phần của dòng, sau đó xây dựng và in chuỗi đó.

Võng mạc , 144 byte

.+
 $&$* $&$* $&
 
$`#$'¶
¶\d+$

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1
( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3
+` (# +#)
$1 
+` #...
#
##

Hãy thử trực tuyến! Giải trình:

.+
 $&$* $&$* $&

Thêm 2n + 1 khoảng trắng trước giá trị đầu vào (một cho mỗi dòng đầu ra).

$`#$'¶

Thay thế mỗi không gian bằng a #và thu thập kết quả. Điều này cung cấp một đường chéo của #s, không gian được đệm ở cả hai bên, với giá trị đầu vào được thêm vào.

¶\d+$

Xóa giá trị đầu vào ban đầu, vì bây giờ chúng tôi có một bản sao trên mỗi dòng.

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1

Xây dựng hai đường chéo của n *s, với một cột phân cách các nkhoảng trắng được bọc trong một cặp #s.

( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3

Trên các đường mà *s ở gần giữa, hoán đổi hai nửa xung quanh. Điều này cho một sự xuất hiện giống như > | | <.

+` (# +#)
$1 

Di chuyển | |s càng xa bên trái, họ sẽ >> > <xuất hiện.

+` #...
#

Đối với mỗi khoảng trắng giữa các #s, xóa ba ký tự sau. Điều này tham gia > <vào một X.

##

Xóa các #s không cần thiết bây giờ .