আরগিল এএসসিআইআই আর্ট

Question

একটি প্রোগ্রাম লিখুন (বা ফাংশন) যা ধনাত্মক পূর্ণসংখ্যায় নিয়ে যায়।

যদি ইনপুটটি হয় 1, পাশাপাশি পাশের দুটি পাশের দুটি হীরা প্রিন্ট করুন (বা প্রত্যাবর্তন করুন), প্রতিটি স্ল্যাশের পাশের দৈর্ঘ্য সহ:

/\/\
\/\/

প্রত্যেক ইনপুট করতে N1 তার চেয়ে অনেক বেশী, জন্য আউটপুট এ বর্ণন N-1এবং প্রতিবেশী হিরে প্রতিটি জোড়া জন্য তাদের যার পাশ দৈর্ঘ্য মধ্যে একটি নতুন হীরা সন্নিবেশ দুই প্রতিবেশী পাশ লেন্থ এর সমষ্টি। এই নতুন হীরক প্যাটার্নটি মুদ্রণ করুন (বা প্রত্যাবর্তন করুন)।

সুতরাং যখন 2ইনপুট হয়, আমরা আউটপুটটির দিকে নজর রাখি 1এবং দেখতে পাচ্ছি যে দুটি পাশের হীরা রয়েছে, উভয় পাশের দৈর্ঘ্য 1। সুতরাং আমরা তাদের মধ্যে একটি পাশের দৈর্ঘ্য 2 (1 + 1) হীরাটি সন্নিবেশ করি:

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

ইনপুটটির জন্য 3আমরা 2প্রতিবেশী হীরার দুটি জোড়াের মধ্যে পাশের দৈর্ঘ্য 3 (1 + 2 এবং 2 + 1) সহ দুটি হীরা যুক্ত করে আউটপুটটি দেখি :

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

নিদর্শন অব্যাহত রাখার জন্য আউটপুটটি 4হ'ল:

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

ইত্যাদি।

আপনার আউটপুটগুলির যে কোনও লাইনে ট্রেলিং স্পেস থাকতে পারে তবে কেবলমাত্র একটি ট্রেলিং নিউলাইন পর্যন্ত (এবং কোনও শীর্ষস্থানীয় নিউলাইন নেই)।

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী।

Comments

প্রাসঙ্গিক OEIS: oeis.org/A002487 ।

— orlp

Answer 1

পাইথ, 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.

Comments

মতভেদ কি? আমিও ঠিক আছে u.iGsM.:G2tQjT9আমার (আংশিক) দ্রবণে। আমি কখনও আপনার উত্তরের দিকে

— তাকাতে

@ অর্পল প্রায়শই কিছু করার একমাত্র সেরা উপায়।

— isaacg

Answer 2

কমন লিস্প, 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))

Answer 3

সিজেম, 59 58 57 বাইট

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

1 বাইট বন্ধ করে গল্ফ করার জন্য @ মার্টিনব্যাটনারকে ধন্যবাদ।

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

ধারণা

ইনপুট 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.

Answer 4

রেভ 1: রুবি 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""}}

রেভ 0: রুবি, 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 থেকে পুনরাবৃত্ত সম্পর্কের সাথে গণনা করা হয় সুতরাং আমরা a1 থেকে শুরু করে সমস্ত সারিগুলির জন্য সমস্ত উপাদানযুক্ত অ্যারে তৈরি করি n। আমরা কেবলমাত্র শেষ 1<<n-1উপাদানগুলিতে আগ্রহী (রুবি আমাদের এড়াতে নেতিবাচক সূচকগুলি ব্যবহার করে, -1 অ্যারেতে সর্বশেষ উপাদান হ'ল), এবং 1অবস্থান 0 থেকে একটি ইনিটাল ।

লাইন দ্বারা লাইনে এবং হীরা দ্বারা হীরা, আমরা বৃহত্তম হীরাটির জন্য অক্ষরের সারি আঁকি, তারপরে প্রয়োজনীয় হীরাটির সারিটি পাওয়ার জন্য মাঝের কলামগুলি কেটে ফেলি। Rev 1 ছোট, তবে আমি এই পদ্ধতিটি পছন্দ করেছি।

মডুলার গাণিতিক চারপাশে মোড়ানো ব্যবহার করা হয় যাতে একই অভিব্যক্তিটি /সরাসরি যুক্ত করে এবং একইভাবে একটি এক্সপ্রেশন সমস্ত \সরাসরি যুক্ত করে।

পরীক্ষা প্রোগ্রামে অসম্পূর্ণ

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)