पास्कल की वैकल्पिक त्रिभुज

21

पास्कल का त्रिकोण1 क्रमिक जोड़ से बनने वाली प्रत्येक पंक्ति के साथ शुरू होने और उत्पन्न होने से उत्पन्न होता है । यहाँ, इसके बजाय, हम एक गुणा और जोड़कर एक त्रिकोण बनाने जा रहे हैं।

हम 1केवल एकांत के साथ पंक्ति शुरू करते हैं 1। इसके बाद, विषम पंक्तियों पर जोड़ दिया जाता है, और गुणा भी पंक्तियों (1-अनुक्रमित) पर किया जाता है। अतिरिक्त चरण करते समय, मान लें कि त्रिभुज के बाहर रिक्त स्थान 0एस से भरे हुए हैं । गुणन चरण करते समय, मान लें कि बाहर s से भरा है 1।

यहां 7 पंक्तियों के नीचे पूरा त्रिकोण है। *या +छोड़ दिया शो क्या कदम है कि पंक्ति उत्पन्न करने के लिए प्रदर्शन किया गया था पर।

1                1
2 *            1   1
3 +          1   2   1
4 *        1   2   2   1
5 +      1   3   4   3   1
6 *    1   3  12  12   3   1
7 +  1   4  15  24  15   4   1

चुनौती

इनपुट को देखते हुए n, nइस त्रिभुज की वें पंक्ति को आउटपुट करें ।

नियम

  • आप इसके बजाय 0-अनुक्रमणिका चुन सकते हैं, लेकिन फिर महसूस करें कि जोड़ और गुणन पंक्तियाँ फ्लिप-फ्लॉप होनी चाहिए, ताकि ऊपर जैसा ही त्रिकोण उत्पन्न हो। यदि आप ऐसा करने के लिए चुनते हैं तो कृपया अपनी प्रविष्टि में बताएं।
  • इनपुट और आउटपुट को आपकी भाषा के मूल पूर्णांक प्रकार में फिट करने के लिए ग्रहण किया जा सकता है।
  • इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में दिए जा सकते हैं ।
  • या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
  • यदि संभव हो, तो कृपया ऑनलाइन परीक्षण वातावरण का लिंक शामिल करें ताकि अन्य लोग आपके कोड को आज़मा सकें!
  • मानक खामियों को मना किया जाता है।
  • यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

उदाहरण

कई में से आउटपुट के दो संभावित उदाहरण दिखाते हैं: एक सूची, या एक अंतरिक्ष अलग स्ट्रिंग।

4
[1, 2, 2, 1]

8
"1 4 60 360 360 60 4 1"
code-golf  math  number  arithmetic  number-theory 
— AdmBorkBork
स्रोत
2
@totallyhuman नहीं, stdout की एकमात्र चीज nवें पंक्ति होनी चाहिए ।
— AdmBorkBork 13

जवाबों:

16

पास्कल , 249 247 233 बाइट्स

खैर, यह पास्कल का वैकल्पिक त्रिकोण है।

1 बाइट ने @ Mr.Xcoder को धन्यवाद दिया

function f(n,k:integer):integer;begin if((k<1)or(k>n)or(n=1))then f:=n mod 2 else if n mod 2=0then f:=f(n-1,k-1)*f(n-1,k)else f:=f(n-1,k-1)+f(n-1,k)end;
procedure g(n:integer);var k:integer;begin for k:=1to n do write(f(n,k),' ')end;

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

— Uriel
स्रोत
— मिस्टर एक्सकोडर
7

पायथन 2 , 97 93 86 81 78 बाइट्स

-4 बाइट्स रॉड के लिए धन्यवाद। -10 बाइट्स हैलवार्ड भेड़िये का धन्यवाद।

f=lambda n:n and[[i+j,i*j][n%2]for i,j in zip([n%2]+f(n-1),f(n-1)+[n%2])]or[1]

0 अनुक्रमित।

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

— totallyhuman
स्रोत
1
अच्छा काम, मेरे पास एक (बहुत) लंबा दृष्टिकोण था । हालांकि मेरे पास अभी तक इसे गोल्फ के लिए समय नहीं था।
— श्री एक्सकोडर
1
मुझे लगता है कि map([int.__add__ ,int.__mul__][i%2],[i%2]+a,a+[i%2])काम करना चाहिए (परीक्षण नहीं किया गया)
— रॉड
1
— Halvard Wil
1
नहीं, यह पुनरावर्ती है। आपको नाम शामिल करना चाहिए।
— श्री एक्सकोडर
1
— Halvard Wil
5

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

µ×+LḂ$?Ḋ1;µ¡

यह एक पूर्ण कार्यक्रम (या निलाडिक लिंक) है जो एसटीडीआईएन से इनपुट लेता है।

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

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

µ×+LḂ$?Ḋ1;µ¡  Main link. No arguments. Implicit argument: 0

          µ¡  Start a monadic chain and apply the ntimes quick to the previous one.
              This reads an integer n from STDIN and executes the previous chain n
              times, with initial argument 0, returning the last result.
µ             Start a monadic chain. Argument: A (array or 0)
       Ḋ          Dequeue; yield A without its first element.
   LḂ$?           If the length of A is odd:
 ×                    Multiply A and dequeued A.
                  Else:
  +                   Add A and dequeued A.
        1;        Prepend a 1 to the result.
— डेनिस
स्रोत
5

पायथन 2 , 96 89 87 बाइट्स

  • 2 बाइट्स श्री एक्सकोडर को धन्यवाद: s=[1]

  • पूरी तरह से अमानवीय जवाब से थोड़ा अलग

s=a=[1]
for i in range(1,input()):a=s+[[k+l,k*l][i%2]for k,l in zip(a[1:],a)]+s
print a

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

— officialaimm
स्रोत
1
— ओग
@totallyhuman धन्यवाद .. मैंने इसे वापस ले लिया ...
— आधिकारिक
1
अचानक निष्पादन विधि अग्रणी है: D
— डेड पोसूम
1
87 बाइट्स , घोषित करना [1]।
— श्री एक्सकोडर
3

सीजेएम , 25 बाइट्स

{1a\{2%!_2$+\{.*}{.+}?}/}

0 अनुक्रमित।

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

व्याख्या

यह एक अनाम ब्लॉक है जो स्टैक से संख्या लेता है और स्टैक पर परिणाम छोड़ता है।

1a                        Push [1].
  \                       Bring the number to the top.
   {                 }/   For reach number 0 .. arg-1, do:
    2%!                    Push 0 if even, 1 if odd.
       _                   Copy that.
        2$+                Copy the list so far and prepend the 0 or 1 to it.
           \               Bring the 0 or 1 back to the top.
            {.*}{.+}?      If 1, element-wise multiplication. If 0, element-wise addition.
— बिजनेस कैट
स्रोत
रुको 2%!1 धक्का चाहिए भले ही और 0 अगर विषम, नहीं?
— 1
3

हास्केल , 76 72 बाइट्स

0-अनुक्रमित समाधान:

(p!!)
p=[1]:[zipWith o(e:l)l++[1]|(l,(o,e))<-zip p$cycle[((*),1),((+),0)]]

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

व्याख्या

p प्रत्यावर्ती रूप से प्रत्यावर्ती त्रिभुज को परिभाषित करता है, इसका आधार मामला / पहला तत्व है [1]

p=[1]:[                                                            ]

यह फिर पिछली पंक्ति ( l) लेकर त्रिकोण बनाता है । यह जानने के लिए कि हमें इसके साथ क्या करना है, हमें सही ऑपरेटर ( o) और संबंधित तटस्थ तत्व ( e) का ट्रैक रखने की आवश्यकता है :

                           |(l,(o,e))<-zip p$cycle[((*),1),((+),0)]

इसमें से लाइन को डुप्लिकेट करके नई लाइन का निर्माण करें और एक कॉपी के लिए हम न्यूट्रल एलिमेंट को प्रिपेंड करते हैं, उन्हें ऑपरेटर के साथ पिन करते हैं और 1:

       zipWith o(e:l)l++[1]
— ბიმო
स्रोत
3

आर , 108 98 बाइट्स

-10 बाइट्स को एक प्लस चिन्ह के साथ वास्तविक गुणा चिन्ह को बदलकर। मुझे माफ़ कर दें।

f=function(n){if(n<3)return(rep(1,n))else{v=f(n-1)};if(n%%2)`*`=`+`;return(c(1,v[3:n-2]*v[-1],1))}

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

सामान्य तरीके से प्रसन्न (पहली बार जब मैंने एक आदिम को अलियास किया है), लेकिन मुझे यकीन है कि इस पर अभी तक गोल्फ होना है, विशेष रूप से उन मामलों की अजीब हैंडलिंग के साथ जहां n <3 जो बहुत सारे बॉयलरप्लेट की ओर जाता है।

— CriminallyVulgar
स्रोत
85 बाइट्स । मैं वास्तव में आपके समाधान के साथ प्यार करता हूँ `*`=`+`! अत्यंत चालाक। मेरे बाकी सुधार सिर्फ मानक गोल्फ तकनीक हैं, जिन्हें मुझे आपके अनुरोध पर समझाने में खुशी होगी :)
— Giuseppe
80 बाइट्स । मैंने आपके नोट से उन मामलों के बारे में प्रेरणा ली, जहांn<3
— Giuseppe
2

हस्क , 17 16 बाइट्स

!G₅;1¢e*+
:1Sż⁰t

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

1-अनुक्रमित समाधान।

व्याख्या

पहली पंक्ति मुख्य फ़ंक्शन है, जो दूसरी पंक्ति में सहायक फ़ंक्शन को कॉल करती है। सहायक फ़ंक्शन को आमतौर पर कहा जाता है ₁, लेकिन इस मामले में मैं अतिप्रवाहित लेबल का उपयोग कर रहा हूं भूसी फीचर का : यदि आप M <N लाइनों के साथ एक प्रोग्राम में लाइन एन का उल्लेख करते हैं, तो आप संशोधक फ़ंक्शन एम / के साथ लाइन एन मॉड एम प्राप्त करते हैं। एन ने इसके लिए आवेदन किया। दूसरा संशोधक फ़ंक्शन है , इसलिए मैं हेल्पर फ़ंक्शन के तर्कों को अतिरिक्त बाइट लागत के साथ फ्लिप करने के लिए उपयोग कर रहा हूं ।flip₅

यहाँ हेल्पर फंक्शन है।

:1Sż⁰t  Takes a function f and a list x.
   ż    Zip preserving elements of longer list
    ⁰   using function f
  S  t  x and its tail,
:1      then prepend 1.

यहाँ मुख्य कार्य है।

!G₅;1¢e*+  Takes a number n.
      e*+  2-element list of the functions * and +
     ¢     repeated infinitely.
 G         Left scan this list
  ₅        using the flipped helper function
   ;1      with initial value [1].
!          Get n'th element.
— Zgarb
स्रोत
2

सी # (.NET कोर) , 143 134 128 बाइट्स

-4 बाइट्स फेज के लिए शुक्रिया
-5 बाइट्स के लिए धन्यवाद Zac Faragher
-6 बाइट्स के लिए धन्यवाद केविन क्रूज़सेन

n=>{int[]b={1},c;for(int i=0,j;++i<n;b=c)for(c=new int[i+1],c[0]=c[i]=1,j=0;++j<i;)c[j]=i%2<1?b[j-1]+b[j]:b[j-1]*b[j];return b;}

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

स्पष्टीकरण:

n =>
{
    int[] b = { 1 }, c;               // Create first layer
    for(int i = 0, j; ++i < n; b = c) // Iterate for every layer, replace last layer with a new one
        for(c = new int[i+1],         // Create new layer
            c[0] = c[i] = 1,          // First and last elements are always 1
            j = 0;
            ++j < i; )                // Replace every element (besides 1st and last)...
                c[j] = i % 2 == 0 ?
                    b[j - 1] + b[j] : // ... with addition...
                    b[j - 1] * b[j];  // ... or multiplication of two from previous layers
    return b;                         // Return latest layer
};
— ग्रेज़गोरज़ पुलावस्की
स्रोत
आपको अपने b सरणी आरंभीकरण को बदलने में सक्षम होना चाहिए var b=new[]{1};और कंपाइलर आपके लिए सरणी प्रकार निर्धारित करेगा।
— जस्टिनएम -
1
पहली परत बनाने का एक और तरीका है int[]b={1};- 11 बाइट्स बनाम 20 जैसा या 16 है जैसा कि @Phaeze के सुझाव में है
— Zac Faragher
1
@ZacFaragher और चरणजी धन्यवाद!
— ग्रेज़गोरज़ पूलावस्की
1
मुझे पता है कि यह काफी समय हो गया है, लेकिन आप 6 और बाइट्स गोल्फ कर सकते हैं n=>{int[]b={1},c;for(int i=0,j;++i<n;b=c)for(c=new int[i+1],c[0]=c[i]=1,j=0;++j<i;)c[j]=i%2<1?b[j-1]+b[j]:b[j-1]*b[j];return b;}:। मैंने cइस तरह संयुक्त किया है int[]b={1},c;; छोटा कर i%2==0दिया i%2<1; और अंदर सब कुछ डालकर लूप के ब्रैकेट्स को हटा दिया।
— केविन क्रूज़सेन
महान! धन्यवाद @KevinCruijssen
— ग्रेज़गोरज़ पुलावस्की
1

पायथ , 22 बाइट्स

@FryAmTheEggman के लिए धन्यवाद बाइट के टन बचाया ! प्रारंभिक समाधान नीचे है।

u++1@,+VGtG*VGtGlG1Q[1

पूर्ण टेस्ट सूट (0-अनुक्रमित)।

पायथ , 40 38 36 35 बाइट्स

ऐसा लगता है कि waaaaaaaay बहुत अधिक लंबा है। सुझावों का स्वागत है।

K]1VStQ=K++]1m@,sd*hded%N2C,KtK]1;K

टेस्ट सूट या ऑनलाइन यह कोशिश करो!

— श्री Xcoder
स्रोत
को कम करने का उपयोग करना ज्यादा हो रहा है कम । मुझे यकीन नहीं है कि यह या तो इष्टतम है, मुझे लगता है कि उप 20 प्रबंधनीय है?
— FryAmTheEggman
@FryAmTheEggman मेरा संशोधन इतिहास देखें। मैंने कहा कि मैं कम के साथ एक वर्कअराउंड खोजने की कोशिश कर रहा था u(लेकिन यह पता नहीं लगा सका)। धन्यवाद!
— श्री एक्सकोडर
यदि पाइथ में एक प्रीपेन्ड-अपेंडेड बिल्ट-इन होगा ...
— मिस्टर एक्सकोडर
1

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

Fold[#2@@@Partition[#,2,1,{-1,1},{}]&,{1},PadRight[{},#,{1##&,Plus}]]&

इसे वुल्फ्राम सैंडबॉक्स पर आज़माएं ! यह दुर्भाग्य से गणित में काम नहीं करता है। यह 0-अनुक्रमित है।

स्पष्टीकरण: Partition[#,2,1,{-1,1},{}]एक सूची लेता है और सभी दो-तत्व सब्लिस्ट को वापस करता है, साथ ही प्रारंभ और अंत के लिए 1-तत्व सूची - जैसे, {1,2,3,4}बन जाता है {{1}, {1,2}, {2,3}, {3,4}, {4}}। (प्रभावी रूप से ) PadRight[{},#,{1##&,Plus}]की एक वैकल्पिक सूची बनाता है और जिसकी लंबाई इनपुट संख्या है। फिर त्रिभुज की पंक्तियों को बनाने के लिए, बार-बार तों और विभाजन के साथ विभाजन फ़ंक्शन लागू करता है ।1##&TimesPlusFoldPlusTimes

— पेड़ नहीं
स्रोत
0

टीआई-बेसिक (TI-84 Plus CE), 100 बाइट्स

Prompt X
{1→M
For(A,2,X
LM→L
A→dim(M
For(B,2,A–1
If A/2=int(A/2
Then
LL(B–1)LL(B→LM(B
Else
LL(B–1)+LL(B→LM(B
End
End
1→LM(dim(LM
End
LM

1-अनुक्रमित, इनपुट के लिए उपयोगकर्ता को संकेत देता है और सूची युक्त प्रिंट करता है n पास्कल की अल्टरनेटिंग ट्रायंगल की वें पंक्ति होती है।

लूपिंग करते समय: एल एम वर्तमान पंक्ति है, और एल एल पिछली पंक्ति है।

टीआई-बेसिक ए है टोकन भाषा है । यहां इस्तेमाल होने वाले सभी टोकन एक-एक बाइट टोकन हैं।

मुझे लगता है कि मैं अंत से एम-इन-प्लेस को संशोधित करके इसे आगे बढ़ा सकता हूं।

स्पष्टीकरण: 

Prompt X            # 3 bytes; get user input, store in X
{1→M                # 5 bytes, store the first row into LM
For(A,2,X           # 7 bytes, Loop X-1 times, with A as the counter, starting at 2
LM→L                # 5 bytes, copy list M into list L
A→dim(M             # 5 bytes, extend M by one
For(B,2,A–1         # 9 bytes, for each index B that isn't the first or last...
If A/2=int(A/2      # 10 bytes,    if A is even...
Then                # 2 bytes,     then...
LL(B–1)LL(B→LM(B     # 17 bytes,        the Bth item in this row is the Bth times the (B-1)th of the previous row
Else                # 2 bytes,     else...
LL(B–1)+LL(B→LM(B    # 18 bytes,        the Bth item in this row is the Bth plus the (B-1)th of the previous row
End                 # 2 bytes,     endif
End                 # 2 bytes,  endfor
1→LM(dim(LM         # 9 bytes, the last item is always 1
End                 # 2 bytes, endfor
LM                  # 2 bytes, Implicitly print the final row

— pizzapants184
स्रोत
0

जावास्क्रिप्ट (ईएस 6), 71 69 66 बाइट्स

f=n=>n?(p=f(n-1),[...p.map((v,i)=>i--?n%2?v*p[i]:v+p[i]:1),1]):[1]

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

0 अनुक्रमित।
-3 बाइट्स @Arnauld द्वारा

f=n=>n?(p=f(n-1),[...p.map((v,i)=>i--?n%2?v*p[i]:v+p[i]:1),1]):[1]

for (var i = 0; i < 10; ++i) {
  console.log(JSON.stringify(f(i)));
}
स्निपेट का विस्तार करें

— Birjolaxew
स्रोत
1
एक टर्नरी का उपयोग करके 3 बाइट्स बचाना चाहिए: i--?n%2?v*p[i]:v+p[i]
— अरनौल्ड
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.