Gould’s Sequence

Given a positive Integer n, The task is to print Gould’s sequence up to nth term.

In Mathematics, Gould’s sequence is an integer sequence whose nth term tells the count of odd numbers in n-1th row of the pascal triangle. This sequence is consist of only power’s of 2.

For Example:

Row Number                Pascal's tringle                 count of odd numbers in ith row
0th row                             1                                         1    
1st row                           1   1                                       2    
2nd row                         1   2   1                                     2    
3rd row                       1   3   3   1                                   4    
4th row                     1   4   6   4   1                                 2   
5th row                   1   5   10  10  5   1                               4   
6th row                 1   6   15  20  15  6   1                             4   
7th row               1   7   21  35  35  21  7   1                           8 
8th row             1  8   28   56  70   56  28  8  1                         2 
9th row           1   9  36  84  126  126  84  36  9  1                       4  
10th row        1  10  45  120 210  256  210 120 45 10  1                     4 

So first few terms of Gould’s sequence are-

1, 2, 2, 4, 2, 4, 4, 8, 2, 4, 4, 8, 4, 8, 8, 16, 2, 4, 4, 8, 4, 8, 8, 16, 4, 8, 8, 16, 8, 16, 16, 32

A Simple Solution to generate Gould’s sequence is to generate every row of pascal’s triangle from 0th row to nth row and count odd numbers appearing in each row.
ith element of nth row can be calculated easily by calculating binomial coefficient C(n, i).
For More detail about this approach Refer This –Pascal’s triangle.
Below is the implementation of above idea

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to generate
// Gould's Sequence
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to generate gould's Sequence
void gouldSequence(int n)
{
    // loop to generate each row
    // of pascal's Triangle up to nth row
    for (int row_num = 1; row_num <= n; row_num++) {
  
        int count = 1;
        int c = 1;
  
        // Loop to generate each element of ith row
        for (int i = 1; i <= row_num; i++) {
  
            c = c * (row_num - i) / i;
  
            // if c is odd
            // increment count
            if (c % 2 == 1)
                count++;
        }
  
        // print count of odd elements
        cout << count << " ";
    }
}
  
// Driver code
int main()
{
  
    // Get n
    int n = 16;
  
    // Function call
    gouldSequence(n);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// JAVA program to generate
// Gould's Sequence
  
class GFG {
  
    // Function to generate gould's Sequence
    static void gouldSequence(int n)
    {
        // loop to generate each row
        // of pascal's Triangle up to nth row
        for (int row_num = 1; row_num <= n; row_num++) {
  
            int count = 1;
            int c = 1;
  
            // Loop to generate each element of ith row
            for (int i = 1; i <= row_num; i++) {
  
                c = c * (row_num - i) / i;
  
                // if c is odd
                // increment count
                if (c % 2 == 1)
                    count++;
            }
  
            // print count of odd elements
            System.out.print(count + " ");
        }
    }
  
    // Driver code
    public static void main(String[] args)
    {
  
        // Get n
        int n = 16;
  
        // Function call
        gouldSequence(n);
    }
}

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 program to generate
# Gould's Sequence
  
# Function to generate gould's Sequence
def gouldSequence(n):
  
    # loop to generate each row
    # of pascal's Triangle up to nth row
    for row_num in range (1, n): 
      
        count = 1
        c = 1
  
        # Loop to generate each 
        # element of ith row
        for i in range (1, row_num):
            c = c * (row_num - i) / i
  
            # if c is odd
            # increment count
            if (c % 2 == 1):
                count += 1
  
        # print count of odd elements
        print(count, end = " ")
          
# Driver code
  
# Get n
n = 16;
  
# Function call
gouldSequence(n)
  
# This code is contributed 
# by Akanksha Rai

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to generate
// Gould's Sequence
  
using System;
class GFG {
  
    // Function to generate gould's Sequence
    static void gouldSequence(int n)
    {
        // loop to generate each row
        // of pascal's Triangle up to nth row
        for (int row_num = 1; row_num <= n; row_num++) {
  
            int count = 1;
            int c = 1;
  
            // Loop to generate each element of ith row
            for (int i = 1; i <= row_num; i++) {
  
                c = c * (row_num - i) / i;
  
                // if c is odd
                // increment count
                if (c % 2 == 1)
                    count++;
            }
  
            // print count of odd elements
            Console.Write(count + " ");
        }
    }
  
    // Driver code
    public static void Main()
    {
  
        // Get n
        int n = 16;
  
        // Function call
        gouldSequence(n);
    }
}

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to generate 
// Gould's Sequence 
// Function to generate gould's Sequence 
function  gouldSequence($n
    // loop to generate each row 
    // of pascal's Triangle up to nth row 
    for ($row_num = 1; $row_num <= $n; $row_num++) { 
  
        $count = 1; 
        $c = 1; 
  
        // Loop to generate each element of ith row 
        for ($i = 1; $i <= $row_num; $i++) { 
  
            $c = $c * ($row_num - $i) / $i
  
            // if c is odd 
            // increment count 
            if ($c % 2 == 1) 
                $count++; 
        
  
        // print count of odd elements 
    echo  $count , " "
    
  
// Driver code 
    // Get n 
    $n = 16; 
    // Function call 
    gouldSequence($n); 
  
?>

chevron_right


Output

1 2 2 4 2 4 4 8 2 4 4 8 4 8 8 16 

An Efficient Solution is based on the fact that the count of odd numbers in ith row of pascal’s Triangle is 2 raised to the count of 1’s in binary representation of i.

For Example

for row=5
5 in binary = 101
count of 1's =2
22= 4

So, 5th row of pascal triangle will have 4 odd number

By counting 1’s in binary representation of every row number up to n, we can generate Gould’s Sequence up to n.

Below is the implementation of above idea-

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to generate
// Gould's Sequence
  
#include <bits/stdc++.h>
using namespace std;
  
// Utility function to count odd numbers
// in ith row of Pascals's triangle
int countOddNumber(int row_num)
{
  
    // Count set bits in row_num
  
    // Intialize count as zero
    unsigned int count = 0;
    while (row_num) {
        count += row_num & 1;
        row_num >>= 1;
    }
  
    // Return 2^count
    return (1 << count);
}
  
// Function to generate gould's Sequence
void gouldSequence(int n)
{
    // loop to generate gould's Sequence up to n
    for (int row_num = 0; row_num < n; row_num++) {
  
        cout << countOddNumber(row_num) << " ";
    }
}
  
// Driver code
int main()
{
  
    // Get n
    int n = 16;
  
    // Function call
    gouldSequence(n);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// JAVA program to generate
// Gould's Sequence
  
class GFG {
  
    // Utility function to count odd numbers
    // in ith row of Pascals's triangle
    static int countOddNumber(int row_num)
    {
  
        // Count set bits in row_num
  
        // Intialize count as zero
        int count = 0;
        while (row_num > 0) {
            count += row_num & 1;
            row_num >>= 1;
        }
  
        // Return 2^count
        return (1 << count);
    }
  
    // Function to generate gould's Sequence
    static void gouldSequence(int n)
    {
        // loop to generate gould's Sequence up to n
        for (int row_num = 0; row_num < n; row_num++) {
  
            System.out.print(countOddNumber(row_num) + " ");
        }
    }
  
    // Driver code
    public static void main(String[] args)
    {
  
        // Get n
        int n = 16;
  
        // Function call
        gouldSequence(n);
    }
}

chevron_right


Python3

# Python3 program to generate
# Gould’s Sequence

# Utility function to count odd numbers
# in ith row of Pascals’s triangle
def countOddNumber(row_num):

# Count set bits in row_num
# Intialize count as zero
count = 0
while row_num != 0:
count += row_num & 1
row_num >>= 1

# Return 2^count
return (1 << count) # Function to generate gould's Sequence def gouldSequence(n): # loop to generate gould's # Sequence up to n for row_num in range(0, n): print(countOddNumber(row_num), end = " ") # Driver code if __name__ == "__main__": # Get n n = 16 # Function call gouldSequence(n) # This code is contributed # by Rituraj Jain [tabby title="C#"]

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to generate
// Gould's Sequence
  
using System;
class GFG {
  
    // Utility function to count odd numbers
    // in ith row of Pascals's triangle
    static int countOddNumber(int row_num)
    {
  
        // Count set bits in row_num
  
        // Initialize count as zero
        int count = 0;
        while (row_num > 0) {
            count += row_num & 1;
            row_num >>= 1;
        }
  
        // Return 2^count
        return (1 << count);
    }
  
    // Function to generate gould's Sequence
    static void gouldSequence(int n)
    {
        // loop to generate gould's Sequence up to n
        for (int row_num = 0; row_num < n; row_num++) {
  
            Console.Write(countOddNumber(row_num) + " ");
        }
    }
  
    // Driver code
    public static void Main()
    {
        // Get n
        int n = 16;
  
        // Function call
        gouldSequence(n);
    }
}

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to generate
// Gould's Sequence
  
// Utility function to count odd numbers
// in ith row of Pascals's triangle
function countOddNumber($row_num)
{
  
    // Count set bits in row_num
  
    // Intialize count as zero
    $count = 0;
    while ($row_num)
    {
        $count += $row_num & 1;
        $row_num >>= 1;
    }
  
    // Return 2^count
    return (1 << $count);
}
  
// Function to generate gould's Sequence
function gouldSequence($n)
{
    // loop to generate gould's Sequence up to n
    for ($row_num = 0; 
         $row_num < $n; $row_num++)
    {
  
        echo countOddNumber($row_num), " ";
    }
}
  
// Driver code
  
// Get n
$n = 16;
  
// Function call
gouldSequence($n);
  
// This code is contributed 
// by Sach_Code
?>

chevron_right


Output

1 2 2 4 2 4 4 8 2 4 4 8 4 8 8 16 

A Better Solution ( Using Dynamic programming ) is based on the observation that after every power of 2 earlier terms got double up.

For Example


first term of the sequence is - 1
Now After every power of 2 we will double the value of previous terms

Terms up to 21  1 2
Terms up to 22  1 2 2 4
Terms up to 23  1 2 2 4 2 4 4 8
Terms up to 24  1 2 2 4 2 4 4 8 2 4 4 8 4 8 8 16

So, We can compute Gould’s Sequence terms after 2i by doubling the value of previous terms

Below is the implementation of above appraoch-

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to generate
// Gould's Sequence
  
#include <bits/stdc++.h>
using namespace std;
  
// 32768 = 2^15
#define MAX 32768
  
// Array to store Sequence up to
// 2^16 = 65536
int arr[2 * MAX];
  
// Utility function to pre-compute odd numbers
// in ith row of Pascals's triangle
int gouldSequence()
{
  
    // First term of the Sequence is 1
    arr[0] = 1;
  
    // Initilize i to 1
    int i = 1;
  
    // Initilize p to 1 (i.e 2^i)
    // in each iteration
    // i will be pth power of 2
    int p = 1;
  
    // loop to generate gould's Sequence
    while (i <= MAX) {
  
        // i is pth power of 2
        // traverse the array
        // from j=0 to i i.e (2^p)
  
        int j = 0;
  
        while (j < i) {
  
            // double the value of arr[j]
            // and store to arr[i+j]
            arr[i + j] = 2 * arr[j];
            j++;
        }
  
        // upadate i to next power of 2
        i = (1 << p);
  
        // increment p
        p++;
    }
}
  
// Function to print gould's Sequence
void printSequence(int n)
{
    // loop to generate gould's Sequence up to n
  
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
}
  
// Driver code
int main()
{
  
    gouldSequence();
  
    // Get n
    int n = 16;
  
    // Function call
    printSequence(n);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// JAVA program to generate
// Gould's Sequence
  
class GFG {
  
    // 32768 = 2^15
    static final int MAX = 32768;
  
    // Array to store Sequence up to
    // 2^16 = 65536
    static int[] arr = new int[2 * MAX];
  
    // Utility function to pre-compute odd numbers
    // in ith row of Pascals's triangle
    static void gouldSequence()
    {
  
        // First term of the Sequence is 1
        arr[0] = 1;
  
        // Initilize i to 1
        int i = 1;
  
        // Initilize p to 1 (i.e 2^i)
        // in each iteration
        // i will be pth power of 2
        int p = 1;
  
        // loop to generate gould's Sequence
        while (i <= MAX) {
  
            // i is pth power of 2
            // traverse the array
            // from j=0 to i i.e (2^p)
  
            int j = 0;
  
            while (j < i) {
                // double the value of arr[j]
                // and store to arr[i+j]
                arr[i + j] = 2 * arr[j];
                j++;
            }
  
            // upadate i to next power of 2
            i = (1 << p);
  
            // increment p
            p++;
        }
    }
  
    // Function to print gould's Sequence
    static void printSequence(int n)
    {
        // loop to generate gould's Sequence up to n
  
        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
    }
  
    // Driver code
    public static void main(String[] args)
    {
        gouldSequence();
  
        // Get n
        int n = 16;
  
        // Function call
        printSequence(n);
    }
}

chevron_right


Python3

# Python3 program to generate
# Gould’s Sequence

# 32768 = 2^15
MAX = 32768

# Array to store Sequence up to
# 2^16 = 65536
arr = [None] * (2 * MAX)

# Utility function to pre-compute
# odd numbers in ith row of Pascals’s
# triangle
def gouldSequence():

# First term of the Sequence is 1
arr[0] = 1

# Initilize i to 1
i = 1

# Initilize p to 1 (i.e 2^i)
# in each iteration
# i will be pth power of 2
p = 1

# loop to generate gould’s Sequence
while i <= MAX: # i is pth power of 2 # traverse the array # from j=0 to i i.e (2^p) j = 0 while j < i: # double the value of arr[j] # and store to arr[i+j] arr[i + j] = 2 * arr[j] j += 1 # upadate i to next power of 2 i = (1 << p) # increment p p += 1 # Function to print gould's Sequence def printSequence(n): # loop to generate gould's Sequence # up to n for i in range(0, n): print(arr[i], end = " ") # Driver code if __name__ == "__main__": gouldSequence() # Get n n = 16 # Function call printSequence(n) # This code is contributed # by Rituraj Jain [tabby title="C#"]

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to generate
// Gould's Sequence
  
using System;
class GFG {
  
    // 32768 = 2^15
    static int MAX = 32768;
  
    // Array to store Sequence up to
    // 2^16 = 65536
    static int[] arr = new int[2 * MAX];
  
    // Utility function to pre-compute odd numbers
    // in ith row of Pascals's triangle
    static void gouldSequence()
    {
  
        // First term of the Sequence is 1
        arr[0] = 1;
  
        // Initialize i to 1
        int i = 1;
  
        // Initialize p to 1 (i.e 2^i)
        // in each iteration
        // i will be pth power of 2
        int p = 1;
  
        // loop to generate gould's Sequence
        while (i <= MAX) {
  
            // i is pth power of 2
            // traverse the array
            // from j=0 to i i.e (2^p)
  
            int j = 0;
  
            while (j < i) {
                // double the value of arr[j]
                // and store to arr[i+j]
                arr[i + j] = 2 * arr[j];
                j++;
            }
  
            // upadate i to next power of 2
            i = (1 << p);
  
            // increment p
            p++;
        }
    }
  
    // Function to print gould's Sequence
    static void printSequence(int n)
    {
        // loop to generate gould's Sequence up to n
  
        for (int i = 0; i < n; i++) {
            Console.Write(arr[i] + " ");
        }
    }
  
    // Driver code
    public static void Main()
    {
  
        gouldSequence();
  
        // Get n
        int n = 16;
  
        // Function call
        printSequence(n);
    }
}

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to generate
// Gould's Sequence 
  
// 32768 = 2^15 
$MAX = 32768; 
  
// Array to store Sequence up to 
// 2^16 = 65536 
$arr = array_fill(0, 2 * $MAX, 0); 
  
// Utility function to pre-compute 
// odd numbers in ith row of 
// Pascals's triangle 
function gouldSequence() 
    global $MAX, $arr;
      
    // First term of the Sequence is 1 
    $arr[0] = 1; 
  
    // Initilize i to 1 
    $i = 1; 
  
    // Initilize p to 1 (i.e 2^i) 
    // in each iteration 
    // i will be pth power of 2 
    $p = 1; 
  
    // loop to generate gould's Sequence 
    while ($i <= $MAX)
    
  
        // i is pth power of 2 
        // traverse the array 
        // from j=0 to i i.e (2^p) 
        $j = 0; 
  
        while ($j < $i
        
  
            // double the value of arr[j] 
            // and store to arr[i+j] 
            $arr[$i + $j] = 2 * $arr[$j]; 
            $j++; 
        
  
        // upadate i to next power of 2 
        $i = (1 << $p); 
  
        // increment p 
        $p++; 
    
  
// Function to print gould's Sequence 
function printSequence($n
{
    global $MAX, $arr;
      
    // loop to generate gould's
    // Sequence up to n 
  
    for ($i = 0; $i < $n; $i++)
    
        echo $arr[$i]." "
    
  
// Driver code 
gouldSequence(); 
  
// Get n 
$n = 16; 
  
// Function call 
printSequence($n); 
  
// This code is contributed by mits
?>

chevron_right


Output

1 2 2 4 2 4 4 8 2 4 4 8 4 8 8 16 


My Personal Notes arrow_drop_up

self motivated and passionate programmer

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.