Masalah

Terinspirasi oleh tantangan sebelumnya melakukan hal serupa

Diberikan noutput input integer positif bentuk yang mengikuti pola ini:

masukan n=1:

* *
 *
* *

masukan n=2:

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

masukan n=3:

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

dan seterusnya...

Ini memiliki sifat-sifat ini:

n*2+1 garis tinggi

"lengan" nlebar kecuali ketika mereka bergabung

garis tengahnya nlebar

jika nbahkan garis-garis di atas dan di bawah pusatnya n*2lebar

jika naneh garis-garis di atas dan di bawah pusat n*2-1lebar

Aturan

• Mengikuti baris baru diterima
• Celah standar berlaku
• Bytes terpendek menang
• Output dapat dicetak atau string atau array string

Suntingan

• n=0 tidak perlu ditangani
• Ruang tambahan diperbolehkan

Arang , 13 12 byte

Terima kasih kepada @ErikTheOutgolfer untuk satu byte

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

Cobalah online!

Ini adalah jawaban pertama saya untuk Arang, dan saya cukup yakin ini bukan golf, tetapi saya pikir saya akan mulai dari suatu tempat.

 ＦＮ«            # 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

Cobalah online!

Penjelasan

Pertimbangkan input 2sebagai contoh. Isi tumpukan ditunjukkan dengan yang lebih baru di bawah ini.

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

Jelly , 15 byte

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

Cobalah online!

V , 18 17 byte

Menyimpan satu byte berkat trik input @ DJMcMayhem.

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

Cobalah online!

Penjelasan

Àé*ÄJÀäl

Ini menyisipkan [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

Setiap iterasi dari loop buffer berasal

|**   ***

Untuk

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

Di mana |kursor dengan *di bawahnya

05AB1E , 18 byte

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

Cobalah online!

Penjelasan

Contoh untuk 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

Cobalah online!

Hexdump:

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

Untuk alasan apa pun, tantangan ini jauh lebih sulit di V daripada yang terakhir. Karena pendekatan umum kita n kali, menumbuhkan 'x' tidak akan berfungsi di sini, sebagai gantinya kita akan membangun bagian atas X, menyalinnya dan membaliknya, lalu menempelkan kedua bagian bersama-sama.

Penjelasan:

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

Melakukan indentasi pada akhir loop, memungkinkan kita untuk mengambil keuntungan dari akhiran implisit . Ini juga dengan mudah membuat n + 1 baris, yang persis merupakan bagian atas dari 'X'. Katakanlah inputnya adalah 4. Kemudian pada titik ini, buffer terlihat seperti ini:

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

Dan kita berada di baris terakhir. Jadi kita:

                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 dengan membuat string dan panggilan WriteLine, sehingga menghemat pemeriksaan untuk baris baru.
-6 byte terima kasih kepada Kevin dan teknik main golfnya!
-2 byte dengan mengganti n*3-ndengan n*2.
-15 byte setelah Kevin dengan ramah menunjuk saya ke arah yang benar: Saya hanya bisa mengembalikan string daripada mencetaknya, sehingga menghemat panggilan System.Console.WriteLine(). Dan beberapa tips lainnya juga ...

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

Cobalah online!

Tidak Terkumpul:

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

Itu hanya mengulang sepanjang baris dan kolom ruang yang diperlukan untuk mencetak X besar dan mencetak baik a '*'atau a ' 'tergantung pada kondisi.

Haskell , 88 87 86 byte

-1 terima kasih kepada @Laikoni

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

Cobalah online!

Jelly , 24 23 16 byte

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

Cobalah online!

MATLAB, 153 126 byte (17,6% ↓)

Berkat komentar @ LuisMendo, fungsi disp()dapat menampilkan karakter tanpa tanda kutip tunggal, sehingga saya dapat mencegah penggunaan fprintfdengan formatsdan menghilangkan beberapa byte. Selain itu, komentarnya mengingatkan saya bahwa saya perlu menggunakan char(32)untuk memberikan ruang daripadachar(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 ''])

Cobalah online!

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

Contoh hasil: n = 10

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

Python 2 , 93 90 89 83 byte

^{-3 bytes berkat Leaky Nun
-1 byte terima kasih kepada Zachary T
-6 bytes berkat xnor}

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

[Cobalah online!] [TIO-j3xwsktf]

Mulai dengan string seperti '*** 'untuk n=3, melamar map/maxuntuk mengambil *spasi untuk setiap posisi, lalu menambahkan spasi dan menghapus karakter terakhir dari string dan melakukan ini semua lagi.

Haskell , 70 byte

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

Cobalah online!

Menghasilkan daftar string.

Untuk setiap posisi baris r, kolom c, menggunakan rumus untuk menentukan apakah itu termasuk dalam salah satu dari dua band diagonal dan begitu juga *.

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

Port dari @CarlosAlejo jawaban C # yang luar biasa , setelah saya membantunya bermain golf beberapa hal. Jadi, pastikan Anda juga mendukungnya!

Coba di sini.

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

Mengembalikan array string. Saya melakukan operasi pada array kemudian mirror itu. Ini mungkin dapat dioptimalkan dengan matriks seperti jawaban lain, tetapi saya ingin menjadi unik.

Sunting: Seperti yang ditunjukkan oleh Neil, untuk nilai genap n, garis tengah tidak nlebar, jadi saya menambahkan modulus untuk mendeteksi genap / ganjil saat mengiris kolom.

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

Tidak disatukan

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
}

Kuadran

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

Cermin Secara horizontal

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

Cermin Secara Vertikal

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

Mathematica, 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

Kode:

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)

Uji:

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

Ini adalah blok yang mengambil nomor dari tumpukan dan menampilkan daftar garis ke tumpukan.

Penjelasan:

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

Program ini memecah setiap baris menjadi 4 bagian, spasi pertama, bintang pertama, spasi kedua dan kemudian bintang kedua. Untuk setiap garis horizontal X, ia menghitung berapa banyak bintang atau ruang yang dibutuhkan untuk masing-masing dari 4 bagian garis, kemudian membuat dan mencetak string itu.

Retina , 144 byte

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

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

Cobalah online! Penjelasan:

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

Tambahkan 2n + 1 spasi sebelum nilai input (satu untuk setiap jalur output).

$`#$'¶

Ganti setiap ruang dengan #dan kumpulkan hasilnya. Ini memberikan garis diagonal #s, ruang empuk di kedua sisi, dengan nilai input suffixed.

¶\d+$

Hapus nilai input asli, karena kami sekarang memiliki salinan di setiap baris.

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

Bangun dua garis diagonal ns *, dengan kolom pemisah nruang yang terbungkus sepasang #s.

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

Pada garis-garis di mana *s lebih dekat ke tengah, bertukar dua bagian di sekitar. Ini memberikan penampilan yang menyerupai > | | <.

+` (# +#)
$1 

Pindahkan | |s ke kiri sejauh mereka akan pergi, memberikan semacam >> > <penampilan.

+` #...
#

Untuk setiap spasi di antara #huruf s, hapus tiga karakter berikut. Ini bergabung > <menjadi X.

##

Hapus #s sekarang tidak perlu .