32
\$\begingroup\$

Pascal's triangle is generated by starting with a 1 on the first row. On subsequent rows, the number is determined by the sum of the two numbers directly above it to the left and right.

To demonstrate, here are the first 5 rows of Pascal's triangle:

    1
   1 1
  1 2 1
 1 3 3 1
1 4 6 4 1

The Challenge

Given an input n (provided however is most convenient in your chosen language), generate the first n rows of Pascal's triangle. You may assume that n is an integer inclusively between 1 and 25. There must be a line break between each row and a space between each number, but aside from that, you may format it however you like.

This is code-golf, so the shortest solution wins.

Example 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
\$\endgroup\$
  • \$\begingroup\$ NB In a sense this is a simplified version of Distributing the balls \$\endgroup\$ – Peter Taylor Oct 21 '11 at 11:03
  • \$\begingroup\$ @Peter Olson: What's your opinion of ratchet freak's interpretation of "you may format it however you like"? If I followed his interpretation I could shave 18 characters. \$\endgroup\$ – Steven Rumbalski Oct 21 '11 at 20:57
  • \$\begingroup\$ @StevenRumbalski He's fine. There's a newline between each row, and there is a space between each number, so it meets the criteria. \$\endgroup\$ – Peter Olson Oct 21 '11 at 21:32
  • \$\begingroup\$ @Peter Olson: Thanks for the clarification. What about Tomas T's assumption that n is defined already? \$\endgroup\$ – Steven Rumbalski Oct 21 '11 at 21:50
  • 2
    \$\begingroup\$ @Gaffi Probably not, accepting an answer makes me feel like I'm ending the contest and discouraging new and possibly better answers. \$\endgroup\$ – Peter Olson Jun 8 '12 at 4:05

45 Answers 45

30
\$\begingroup\$

J, 12 characters

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

   i.5
0 1 2 3 4
   {:i.5
4
   (i.5)!{:i.5
1 4 6 4 1
   (!{:)i.5
1 4 6 4 1
   (!{:)\i.5
1 0 0 0 0
1 1 0 0 0
1 2 1 0 0
1 3 3 1 0
1 4 6 4 1
   ":@(!{:)\i.5
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
   (":@(!{:)\@i.)`''
+----------------------------------+
|+-+------------------------------+|
||@|+-------------------------+--+||
|| ||+-+---------------------+|i.|||
|| |||\|+-------------------+||  |||
|| ||| ||+-+---------------+|||  |||
|| ||| |||@|+--+----------+||||  |||
|| ||| ||| ||":|+-+------+|||||  |||
|| ||| ||| ||  ||2|+-+--+||||||  |||
|| ||| ||| ||  || ||!|{:|||||||  |||
|| ||| ||| ||  || |+-+--+||||||  |||
|| ||| ||| ||  |+-+------+|||||  |||
|| ||| ||| |+--+----------+||||  |||
|| ||| ||+-+---------------+|||  |||
|| ||| |+-------------------+||  |||
|| ||+-+---------------------+|  |||
|| |+-------------------------+--+||
|+-+------------------------------+|
+----------------------------------+
\$\endgroup\$
  • 1
    \$\begingroup\$ J beats GolfScript? Interesting. I would like to see an explanation for this code, if you have time. \$\endgroup\$ – Mr.Wizard Oct 26 '11 at 9:31
  • 4
    \$\begingroup\$ It's already split down, but here's a line by line if you'd like additional english. Line 1 i.5 returns the first five naturals. Line 2 adds {: "Tail" (return last). Line 3 combines them with ! "Out Of" (number of combinations). Line 4 (!{:)i.5 is the same. factoring the hook out. So (!:) is an operation that transforms the first n naturals to the nth line of Pascal's triangle. Line 5 applies it to all Prefixes (backslash) of 0..4, but J fills in the unused spots with 0, so the operation is combined (@) with the string formatting operation ":. Very cool J, upvoted. \$\endgroup\$ – J B Nov 2 '11 at 14:51
  • \$\begingroup\$ @JB Isn't ! means factorial here? Also we can get rid of @ at the right. \$\endgroup\$ – defhlt Aug 15 '12 at 14:35
  • \$\begingroup\$ @ArtemIce Monadic ! means factorial; dyadic ! counts combinations. The final @ in ":@(!{:)\@i. is just there to make this a stand-alone verb. \$\endgroup\$ – ephemient Aug 15 '12 at 14:38
17
\$\begingroup\$

Python, 56 Bytes

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

Sample usage:

echo 9 | python filename.py

Produces:

[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]
\$\endgroup\$
  • 1
    \$\begingroup\$ +1 Clever way to use exec avoid a for loop. \$\endgroup\$ – Steven Rumbalski Nov 23 '11 at 18:00
15
\$\begingroup\$

Python, 94 91 88 70 63 characters

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

Mathematica: 36 (41?)


Mathematica has the Binomial function, but that takes the fun out of this. I propose:

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

The line above will render a ragged array such as:

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

Since this is a basic format in Mathematica I thought it would be acceptable, but as I read the rules again, I think it may not be. Adding Grid@ will produce unequivocally acceptable output, for a total of 41 characters:

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
\$\endgroup\$
13
\$\begingroup\$

C, 522

A self demonstrating C answer. Couldn't be clearer! Bonus points for finding the extra character.

#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; }
\$\endgroup\$
  • 4
    \$\begingroup\$ I can't help but feel that this misses the point of code golf. (I also can't help pointing out that the extra character is in the \binom{5}{4} position). \$\endgroup\$ – Peter Taylor Jun 6 '12 at 16:11
  • 2
    \$\begingroup\$ It was fun to write. That's generally what I come to codegolf for. \$\endgroup\$ – walpen Jun 6 '12 at 21:03
  • 1
    \$\begingroup\$ Clever :) Have an upvote. Maybe not a winner candidate but a creative one! \$\endgroup\$ – Accatyyc Aug 10 '12 at 13:02
11
\$\begingroup\$

Golfscript (21 chars)

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

Since an explanation was requested:

# 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
;
\$\endgroup\$
  • \$\begingroup\$ You might want to try golf.shinh.org/p.rb?pascal+triangle \$\endgroup\$ – Nabb Oct 22 '11 at 3:31
  • \$\begingroup\$ Could you please provide some pseudo-code or explanation? I kind of understand what's going on, but I'm not entirely understanding the swapping part. \$\endgroup\$ – Rob Aug 10 '12 at 2:50
  • \$\begingroup\$ Thank you for the detailed explanation and excellent answer (+1), but I'm even more confused now. The logic (process) isn't sitting right. \$\endgroup\$ – Rob Aug 10 '12 at 19:03
  • \$\begingroup\$ @MikeDtrick, there was a slight error in the explanation. There's also a subtle point which needed explaining, but which I'd missed because it's so long since I wrote the code. \$\endgroup\$ – Peter Taylor Aug 10 '12 at 19:23
  • \$\begingroup\$ Okay, it's starting to make sense. My final question be does the printing and executing process work from the top down or the bottom up (1, 1 1, 1 2 1: top down, 1 2 1, 1 1, 1: bottom up)? \$\endgroup\$ – Rob Aug 11 '12 at 2:40
7
\$\begingroup\$

Haskell, 94 92

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

Output:

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

A 71 character version which does not print a space between each number:

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

Output:

[1]
[1,1]
[1,2,1]
[1,3,3,1]
\$\endgroup\$
  • \$\begingroup\$ You can save a character by using mapM instead of mapM_. \$\endgroup\$ – dfeuer Feb 25 at 4:23
7
\$\begingroup\$

Scala, 81 78 72 70 characters

81 chars: first attempt, shamelessly copied from the Python version :)

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

Run it as a script, or directly in the REPL.

Cut to 70 chars with something surprisingly readable and idiomatic:

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

Or 72 70 characters with a totally different method:

0 to(readInt-1)map(i=>println(0 to i map(1 to i combinations(_)size)))
\$\endgroup\$
  • \$\begingroup\$ + 1 for shameless copying! \$\endgroup\$ – Steven Rumbalski Oct 25 '11 at 21:23
  • \$\begingroup\$ The last version should be used carefully for huge values of readInt, like 50. ;) \$\endgroup\$ – user unknown May 31 '12 at 22:16
  • \$\begingroup\$ @userunknown presumably that's why the question specifies an upper limit of 25... \$\endgroup\$ – Luigi Plinge May 31 '12 at 22:25
  • \$\begingroup\$ It wasn't meant as critique, just as a warning for the curious. \$\endgroup\$ – user unknown May 31 '12 at 22:41
5
\$\begingroup\$

JavaScript (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)

Demo: http://jsfiddle.net/tcRCS/3/

NOTE: Doesn't work well in practice for about n > 30 because numbers overflow built-in integer data type and become floating-point numbers.


Edit 1: removed 5 characters by converting while to for and combining statements

Edit 2: move s= statement inside for and save 2 chars

Edit 3: combine s=1,j=1 initializer into s=j=1 and save 2 chars

\$\endgroup\$
  • \$\begingroup\$ Nice! You can save one more character by changing "s=s*..." to "s*=..." \$\endgroup\$ – Derek Kurth Oct 25 '11 at 19:41
  • \$\begingroup\$ @DerekKurth: I had thought that when I was first doing optimizations, but that would mess up the logic because it needs to be s*(i-j)/j, not s*((i-j)/j). \$\endgroup\$ – mellamokb Oct 25 '11 at 19:49
  • \$\begingroup\$ Hmm, I tried it as s*=... in the jsfiddle and it seemed to work. Maybe I did something wrong, though. \$\endgroup\$ – Derek Kurth Oct 25 '11 at 20:16
  • 1
    \$\begingroup\$ @DerekKurth: Technically it is the same, but the idea is that if you multiply by (i-j) before dividing by j, then there is no need for floating point arithmetic because the results should always be an integer. If you do ((i-j)/j) first, this will result in decimal values which can be a source of error, and at the very least will require extra code for rounding/truncating. You don't begin to see this until you get to about n>11, and you'll see decimal values in the output, i.e., 1 11 55 165 330 461.99999999999994 461.99999999999994... \$\endgroup\$ – mellamokb Oct 25 '11 at 21:47
  • \$\begingroup\$ Ah, that makes sense! \$\endgroup\$ – Derek Kurth Oct 25 '11 at 22:10
5
\$\begingroup\$

R, 39 chars

R seems to be the very right tool for this task :-)

x=1;for(i in 1:n)x=c(print(x),0)+c(0,x)
\$\endgroup\$
  • 3
    \$\begingroup\$ You're missing one of the requirements: "Given an input n (provided however is most convenient in your chosen language)" \$\endgroup\$ – Steven Rumbalski Oct 21 '11 at 20:59
  • \$\begingroup\$ @Steven, "Given an input n"... so may I assume the n is given? I corrected the code. Is this now OK? \$\endgroup\$ – Tomas Oct 21 '11 at 21:38
  • \$\begingroup\$ I'm asked Peter Olson to clarify. \$\endgroup\$ – Steven Rumbalski Oct 21 '11 at 21:52
  • \$\begingroup\$ @StevenRumbalski I don't think that's valid unless it takes input. I don't know R, so maybe the compiler makes it so that undefined variables prompt an input, so it might be ok, but if it's like most other languages in that regard, I don't think it is. \$\endgroup\$ – Peter Olson Oct 22 '11 at 0:04
  • 1
    \$\begingroup\$ Basically, the n must be supplied from an external source at run time and the apparatus for capturing it is included in your program. Typically, that means by command line argument, or stdin, or file. By file is almost never used because it's invariably longer than the other two options. \$\endgroup\$ – Steven Rumbalski Oct 24 '11 at 13:01
5
\$\begingroup\$

in Q (25 characters/20 with shorter version)

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

Shorter

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

Sample usage:

q)t 4
1
1 1
1 2 1
1 3 3 1
\$\endgroup\$
  • \$\begingroup\$ Or alternatively, 20 characters t:{(x-1){0+':x,0}\1} \$\endgroup\$ – skeevey Mar 8 '12 at 20:35
  • \$\begingroup\$ Nice, shorter than the GolfScript solution now. \$\endgroup\$ – sinedcm Mar 9 '12 at 12:10
5
\$\begingroup\$

Ruby: 51 49 46 characters

(45 characters code + 1 character command line option)

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

Thanks to:

  • jsvnm for suggesting an alternative for the value switching (2 characters)
  • G B for spotting out a variable unused after previous improvement (4 characters)

Sample run:

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]

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ you can save 2 chars with p.map!{|i|(v=n)+n=i} \$\endgroup\$ – jsvnm Aug 10 '12 at 11:21
  • \$\begingroup\$ Great one, @jsvnm! Man, how long I combined to shorten that part. Thanks. \$\endgroup\$ – manatwork Aug 10 '12 at 11:44
  • 1
    \$\begingroup\$ Maybe a little late, but: why use the variable v? \$\endgroup\$ – G B Dec 15 '17 at 8:08
  • \$\begingroup\$ Good catch, @GB! That left behind from 1st revision, where… where… doh. Where was also kind of useless. I guess it comes from an earlier attempt when used .map. Thank you. \$\endgroup\$ – manatwork Dec 15 '17 at 9:07
4
\$\begingroup\$

awk - 73 chars

fairly straightforward implementation:

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

sample run:

% 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
\$\endgroup\$
4
\$\begingroup\$

Perl, 52, 49 characters

Edit: using say instead of print

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

Perl, 47 54 characters

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

It takes a number from the command line, but doesn't perform any error checks.

Just realized it only works up to n=4. It was some old code I had on my hd.

This works though:

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

n has to be input into the script though, or it would be one character more.

\$\endgroup\$
3
\$\begingroup\$

Perl, 77 Chars

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

Example input

5

Example output

 1
 1 1
 1 2 1
 1 3 3 1
 1 4 6 4 1
\$\endgroup\$
3
\$\begingroup\$

C, 132 127 characters

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);}
\$\endgroup\$
3
\$\begingroup\$

Pascal: 216 192 characters

(Not a real competitor, just an honorific presence.)

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.

Sample run:

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 
\$\endgroup\$
3
\$\begingroup\$

MATL, 10 bytes

Language created after this challenge

1iq:"tTTY+

Try it online!

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
\$\endgroup\$
  • \$\begingroup\$ non-competing but a holy disaster, none from previous submissions (even J) succeeded to reduce it up to how much Matl did !!! \$\endgroup\$ – Abr001am May 21 '16 at 9:09
  • \$\begingroup\$ I'm pretty sure Jelly or 05AB1E would be shorter though :-) \$\endgroup\$ – Luis Mendo May 21 '16 at 10:34
2
\$\begingroup\$

D 134 128 chars

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);}}

output for 9 is

>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]

taking full advantage of "you may format it however you like"; there is a space between each number and a linebreak

edit repositioned the assignment to l to shave of some chars

\$\endgroup\$
2
\$\begingroup\$

Scala, 131 characters

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

Takes the input from the command line.

Output for 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
\$\endgroup\$
  • \$\begingroup\$ What's with all those 0s :-)? \$\endgroup\$ – mellamokb Oct 20 '11 at 22:23
  • \$\begingroup\$ @mellamokb Bit of re-arranging made them go away and shortened the code. :-) \$\endgroup\$ – Gareth Oct 20 '11 at 22:28
2
\$\begingroup\$

F♯ - 203 characters

My first attempt at a round of code golf, and first attempt at functional programming. There is probably some obvious way to shorten it I haven't quite figured out yet. It complies in VS2010s F♯ compiler (which has the effect of running #light by default unlike earlier versions), and also works in the F♯ interpreter. Accepts input via stdin. Wish there was a better way for the input/output though! Lots of characters!

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")
\$\endgroup\$
2
\$\begingroup\$

Why is there no accepted answer to this question?

VBA - 249 chars

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
\$\endgroup\$
2
\$\begingroup\$

postscript - 59 chars (63 if you count -dn= to get the number of rows in)

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

run with

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

to get

[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]
\$\endgroup\$
2
\$\begingroup\$

Mathematica 35 chars

Here is the dull and lazy way of slicing Pascal's triangle:

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}}
\$\endgroup\$
2
\$\begingroup\$

APL, 19 15 characters

A bit late to the party, perhaps?

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

It doesn't beat the J entry, though.

This assumes that the index origin (⎕IO) is set to 0. Unfortunately, with an index origin of 1, we need 25 18 characters:

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

There are two s in the code to express my frustration.

Demo:

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

Explanations

Short version:

  • ⍳⍵ (with an index origin of 0) produces an array of the numbers from 0 to ⍵-1 inclusive, where is the right argument to the function.
  • ⍳⍵+1 generates all numbers from 0 to
  • {⍵!⍨⍳⍵+1} generates choose k for every element k in ⍳⍵+1. The (commute) operator swaps the arguments to a function around, such that the right hand argument becomes the left, and vice versa.
  • {⍵!⍨⍳⍵+1}¨⍳⍵ passes each element in ⍳⍵ using the ¨ (each) operator. The result is a one dimensional array containing the first rows of the Pascal's Triangle.
  • The one argument form of takes a one dimensional vector, and makes it a column rather than a row. Each row of the triangle is put on its own line.

Long answer:

  • Virtually the same as the other version, except that 1-⍨ is placed before an to replicate an index origin of 0.
  • 0,⍳⍵ with an index origin of 1 replicates ⍳⍵+1 with an index origin of 0.
\$\endgroup\$
2
\$\begingroup\$

VBA, 162 142 102 80 bytes

Saved 22 bytes thanks to Taylor Scott.

This is an old question now but I saw a shorter solution for VBA.

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

This is meant to be run in the immediate window. Input is in cell A1 of the active worksheet. Output is in the active worksheet starting at B2 and using however many cells are required based on the input. The COLUMN()>ROW() check keeps the top right of the triangle blank. The ROW()=2 check makes the first value 1 to initiate the triangle. I could have shifted the output down and dropped this check, but it introduces a lot of extraneous output before the actual triangle and I didn't feel that it was in the spirit of the challenge.

I originally posted a much more complicated method that calculated every value based on its row and column. All this method does, though, is to use in-cell formulas. I start at B2 so I can reference the row above it without #REF! errors. Then, it copies and pastes the same formula over a block of cells n wide and n tall. The input and output for n=25 looks like this:

Output

\$\endgroup\$
  • \$\begingroup\$ Very cool answer, but you can golf this quite a bit. Converting Function p(r) to Sub p(r) since you have no function output value, removing the space from debug.? c(n,k); and converting the multiline if-then-else statement to a single line (If k Then c=c(n-1,k-1)*n/k Else c=1) brings the byte-count down to 130 by my count \$\endgroup\$ – Taylor Scott Mar 28 '17 at 21:43
  • \$\begingroup\$ @TaylorScott Thanks! I'm pretty new at golfing and only slightly less new to programming in general. I counted 142 because of the line breaks. From what I could find, those are supposed to count. \$\endgroup\$ – Engineer Toast Mar 29 '17 at 12:08
  • \$\begingroup\$ Ah, you are right, I did forget to count my newlines, and as it turns out, at least one other golfing trick For n=0 To... can be condensed to For n=0To... bringing my version of the code to 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 [char(10)] End Function with a byte count of 139 \$\endgroup\$ – Taylor Scott Mar 30 '17 at 2:44
  • \$\begingroup\$ A second look at this suggests that if you break it down into an immediate window function with a helper function, you can get it down to 112 Bytes (Immediate Window Function: For n=0To[A1-1]:For k=0To n:?c(n,k);:Next:?:Next Helper Function: Function c(n,k) If k Then c=c(n-1,k-1)*n/k Else c=1 End Function) \$\endgroup\$ – Taylor Scott Sep 18 '17 at 1:57
  • 1
    \$\begingroup\$ @TaylorScott What about just dropping them entirely? With a change in the formula, it works just fine. I think that output starting at B2 instead of A1 is acceptable. \$\endgroup\$ – Engineer Toast Sep 20 '17 at 12:23
2
\$\begingroup\$

05AB1E, 14 bytes

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

Try it online!


1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
\$\endgroup\$
1
\$\begingroup\$

Python 105 chars

A=[1]
for i in range(input()):
    B=[sum(A[j:j+2])for j in range(i)]
    B[:0]=[1]
    B[i+1:]=[1]
    print A
    A=B
\$\endgroup\$
  • 2
    \$\begingroup\$ You can spare 4 characters with list slice: replace B.insert(0,1) with B[:0]=[1]. \$\endgroup\$ – manatwork May 23 '12 at 17:51
  • \$\begingroup\$ Yeah! I'm not a very advanced python programmer. And I've changed both of them. \$\endgroup\$ – Rushil Paul May 23 '12 at 19:31
1
\$\begingroup\$

Maple, 46

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

Usage:

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

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.