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 triangle 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
// 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;
} |
// 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);
}
} |
# 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 |
// 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);
}
} |
<?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 );
?> |
<script> // Javascript 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 ( var row_num = 1; row_num <= n; row_num++) {
var count = 1;
var c = 1;
// Loop to generate each element of ith row
for ( var 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
document.write( count + " " );
}
} // Driver code // Get n var n = 16;
// Function call gouldSequence(n); </script> |
1 2 2 4 2 4 4 8 2 4 4 8 4 8 8 16
Time Complexity: O(n2)
Auxiliary Space: O(1)
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-
// 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
// Initialize 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;
} |
// 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
// 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++) {
System.out.print(countOddNumber(row_num) + " " );
}
}
// Driver code
public static void main(String[] args)
{
// Get n
int n = 16 ;
// Function call
gouldSequence(n);
}
} |
# 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
# Initialize 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 |
// 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);
}
} |
<?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
// Initialize 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 ?> |
<script> // javascript 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
// Initialize count as zero
var 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
function gouldSequence(n)
{
// loop to generate gould's Sequence up to n
for ( var row_num = 0; row_num < n; row_num++) {
document.write(countOddNumber(row_num) + " " );
}
}
// Driver code
// Get n
var n = 16;
// Function call
gouldSequence(n);
// This code is contributed by gauravrajput1 </script> |
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 approach-
// 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;
// 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++;
}
// update 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;
} |
// 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 ;
// 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++;
}
// update 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);
}
} |
# 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
# Initialize i to 1
i = 1
# Initialize 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
# update 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 |
// 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++;
}
// update 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);
}
} |
<?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;
// Initialize i to 1
$i = 1;
// Initialize 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 ++;
}
// update 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 ?> |
<script> // Javascript program to generate // Gould's Sequence // 32768 = 2^15 var MAX = 32768;
// Array to store Sequence up to // 2^16 = 65536 var arr = Array(2 * MAX);
// Utility function to pre-compute odd numbers // in ith row of Pascals's triangle function gouldSequence()
{ // First term of the Sequence is 1
arr[0] = 1;
// Initialize i to 1
var i = 1;
// Initialize p to 1 (i.e 2^i)
// in each iteration
// i will be pth power of 2
var 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)
var j = 0;
while (j < i) {
// double the value of arr[j]
// and store to arr[i+j]
arr[i + j] = 2 * arr[j];
j++;
}
// update i to next power of 2
i = (1 << p);
// increment p
p++;
}
} // Function to print gould's Sequence function printSequence(n)
{ // loop to generate gould's Sequence up to n
for ( var i = 0; i < n; i++) {
document.write( arr[i] + " " );
}
} // Driver code gouldSequence(); // Get n var n = 16;
// Function call printSequence(n); </script> |
1 2 2 4 2 4 4 8 2 4 4 8 4 8 8 16