How can I modify my program to print out Pascal's triangle? - perl

Question

So first of all Pascal's Triangle looks like this:
The first row that you see is the zero-ith row.
That's nothing unusual
when you are a computer scientist.
Each term in Pascal's triangle can be predicted with a combination with the formula:
C(n, k) = n! / [k! * (n - k)!], where "n" is the row and "k" is any integer from zero to n.
So thus it follows that Pascal's triangle can be predicted with (n, k) combinations:
And that's what you are seeing in the figure above.
Pascal's triangle is basically binomial probability:
(H + T)^n # You flip a two sided coin "n" times and it lands on "heads" or "tails" and you collect the frequency of each in a set of coefficients, for n = 3, we get the expansion:
(H + T)^3 = 1(H^3) + 3(H^2)(T) + 3(H)(T^2) + 1(T^3), where those coefficients:
1, 3, 3, 1 are in row 3 of Pascal's triangle.
I defined a factorial (!), and a combination and was able to get the
coefficient numbers on any row of Pascal's triangle with some looping Perl code:
use strict;
use warnings;
# Note the first row is row 0.
print("\nWhich row of Pascal's triangle to display: ");
my $row = <STDIN>; # The row that you want to display # This is also n.
my $terms = $row + 1; # The number of terms is one more than the row number.
Pascal_Row($row); # Print the Pascal numbers for that row.
# Function displays the numbers for a row of Pascal's triangle.
#######################################################
sub Pascal_Row
{
my $row = shift; # Row is passed in.
for(my $k = 0; $k < $row + 1; $k++) # k alternates, but not the row which is n.
{
print(combination($row, $k), "\t") # Print each row.
}
print("\n"); # Print a newline after each time this function is called.
}
# This computes the factorial of a number.
###########################################
sub factorial
{
my $number = shift; # argument.
my $factorial_number = 1; # initalize the factorial.
for(my $i = 1; $i <= $number; $i++)
{
$factorial_number *= $i; # compute the factorial, by multiplying all terms up to and including number.
}
return $factorial_number; # Return the factorial number.
}
# Computes a matehmatical combination usually denoted as C(n, k)
# where n is the row number, and k is each item in a row of Pascal's traingle
sub combination
{
my($n, $k) = #_; # from input.
# This is the mathematical formula for a combination.
my $combination_number = factorial($n) / (factorial($k) * factorial($n - $k));
return $combination_number # And returning it.
}
If I run the code and ask for row 8 of Pascal's triangle I get this:
Which row of Pascal's triangle to display: 8
1 8 28 56 70 56 28 8 1
That's entirely true for row 8 of Pascal's triangle. If I were to loop this from row 0 to the row 8 of Pascal's triangle I would get all correct rows of Pascal's triangle, but it wouldn't look like a triangle (it would look more like a box), so how could I modify my code to adjust the indenting.
How do I decide how much to indent the first row if I want 8 rows of Pascal's triangle displayed? How can I make a "triangle"?

Answer 1

Left-aligned triangle:
my $MAX_VAL_SIZE = 5;
for my $n (0...$N) {
my #row;
for my $k (0..$n) {
push #row, C($n, $k);
}
say join " ", map sprintf("%*d", $MAX_VAL_SIZE, $_), #row;
}
Centered triangle:
sub center {
my ($n, $s) = #_;
my $pad_len = $n - length($s);
my $pad_len_l = int($pad_len/2);
my $pad_len_r = $pad_len - $pad_len_l;
return ( " " x $pad_len_l ) . $s . ( " " x $pad_len_r );
}
my $MAX_VAL_SIZE = 5;
for my $n (0...$N) {
my #row;
for my $k (0..$n) {
push #row, C($n, $k);
}
my $row = join " ", map center($MAX_VAL_SIZE, $_), #row;
say center(($N+1)*($MAX_VAL_SIZE+2)-2, $row);
}

Answer 2

This is tricky since the varying width of numbers matters for layout.
Each row need be indented by half the separation between numbers in the row, suitably multiplied (zero for last row, rows-1 for first) -- that is, if numbers themselves were all of equal width.
But this isn't the case, except for the first few rows; the numbers take varying amount of space. One remedy is to use fixed-width for numbers and adjust indent and separation using that width.
All rows are computed first so that the maximum width of a number can be found.
use warnings;
use strict;
use feature 'say';
use List::Util qw(max);
my $max_row = (shift || 8);
my #rows = map { pascal_row($_) } 0..$max_row-1;
my $max_num_wd = max map { length } #{$rows[-1]};
my $pad = 1; # choice (must be non-zero)
my $sep = ' ' x ($max_num_wd + 2*$pad);
my $lead_sp = ' ' x ($max_num_wd + $pad);
for my $n (0..$#rows) {
say $lead_sp x ($max_row-1-$n),
join $sep, map { sprintf "%${max_num_wd}d", $_ } #{$rows[$n]};
}
sub pascal_row {
my ($row) = #_;
return [ map { n_over_k($row, $_) } 0..$row ];
}
sub n_over_k {
my ($n, $k) = #_;
return factorial($n) / (factorial($k) * factorial($n - $k));
}
sub factorial {
my ($n) = #_;
my $fact = 1;
$fact *= $_ for 2..$n;
return $fact;
}
This prints the correct layout. The $pad is an arbitrary integer for extra space over the maximum number width, for indent and separation; it must be >0 to coordinate them. (Separation needs that space both left and right of the centered number in the row above, thus the factor of 2.)
Original code, printing as it computes so $max_num_wd is set ahead by hand
# (includes and subs same as above except for List::Util)
my $max_row = (shift || 8);
my $max_num_wd = 4; # maximum width of numbers
my $pad = 1; # choice (non-zero)
my $sep = ' ' x ($max_num_wd + 2*$pad);
my $lead_sp = ' ' x ($max_num_wd + $pad);
for my $n (0..$max_row-1) {
my #row = #{ pascal_row($n) };
say $lead_sp x ($max_row-1-$n),
join $sep, map { sprintf "%${max_num_wd}d", $_ } #row;
}
This prints a correct layout with numbers up to 4-digits wide, or $max_num_wd need be adjusted.

Answer 3

Here is another way of doing it:
use strict;
use warnings;
sub fact {
my $n = shift;
return 1 if $n < 1;
return $n * fact($n - 1);
}
sub n_over_k {
my $n = shift;
my $k = shift;
return fact($n) / ( fact($k) * fact($n - $k) );
}
sub pascal_row {
my $n = shift;
return map { n_over_k($n - 1, $_) } (0 .. $n - 1);
}
my $n = shift || 8;
# $maxw is the first odd width where the biggest number will fit
my $max = 0;
map { $max = $_ if $_ > $max } pascal_row($n);
my $maxw = length('' . $max);
$maxw += ($maxw + 1) % 2;
# Print the Pascal´s triangle
foreach my $i (1..$n) {
print ' ' x ( ( $maxw + 1 ) * ($n - $i) / 2 );
foreach my $j ( pascal_row($i) ) {
printf "%${maxw}d ", $j;
}
print "\n";
}
How is it done? Fit each number within the first odd width where the max of the numbers to print will fit. That´s because numbers are separated with a space and that will make each width even (and so divisible by two for odd-valued triangle rows.) Then use printf to format the numbers. For instance %5d will right align the number within 5 characters. Precede each line except the last with the necessary spaces using ' ' x N which generates a string of N spaces.
Pascal's triangle of 8:
# pascal.pl 8
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
Pascal's triangle of 13:
# pascal.pl 13
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
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1

Answer 4

You can generate the triangle without any combinatoric formulas.
The reason to do it this way is that this is the most effective method.
The basic idea is to employ the observation, that the value in the next
row is the sum of 2 elements located above.
This solution is also a good example of how to work with an array of
(references to) arrays.
An interesting feature is that the indent is computed from the
middle element in the last row (with the greatest value).
To provide pretty look of the triangle, the cell size must be an even number.
The "basic" indent is the half of this size.
The actual indent for each row is this basic size, multiplied by a respective
number, derived from the row index and the total number of rows.
The whole script is given below:
use strict;
use warnings;
use feature qw(say);
use POSIX qw(ceil);
my $rowCnt = 14; # How many rows
say "Pascal Triangle with $rowCnt rows:";
# Rows container, filled with a single row (containing single 1)
my #rows = ([ 1 ]);
my ($lastRow, $row, $ind);
# Generate / add further rows
for ($ind = 1; $ind < $rowCnt; $ind++) {
$lastRow = $rows[$#rows]; # Last row gathered so far
push(#rows, getNextRow($lastRow));
}
$lastRow = $rows[$#rows];
# Middle elem. of the last row
my $midElem = $$lastRow[($rowCnt - 1) / 2];
# No of digits + separator, rounded up to even
my $elemSize = ceil((length($midElem) + 1) / 2) * 2;
my $shf = $elemSize / 2; # Shift size for a sigle step
# Print rows
for ($ind = 0; $ind < $rowCnt; $ind++) {
my $row = $rows[$ind];
my $spc = $shf * ($rowCnt - $ind - 1);
printRow($spc, $row, $elemSize);
}
sub getNextRow { # Create the next row and return the reference to it
my $lastRow = $_[0]; # Read param
my #row = (1); # Start the new row from a single 1
for (my $i = 0; $i < $#$lastRow; $i++) {
push(#row, $$lastRow[$i] + $$lastRow[$i + 1]);
}
push(#row, 1); # Add terminating 1
return \#row; # Result - reference to the created row
}
sub printRow { # Print a row of the triangle
my ($leadSpc, $row, $elemSize) = #_; # Read params
# Leading spaces and the initial element (always 1)
printf("%s1", ' ' x $leadSpc);
# Print the rest of the row
for (my $i = 1; $i <= $#$row; $i++) {
printf("%*d", $elemSize, $$row[$i]);
}
print("\n");
}