Question

Part-1: find the longest block (subsequence of elements with same value) in

an array.

Part-2: find all subsequences in an array of int that add up to a given sum.

*/

#include <iostream>

#include <cstdlib>

using namespace std;

void printSeq(int* a, int s, int e);

// -------------------------------------------- functions to be implemented by you

void longestBlock(const int* a, int n, int& s, int& e)

{

// s = start index of the block

// e = end index of the block (exclusive, i.e. the block contains elements

from a[s] to a[e-1])

s = e = 0; // empty block

// your codes

}

/*

Determine all subsequences in the array such that the sum

of each subsequence is equal to the targetSum

example: A[] = {5, 1, 4, 4, 2, 5, 3, 2, 4, 5}

if targetSum = 10

the function prints: subsequence : 5, 1, 4

subsequence : 4, 4, 2

subsequence : 2, 5, 3

subsequence : 5, 3, 2

if targetSum = 13

the function prints: no subsequence found

*/

void findAllSubSeq(int a[], int n, int targetSum)

{

cout << "Subsequence with sum = " << targetSum << endl;

// Your codes

}

// -------------------------------------------------- functions given to you

void printSeq(int* a, int s, int e)

{

for (int i = s; i < e; i++)

cout << a[i] << ", ";

cout << endl;

}

void part_1()

{

cout << "Part_1:\n\n";

int a[] = {1, 2, 3, 3, 1, 4, 4, 4, 5, 8, 6, 6, 5, 5, 5, 5, 2, 1, 7, 7};

int n = 20;

cout << "a[] : ";

printSeq(a, 0, n);

cout << endl;

int s, e;

longestBlock(a, n, s, e);

cout << "Longest block in the array:\n";

cout << "Data value = " << (e > s ? a[s] : 0) << ", start index = " << s;

cout << ", block length = " << e - s << endl << endl;

cout << "Test with empty array:\n";

longestBlock(a, 0, s, e);

cout << "Longest block in the array:\n";

cout << "Data value = " << (e > s ? a[s] : 0) << ", start index = " << s;

cout << ", block length = " << e - s << endl << endl;

}

void part_2()

{

cout << "\n------------------------------------------------------\n";

cout << "Part-2:\n\n";

int a[] = {5, 1, 4, -4, 2, 1, 5, 3, -2, 4, 5, -8, 7, 9, 1};

int n = 15;

cout << "a[] : ";

printSeq(a, 0, n);

cout << endl;

int targetSum = 16;

findAllSubSeq(a, n, targetSum);

cout << endl;

targetSum = 31;

findAllSubSeq(a, n, targetSum);

cout << "\nTest with empty array:\n";

targetSum = 16;

findAllSubSeq(a, 0, targetSum);

}

int main()

{

part_1();

part_2();

cout << endl;

system("pause");

return 0;

}

Answer 1

C++ code:

//=========================================================

#include <iostream>
#include <cstdlib>
using namespace std;
void printSeq(int* a, int s, int e);
// -------------------------------------------- functions to be implemented by you
void longestBlock(const int* a, int n, int& s, int& e)
{
   // s = start index of the block
   // e = end index of the block (exclusive, i.e. the block contains elements
   //from a[s] to a[e - 1])
   s = e = 0; // empty block
   int temp_s = 0; // starting point
   int length = 0; // largest block length
   for (int i = 1; i < n; i++)
   {
       // if 2 character does not match
       if (a[i-1] != a[i])
       {
           // check if new block is larger than previous longest block
           if ( i - temp_s >length)
           {
               length = i - temp_s; //update length
               s = temp_s;          // update starting point
               e = i;               // update end point
           }
           temp_s = i; // start finding new block
       }
   }
   // check if last block is longest block or not
   if (n - temp_s > length)
   {
       s = temp_s;
       e = n - 1;
   }
  
}

/*
Determine all subsequences in the array such that the sum
of each subsequence is equal to the targetSum
example: A[] = {5, 1, 4, 4, 2, 5, 3, 2, 4, 5}
if targetSum = 10
the function prints: subsequence : 5, 1, 4
subsequence : 4, 4, 2
subsequence : 2, 5, 3
subsequence : 5, 3, 2
if targetSum = 13
the function prints: no subsequence found
*/
void findAllSubSeq(int a[], int n, int targetSum)
{
   cout << "Subsequence with sum = " << targetSum << endl;

   int start = 0;     // starting index of subsequence
   int sum =0;        // sum of sequence
   bool flag = 0;     // flag to check found atleast one sequence
   for (int i = 0; i < n; i++) // starting index of array
   {
       sum = 0;
       for (int j = i; j < n; j++) // end index of array
       {
           sum += a[j];
           if (sum == targetSum) // when array sum become required target sum
           {
               cout << "subsequence : ";
               printSeq(a, i, j + 1); // print subsequence
               flag = 1;               // atlest found one sequence
           }
       }
   }

   // no sequence found
   if (flag == 0) cout << "no subsequence found" << endl;
}

//added to test part 2 with more example
void part_2_1()
{
   cout << "\n------------------------------------------------------\n";
   cout << "Part-2 test2:\n\n";
   int a[] = { 5, 1, 4, 4, 2, 5, 3, 2, 4, 5 };
   int n = 10;
   cout << "a[] : ";
   printSeq(a, 0, n);
   cout << endl;
   int targetSum = 10;
   findAllSubSeq(a, n, targetSum);
   cout << endl;
   targetSum = 13;
   findAllSubSeq(a, n, targetSum);
   cout << "\nTest with empty array:\n";
   targetSum = 16;
   findAllSubSeq(a, 0, targetSum);
}

// -------------------------------------------------- functions given to you
void printSeq(int* a, int s, int e)
{
   for (int i = s; i < e; i++)
       cout << a[i] << ", ";
   cout << endl;
}
void part_1()
{
   cout << "Part_1:\n\n";
   int a[] = { 1, 2, 3, 3, 1, 4, 4, 4, 5, 8, 6, 6, 5, 5, 5, 5, 2, 1, 7, 7 };
   int n = 20;
   cout << "a[] : ";
   printSeq(a, 0, n);
   cout << endl;
   int s, e;
   longestBlock(a, n, s, e);
   cout << "Longest block in the array:\n";
   cout << "Data value = " << (e > s ? a[s] : 0) << ", start index = " << s;
   cout << ", block length = " << e - s << endl << endl;
   cout << "Test with empty array:\n";
   longestBlock(a, 0, s, e);
   cout << "Longest block in the array:\n";
   cout << "Data value = " << (e > s ? a[s] : 0) << ", start index = " << s;
   cout << ", block length = " << e - s << endl << endl;
}

void part_2()
{
   cout << "\n------------------------------------------------------\n";
   cout << "Part-2:\n\n";
   int a[] = { 5, 1, 4, -4, 2, 1, 5, 3, -2, 4, 5, -8, 7, 9, 1 };
   int n = 15;
   cout << "a[] : ";
   printSeq(a, 0, n);
   cout << endl;
   int targetSum = 16;
   findAllSubSeq(a, n, targetSum);
   cout << endl;
   targetSum = 31;
   findAllSubSeq(a, n, targetSum);
   cout << "\nTest with empty array:\n";
   targetSum = 16;
   findAllSubSeq(a, 0, targetSum);
}

int main()
{
   part_1();
   part_2();
   part_2_1();
   cout << endl;
   system("pause");
   return 0;
}

//=========================================================

sample output:

Explanation:

longestBlock : check if two continues index contain same number. if not than calculate largest block length by using temp_s and current index.

findAllSubSeq : choose one starting pointing of subsequence and iterate over remaining array to find target sum.

Comment: I have added one more test case for testing part 2( part_2_1) and part which I have added are in BOLD TEXT.