Merge pull request ashutosh97#98 from Muskan-goyal6/new-branch

Subsequences in C++

Author: ashutosh97

.DS_Store

@@ -0,0 +1,78 @@
+
+#include "../helper.h"
+#include <iostream>
+using namespace std;
+
+void copyArr(int from[], int si, int ei, int * to) {
+    // while (si <= ei) *to++ = *si++;
+    while (si <= ei) {
+        *to = from[si];
+        ++si;
+        ++to;
+    }
+}
+
+
+void mergeSortedArray(int arr[], int si, int ei, int mid) {
+
+    int tmp_A[100];
+    int tmp_B[100];
+
+    copyArr(arr, si, mid, tmp_A);
+    copyArr(arr, mid + 1, ei, tmp_B);
+
+    int i = 0;
+    int j = 0;
+    int k = si;
+
+    //while a has elements and b has elements, I have to do something
+    int size_A = mid - si + 1;
+    int size_B = ei - (mid + 1) + 1;
+
+    while (i < size_A && j < size_B) {
+        if (tmp_A[i] < tmp_B[j]) {
+            arr[k] = tmp_A[i];
+            i++;
+            k++;
+        }
+        else {
+            arr[k++] = tmp_B[j++];
+        }
+    }
+
+    while (i < size_A) {
+        arr[k++] = tmp_A[i++];
+    }
+
+    while (j < size_B) arr[k++] = tmp_B[j++];
+
+
+}
+
+
+void mergeSort(int arr[], int si, int ei) {
+    if (si >= ei) {
+        //no elements
+        return;
+    }
+
+    int mid = (si + ei) / 2;
+    //sort the left part
+    mergeSort(arr, si, mid);
+    mergeSort(arr, mid + 1, ei);
+
+    mergeSortedArray(arr, si, ei, mid);
+
+}
+
+
+int main() {
+    int arr[100];
+    int n;
+    cin >> n;
+    inputArr(arr, n);
+
+    mergeSort(arr, 0, n - 1);
+
+    printArr(arr, n);
+}

Mersort_In_C++/mergeSort.cpp

@@ -0,0 +1,13 @@
+Merge Sort is a Divide and Conquer algorithm. It divides input array in 
+two halves, calls itself for the two halves and then merges the two sorted halves.
+Algorithm:
+MergeSort(arr[], l,  r)
+If r > l
+1. Find the middle point to divide the array into two halves:  
+             middle m = (l+r)/2
+2. Call mergeSort for first half:   
+             Call mergeSort(arr, l, m)
+3. Call mergeSort for second half:
+             Call mergeSort(arr, m+1, r)
+4. Merge the two halves sorted in step 2 and 3:
+             Call merge(arr, l, m, r)

Mersort_In_C++/mergesort.txt

@@ -0,0 +1,6 @@
+Print all the subsequences of a string. A String is a subsequence of a given String,
+that is generated by deleting some character of a given string without changing 
+its order.
+Example:
+Input : abc
+Output : a, b, c, ab, bc, ac, abc

Subsequences/question.txt

@@ -0,0 +1,27 @@
+//find all the sub sequences of a string
+#include <iostream>
+using namespace std;
+char output[100] = "";
+
+void printSubSeq(char str[], int be, int idx)
+{
+    if (str[be] == '\0')
+    {
+        output[idx] = '\0';
+        cout << output << endl;
+        return;
+    }
+
+    printSubSeq(str, be + 1, idx);
+    output[idx] = str[be];
+    printSubSeq(str, be + 1, idx + 1);
+}
+
+
+int main() {
+    char str[100];
+    cin >> str;
+
+
+    printSubSeq(str, 0, 0);
+}

Subsequences/subsequences.cpp

@@ -0,0 +1,10 @@
+The N Queen is the problem of placing N chess queens on an N×N chessboard so
+that no two queens attack each other. For example, following is a solution 
+for 4 Queen problem.
+The expected output is a binary matrix which has Qs for the blocks where 
+queens are placed and Xs where queens are not placed. 
+EXAMPLE:
+X  X  Q  X 
+Q  X  X  X
+X  X  X  Q
+X  Q  X  X  

nQueen/Question.txt

@@ -0,0 +1,90 @@
+
+#include <iostream>
+using namespace std;
+
+char board[30][30];
+
+void printBoard(char arr[][30], int n) {
+    for (int r = 0; r < n; ++r) {
+        for (int c = 0; c < n; ++c) {
+            cout << arr[r][c] << " " ;
+        }
+        cout << endl;
+    }
+}
+
+void initialiseBoard(int n) {
+    for (int r = 0; r < n; ++r) {
+        for (int c = 0; c < n; ++c) {
+            board[r][c] = 'X';
+        }
+    }
+}
+
+bool canPlace(char board[][30], int N, int x, int y)
+{
+    //check the row if aqueen already exists
+    for (int r = 0; r < N; ++r)
+    {
+        if (board[r][y] == 'Q') 
+            return false;
+    }
+
+    int rInc[] = { -1, +1, +1, -1};
+    int cInc[] = { -1, +1, -1, +1};
+     //check diagonal if queen already exists
+    for (int dir = 0; dir < 4; ++dir)
+    {
+        int rowAdd = rInc[dir];
+        int colAdd = cInc[dir];
+        int r = x + rowAdd;
+        int c = y + colAdd;
+        //check that r c is within the board
+        while (r >= 0 && r < N && c >= 0 && c < N)
+        {
+            if (board[r][c] == 'Q')
+             return false;
+            r = r + rowAdd;
+            c = c + colAdd;
+        }
+    }
+    return true;
+}
+
+bool nqueen(int r, int n)
+{
+    if (r == n)//base case if all queens are placed 
+    {
+        return true;
+    }
+    //for every column, use hit and trial by placing a queen in the each cell of curr Row
+    for (int c = 0; c < n; ++c)
+    {
+        int x = r;
+        int y = c;
+        //check if queen can be placed on board[i][c]
+        if (canPlace(board, n, x, y)==true)
+        {
+            board[x][y] = 'Q'; //place queen in each column
+            bool isSuccessful = nqueen(r + 1, n);   //recursion to place rest of queens
+            if (isSuccessful == true)
+             return true;
+            board[x][y] = 'X';   //else unmark the cell or backtrack
+        }
+    }
+    return false; //if queen cannot be placed in any row in this column then return false
+}
+
+int main()
+{
+    int n;
+    cin >> n;
+
+    initialiseBoard(n);//initialse all the board with X
+    bool isSuccessful = nqueen(0, n);
+
+    if (isSuccessful) printBoard(board, n);
+    else cout << "Sorry man! You need to have a larger board!\n";
+
+    return 0;
+}