Recursion and DP problems solutions in C

C/Chapter_9/Question9_1.c

@@ -0,0 +1,32 @@
+#include<stdio.h>
+#include<string.h>
+
+int countWaysDp(int n, int arr[]) {
+  if(n < 0) {
+    return 0; //no ways possible
+  }
+  else if(n == 0) {
+    return 1; // found exactly one way - no way to climb the stairs
+  }
+  else if (arr[n] > -1) {
+    return arr[n];
+  }
+  else {
+    arr[n] = countWaysDp(n - 1, arr) + countWaysDp(n - 2, arr) + countWaysDp(n - 3, arr);
+    return arr[n];
+  }
+}
+
+int main() {
+
+  int n = 3;
+  int arr[4];
+  int res = 0;
+
+  memset(&arr,-1,sizeof(arr));
+  res = countWaysDp(n, arr);
+
+  printf("Number of ways %d\n",res);
+
+  return 0;
+}

C/Chapter_9/Question9_2.c

@@ -0,0 +1,70 @@
+#include<stdio.h>
+
+int countPathsDp(int x, int y) {
+
+  int i, j;
+  int dp[3][3]; //dp[x + 1][y + 1];
+
+  for(i = x; i >= 0; i--) {
+    for(j = y; j >= 0; j--) {
+      if(i == x || j == y)
+        dp[i][j] = 1;
+      else
+        dp[i][j] = dp[i + 1][j] + dp[i][j + 1];
+    }
+  }
+  return dp[0][0];
+}
+
+int countPathsWithObstacle(int x, int y, int obs[][3]) {
+  int dp[3][3]; //dp[x + 1][y + 1];
+  int i, j, val;
+
+  for(i = x; i >= 0; i--) {
+    for(j = y; j >= 0; j--) {
+
+      val = obs[i][j];
+      printf("%d \n", val);
+      if(i == x && j == y) {
+        if(val)
+          dp[i][j] = 0;
+        else
+          dp[i][j] = 1;
+      }
+      else if(i == x) {
+         if(val)
+          dp[i][j] = 0;
+        else
+          dp[i][j] = dp[i][j + 1];
+      }
+      else if(j == y) {
+         if(val)
+          dp[i][j] = 0;
+        else
+          dp[i][j] = dp[i + 1][j];
+      }
+      else {
+         if(val)
+          dp[i][j] = 0;
+        else
+          dp[i][j] = dp[i + 1][j] + dp[i][j + 1];
+      }
+    }
+  }
+
+  return dp[0][0];
+}
+
+int main() {
+  int x = 2; // index - row
+  int y = 2; // index - col
+  int res = 0, i, j;
+  int obstacleMatrix[3][3] = {0 , 0, 0, 0, 1, 0, 0, 0, 0};
+
+  res = countPathsDp(x, y);
+  printf("%d ways\n",res);
+
+  res = countPathsWithObstacle(x,y,obstacleMatrix);
+  printf("%d ways\n",res);
+  return 0;
+}

C/Chapter_9/Question9_3.c

@@ -0,0 +1,60 @@
+#include<stdio.h>
+
+int findMagicIndex(int arr[], int start, int end) {
+  int mid;
+
+  if(end < start || start < 0)
+    return -1;
+
+  mid = (start + end) / 2;
+
+  if(arr[mid] == mid)
+    return mid;
+  else if (arr[mid] > mid)
+    return findMagicIndex(arr, start, mid - 1);
+  else
+    return findMagicIndex(arr, mid + 1, end);
+}
+
+int findMin(int a, int b) {
+  return (a < b) ? a : b;
+}
+
+int findMagicWithDuplicate(int arr[], int start, int end) {
+  int mid, midValue, left, right, li, ri;
+
+  if(end < start || start < 0)
+    return -1;
+
+  mid = (start + end) / 2;
+
+  midValue = arr[mid];
+
+  if(midValue == mid)
+    return mid;
+
+  // search left
+  left = findMin(mid - 1, midValue);
+  li = findMagicWithDuplicate(arr, start, left);
+  if(li >= 0)
+    return li;
+
+  //search right
+  right = findMin(mid + 1, midValue);
+  ri = findMagicWithDuplicate(arr, right, end);
+  return ri;
+}
+
+int main() {
+  //int arr[] = {-40, -20, -1, 1, 2, 3, 5, 7, 9, 12, 13};
+  int arr[] = {-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13};
+  int n = 11;
+  int res;
+
+  //res = findMagicIndex(arr, 0, n - 1);
+  //printf("%d is result\n",res);
+
+  res = findMagicWithDuplicate(arr, 0, n - 1);
+  printf("%d is result\n",res);
+  return 0;
+}

C/Chapter_9/Question9_4.c

@@ -0,0 +1,29 @@
+#include<stdio.h>
+
+void printSubsets(int arr[], int n, int cnt) {
+  int j;
+
+  if(cnt < 0)
+    return;
+
+  printf("{");
+
+  for(j = 0; j < n; j++) {
+    if(cnt & (1 << j))
+      printf("%d ",arr[j]);
+  }
+  printf("}\n");
+
+  printSubsets(arr, n, cnt - 1);
+
+  return;
+}
+
+int main() {
+
+  int arr[] = {1, 2, 3, 4};
+
+  printSubsets(arr, 4, 16 - 1);
+
+  return 0;
+}

C/Chapter_9/Question9_5.c

@@ -0,0 +1,33 @@
+#include<stdio.h>
+
+/* Function to swap values at two pointers */
+void swap (char *x, char *y)
+{
+    char temp;
+    temp = *x;
+    *x = *y;
+    *y = temp;
+}
+
+void permutations(char *arr, int index, int n) {
+  int j;
+
+  if(index == n)
+    printf("%s\n",arr);
+  else {
+    for(j = index; j <= n; j++) {
+      swap((arr + index), (arr + j));
+      permutations(arr, index + 1, n);
+      swap((arr + index), (arr + j));
+    }
+  }
+}
+
+
+int main() {
+  char arr[] = "abc";
+
+  permutations(arr, 0, 2);
+
+  return 0;
+}

C/Chapter_9/Question9_6.c

@@ -0,0 +1,29 @@
+#include<stdio.h>
+#include<string.h>
+
+void printParanthesis(char str[], int leftRem, int rightRem, int count) {
+  if(leftRem < 0 || rightRem < leftRem)
+    return;
+
+  if(leftRem == 0 && rightRem == 0) {
+    printf("%s\n",str);
+  }
+  else {
+    if(leftRem > 0) {
+      str[count] = '(';
+      printParanthesis(str, leftRem - 1, rightRem, count + 1);
+    }
+    if(rightRem > leftRem){
+      str[count] = ')';
+      printParanthesis(str, leftRem, rightRem - 1, count + 1);
+    }
+  }
+}
+
+int main() {
+  int n = 3;
+  char str[6];
+  printParanthesis(str, n, n, 0);
+
+  return 0;
+}

C/Chapter_9/Question9_7.c

@@ -0,0 +1,41 @@
+#include<stdio.h>
+//x is column y is row.
+
+void paintfill(int screen[5][5], int x, int y, int n, int m, int ocolor, int ncolor) {
+  int i, j;
+
+  if(x < 0 || x >= n || y < 0 || y >= m)
+    return ;
+
+  if(screen[y][x] == ocolor) {
+    screen[y][x] = ncolor;
+    paintfill(screen, x - 1, y, n, m, ocolor, ncolor);
+    paintfill(screen, x + 1, y, n, m, ocolor, ncolor);
+    paintfill(screen, x, y - 1, n, m, ocolor, ncolor);
+    paintfill(screen, x, y + 1, n, m, ocolor, ncolor);
+  }
+
+  return;
+}
+
+int main() {
+  int i, j, tmp, screen[5][5], n = 5, m = 5;
+
+  for (i = 0; i < m; i++) {
+    for (j = 0; j < n; j++) {
+      printf("Enter at %d %d\n",i,j);
+      scanf("%d",&tmp);
+      screen[i][j] = tmp;
+    }
+  }
+  paintfill(screen, 3, 1, 5, 5, 3, 2);
+
+  for (i = 0; i < m; i++) {
+    for (j = 0; j < n; j++) {
+      printf("%d ", screen[i][j]);
+    }
+    printf("\n");
+  }
+
+  return 0;
+}

C/Chapter_9/Question9_8.c

@@ -0,0 +1,33 @@
+#include<stdio.h>
+
+int makeChange(int n, int denom) {
+
+  int next_denom = 0, ways = 0, i;
+
+  switch(denom){
+  case 25 :
+    next_denom = 10;
+    break;
+  case 10 :
+    next_denom = 5;
+    break;
+  case 5 :
+    next_denom = 1;
+    break;
+  case 1 :
+    return 1;
+  }
+
+  for(i = 0; i * denom <= n; i++)
+    ways += makeChange(n - (i * denom),next_denom);
+
+  return ways;
+}
+
+int main() {
+  int res;
+  res = makeChange(10, 25);
+
+  printf("%d ways\n",res);
+  return 0;
+}

C/Chapter_9/Question9_9.c

@@ -0,0 +1,51 @@
+#include<stdio.h>
+#include<string.h>
+
+int row[8], ld[15], rd[15], gc, gr, lc = 0, rw[8], row[8];
+
+void placeCol(int col) {
+  int i, j;
+
+  if( col >= 8 && row[gc] == gr) {
+    printf("%2d    %d", ++lc, row[0] + 1);
+    for(j = 1; j < 8 ; j++) {
+      printf(" %d", row[j] + 1);
+    }
+    printf("\n");
+    return; //all queens placed
+  }
+  else {
+    for(i = 0; i < 8; i++) {
+      if(rw[i] == 0 && ld[i - col + 7] == 0 && rd[i + col] == 0) {
+        row[col] = i;
+
+        if(col == gc && row[col] != gr)
+          continue;
+        else {
+          rw[i] = ld[i - col + 7] = rd[i + col] = 1;
+          placeCol(col + 1);
+          rw[i] = ld[i - col + 7] = rd[i + col] = 0;
+        }
+      }
+    }
+  }
+}
+
+int main() {
+
+  int i, j, res;
+  int board[8][8] = {0};
+
+  memset(row, 0 , sizeof(row));
+  lc = 0;
+
+  scanf("%d %d",&gr,&gc);
+  gr--;
+  gc--;
+
+  printf("SOLN     COLUMN\n");
+  printf(" #    1 2 3 4 5 6 7 8\n\n");
+  placeCol(0);
+
+  return 0;
+}