TCS codevita:

PARENTHESIS GENERATION:

#include <stdio.h>

#include <stdlib.h>

#define MAX 20

int n, kind;

char s[MAX*2+1];

void print(char* dest, int left, int right)

{

    if(left == n && right == n){

        puts(dest);

        ++kind;

        return;

    }

    if(left < n){

        dest[left+right] = '(';

        print(dest, left+1, right);

    }

    if(right < left){

        dest[left+right] = ')';

        print(dest, left, right+1);

    }

}

int main()

{   

   scanf("%d", &n);

        s[n<<1] = '\0';

        kind = 0;

        print(s, 0, 0);

    

    

    return 0;

}

CWS RETURNING RESULTS:

#include<stdio.h>

int isSubsetSum(int set[], int n, int sum)

{

    if (sum == 0)

     return 1;

   if (n == 0 && sum != 0)

     return 0;

   if (set[n-1] > sum)

     return isSubsetSum(set, n-1, sum);

     

   return isSubsetSum(set, n-1, sum) || 

                        isSubsetSum(set, n-1, sum-set[n-1]);

}

int main()

{

  int set[20],sum,n,i;

  scanf("%d",&n);

  for(i=0;i<n;i++)

    scanf("%d",&set[i]);

  scanf("%d",&sum);

  if (isSubsetSum(set, n, sum) == 1)

     printf("Combination Found = 1");

  else

     printf("Combination Found = 0");

  return 0;

}

COMBINATIONS IN C:

#include <stdio.h>
void printCombinations(int a[], int n, int selected[],int visited_count);
#define SIZE 10
int main() {
    int arr[SIZE], n, i,selected[100],visited_count;
    scanf("%d", &n);
    for(i=0; i<n; i++)
    {
      scanf("%d", &arr[i]);
    }
    printCombinations(arr, n,selected,visited_count);
    return 0;
}
void printCombinations(int a[], int n, int selected[],int visited_count)
{
  if(visited_count==n)
  {
    int i;
    for(i=0;i<n;i++)
    {
      if(selected[i]==1)
      {
        printf("%d,",a[i]);
}}
    printf("\n");
    return;
  }
  selected[visited_count]=1;
  printCombinations(a,n,selected,visited_count+1);
  selected[visited_count]=0;
  printCombinations(a,n,selected,visited_count+1);
}

*optimal stealing:

OPTIMUM STEALING PROBLEM:

#include <stdio.h>
#define MAX_STALLS 50
#define MAX(a, b) (a>b) ? a : b
int max_stealing_opt(int house_values[], 
int n, 
int current_house,
int results_cache[])
{
    if(current_house >= n)
    {
        return 0;
    }

if(results_cache[current_house] != -1)
{
return results_cache[current_house];
}
    
    int if_stolen = house_values[current_house] + 
max_stealing_opt(house_values, 
     n, 
     current_house + 2,
     results_cache);

int if_not_stolen = max_stealing_opt(house_values, 
         n, 
         current_house + 1,
         results_cache);
    
    results_cache[current_house] = MAX(if_stolen, if_not_stolen);
return results_cache[current_house];
}
int max_stealing_opt_wrapper(int house_values[], int n)
{
int results_cache[n], i;
for(i = 0; i < n; i++)
{
results_cache[i] = -1;
}

return max_stealing_opt(house_values,  n, 0,results_cache);
}
int main() {
int n, house_values[MAX_STALLS], i;
scanf("%d", &n);
for(i = 0; i < n; i++)
{
    scanf("%d", &house_values[i]);
}
printf("%d", max_stealing_opt_wrapper(house_values, n));
return 0;
}

*Staircase problem:

FIND THE FIBONACCI NUMBER BY ENTERING VALUE:

#include <stdio.h>
int find_total_ways_recur(int curr_step, int n)
{
    if(curr_step>n)
    {
      return 0;
    }

    if(curr_step==n)
    {
        return 1;
    }

int total_ways = find_total_ways_recur(curr_step + 1, n) +
     find_total_ways_recur(curr_step + 2, n);

    return total_ways;
}

int find_total_ways_recur_wrap(int n)
{
return find_total_ways_recur(0,n);
}

int find_total_ways_recur_opt(int curr_step,int n,int results_cache[])
{
    if(curr_step>n)
    {
      return 0;
    }

    if(curr_step==n)
    {
        return 1;
    }

  if(results_cache[curr_step]!=-1)
  {
  return results_cache[curr_step];
  }

int total_ways = find_total_ways_recur_opt(curr_step + 1, n, results_cache) +
     find_total_ways_recur_opt(curr_step + 2, n, results_cache);

results_cache[curr_step] = total_ways;
    return total_ways;
}

int find_total_ways_recur_opt_wrap(int n)
{
int results_cache[n+1], i;
for(i = 0; i <= n; i++)
{
results_cache[i] = -1;
}

return find_total_ways_recur_opt(0 , n, results_cache);
}

int main() {
int n;
scanf("%d", &n);
printf("%d\n", find_total_ways_recur_opt_wrap(n));
return 0;
}