Viết chương trình (hoặc hàm) lấy số nguyên dương.

Nếu đầu vào là 1, in (hoặc trả lại) hai viên kim cương cạnh nhau, mỗi viên có độ dài 1 cạnh:

/\/\
\/\/

Đối với mỗi đầu vào Nlớn hơn 1, hãy nhìn vào đầu ra cho N-1và cho mỗi cặp kim cương lân cận, chèn một viên kim cương mới vào giữa chúng có chiều dài cạnh là tổng chiều dài của hai hàng xóm. In (hoặc trả lại) mẫu kim cương mới này.

Vì vậy, khi 2là đầu vào, chúng ta nhìn vào đầu ra 1và có thể thấy rằng có hai viên kim cương lân cận, cả hai đều có chiều dài cạnh 1. Vì vậy, chúng ta chèn một viên kim cương có chiều dài 2 (1 + 1) vào giữa chúng:

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

Đối với đầu vào, 3chúng tôi xem xét đầu ra 2và thêm hai viên kim cương có chiều dài cạnh 3 (1 + 2 và 2 + 1) ở giữa hai cặp kim cương lân cận:

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

Tiếp tục mẫu, đầu ra cho 4là:

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

Và như vậy.

Đầu ra của bạn có thể có dấu cách ở bất kỳ dòng nào nhưng chỉ có tối đa một dòng mới (và không có dòng mới hàng đầu).

Mã ngắn nhất tính bằng byte thắng.

Bình thường, 50 49 byte

L.rR"\/"_bjbyK.tsm+Jm+*\ k\\dyJu.iGsM.:G2tQjT9djK

Trình diễn

Giải trình:

L.rR"\/"_bjbyK.tsm+Jm+*\ k\\dyJu.iGsM.:G2tQjT9djK
                                                     Implicit:
                                                     Q = eval(input())
                                                     T = 10
                                                     d = ' '
                                                     b = '\n'
L                                                    def y(b): return
 .rR"\/"                                             Swap \ and / in
        _b                                           reversed input.
                                                     This effectively vertically
                                                     mirrors the input.
                               u                     Apply the function repeatedly
                                           jT9       Starting with [1, 1]
                                         tQ          and repeating Q - 1 times
                                .iG                  interlace G (input) with
                                     .:G2            All 2 element substrings of G
                                   sM                mapped to their sums.
                 m                                   map over these values
                                                     implicitly cast to ranges
                    m       d                        map over the range values
                                                     impicitly cast to ranges
                     +*\ k\\                         to k spaces followed by
                                                     a backslash.
                   J                                 Save to J, which is roughly:
                                                     \
                                                      \
                  +          yJ                      And add on y(J), giving
                                                     \
                                                      \
                                                      /
                                                     /
                s                                    Combine the half diamonds
                                                     into one list.
              .t                              d      Traspose, filling with ' '.
             K                                       Save to K, giving
                                                     something like:
                                                     \  /
                                                      \/
            y                                        Vertically mirror.
          jb                                         Join on newlines and print.
                                               jK    Join K on (implicitly)
                                                     newlines and print.

Lisp thường gặp, 425

(labels((a(n)(if(> n 1)(loop for(x y)on(a(1- n))by #'cdr collect x when y collect(+ x y))'(1 1))))(lambda(~ &aux(l(a ~))(h(apply'max l))(w(*(apply'+ l)2))(o(* 2 h))(m(make-array(list o w):initial-element #\ ))(x 0)(y h))(labels((k(^ v)(setf(aref m y x)^(aref m(- o y 1)x)v)(incf x))(d(i)(when(plusp i)(k #\\ #\/)(incf y)(d(1- i))(decf y)(k #\/ #\\))))(mapc #'d l))(dotimes(j o)(fresh-line)(dotimes(i w)(princ(aref m j i))))))

Thí dụ

(funcall *fun* 4)

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

Bị đánh cắp

(labels
    ((sequence (n)
       (if (> n 1)
           (loop for(x y) on (sequence (1- n)) by #'cdr
                 collect x
                 when y
                   collect(+ x y))
           '(1 1))))
  (defun argyle (input &aux
                  (list (sequence input))
                  (half-height (apply'max list))
                  (width (* (apply '+ list) 2))
                  (height (* 2 half-height))
                  (board (make-array
                          (list height width)
                          :initial-element #\ ))
                  (x 0)
                  (y half-height))
    (labels ((engrave (^ v)
               (setf (aref board y              x) ^ ;; draw UP character
                     (aref board (- height y 1) x) v ;; draw DOWN character (mirrored)
                     )
               (incf x) ;; advance x
               )
             (draw (i)
               (when (plusp i)
                 (engrave #\\ #\/)  ;; write opening "<" shape of diamond
                 (incf y)
                 (draw (1- i))   ;; recursive draw
                 (decf y)
                 (engrave #\/ #\\)  ;; write closing ">" shape of diamond
                 )))
      ;; draw into board for each entry in the sequence
      (mapc #'draw list))

    ;; ACTUAL drawing
    (dotimes(j height)
      (fresh-line)
      (dotimes(i width)
        (princ (aref board j i))))
    board))

CJam, 59 58 57 byte

YXbri({{_2$+\}*]}*:,_:|,S*0'\tf{fm>_W%'\f/'/f*}:+zN*_W%N@

Cảm ơn @ MartinBüttner vì đã chơi golf 1 byte.

Hãy thử trực tuyến trong trình thông dịch CJam .

Ý kiến

Ví dụ, đối với đầu vào 3 , chúng tôi tạo ra

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

bằng cách xoay chuỗi  \và thay thế một số dấu gạch chéo ngược bằng dấu gạch chéo.

Sau đó, chúng tôi nén mảng kết quả (chuyển hàng và cột) để có được nửa dưới của đầu ra mong muốn.

Nửa trên là byte trên mỗi byte bằng nửa dưới ngược lại.

Mã

YXb     e# Push A := [1 1] and 2 in unary.
ri(     e# Read an integer fro STDIN and subtract 1.
{       e# Do the following that many times:
  {     e#   For each I in A but the first:
    _2$ e#     Push a copy of I and the preceding array element.
    +\  e#     Compute the sum of the copies and swap it with I.
  }*    e#
  ]     e#   Collect the entire stack in an array.
}*      e#
:,      e# Replace each I in A with [0 ... I-1].
_       e# Push a copy of A.
:|      e# Perform set union of all the ranges.
,S*     e# Get the length (highest I in A) and push a string of that many spaces.
0'\t    e# Replace the first space with a backslash.
f{      e# For each range in A, push the generated string; then:
  fm>   e#   Rotate the string by each amount in the array.
  _W%   e#   Push a reversed copy of the resulting array of strings.
  '\f/  e#   In each string, split at backslashes.
  '/f*  e#   Join each string, separating with slashes.
}       e#
:+      e# Concatenate the resulting arrays of strings.
zN*     e# Zip and join, separating by linefeeds.
_W%     e# Push a reversed copy of the string.
N@      e# Push a linefeed and rotate the original string on top of it.

Rev 1: Ruby 170

Phương pháp mới tránh tạo ra viên kim cương lớn và giảm.

->n{a=[1]
m=1<<n-1
(m-1).times{|i|a<<a[i]<<a[i]+a[i+1]}
(-b=a.max).upto(b-1){|j|0.upto(m){|i|d=' '*q=a[-i]*2
(j*2+1).abs<q&&(d[j%q]=?\\;d[-1-j%q]=?/)   
print d}
puts""}}

Rev 0: Ruby, 187

->n{a=[1]
m=1<<n-1
(m-1).times{|i|a<<a[i]<<a[i]+a[i+1]}
(2*b=a.max).times{|j|
0.upto(m){|i|d=' '*b*2;d[(b+j)%(b*2)]='\\';d[(b-1-j)%(b*2)]=?/
r=b-a[-i]
d.slice!(b-r,r*2)
print d}
puts ""}}

Kích thước của các viên kim cương được tính toán theo mối quan hệ lặp lại từ https://oeis.org/A002487 Do đó, chúng tôi tạo ra mảng achứa tất cả các phần tử cho tất cả các hàng từ 1 đến n. Chúng tôi chỉ quan tâm đến các 1<<n-1yếu tố cuối cùng (Ruby cho phép chúng tôi lấy chúng từ mảng bằng cách sử dụng các chỉ số âm, -1 là yếu tố cuối cùng trong mảng), cộng với một 1vị trí từ vị trí 0.

Từng dòng và kim cương bằng kim cương, chúng tôi vẽ hàng ký tự cho viên kim cương lớn nhất, sau đó cắt ra các cột ở giữa để lấy hàng cho viên kim cương cần thiết. Rev 1 ngắn hơn, nhưng tôi thích phương pháp này.

Số học mô-đun được sử dụng để bọc xung quanh sao cho cùng một biểu thức thêm tất cả /trực tiếp và tương tự như vậy một biểu thức thêm tất cả \trực tiếp.

Ungolfed trong chương trình thử nghiệm

f=->n{
  a=[1]
  m=1<<n-1
  (m-1).times{|i|a<<a[i]<<a[i]+a[i+1]}                   #concatenate a[i] and a[i]+a[i+1] to the end of a
    (2*b=a.max).times{|j|                                #run through lines (twice the largest number in a
      0.upto(m){|i|                                      #run through an initial '1' plus the last m numbers in a
      d=' '*b*2;d[(b+j)%(b*2)]='\\';d[(b-1-j)%(b*2)]=?/  #d is the correct string for this line of the largest diamond
      r=b-a[-i]                                          #calculate number of characters to be deleted from middle of d
      d.slice!(b-r,r*2)                                  #and delete them
      print d                                            #print the result
    }
    puts ""                                              #at the end of the line, print a newline
  }
}

f.call(gets.to_i)