Vấn đề

Cho một số nguyên dương ntrong đón < 100

Xuất ra một mẫu kim cương như sau:

Đầu vào n=1

/\/\
\/\/

Đầu vào n=2:

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

Đầu vào n=3:

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

Đầu vào n=4:

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

Và như vậy.

Quy tắc

• Chương trình và chức năng cho phép.
• Trailing khoảng trắng cho phép.
• Khoảng trắng hàng đầu trên các dòng không có /hoặc \cho phép.
• Trailing và hàng đầu mới cho phép.
• Mã ngắn nhất trong byte giành chiến thắng

Điều này có lẽ khá liên quan

SOGL V0.12 , 24 byte

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

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

Giải trình:

ā                         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

Than , 30 27 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải thích: Các nguyên thủy vẽ của than củi không thể vẽ một viên kim cương, bởi vì các chuyển động chéo nằm trên các hình vuông có cùng độ chẵn. Chỉnh sửa: Giải pháp mới là vẽ một mặt của viên kim cương và sau đó xoay toàn bộ khung vẽ sẵn sàng để vẽ mặt tiếp theo, cho phép một viên kim cương được vẽ theo vòng. Vòng lặp này sau đó được chứa trong một vòng lặp để vẽ tất cả các viên kim cương bên trong cho mỗi viên kim cương. Vòng ngoài cùng vẽ tất cả các viên kim cương liền kề nhau. Cuối cùng hình ảnh được nhân đôi.

Lưu ý rằng Char than đã được mở rộng và một byte khác có thể được lưu bằng cách sử dụng Increment.

APL (Dyalog) , 70 69 66 byte

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

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

Giả sử ⎕IO←0, là tiêu chuẩn trên nhiều hệ thống, vì vậy chương trình được lập chỉ mục 0.

Đây là một tradfn nhận đầu vào thông qua STDIN.

Giải trình

(hơi lỗi thời)

Lưu ý rằng đó ⍺là đối số bên trái, ⍵là đối số bên phải và ⍺⍺là toán tử bên trái.

Blà một chức năng giúp phản chiếu những viên kim cương. Nó nhận chuỗi là đối số bên phải và hàm ngược lại là bên trái ( Btoán tử cũng vậy).

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

Và bây giờ chúng ta đi đến phần chính của chương trình.

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

Điều này là cần thiết để đảm bảo rằng tất cả các hình tam giác được tạo cho mọi phần tử trong phạm vi ⌽⍳Acó cùng chiều cao để sau này chúng có thể được nối với nhau.

 ⊖               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

Bây giờ phần trên cùng bên trái của mẫu đã hoàn thành. Tất cả những gì còn lại là lật nó theo chiều dọc và sau đó theo chiều ngang.

(⊢⍪⊖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

Và đó là nó! Đầu ra là một ma trận ký tự có /\s và được đệm bằng khoảng trắng.

05AB1E , 47 43 41 35 34 33 32 byte

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

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

(-4 byte nhờ @Emigna, người đã đề xuất 3 cải tiến)

Giải thích này là cho phiên bản trước đó, đã có một vài lần lặp lại kể từ đó.

>                                          # [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*

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

Giải trình

Trong phần giải thích này, tôi sẽ đề cập đến số đầu vào là 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 nhờ nhạcman523}

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)

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

Điều này hoạt động bằng cách cắt các cột bên trong của viên kim cương lớn nhất để tạo ra các cột nhỏ hơn, sử dụng [0,..,n,n,..,0]để kiểm soát số lượng cột cần loại bỏ.

Bình thường, 35 32 byte

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

Bộ kiểm tra

Xong để xem cách tiếp cận của tôi và @ LeakyNun sẽ khác nhau như thế nào.

Thuốc nhuộm APL, 46

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

Bình thường , 49 byte

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

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

V , 38 byte

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

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