Masalah

Diberikan bilangan bulat positif di nmanan < 100

Keluarkan pola berlian sebagai berikut:

Memasukkan n=1

/\/\
\/\/

Masukan n=2:

 /\      /\
//\\/\/\//\\
\\//\/\/\\//
 \/      \/

Masukan n=3:

  /\                /\
 //\\  /\      /\  //\\
///\\\//\\/\/\//\\///\\\
\\\///\\//\/\/\\//\\\///
 \\//  \/      \/  \\//
  \/                \/

Masukan n=4:

   /\                              /\
  //\\    /\                /\    //\\
 ///\\\  //\\  /\      /\  //\\  ///\\\
////\\\\///\\\//\\/\/\//\\///\\\////\\\\
\\\\////\\\///\\//\/\/\\//\\\///\\\\////
 \\\///  \\//  \/      \/  \\//  \\\///
  \\//    \/                \/    \\//
   \/                              \/

Dan seterusnya.

Aturan

• Program dan fungsi diizinkan.
• Trailing whitespace diizinkan.
• Memimpin spasi putih pada garis tanpa /atau \diizinkan.
• Mengejar dan memimpin baris baru diizinkan.
• Kode terpendek dalam byte menang

Ini mungkin sangat terkait

SOGL V0.12 , 24 byte

ā.∫ā;∫ \*+}ø┼↔±╬¡;øΚ┼}╬³

Coba Di Sini!

Penjelasan:

ā                         push an empty array (the main canvas)
 .∫                  }    iterate over the input, pushing 1-indexed iteration
   ā;                       push an empty array below the iteration
     ∫    }                 iterate over the iteration counter
       \*                     push current iteration amount of slashes
         +                    append those to the 2nd array
           ø┼               append nothing (so it'd space the array to a square)
             ↔±             reverse horizontally (swapping slashes)
               έ           quad-palindromize with 0 overlap and swapping characters as required
                 ;          get the canvas ontop
                  øΚ        prepend to it an empty line (so the now bigger romb would be one up)
                    ┼       append horizontally the canvas to the current romb
                      ╬³  palindromize horizontally with no overlap and swapping characters

Arang , 30 27 byte

Ｆ⁺¹Ｎ«Ｆι«Ｆ⁴«↙⁻ικ↑⟲Ｔ»←»Ｍι←»‖Ｍ

Cobalah online!Tautan adalah untuk mengucapkan versi kode. Penjelasan: Primitif gambar Charcoal tidak bisa menggambar berlian, karena gerakan diagonal tetap pada kotak dengan paritas yang sama. Sunting: Solusi baru adalah menggambar satu sisi berlian dan kemudian memutar seluruh kanvas siap untuk menggambar sisi berikutnya, memungkinkan berlian untuk ditarik dalam satu lingkaran. Loop ini kemudian terkandung dalam satu loop untuk menggambar semua berlian bagian dalam untuk setiap berlian. Lingkaran terluar menarik semua berlian yang berdekatan satu sama lain. Akhirnya gambar dicerminkan.

Perhatikan bahwa Arang telah diperpanjang dan byte lain dapat disimpan dengan menggunakan Increment.

APL (Dyalog) , 70 69 66 byte

B←{'/\ '['\/'⍳⍺⍺⍵]}
C←⊢,⌽B
C(⊢⍪⊖B)⊃,/{C⊖A↑⊖' /'[⍵≤∘.+⍨⍳⍵+1]}¨⌽⍳A←⎕

Cobalah online!

Asumsikan ⎕IO←0, yang merupakan standar pada banyak sistem, sehingga program ini diindeks 0.

Ini adalah tradfn yang mengambil input melalui STDIN.

Penjelasan

(sedikit ketinggalan jaman)

Perhatikan bahwa ⍺argumen kiri, ⍵argumen kanan dan⍺⍺ operator kiri.

Badalah fungsi yang membantu dalam mirroring berlian. Dibutuhkan string sebagai argumen kanan dan fungsi mundur sebagai kiri (demikian Bjuga operator).

B←{'/\ '['\/'⍳⍺⍺⍵]}
              ⍺⍺⍵            Apply ⍺⍺ on ⍵
         '\/'⍳               Find the index of the reflected string in '\/' (if the character is not found in `'\/'`, then return an index out of the bounds of the string, ie `2` if the character is a space)
   '/\ '[        ]           Use these indexes on '/\ ' to reflect the '/\' characters

Dan sekarang kita pergi ke bagian utama dari program ini.

A←⎕              Assign the input to variable A
⍳                Create a range 0 .. A-1
⌽                Reverse it so that it becomes A-1 .. 0
¨                For each element do (the right argument is the element):
 ⍳⍵+1             Create a range 0 .. ⍵
 ∘.+⍨             Create an addition table using the range to result in a matrix like so:
                   0+0 0+1 0+2 .. 0+⍵
                   1+0 1+1 1+2 .. 1+⍵
                   2+0 2+1 2+2 .. 2+⍵
                   ...
                   ⍵+0 ⍵+1 ⍵+2 .. ⍵+⍵
 ⍵≤              The elements of the matrix that are greater than or equal to the ⍵,
                 this creates a triangle matrix that looks like this:
                   0 0 .. 0 1
                   0 0 .. 1 1
                   ..
                   1 1 .. 1 1
 ' /'[...]       Index it in ' /' to get a character matrix
                 (ie replace 0s with spaces and 1s with '/'s)
 ⊖               Flip this vertically
 A↑              Pad the top spaces

Ini diperlukan untuk memastikan bahwa semua segitiga yang dibuat untuk setiap elemen dalam rentang ⌽⍳Amemiliki ketinggian yang sama sehingga mereka dapat digabungkan satu sama lain.

 ⊖               Flip the matrix vertically again to go back to the original state
 (⊢,  )          Concatenate it with
    ⌽B           itself, but flipped horizontally
,/              Concatenate all triangles formed by the range operator
⊃               The resulting matrix is nested, so this operator "un-nests" it

Sekarang bagian kiri atas pola sudah selesai. Yang tersisa hanyalah membalikkannya secara vertikal dan kemudian secara horizontal.

(⊢⍪⊖B)          Concatenate the resulting matrix with itself but flipped vertically
                (the vertically flipped matrix is concatenated below of the original matrix)
                Now the left part of the pattern is complete
(⊢,⌽B)         Concatenate the resulting matrix with itself flipped horizontally

Dan itu dia! Outputnya adalah matriks karakter dengan /\s dan diisi dengan spasi.

05AB1E , 47 43 41 35 34 33 32 byte

'/×ηηvy∞.C.Bø€∞¹NαGð.ø}})øíJ.B»∞

Cobalah online!

(-4 byte terima kasih kepada @Emigna yang menyarankan 3 peningkatan)

Penjelasan ini untuk versi sebelumnya, ada beberapa iterasi sejak itu.

>                                          # [2]
 '/×                                       # ['//']
    η                                      # ['/','//']
     €η                                    # [['/'], ['/', '//']]
       vy                    }             # {For each element...}
         ∞                                 # Mirror horizontally.
          ¶¡                               # Split mirror on newlines.
            N£                             # Shave each diamond down a layer.
              .C                           # Horizontal center.
                .B                         # Pad for the transpose.
                  ø                        # Transpose.
                   €∞                      # Mirror each (vertically).
                     ¹NαFð.ø}              # Pad each list for transpose (verticaly).
                              )            # Wrap back to list...
                               €.B         # Pad each horizontally.
                                  ¦        # Remove the random numbers?
                                   ø       # Back to horizontal...
                                    €R     # Reverse to get correct order.
                                      J    # Join, no spaces.
                                       »   # Join newlines.
                                        ∞  # Final horizontal mirror.

CJam , 65 63 byte

q~_,:)_W%\+f{_2*S*a@2$-*\_,f{)'/*\Se[_W%'/'\er+}_W%Wf%+1$++}zN*

Cobalah online!

Penjelasan

Dalam penjelasan ini, saya akan merujuk ke nomor input sebagai n.

q~        e# Read and eval the input (push n to the stack).
_,        e# Copy it an get the range [0 .. n-1].
:)        e# Increment each element to get [1 .. n].
_W%       e# Copy it and reverse it.
\+        e# Prepend the reverse to the original range, resulting in [n n-1 .. 1 1 .. n-1 n].
f{        e# Map over each number x in the range using n as an extra parameter:
 _2*S*a   e#  Push a string containing n*2 spaces, and wrap it in an array.
 @2$-     e#  Push n-x.
 *        e#  Repeat the space string from before n-x times.
 \        e#  Bring x back to the top.
 _,       e#  Copy it and get the range [0 .. x-1].
 f{       e#  Map over each number y in this range, using x as an extra parameter:
  )       e#   Increment y.
  '/*     e#   Repeat '/' y times.
  \Se[    e#   Pad the resulting string to length x by adding spaces to the left.
  _W%     e#   Copy the result and reverse it.
  '/'\er  e#   Replace '/' with '\' in that.
  +       e#   Concatenate to the other string. This forms one row of one diamond.
 }        e#  (end map, now we have the top half of a diamond of size x)
 _W%      e#  Copy the half-diamond and reverse it.
 Wf%      e#  Reverse each row.
 +        e#  Concatenate to the top half. Now we have a full diamond of size x.
 1$++     e#  Put the spaces from before at the beginning and end. This is to pad the top
          e#  and bottom of the smaller diamonds.
}         e# (end map)
z         e# Transpose.
N*        e# Join with newlines. Implicit output.

Python 2 , 152 147 143 140 byte

^{-1 byte terima kasih kepada musicman523}

n=input()
r=range(n)
r+=r[::-1]
for x,i in enumerate(r):a,b='/\\\/'[i<x::2];s=' '*(n+~i);print''.join((s+a*n)[:n-j]+(b*-~i+s)[j:]for j in r)

Cobalah online!

Ini bekerja dengan memotong kolom bagian dalam berlian terbesar untuk membuat yang lebih kecil, gunakan [0,..,n,n,..,0]untuk mengontrol jumlah kolom yang akan dihapus.

Pyth, 35 32 byte

j.tsm+Jm.[yQS*"\/"k\ Sd_M_Js__BS

Suite uji

Selesai untuk melihat bagaimana pendekatan saya dan @ LeakyNun akan berbeda.

Dyalog APL, 46

{⊃,/⍵∘{'/ \'[2+((-⍪⊖)⌽,-)(-⍺)↑∘.≥⍨⍳⍵]}¨(⌽,⊢)⍳⍵}

Pyth , 49 byte

LC.tb)L+_b.rb"\/"js_,J'MsMCyMy_Mm'Myd._._*\/Q__MJ

Cobalah online!

V , 38 byte

Àá/Àá\ò2ÙlX$xòÍî
òYGpVæHÄÓ¯¨¯*Ü*©Ü/ ± 

Cobalah online!