เขียนโปรแกรม (หรือฟังก์ชั่น) ที่ใช้จำนวนเต็มบวก

หากอินพุตคือ1ให้พิมพ์ (หรือส่งคืน) เพชรสองเม็ดที่อยู่ติดกันแบบเรียงต่อกันแต่ละอันมีความยาวด้านข้างเท่ากับ 1 ทับ:

/\/\
\/\/

สำหรับทุกอินพุตที่Nมากกว่า 1 ให้ดูที่เอาต์พุตสำหรับN-1และสำหรับแต่ละคู่ของเพชรข้างเคียงใส่เพชรใหม่ในระหว่างที่พวกเขามีความยาวด้านคือผลรวมของความยาวด้านของทั้งสองประเทศเพื่อนบ้าน พิมพ์ (หรือส่งคืน) รูปแบบเพชรใหม่นี้

ดังนั้นเมื่อ2มีการป้อนข้อมูลเราจะดูที่เอาท์พุท1และจะเห็นว่ามีเพชรข้างเคียงสองอันที่มีความยาวด้าน 1 ดังนั้นเราจึงแทรกความยาวด้าน 2 (1 + 1) เพชรไว้ระหว่าง:

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

สำหรับอินพุต3เราดูที่เอาต์พุต2และเพิ่มสองเพชรที่มีความยาวด้าน 3 (1 + 2 และ 2 + 1) ระหว่างสองคู่ของเพชรข้างเคียง:

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

ดำเนินการตามรูปแบบต่อไปผลลัพธ์สำหรับ4:

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

และอื่น ๆ

เอาต์พุตของคุณอาจมีช่องว่างต่อท้ายบนบรรทัดใด ๆ แต่ขึ้นบรรทัดใหม่ไม่เกินหนึ่งบรรทัดเท่านั้น (และไม่มีการขึ้นบรรทัดใหม่)

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

Pyth, 50 49 ไบต์

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

สาธิต

คำอธิบาย:

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.

เสียงกระเพื่อมสามัญ 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))))))

ตัวอย่าง

(funcall *fun* 4)

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

Ungolfed

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

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

ขอบคุณ @ MartinBüttnerสำหรับการลงเล่น 1 ไบต์

ลองใช้ออนไลน์ในล่าม CJam

ความคิด

เช่นอินพุท3เราสร้าง

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

โดยหมุนสตริง  \และแทนที่แบ็กสแลชบางส่วนด้วยสแลช

จากนั้นเราซิปอาร์เรย์ผลลัพธ์ (สลับแถวและคอลัมน์) เพื่อให้ได้ครึ่งล่างของเอาต์พุตที่ต้องการ

ครึ่งบนคือไบต์ต่อไบต์เท่ากับครึ่งล่างในการย้อนกลับ

รหัส

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

วิธีการใหม่ในการหลีกเลี่ยงการสร้างเพชรขนาดใหญ่และลดขนาด

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

ขนาดของเพชรจะถูกคำนวณให้สอดคล้องกับความสัมพันธ์เวียนเกิดจากhttps://oeis.org/A002487ดังนั้นเราจึงให้อาร์เรย์aที่มีองค์ประกอบทั้งหมดของแถวทั้งหมดตั้งแต่ 1 nถึง เราสนใจเฉพาะ1<<n-1องค์ประกอบสุดท้ายเท่านั้น (Ruby อนุญาตให้เราดึงมันออกมาจากอาร์เรย์โดยใช้ดัชนีลบ -1 เป็นองค์ประกอบสุดท้ายในอาร์เรย์) บวกค่า1เริ่มต้นจากตำแหน่ง 0

ทีละบรรทัดและเพชรแต่ละเม็ดเราวาดแถวของตัวละครสำหรับเพชรที่ใหญ่ที่สุดจากนั้นตัดคอลัมน์กลางออกมาเพื่อให้ได้แถวสำหรับเพชรที่ต้องการ Rev 1 สั้นกว่านี้ แต่ฉันชอบวิธีนี้

ใช้การคำนวณแบบโมดูลาร์เพื่อห่อรอบเพื่อให้นิพจน์เดียวกันเพิ่มทั้งหมด/โดยตรงและในทำนองเดียวกันหนึ่งการเพิ่มทั้งหมด\โดยตรง

Ungolfed ในโปรแกรมทดสอบ

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)