2-आयामी सूची के रूप में पास्कल का त्रिकोण

Question

एक पास्कल त्रिभुज बनाएँ जो एक नेस्टेड सूची है और अप्रयुक्त स्थानों में शून्य शामिल है।

आउटपुट सरणी में, पास्कल के त्रिभुज की संख्या को शून्य से अलग किया जाता है और प्रत्येक पक्ष पर शून्य से पैडेड किया जाता है ताकि वे केंद्रित हों। उदाहरण के लिए, नीचे की पंक्ति (अंतिम उप-सरणी) में बाईं और दाईं ओर कोई शून्य नहीं होना चाहिए; दूसरे-अंतिम उप-सरणी में प्रत्येक तरफ एक शून्य पैडिंग है, और इसी तरह।

यहाँ इनपुट के लिए आउटपुट है 5:

[[0,0,0,0,1,0,0,0,0],
[0,0,0,1,0,1,0,0,0],
[0,0,1,0,2,0,1,0,0],
[0,1,0,3,0,3,0,1,0],
[1,0,4,0,6,0,4,0,1]]

हमेशा की तरह, सबसे कम बाइट के साथ समाधान जीतता है।

Comments

का डुप्लीकेट इस । बस आउटपुट स्वरूप बदलने से चुनौती नहीं बदली जाती, दुर्भाग्य से। स्टैक ओवरफ्लो पर पोस्ट करने का प्रयास करें यदि आपको अभी भी इस के साथ मदद की ज़रूरत है।

— GamrCorps

खैर, अतिरिक्त शून्य हैं।

— कैलक्यूलेटर

यह कार्यक्रम आपके इच्छित एक (3 पायथन) को प्रिंट करता है:print("def pascal(n):\n #make the nested list\n a=[[0 for i in range(2*n+1)] for j in range(n+1)] #make the list\n a[0][n]=1 #add the initial 1\n for i in range(1,n+1):\n for j in range(2*n+1):\n a[i][j]=a[i-1][j-1]+a[i-1][(j+1)%(2*n+1)] #the main part\n return a")

— कैलक्यूलेटर

@CatsAreFluffy अतिरिक्त शून्य केवल पिछली पुनरावृत्ति में रिक्त स्थान को बदलते हैं - यह कार्यात्मक रूप से सटीक एक ही समस्या है।

— रिक्सी

क्या मैं अपनी भाषा के लिए मूल सरणी प्रतिनिधित्व सिंटैक्स का उपयोग कर सकता हूं, या प्रारूप गैर-परक्राम्य है?

— बिल्ली

Answer 1

गणितज्ञ, 70 68 बाइट्स

NestList[ListConvolve[{1,0,1},#,2]&,Join[#,{1},#],#2]&[0~Table~#,#]&

MATL समाधान के समान।

Answer 2

मैथेमेटिका, 48 बाइट्स

CellularAutomaton[{#+#3&@@#&,{},1},{{1},0},#-1]&

---

CellularAutomation शानदार है।

Answer 3

जेली, 12 बाइट्स

NR¬ṙ-,1S$³Ð¡

इसे यहाँ आज़माएँ।

व्याख्या

                   This is a list of functions, each operating on the input, n:
NR                 Get the range [-n -n+1 ... 0 ... n-1 n].
  ¬                Logical NOT the entire range: [0 0 ... 1 ... 0 0].
         ³Ð¡       Repeat n times, and cumulate the results:
   ṙ-,1                Rotate by both -1 and 1
       S               Sum the results.
        $              (Joins the above two functions)

Answer 4

हास्केल, 66 बाइट्स

q n|d<-0<$[2..n]=scanl(\(s:t)_->zipWith(+)(0:s:t)$t++[0])(d++1:d)d

प्रयोग उदाहरण: q 4-> [[0,0,0,1,0,0,0],[0,0,1,0,1,0,0],[0,1,0,2,0,1,0],[1,0,3,0,3,0,1]]।

यह काम किस प्रकार करता है:

d <- 0<$[2..n]                      -- bind d to a list of (length n)-1 zeros
scanl                               -- build a list
                         (d++1:d)   -- starting with  [d ++ 1 ++ d]
      \(s:t)_                    d  -- by combining the previous element with the
                                    -- elements of d, but ignoring them, i.e.
                                    -- build a list of (length d) by repeatedly
                                    -- modifying the start element by
          zipWith(+)                -- adding element-wise
                    (0:s:t)         -- the previous element prepended by 0  
                           t++[0]   -- and the tail of the previous element
                                    -- followed by a 0 

Answer 5

पायथन 3, 172 158 133 बाइट्स

def p(n):
 x=2*n+1;y=range
 a=[[0]*x]*n;a[0][n]=1
 for i in y(1,n+1):
  for j in y(x):a[i][j]=a[i-1][j-1]+a[i-1][(j+1)%(x)]
 return a

बेहतर हो रहा है

Comments

यह पूरी तरह से अभी तक गोल्फ नहीं है, है ना?

— बिल्ली

उम, हाँ। यह (थोड़े कम गोल्फ वाले रूप में) एक कार्यक्रम द्वारा मुद्रित किया जाता है मैंने प्रश्न पर एक टिप्पणी छोड़ दी।

— कैलकुलेटर

Answer 6

MATL , 24 22 21 बाइट्स

tEq:=Gq:"t5BX+8L)]N$v

EDIT (20 मई, 2016): भाषा के संस्करण 18.0.0 के रूप में, उपरोक्त कोड को चलाने के लिए कुछ परिवर्तनों की आवश्यकता है। नीचे दिए गए लिंक में वे संशोधन शामिल हैं

इसे ऑनलाइन आज़माएं!

यह स्टैक पर प्रत्येक नई पंक्ति को पुश करने के लिए लूप का उपयोग करता है। एक नई पंक्ति की गणना पिछली पंक्ति से कनवल्शन को लागू करने [1,0,1]और केवल वांछित आकार को ध्यान में रखते हुए की जाती है। लूप के बाद, सभी पंक्तियों को एक 2 डी सरणी में समतल किया जाता है, जिसे प्रदर्शित किया जाता है। 2 डी सरणी MATL में स्तंभ-संरेखित संख्यात्मक तालिकाओं के रूप में प्रदर्शित होती है।

t           % implicit input n. Duplicate
Eq          % 2*n-1
:           % range [1,2,...,2*n-1]
=           % gives [0,0,...1,...0,0]. This is the first row
Gq:         % range [1,2,...,n-1]
"           % for each. Repeat n-1 times
  t         %   duplicate latest row. This duplicate will become the next row
  5B        %   push array [1,0,1] (5 converted to binary)
  X+        %   convolution
  8L        %   predefined literal [2,-1i]. Used for indexing
  )         %   apply that index: remove one element at each end
]           % end for each
N$v         % concatenate all rows into a 2D array. Implicitly display

Answer 7

जावास्क्रिप्ट, 152 146 बाइट्स

f=i=>[...Array(i)].map((x,j)=>(z=[...Array(i*2-1)].map((_,k)=>+!!~[i-j,i+j].indexOf(k+1)),y=j?z.map((_,k)=>_||(k&&(k+1 in y)?y[k-1]+y[k+1]:_)):z))

f=i=>[...Array(i)].map(
    (x,j)=>(
        z=[...Array(i*2-1)].map(
            (_,k)=>
                +!!~[i-j,i+j]
                    .indexOf(k+1)
        ),
        y=j?z.map(
            (_,k)=>_||
                (k&&(k+1 in y)?
                    y[k-1]+y[k+1]
                :_)
        ):z
    )
)

F=i=>JSON.stringify(f(+i)).replace(/],|^.|.(?=.$)/g,'$&\n')
I.oninput()

<input id=I onInput="O.innerHTML=F(I.value)" value=5><pre id=O>

Answer 8

गंभीरता से, 33 बाइट्स

╩╜r`╣;lD0nkdZΣ`M╜rRZ`i0nkd@;)kΣ`M

इसे ऑनलाइन आज़माएं

मैं अपेक्षाकृत कम से कम 7 या कुछ हद तक उन बाइट्स का मुंडन किया जा सकता हूं, इसलिए मैं एक स्पष्टीकरण पोस्ट करने के लिए इंतजार करने जा रहा हूं जब तक कि मैं इसे और आगे नहीं बढ़ाऊंगा।

Answer 9

PHP , 106 बाइट्स

for(;$r++<$a=$argn;)for($c=-$a;++$c<$a;)$t[$r][$c]=$r>1|$c?$t[$r-1][$c-1]+$t[$r-1][$c+1]?:0:1;print_r($t);

इसे ऑनलाइन आज़माएं!