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
C++
// 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>
Output 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-
C++
// 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>
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 approach-
C++
// 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>
Output 1 2 2 4 2 4 4 8 2 4 4 8 4 8 8 16
Similar Reads
Golomb sequence In mathematics, the Golomb sequence is a non-decreasing integer sequence where n-th term is equal to number of times n appears in the sequence.The first few values are 1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 5, ...... Explanation of few terms: Third term is 2, note that three appears 2 times. Second term is 2
7 min read
Aronson's Sequence Given an integer n , generate the first n terms of the Aronson's sequence.Aronson's sequence is an infinite sequence of integers obtained from the index of T (or t) in the sentence: "T is the first, fourth, eleventh, sixteenth, ... letter in this sentence." The first occurrence of T in the sentence
13 min read
Gijswijt's Sequence Gijswijt's sequence is a self-describing sequence where the value of each term is equal to the maximum number of repeated blocks of numbers in the sequence preceding the number.Let us take the ith term of the sequence a(i), Then for this Gijswijt's Sequence: where k is the largest natural number suc
9 min read
Connell Sequence Given an integer 'n', generate the first 'n' terms of the Connell Sequence. Connell Sequence is the sequence formed with the first odd number, i.e 1 as its first term. The subsequent terms of the sequence are made up of the first two even numbers, i.e 2 and 4, followed by the next three odd numbers,
7 min read
Juggler Sequence Juggler Sequence is a series of integer number in which the first term starts with a positive integer number a and the remaining terms are generated from the immediate previous term using the below recurrence relation : a_{k+1}=\begin{Bmatrix} \lfloor a_{k}^{1/2} \rfloor & for \quad even \quad a
5 min read
Moser-de Bruijn Sequence Given an integer 'n', print the first 'n' terms of the Moser-de Bruijn Sequence. Moser-de Bruijn sequence is the sequence obtained by adding up the distinct powers of the number 4 (For example, 1, 4, 16, 64, etc). Examples: Input : 5 Output : 0 1 4 5 16 Input : 10 Output : 0 1 4 5 16 17 20 21 64 65
12 min read
Golomb Sequence | Set 2 Given a number N. The task is to find the first N terms of the Golomb Sequence. Golomb sequence is a non-decreasing integer sequence where the n-th term is equal to the number of times n appears in the sequence. Input: N = 11 Output: 1 2 2 3 3 4 4 4 5 5 5 Explanation: The first term is 1. 1 appears
8 min read
Recaman's sequence Given an integer n. Print first n elements of Recaman’s sequence. Recaman's Sequence starts with 0 as the first term. For each next term, calculate previous term - index (if positive and not already in sequence); otherwise, use previous term + index.Examples: Input: n = 6Output: 0, 1, 3, 6, 2, 7Expl
8 min read
Look-and-Say Sequence Find the nth term in Look-and-say (Or Count and Say) Sequence. The look-and-say sequence is the sequence of the below integers: 1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, ... How is the above sequence generated? The nth term is generated by reading (n-1)th term.The first term is "1"Secon
10 min read
Jolly Jumper Sequence A sequence of n numbers (n < 3000) is called Jolly Jumper if the absolute values of the differences between the successive elements take on all possible values from 1 through n-1. The definition implies that any sequence of a single integer is a jolly jumper. Examples: Input: 1 4 2 3 Output: True
5 min read