ปัญหา

แรงบันดาลใจจากการท้าทายครั้งก่อนทำสิ่งที่คล้ายกัน

รับอินพุตจำนวนเต็มบวก nเอาต์พุตรูปร่างที่ตามหลังรูปแบบนี้:

อินพุตn=1:

* *
 *
* *

อินพุตn=2:

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

อินพุตn=3:

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

และอื่น ๆ ...

มันมีคุณสมบัติเหล่านี้:

n*2+1 เส้นสูง

"แขน" nกว้างยกเว้นเมื่อรวมกัน

เส้นกลางnกว้าง

ถ้าnเป็นแม้กระทั่งเส้นด้านบนและด้านล่างตรงกลางn*2กว้าง

ถ้าnเป็นคี่เส้นด้านบนและด้านล่างตรงกลางn*2-1กว้าง

กฎระเบียบ

• ยอมรับการขึ้นบรรทัดใหม่
• ช่องโหว่มาตรฐานใช้
• ไบต์ที่สั้นที่สุดชนะ
• เอาต์พุตอาจถูกพิมพ์ออกมาหรือสตริงหรืออาร์เรย์ของสตริง

การแก้ไข

• n=0 ไม่จำเป็นต้องได้รับการจัดการ
• อนุญาตให้ใช้ช่องว่างต่อท้าย

Charcoalขนาด13 12 ไบต์

ขอบคุณ @ErikTheOutgolfer สำหรับไบต์

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

ลองออนไลน์!

นี่เป็นคำตอบถ่านครั้งแรกของฉันและฉันค่อนข้างแน่ใจว่ามันไม่ได้เล่นกอล์ฟอย่างที่ควรจะเป็น แต่ฉันคิดว่าฉันจะเริ่มต้นที่ไหนสักแห่ง

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

MATL , 16 ไบต์

EQXyG:Y+tP+g42*c

ลองออนไลน์!

คำอธิบาย

พิจารณาการป้อนข้อมูล2เป็นตัวอย่าง เนื้อหาสแต็คจะแสดงด้วยเนื้อหาล่าสุดด้านล่าง

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: ['**  **';
                  ' **** ';
                  '  **  ';
                  ' **** ';
                  '**  **']

เยลลี่ 15 ไบต์

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

ลองออนไลน์!

V , 18 17 ไบต์

บันทึกเป็นไบต์ด้วยเคล็ดลับการป้อนข้อมูลของ @ DJMcMayhem

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

ลองออนไลน์!

คำอธิบาย

Àé*ÄJÀäl

เม็ดมีดนี้ [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

การวนซ้ำของการวนซ้ำบัฟเฟอร์ที่เริ่มต้น

|**   ***

ไปยัง

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

ที่ไหน|เป็นเคอร์เซอร์ที่มี*อยู่ภายใต้มัน

05AB1E , 18 ไบต์

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

ลองออนไลน์!

คำอธิบาย

ตัวอย่างสำหรับ 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 ไบต์

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

ลองออนไลน์!

hexdump:

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

ไม่ว่าจะด้วยเหตุผลใดก็ตามความท้าทายนี้จะยากกว่า V มากในครั้งสุดท้าย เนื่องจากวิธีการทั่วไปของเราจำนวนn ครั้งการขยายตัว 'x'จะไม่ทำงานที่นี่เราจะสร้างส่วนบนของ X คัดลอกแล้วพลิกกลับจากนั้นแนบสองส่วนเข้าด้วยกัน

คำอธิบาย:

Àé*Ä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.

ทำเยื้องที่สิ้นสุดของวงที่ช่วยให้เราสามารถใช้ประโยชน์จากตอนจบโดยปริยาย สิ่งนี้ยังช่วยสร้างn + 1บรรทัดซึ่งเป็นครึ่งบนของ 'X' อย่างแน่นอน สมมุติว่าอินพุตเป็น 4 จากนั้นถึงจุดนี้บัฟเฟอร์มีลักษณะดังนี้:

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

และเราอยู่ในบรรทัดสุดท้าย ดังนั้นเรา:

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

-1 ไบต์โดยการสร้างสตริงและการโทรWriteLineดังนั้นการบันทึกการตรวจสอบสำหรับบรรทัดใหม่
-6 ไบต์ขอบคุณเควินและเทคนิคการตีลูกกอล์ฟของเขา!
-2 ไบต์โดยการแทนที่ด้วยn*3-n -15 ไบต์หลังจากที่เควินกรุณาชี้ให้ฉันในทิศทางที่เหมาะสม: ฉันเพิ่งสามารถกลับสตริงแทนการพิมพ์จึงช่วยประหยัดการเรียกร้องให้ และเคล็ดลับอื่น ๆ เช่นกัน ...n*2
System.Console.WriteLine()

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;}

ลองออนไลน์!

Ungolfed:

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();
    }
}

มันแค่วนซ้ำตามแถวและคอลัมน์ของพื้นที่ที่จำเป็นในการพิมพ์ X ใหญ่และพิมพ์ a '*'หรือ a ' 'ขึ้นอยู่กับเงื่อนไข

Haskell , 88 87 86 ไบต์

-1 ต้องขอบคุณ @Laikoni

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

ลองออนไลน์!

เยลลี่ , 24 23 16 ไบต์

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

ลองออนไลน์!

MATLAB, 153 126 ไบต์ (17.6% ↓)

ขอบคุณที่ความคิดเห็นของ @ LuisMendo ฟังก์ชั่นdisp()สามารถส่งออกตัวอักษรโดยไม่มีเครื่องหมายอัญประกาศเดียวดังนั้นฉันสามารถป้องกันfprintfด้วยการใช้formatsและละเว้นไม่กี่ไบต์ นอกจากนี้ความคิดเห็นของเขายังทำให้ฉันนึกถึงว่าฉันต้องใช้char(32)เพื่อนำเสนอพื้นที่มากกว่า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 ''])

ลองออนไลน์!

MATLAB, 153 ไบต์

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

ตัวอย่างผลลัพธ์: n = 10

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

Python 2 , 93 90 89 83 ไบต์

^{-3 ไบต์ขอบคุณ Leaky Nun
-1 ไบต์ขอบคุณ Zachary T
-6 ไบต์ขอบคุณ xnor}

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

[ลองออนไลน์!] [TIO-j3xwsktf]

เริ่มต้นด้วยสตริงเช่น'*** 'สำหรับn=3การใช้map/maxที่จะเลือก*มากกว่าพื้นที่สำหรับแต่ละตำแหน่งแล้วผนวกพื้นที่และลบตัวอักษรตัวสุดท้ายจากสตริงและทำเช่นนี้ทั้งหมดอีกครั้ง

Haskell , 70 ไบต์

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

ลองออนไลน์!

ส่งออกรายการของสตริง

สำหรับแต่ละตำแหน่งของแถวr, คอลัมน์c, ใช้สูตรเพื่อตรวจสอบว่ามันตกอยู่ในหนึ่งในสองแถบแนวทแยงและอื่น*ๆ

Java 8, 119 118 ไบต์

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 # ของ@CarlosAlejoน่าทึ่งหลังจากที่ฉันช่วยเขาเล่นกอล์ฟ ดังนั้นอย่าลืมโหวตเขาเช่นกัน!

ลองที่นี่

Javascript (ES2017), 155 157 ไบต์

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)]

ส่งคืนอาร์เรย์ของสตริง ฉันดำเนินการเกี่ยวกับอาร์เรย์แล้วสะท้อนมัน นี่อาจจะปรับให้เหมาะกับเมทริกซ์เหมือนคำตอบอื่น ๆ แต่ฉันต้องการที่จะไม่ซ้ำกัน

แก้ไข: ตามที่ Neil ชี้ให้เห็นถึงค่าnที่เท่ากันเส้นศูนย์กลางไม่nกว้างดังนั้นฉันจึงเพิ่มโมดูลัสเพื่อตรวจจับคู่ / คี่เมื่อตัดคอลัมน์

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

Ungolfed

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
}

Quadrant

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

มิร์เรอร์แนวนอน

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

มิร์เรอร์ในแนวตั้ง

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

Mathematica, 148 ไบต์

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

รหัส:

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)

ทดสอบ:

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

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

นี่คือบล็อกที่ใช้ตัวเลขจากสแต็กและส่งรายการของบรรทัดไปยังสแต็ก

คำอธิบาย:

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

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)

โปรแกรมนี้แบ่งแต่ละบรรทัดออกเป็น 4 ส่วนคือช่องว่างแรกดาวดวงแรกช่องว่างที่สองและดาวดวงที่สอง สำหรับแต่ละเส้นแนวนอนของ X จะคำนวณจำนวนดาวหรือช่องว่างที่จำเป็นสำหรับแต่ละส่วน 4 ของบรรทัดจากนั้นสร้างและพิมพ์สตริงนั้น

เรติน่า 144 ไบต์

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

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

ลองออนไลน์! คำอธิบาย:

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

เพิ่มช่องว่าง 2n + 1 ก่อนค่าอินพุต (หนึ่งช่องสำหรับแต่ละบรรทัดเอาต์พุต)

$`#$'¶

แทนที่แต่ละช่องว่างด้วย a #และรวบรวมผลลัพธ์ สิ่งนี้จะให้เส้นทแยงมุมของ#s มีพื้นที่เบาะทั้งสองด้านโดยมีค่าอินพุตต่อท้าย

¶\d+$

ลบค่าอินพุตดั้งเดิมเนื่องจากเรามีสำเนาในแต่ละบรรทัด

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

สร้างขึ้นมาสองเส้นทแยงของ n *s กับคอลัมน์คั่นของnช่องว่างในห่อคู่ของ#s

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

บนเส้นเหล่านั้นที่*s อยู่ใกล้กึ่งกลางให้สลับสองครึ่งรอบ ๆ สิ่งนี้ทำให้มีลักษณะคล้าย> | | <กัน

+` (# +#)
$1 

ย้าย| |s ไปทางซ้ายเท่าที่จะไปให้เรียงลำดับของ>> > <ลักษณะ

+` #...
#

สำหรับแต่ละช่องว่างระหว่าง#s ให้ลบอักขระสามตัวต่อไปนี้ นี้ร่วมเป็น> <X

##

ลบ#s ที่ไม่จำเป็นตอนนี้