पास्कल का त्रिकोण पहली पंक्ति पर 1 से शुरू होकर उत्पन्न होता है। बाद की पंक्तियों पर, संख्या दो संख्याओं के योग से सीधे उसके ऊपर बाईं और दाईं ओर निर्धारित होती है।

प्रदर्शित करने के लिए, पास्कल के त्रिकोण की पहली 5 पंक्तियाँ इस प्रकार हैं:

चुनौती

इनपुट n को देखते हुए (बशर्ते आपकी चुनी हुई भाषा में सबसे सुविधाजनक हो), पास्कल के त्रिकोण की पहली n पंक्तियाँ बनाएँ। आप मान सकते हैं कि n 1 और 25 के बीच का पूर्णांक है। प्रत्येक पंक्ति और प्रत्येक संख्या के बीच के स्थान के बीच एक पंक्ति विराम होना चाहिए, लेकिन इससे अलग, आप इसे पसंद कर सकते हैं, लेकिन फिर भी।

यह कोड-गोल्फ है , इसलिए सबसे छोटा समाधान जीतता है।

उदाहरण I / O

> 1
1
> 9
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1

code-golf math combinatorics

— पीटर ओल्सन
स्रोत

एनबी एक मायने में यह गेंदों

— पीटर टेलर

@ पैटर ओल्सन: शाफ़्ट फ्रीक की व्याख्या के बारे में आपकी क्या राय है "आप इसे वैसे भी प्रारूपित कर सकते हैं जो आपको पसंद है"? अगर मैंने उनकी व्याख्या का पालन किया तो मैं 18 पात्रों को शेव कर सकता था।

— स्टीवन रूंबल्स्की

@StevenRumbalski वह ठीक है। प्रत्येक पंक्ति के बीच एक नई रेखा है, और प्रत्येक संख्या के बीच एक स्थान है, इसलिए यह मानदंडों को पूरा करता है।

— पीटर ओल्सन

@ पेटर ओल्सन: स्पष्टीकरण के लिए धन्यवाद। टॉमस टी की धारणा के बारे में क्या n पहले से ही परिभाषित है?

— स्टीवन रूंबल्स्की

4

@ गैफ़ी शायद नहीं, एक उत्तर को स्वीकार करने से मुझे ऐसा लगता है कि मैं प्रतियोगिता को समाप्त कर रहा हूं और नए और संभवतः बेहतर उत्तरों को हतोत्साहित कर रहा हूं।

— पीटर ओल्सन

30

जे , 12 वर्ण

":@(!{:)\@i.

   I.5
0 1 2 3 4
   {: I.5
4
   (I.5) {: I.5
१ ४ ६ ४ १
   (! {:) I.5
१ ४ ६ ४ १
   ({:!) \ I.5
१ ० ० ० ०
१ १ ० ० ०
१ २ १ ० ०
१ ३ ३ १ ०
१ ४ ६ ४ १
   ": @ ({:!) \ I.5
1
1 1
१ २ १
१ ३ ३ १
१ ४ ६ ४ १
   ( ": @ ({:।) \ @ I)` ''
+ ---------------------------------- +
| + - + ------------------------------ + |
|| @ | + ------------------------- + - + ||
|| । || + - + --------------------- + | मैं |||
|| ||| \ | + ------------------- + || |||
|| ||| || + - + --------------- + ||| |||
|| ||| ||| @ | + - + ---------- + |||| |||
|| ||| ||| || ": | + - + ------ + ||||| |||
|| ||| ||| || || 2 | + - + - + |||||| |||
|| ||| ||| || || || | {: ||||||| |||
|| ||| ||| || || | + - + - + |||||| |||
|| ||| ||| || | + - + ------ + ||||| |||
|| ||| ||| | + - + ---------- + |||| |||
|| ||| || + - + --------------- + ||| |||
|| ||| | + ------------------- + || |||
|| || + - + --------------------- + | |||
|| | + ------------------------- + - + ||
| + - + ------------------------------ + |
+ ---------------------------------- +

— ephemient
स्रोत

1

J गोल्फ की धड़कन है? दिलचस्प। यदि आपके पास समय हो तो मैं इस कोड के लिए एक स्पष्टीकरण देखना चाहूंगा।

— श्री। छिपकली

4

यदि आप अतिरिक्त अंग्रेजी चाहते हैं तो यह पहले से ही विभाजित है, लेकिन यहां एक पंक्ति है। लाइन 1 i.5में पहले पांच नैचरल रिटर्न हैं। पंक्ति 2 में {:"टेल" (अंतिम बार वापसी) शामिल है। लाइन 3 उन्हें !"आउट" (संयोजनों की संख्या) के साथ जोड़ती है । पंक्ति 4 (!{:)i.5समान है। हुक लगाना। तो (!:)एक ऐसा ऑपरेशन है जो पहले एन- नैचल्स को पास्कल के त्रिकोण की एनटी लाइन में बदल देता है। लाइन 5 इसे 0..4 के सभी प्रीफ़िक्स (बैकस्लैश) पर लागू करता है, लेकिन जे 0 के साथ अप्रयुक्त स्पॉट में भरता है, इसलिए ऑपरेशन को संयुक्त ( @) स्ट्रिंग प्रारूपण ऑपरेशन के साथ जोड़ा जाता है ":। बहुत कूल जे, अपवित्र।

— जेबी

@ जेबी नहीं है! यहाँ गुट का मतलब है? इसके अलावा, हम दाईं ओर @ से छुटकारा पा सकते हैं।

— defhlt

@ArtemIce मोनाडिक का !मतलब है गुटबाजी ; डायडिक !कॉम्बिनेशन मायने रखता है। फाइनल @में ":@(!{:)\@i.यह एक स्टैंड-अलोन क्रिया बनाने के लिए है।

— ईपीएम

18

पायथन, 56 बाइट्स

a=[1];exec"print a;a=map(sum,zip([0]+a,a+[0]));"*input()

नमूना उपयोग:

echo 9 | python filename.py

पैदा करता है:

[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]

— Primo
स्रोत

1

execएक forलूप से बचने के लिए +1 चालाक तरीका ।

— स्टीवन रूंबल्स्की

15

पायथन, 94 91 88 70 63 वर्ण

x=[1]
for i in input()*x:
 print x
 x=map(sum,zip([0]+x,x+[0]))

— स्टीवन रंबलस्की
स्रोत

14

गणितज्ञ: 36 (41?)

Mathematica का Binomialकार्य है, लेकिन इससे मज़ा आता है। मैंने प्रस्ताव रखा है:

NestList[{0,##}+{##,0}&@@#&,{1},n-1]

ऊपर दी गई पंक्ति इस तरह से एक रैग्ड सरणी प्रस्तुत करेगी:

{{1}, {1, 1}, {1, 2, 1}, {1, 3, 3, 1}, {1, 4, 6, 4, 1},
 {1, 5, 10, 10, 5, 1}, {1, 6, 15, 20, 15, 6, 1}}

चूंकि यह मैथमेटिका में एक बुनियादी प्रारूप है, मुझे लगा कि यह स्वीकार्य होगा, लेकिन जैसा कि मैंने नियमों को फिर से पढ़ा, मुझे लगता है कि यह नहीं हो सकता है। Grid@कुल 41 वर्णों के लिए जोड़ने से असमान रूप से स्वीकार्य उत्पादन होगा :

Grid@NestList[{0,##}+{##,0}&@@#&,{1},n-1]

n = 6:

1                       
1   1                   
1   2   1               
1   3   3   1           
1   4   6   4   1       
1   5   10  10  5   1   
1   6   15  20  15  6   1

— Mr.Wizard
स्रोत

14

C, 522

सी का जवाब देने वाला एक स्व। स्पष्ट नहीं हो सका! अतिरिक्त चरित्र खोजने के लिए बोनस अंक।

#define returns return 0
#define fr for
#define twentyonechexpressis0 0
                                                                                i
                                                                               , x
                                                                              [ 52 ]
                                                                            [ 52] ,j, y
                                                                       ; main (c){fr (;i< c
                                                                    ; i++){ x[i][i]=x[ i][0]= 1
                                                         ; }for(i =2;i<c;i++){for (j=1;j<i;j++){x [i][j] =
                                    1 +x[i][j ]+x[i-1][j-1]+x[i-1] [j]+1-1+1-1+1-1+1-1+1-1+111-11- twentyonechexpressis0 -100-1; }
} ;for(i=0 ;i<c;i++){for(j=0;j<=i;j++){ printf("%3d%c",x[i][j],(1+1+1+1)*(1+1+1+1+1+1+1+1)) ;}putchar(1+1+(1<<1+1)+1+1+1+1+1+111111-111111-1);} /*thiscomment_takes28chars*/ returns; }

— walpen
स्रोत

4

मैं मदद नहीं कर सकता, लेकिन यह महसूस करता हूं कि यह कोड गोल्फ की बात याद आती है। (मैं यह इंगित करने में भी मदद नहीं कर सकता कि अतिरिक्त वर्ण \ binom {5} {4} स्थिति) में है।

— पीटर टेलर

2

लिखने में मजा आता था। यह आमतौर पर मैं कोडगुल्फ के लिए आता हूं।

— 21

1

चतुर :) एक उत्थान है। शायद एक विजेता उम्मीदवार नहीं बल्कि रचनात्मक!

— Accatyyc

11

गोल्फस्क्रिप्ट (21 वर्ण)

~]({0\{.@+\}/;1].p}*;

चूंकि एक स्पष्टीकरण का अनुरोध किया गया था:

# Stack contains 'n'
~](
# Stack: [] n
{
    # prev_row is [\binom{i,0} ... \binom{i,i}]
    # We loop to generate almost all of the next row as
    #     [(\binom{i,-1} + \binom{i,0}) ... (\binom{i,i-1} + \binom{i,i})]
    # \binom{i,-1} is, of course, 0
    # Stack: prev_row
    0\
    # Stack: 0 prev_row
    {
        # Stack: ... \binom{i,j-1} \binom{i,j}
        .@+\
        # Stack: ... (\binom{i,j-1} + \binom{i,j}) \binom{i,j}
    }/
    # Stack: \binom{i+1,0} ... \binom{i+1,i} \binom{i,i}
    # unless it's the first time round, when we still have 0
    # so we need to pop and then push a 1 for \binom{i+1,i+1}
    ;1]
    # next_row
    .p
}*
# final_row
;

— पीटर टेलर
स्रोत

आप का प्रयास करना चाहें golf.shinh.org/p.rb?pascal+triangle

— Nabb

क्या आप कुछ छद्म कोड या स्पष्टीकरण प्रदान कर सकते हैं? मैं समझ रहा हूं कि क्या हो रहा है, लेकिन मैं पूरी तरह से स्वैपिंग पार्ट को नहीं समझ रहा हूं।

— रोब

विस्तृत विवरण और उत्कृष्ट उत्तर (+1) के लिए धन्यवाद, लेकिन मैं अब और अधिक भ्रमित हूं। तर्क (प्रक्रिया) सही नहीं बैठा है।

— रोब

@ मायकेड्रिक, स्पष्टीकरण में थोड़ी सी त्रुटि थी। एक सूक्ष्म बिंदु भी है जिसे समझाने की आवश्यकता थी, लेकिन जो मैंने याद किया क्योंकि यह कोड लिखने के बाद से बहुत लंबा है।

— पीटर टेलर

ठीक है, यह समझ में आने लगा है। मेरा अंतिम प्रश्न यह है कि मुद्रण और निष्पादन की प्रक्रिया ऊपर से नीचे या नीचे से ऊपर (1, 1 1, 1 2 1: शीर्ष नीचे, 1 2 1, 1 1, 1: 1: 1) काम करती है?

— रोब

7

हास्केल, 94 92

f=[1]:[zipWith(+)(0:x)x++[1]|x<-f]
main=readLn>>=mapM_(putStrLn.unwords.map show).(`take`f)

आउटपुट:

एक 71 वर्ण संस्करण, जो प्रत्येक संख्या के बीच एक स्थान नहीं छापता है:

f=[1]:[zipWith(+)(0:x)x++[1]|x<-f]
main=readLn>>=mapM_ print.(`take`f)

आउटपुट:

[1]
[1,1]
[1,2,1]
[1,3,3,1]

— Hammar
स्रोत

आप mapMइसके बजाय का उपयोग करके एक चरित्र को बचा सकते हैं mapM_।

— dfeuer

7

स्काला, 81 78 72 70 वर्ण

81 वर्ण: पहला प्रयास, बेशर्मी से पायथन संस्करण से कॉपी किया गया :)

var x=Seq(1)
for(i<-1 to args(0).toInt){println(x)
x=(0+:x,x:+0).zipped.map(_+_)}

इसे स्क्रिप्ट के रूप में, या सीधे REPL में चलाएं।

आश्चर्यजनक रूप से पठनीय और मुहावरेदार चीज़ों के साथ 70 वर्णों को काटें:

Seq.iterate(Seq(1),readInt)(a=>(0+:a,a:+0).zipped.map(_+_))map println

या 72 70 अक्षर पूरी तरह से अलग विधि के साथ:

0 to(readInt-1)map(i=>println(0 to i map(1 to i combinations(_)size)))

— लुइगी प्लिंज
स्रोत

+ 1 बेशर्म नकल के लिए!

— स्टीवन रूम्बल्स्की

पिछले संस्करण को ReadInt के विशाल मानों के लिए सावधानीपूर्वक उपयोग किया जाना चाहिए, जैसे 50.;)

— उपयोगकर्ता अज्ञात

@userunknown शायद इसीलिए यह सवाल 25 की ऊपरी सीमा को निर्दिष्ट करता है ...

— लुइगी प्लिंज

यह आलोचक के रूप में नहीं था, बस जिज्ञासु के लिए एक चेतावनी के रूप में।

— उपयोगकर्ता अज्ञात

6

रूबी: ५१ ४ ९ ४६ अक्षर

(45 वर्ण कोड + 1 वर्ण कमांड लाइन विकल्प)

p=[];$_.to_i.times{n=0;p p.map!{|i|n+n=i}<<1}

करने के लिए धन्यवाद:

मूल्य स्विचिंग के लिए एक विकल्प का सुझाव देने के लिए jsvnm (2 वर्ण)
पिछले सुधार के बाद अप्रयुक्त एक चर को खोलने के लिए GB (4 वर्ण)

नमूना रन:

bash-4.4$ ruby -ne 'p=[];$_.to_i.times{n=0;p p.map!{|i|n+n=i}<<1}' <<< 1
[1]

bash-4.4$ ruby -ne 'p=[];$_.to_i.times{n=0;p p.map!{|i|n+n=i}<<1}' <<< 9
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]

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

— आदमी काम पर है
स्रोत

1

आप के साथ 2 वर्ण बचा सकता हैp.map!{|i|(v=n)+n=i}

— jsvnm

बहुत बढ़िया, @jsvnm! यार, मैं कब तक उस हिस्से को छोटा करने के लिए संयुक्त था। धन्यवाद।

— मैनेटवर्क

1

शायद थोड़ी देर, लेकिन: चर v का उपयोग क्यों करें?

— जीबी

अच्छी पकड़, @GB! यह 1 संशोधन से पीछे रह गया , जहां ... कहां ... दोह। कहाँ भी बेकार की तरह था। मुझे लगता है कि यह पहले के प्रयास से आता है जब उपयोग किया जाता है .map। धन्यवाद।

— मैनटवर्क

5

जावास्क्रिप्ट ( 90 85 83 81)

for(n=prompt(o=i='');i++<n;o+='\n')for(s=j=1;j<=i;s=s*(i-j)/j++)o+=s+' ';alert(o)

डेमो: http://jsfiddle.net/tcRCS/3/

नोट : लगभग n> 30 के लिए अभ्यास में अच्छी तरह से काम नहीं करता है क्योंकि संख्याएं अंतर्निहित पूर्णांक डेटा प्रकार को ओवरफ्लो करती हैं और फ्लोटिंग-पॉइंट नंबर बन जाती हैं।

संपादित करें 1 : बयानों whileको परिवर्तित forऔर संयोजन करके 5 वर्णों को हटा दिया गया

2 संपादित करें : s=स्टेटमेंट को अंदर ले जाएं forऔर 2 वर्णों को सहेजें

संपादित 3 : s=1,j=1इनिशियलाइज़र को संयोजित करेंs=j=1 और 2 वर्णों को सहेजें

— mellamokb
स्रोत

अच्छा! आप "s = s * ..." को "s * = ..." में बदलकर एक और चरित्र को बचा सकते हैं

— Derek Kurth

@DerekKurth: मैंने सोचा था कि जब मैं पहली बार अनुकूलन कर रहा था, लेकिन यह तर्क को गड़बड़ कर देगा क्योंकि इसे होने की आवश्यकता है s*(i-j)/j, नहीं s*((i-j)/j)।

— मेलमोकब

हम्म, मैंने इसे ss = = ... के रूप में jsfiddle में आज़माया और यह काम करने लगा। शायद मैंने कुछ गलत किया है, हालांकि।

— डेरेक कुर्थ

1

@DerekKurth: तकनीकी रूप से यह समान है, लेकिन विचार यह है कि यदि आप (i-j)विभाजित होने से पहले गुणा करते हैं j, तो फ़्लोटिंग पॉइंट अंकगणित की कोई आवश्यकता नहीं है क्योंकि परिणाम हमेशा पूर्णांक होना चाहिए। यदि आप ((i-j)/j)पहले करते हैं , तो इसका परिणाम दशमलव मान होगा जो त्रुटि का एक स्रोत हो सकता है, और बहुत कम से कम गोलाई / छंटाई के लिए अतिरिक्त कोड की आवश्यकता होगी। जब तक आप इसके बारे n>11में नहीं 1 11 55 165 330 461.99999999999994 461.99999999999994...

— जानेंगे

आह, यह समझ में आता है!

— डेरेक कुर्थ

5

आर, 39 वर्ण

आर इस कार्य के लिए बहुत सही उपकरण लगता है :-)

x=1;for(i in 1:n)x=c(print(x),0)+c(0,x)

— टॉमस
स्रोत

3

आप आवश्यकताओं में से एक को याद कर रहे हैं: "इनपुट n को देखते हुए (बशर्ते आपकी चुनी गई भाषा में सबसे सुविधाजनक हो)"

— स्टीवन रूंबल्स्की

@Steven, "इनपुट एन को देखते हुए" ... तो क्या मैं मान सकता हूं कि nयह दिया गया है? मैंने कोड ठीक किया। क्या यह अब ठीक है?

— टॉमस

मैंने पीटर ओल्सन को स्पष्ट करने के लिए कहा है।

— स्टीवन रूंबल्स्की

@StevenRumbalski मुझे नहीं लगता कि यह मान्य है जब तक कि यह इनपुट नहीं लेता है। मुझे R पता नहीं है, इसलिए शायद कंपाइलर इसे बनाता है ताकि अपरिभाषित चर इनपुट का संकेत दे सकें, इसलिए यह ठीक हो सकता है, लेकिन अगर यह उस संबंध में अन्य भाषाओं की तरह है, तो मुझे नहीं लगता कि यह है।

— पीटर ओल्सन

1

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

— स्टीवन रंबलस्की

5

क्यू में (25 अक्षर / 20 छोटे संस्करण के साथ)

t:{(x-1) (p:{0+':x,0})\1}

छोटा

t:{(x-1){0+':x,0}\1}

नमूना उपयोग:

— sinedcm
स्रोत

या वैकल्पिक रूप से, 20 वर्णt:{(x-1){0+':x,0}\1}

— स्कीव

अब गोल्फस्क्रिप्ट समाधान की तुलना में अच्छा है।

— sinedcm

4

awk - 73 वर्ण

काफी सीधा कार्यान्वयन:

{for(i=0;i<$1;++i)for(j=i;j>=0;)printf"%d%c",Y[j]+=i?Y[j-1]:1,j--?32:10}

नमूना रन:

% awk -f pascal.awk <<<10
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1

— डान एंड्राट्टा
स्रोत

4

पर्ल, 52 , 49 अक्षर

संपादित करें: के sayबजाय का उपयोग करprint

map{@_=(1,map$_[$_-1]+$_[$_],1..@_);say"@_"}1..<>

— टोटो
स्रोत

4

पर्ल, 47 54 वर्ण

$p=1;map{print"@{[split//,$p]}\n";$p*=11}1..<>

यह कमांड लाइन से एक नंबर लेता है, लेकिन कोई त्रुटि जांच नहीं करता है।

बस एहसास हुआ कि यह केवल n = 4 तक काम करता है। यह मेरे एचडी पर कुछ पुराना कोड था।

हालांकि यह काम करता है:

map{@a=(1,map$a[$_-1]+=$a[$_],1..@a);print"@a\n"}a..n

n को स्क्रिप्ट में इनपुट होना चाहिए, हालांकि, यह एक चरित्र अधिक होगा।

— flesk
स्रोत

4

केजी , 40 बाइट्स

1®n1¿1.
,(|(©n|:©n$@MCƒℤ. ,⑨)©n⑨®n_01.
,

व्याख्या की

कलम हाइलाइट

— जोनो 2906
स्रोत

3

पर्ल, 77 चार्ज

$o[0]=1;for(1..<>){$"=" ";for(1..$_){$n[$_]=$o[$_]+$o[$_-1]}@o=@n;print"@o
"}

उदाहरण इनपुट

उदाहरण आउटपुट

— PhiNotPi
स्रोत

3

C, 132 127 अक्षर

c[25][25],n,i,j;main(){for(scanf("%d",&n);i<n;i++)for(j=0;j<=i;j++)printf("%d%c",c[i][j]=j?c[i-1][j-1]+c[i-1][j]:1,i-j?32:10);}

— saeedn
स्रोत

3

पास्कल: 216 192 अक्षर

(वास्तविक प्रतियोगी नहीं, सिर्फ एक सम्मानजनक उपस्थिति।)

var p:array[0..1,0..25]of LongInt;i,j,n,u:Word;begin
Read(n);u:=0;for i:=1to n do begin
p[1,1]:=1;for j:=1to i do begin
p[u,j]:=p[1-u,j-1]+p[1-u,j];Write(p[u,j],' ')end;u:=1-u;Writeln
end
end.

नमूना रन:

bash-4.2$ fpc pascal.pas 
/usr/bin/ld: warning: link.res contains output sections; did you forget -T?

bash-4.2$ ./pascal <<< 1
1 

bash-4.2$ ./pascal <<< 9
1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1 
1 7 21 35 35 21 7 1 
1 8 28 56 70 56 28 8 1

— आदमी काम पर है
स्रोत

3

MATL , 10 बाइट्स

इस चुनौती के बाद बनी भाषा

1iq:"tTTY+

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

1       % Push a 1. This will be the first row
iq:     % Take input n. Generate range [1,2,...,n-1]
"       % For each (that is, repeat n-1 times)
  t     %   Duplicate latest row
  TT    %   Push [1 1]
  Y+    %   Convolve latest row with [1 1] to produce next row
        % Implicitly end for each
        % Implicitly display stack contents

— लुइस मेंडो
स्रोत

गैर-प्रतिस्पर्धी लेकिन एक पवित्र आपदा, पिछले सबमिशन (यहां तक कि जे) से कोई भी इसे कम करने में सफल नहीं हुआ कि मैटल ने कितना किया !!!

— अब्रीराम

मुझे पूरा यकीन है कि जेली या 05AB1E छोटी होगी, लेकिन :-)

— लुइस

2

डी 134 128 चरस

import std.stdio;void main(){int n,m;int[]l,k=[0,1];readf("%d",&n);foreach(i;0..n){writeln(l=k~0);k=[];foreach(e;l)k~=m+(m=e);}}

9 के लिए आउटपुट है

>9
[0, 1, 0]
[0, 1, 1, 0]
[0, 1, 2, 1, 0]
[0, 1, 3, 3, 1, 0]
[0, 1, 4, 6, 4, 1, 0]
[0, 1, 5, 10, 10, 5, 1, 0]
[0, 1, 6, 15, 20, 15, 6, 1, 0]
[0, 1, 7, 21, 35, 35, 21, 7, 1, 0]
[0, 1, 8, 28, 56, 70, 56, 28, 8, 1, 0]

"आप इसे पसंद कर सकते हैं, लेकिन इसका पूरा फायदा उठा सकते हैं"; प्रत्येक संख्या और लाइनब्रेक के बीच एक स्थान होता है

संपादन lने कुछ वर्णों की दाढ़ी बनाने के लिए असाइनमेंट को निरस्त कर दिया

— शाफ़्ट सनकी
स्रोत

2

स्काला, 131 वर्ण

object P extends App{var x=List(1)
while(x.size<=args(0).toInt){println(x.mkString(" "))
x=(0+:x:+0).sliding(2).map(_.sum).toList}}

कमांड लाइन से इनपुट लेता है।

N = 10 के लिए आउटपुट:

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1

— गैरेथ
स्रोत

उन सभी के साथ क्या है 0:-)?

— मेलमोकब

@mellamokb री-व्यवस्था के बिट ने उन्हें दूर कर दिया और कोड को छोटा कर दिया। :-)

— गैरेथ

2

F - 203 वर्ण

कोड गोल्फ के एक दौर में मेरा पहला प्रयास, और कार्यात्मक प्रोग्रामिंग में पहला प्रयास। वहाँ शायद कुछ स्पष्ट तरीका है इसे छोटा करने के लिए मुझे अभी तक पता नहीं चला है। यह VS2010s F♯ कंपाइलर (जिसमें पहले के संस्करणों के विपरीत डिफ़ॉल्ट रूप से # लाइट चलाने का प्रभाव है) का अनुपालन करता है, और F works दुभाषिया में भी काम करता है। स्टड के माध्यम से इनपुट स्वीकार करता है। काश इनपुट / आउटपुट के लिए एक बेहतर तरीका होता! पात्रों के बहुत सारे!

open System
let rec C r m =if r=0||m<=0||m>=r then 1 else C(r-1)m+C(r-1)(m-1)
for j = 0 to Convert.ToInt32(Console.ReadLine ()) do (
 [0..j]|>List.map(C j)|>List.iter(fun k->printf "%i " k)
 printf "\n")

— lochok
स्रोत

2

इस प्रश्न का कोई स्वीकृत उत्तर क्यों नहीं है?

VBA - 249 वर्ण

Sub t(n)
ReDim a(1 To n,1 To n*2)
a(1,n)=1:y=vbCr:z=" ":d=z & 1 & z & y:For b=2 To n:For c=1 To n*2:x=a(b-1,c)
If c>1 Then a(b,c)=a(b-1,c-1)+x
If c<n*2 Then a(b,c)=a(b-1,c+1)+x
d=IIf(a(b,c)<>0,d & z & a(b,c) & z,d):Next:d=d & y:Next:MsgBox d
End Sub

— Gaffi
स्रोत

2

पोस्टस्क्रिप्ट - 59 वर्ण (63 यदि आप -dn=पंक्तियों की संख्या प्राप्त करना चाहते हैं)

[1]n{dup ==[0 3 2 roll{dup 3 2 roll add exch}forall]}repeat

साथ दौड़ो

gs -q -dn=10 -dBATCH pascal.ps

लेना

[1]
[1 1]
[1 2 1]
[1 3 3 1]
[1 4 6 4 1]
[1 5 10 10 5 1]
[1 6 15 20 15 6 1]
[1 7 21 35 35 21 7 1]
[1 8 28 56 70 56 28 8 1]
[1 9 36 84 126 126 84 36 9 1]

— ज्योफ की कॉमेडी
स्रोत

2

गणितज्ञ 35 वर्ण

यहाँ पास्कल के त्रिकोण को फिसलने का सुस्त और आलसी तरीका है:

Table[n~Binomial~k,{n,0,5},{k,0,n}]

(* out *)
{{1}, {1, 1}, {1, 2, 1}, {1, 3, 3, 1}, {1, 4, 6, 4, 1}, {1, 5, 10, 10,5, 1}}

— DavidC
स्रोत

2

एपीएल, 19 15 वर्ण

थोड़ी देर पार्टी में, शायद?

{⍪{⍵!⍨⍳⍵+1}¨⍳⍵}

यह जे प्रविष्टि को हरा नहीं करता है, हालांकि।

यह मानता है कि सूचकांक मूल ( ⎕IO) के लिए सेट है 0। दुर्भाग्य से, एक सूचकांक मूल के साथ 1, हमें २५ १ origin अक्षर चाहिए:

{⍪{⍵!⍨0,⍳⍵}¨1-⍨⍳⍵}

⍨मेरी हताशा व्यक्त करने के लिए कोड में दो s हैं ।

डेमो:

      {⍪{⍵!⍨⍳⍵+1}¨⍳⍵}5
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

स्पष्टीकरण

लघु संस्करण:

⍳⍵(0 के एक सूचकांक मूल के साथ) 0 से ⍵-1समावेशी के लिए संख्याओं की एक सरणी पैदा करता है , जहां ⍵फ़ंक्शन के लिए सही तर्क है।
⍳⍵+1 सभी संख्याओं को 0 से उत्पन्न करता है ⍵
{⍵!⍨⍳⍵+1}में प्रत्येक तत्व के लिए ⍵चुनता है । (लघुकरण) ऑपरेटर के चारों ओर एक कार्य करने के लिए तर्क अदला-बदली, ऐसी है कि दाहिने हाथ तर्क विपरीत बाईं, और इसके बन जाता है।kk⍳⍵+1⍨
{⍵!⍨⍳⍵+1}¨⍳⍵(प्रत्येक) ऑपरेटर ⍳⍵का उपयोग करने में प्रत्येक तत्व को पास करता है ¨। परिणाम ⍵पास्कल के त्रिभुज की पहली पंक्तियों वाला एक आयामी सरणी है ।
एक तर्क रूप ⍪एक आयामी वेक्टर लेता है, और इसे एक पंक्ति के बजाय एक स्तंभ बनाता है। त्रिकोण की प्रत्येक पंक्ति को अपनी लाइन पर रखा जाता है।

लंबा जवाब:

वस्तुतः अन्य संस्करण के समान ही, सिवाय इसके कि 0 के सूचकांक मूल को दोहराने 1-⍨से पहले रखा जाता है ⍳।
0,⍳⍵1 के ⍳⍵+1सूचकांक मूल के साथ 0 के सूचकांक मूल के साथ प्रतिकृति होती है।

— अस्थिरता
स्रोत

2

मेपल, ४६

seq(print(seq(binomial(i,k),k=0..i)),i=0..n-1)

उपयोग:

> f:=n->seq(print(seq(binomial(i,k),k=0..i)),i=0..n-1);
> f(3)
    1
   1 1
  1 2 1

— DSkoog
स्रोत

2

VBA, 162 142 102 80 बाइट्स

_{^{टेलर स्कॉट की बदौलत 22 बाइट्स बचाए।}}

_{यह अब एक पुराना प्रश्न है लेकिन मैंने VBA के लिए एक छोटा समाधान देखा।}

[B2].Resize([A1],[A1])="=IF(COLUMN()>ROW(),"""",IF(ROW()=2,1,IFERROR(A1+B1,1)))"

यह तात्कालिक विंडो में चलाने के लिए है। इनपुट A1सक्रिय वर्कशीट की सेल में है। आउटपुट सक्रिय वर्कशीट में शुरू होता है B2और इनपुट के आधार पर हालांकि कई कोशिकाओं की आवश्यकता होती है। COLUMN()>ROW()जांच त्रिकोण खाली के ऊपरी दाएँ भाग रहता है। ROW()=2जांच पहले मूल्य बनाता है 1त्रिकोण आरंभ करने के लिए। मैं आउटपुट को नीचे स्थानांतरित कर सकता था और इस चेक को गिरा सकता था, लेकिन यह वास्तविक त्रिकोण से पहले बहुत अधिक बाहरी आउटपुट पेश करता है और मुझे नहीं लगा कि यह चुनौती की भावना में था।

मैंने मूल रूप से एक बहुत अधिक जटिल तरीका पोस्ट किया है जो इसकी पंक्ति और स्तंभ के आधार पर हर मूल्य की गणना करता है। यह सब विधि, हालांकि, सेल सूत्र का उपयोग करने के लिए है। मैं शुरू करता हूं B2इसलिए मैं #REF!त्रुटियों के बिना इसके ऊपर की पंक्ति को संदर्भित कर सकता हूं । फिर, यह प्रतियां और चिपकाता कोशिकाओं के एक ब्लॉक से अधिक एक ही सूत्र n व्यापक और एन लंबा। इस n=25तरह दिखता है इनपुट और आउटपुट :

— इंजीनियर टोस्ट
स्रोत

बहुत अच्छा जवाब है, लेकिन आप इसे थोड़ा सा गोल्फ कर सकते हैं। परिवर्तित Function p(r)करने के लिए Sub p(r)जब से तुम कोई समारोह उत्पादन मूल्य है, से अंतरिक्ष को दूर करने debug.? c(n,k);और बहु परिवर्तित if-then-elseएक पंक्ति (करने के लिए बयान If k Then c=c(n-1,k-1)*n/k Else c=1) लाता है करने के लिए नीचे बाइट-गिनती 130मेरी गिनती से

— टेलर स्कॉट

@TaylorScott धन्यवाद! मैं गोल्फ में बहुत नया हूँ और सामान्य रूप से प्रोग्रामिंग में केवल थोड़ा कम नया हूँ। लाइन टूटने के कारण मैंने 142 की गिनती की। से मैं क्या मिल सकता है , उन गिनती करने वाले हैं।

— इंजीनियर टोस्ट

आह, आप सही हैं, मैं अपनी नई कहानियों को गिनना भूल गया, और जैसा कि यह पता चला है, कम से कम एक अन्य गोल्फिंग चाल को कोड के मेरे संस्करण For n=0 To...को For n=0To...लाने के लिए घनीभूत किया जा सकता है Sub p(r):For n=0To r-1:For k=0To n:Debug.?c(n,k);:Next:Debug.?:Next:End Sub Function c(n,k):If k Then c=1 Else c=c(n-1,k-1)*n/k[चार (10)] End Functionबाइट की गिनती के साथ139

— टेलर स्कॉट

इस पर एक दूसरे देखो पता चलता है कि अगर आप इसे तोड़ने एक सहायक समारोह के साथ एक तत्काल खिड़की समारोह में, आप इसे नीचे 112 बाइट्स करने के लिए प्राप्त कर सकते हैं (तत्काल खिड़की फंक्शन: For n=0To[A1-1]:For k=0To n:?c(n,k);:Next:?:Nextहेल्पर फंक्शन: Function c(n,k) If k Then c=c(n-1,k-1)*n/k Else c=1 End Function)

— टेलर स्कॉट

1

@TaylorScott उन्हें पूरी तरह से छोड़ने के बारे में क्या? सूत्र में परिवर्तन के साथ, यह ठीक काम करता है। मुझे लगता है कि B2इसके बजाय शुरू होने वाला आउटपुट A1स्वीकार्य है।

— इंजीनियर टोस्ट

2

05AB1E , 14 बाइट्स

FN©>F®Ne})ˆ}¯»

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

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

— जादू ऑक्टोपस Urn
स्रोत

पास्कल के त्रिकोण उत्पन्न करें

चुनौती

उदाहरण I / O

जे , 12 वर्ण

पायथन, 56 बाइट्स

पायथन, 94 91 88 70 63 वर्ण

गणितज्ञ: 36 (41?)

C, 522

गोल्फस्क्रिप्ट (21 वर्ण)

हास्केल, 94 92

स्काला, 81 78 72 70 वर्ण

रूबी: ५१ ४ ९ ४६ अक्षर

जावास्क्रिप्ट ( 90 85 83 81)

आर, 39 वर्ण

क्यू में (25 अक्षर / 20 छोटे संस्करण के साथ)

awk - 73 वर्ण

पर्ल, 52 , 49 अक्षर

पर्ल, 47 54 वर्ण

केजी , 40 बाइट्स

व्याख्या की

पर्ल, 77 चार्ज

C, 132 127 अक्षर

पास्कल: 216 192 अक्षर

MATL , 10 बाइट्स

डी 134 128 चरस

स्काला, 131 वर्ण

F - 203 वर्ण

VBA - 249 वर्ण

गणितज्ञ 35 वर्ण

एपीएल, 19 15 वर्ण

मेपल, ४६

VBA, 162 142 102 80 बाइट्स

05AB1E , 14 बाइट्स