Merge branch 'master' into new-usera

Author: Anjali041

Ad-Hoc/(CODECHEF) ChefAndStrings.cpp

@@ -0,0 +1,26 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+	// your code goes here
+	int t =1;
+	cin >> t;
+	while(t--){
+	    long long n;
+	    cin >> n;
+	    int arr[n];
+	    for(long long i=0;i<n;i++){
+	        cin >> arr[i];
+	    }
+	    long long sum=0;
+	    for(long long i=0;i<n-1;i++){
+	        long long ma = max(arr[i+1],arr[i]);
+	        long long mi= min(arr[i+1],arr[i]);
+	        if(ma!=mi){
+	            sum += abs((ma-1) -mi);
+	        }
+	    }
+	    cout << sum<<endl;
+	}
+	return 0;
+}

Ad-Hoc/(SPOJ)AMR12D - The Mirror of Galadriel.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <string>
+#include <map>
+using namespace std;
+
+int main () {
+  int t;
+  string tempStr;
+  bool isMagical;
+  scanf ("%d", &t);
+  for (int z = 0; z < t; z++) {
+    isMagical = true;
+    cin >> tempStr;
+    for (int i = 0; i < tempStr.length(); i++)
+      if (tempStr[i] != tempStr[tempStr.length()-1-i])
+        isMagical = false;
+    if (isMagical)
+      cout << "YES\n";
+    else
+      cout << "NO\n";
+  }
+}

Ad-Hoc/(SPOJ)BISHOPS.cpp

@@ -0,0 +1,77 @@
+//https://www.spoj.com/problems/BISHOPS/
+#include<bits/stdc++.h>
+using namespace std;
+
+void mul(string s,string l,char *res)
+{
+	int len1=s.length(),len2=l.length(),i,j;
+	int carry=0,index=-1,maxin=-1;
+	for(i=len1-1;i>=0;i--)
+	{
+		index=len1-i-2;
+		for(j=len2-1;j>=0;j--)
+		{
+			int val=carry+(s[i]-'0')*(l[j]-'0');
+			res[++index]+=val%10;
+			carry=val/10;
+			if(res[index]>'9')
+			{
+				res[index]=res[index]-'9'-1+'0';
+				carry++;
+			}
+		}
+		while(carry)
+		{
+			res[++index]+=carry%10;
+			carry/=10;
+		}
+		if(index>maxin)
+			maxin=index;
+	}
+	res[++maxin]='\0';
+}
+
+int main()
+{
+	string n;
+	while(cin>>n)
+	{
+		if(n=="1"||n=="0")
+		{
+			if(n=="1")
+				cout<<1;
+			else
+				cout<<0;
+			cout<<endl;
+			continue;
+		}
+		string s="2";
+		char res[500];
+		int i;
+		for(i=0;i<500;i++)
+			res[i]='0';
+		mul(n,s,res);
+		int len=strlen(res);
+		i=0;
+		int carry=0;
+		res[0]-=2;
+		while(i<len&&res[i]-carry<'0')
+		{
+			{
+				res[i]=res[i]+10-carry;
+				carry=1;
+			}
+			i++;
+		}
+			res[i]-=carry;
+		i=len-1;
+		while(i>=0&&res[i]=='0')
+			i--;
+		while(i>=0)
+		{
+			cout<<res[i--];
+		}
+		cout<<endl;
+	}
+	return 0;
+}

Backtracking/(LEETCODE)DesignAddAndSearchWordsDS.cpp

@@ -0,0 +1,46 @@
+class WordDictionary {
+    vector<WordDictionary*> children;
+    bool isEndOfWord;
+public:
+    /** Initialize your data structure here. */
+    WordDictionary(): isEndOfWord(false) {
+        children=vector<WordDictionary*>(26,nullptr);
+    }
+    
+    /** Adds a word into the data structure. */
+    void addWord(string word) {
+        WordDictionary *curr  = this;
+        for(char c:word){
+            if(curr->children[c-'a'] == nullptr){
+                curr->children[c-'a'] = new WordDictionary();
+            }
+            curr = curr->children[c-'a'];
+        }
+        curr->isEndOfWord =true;
+    }
+
+    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
+    bool search(string word) {
+         WordDictionary *curr  = this;
+        for(int i=0;i<word.length();++i){
+            char c= word[i];
+            if(c=='.'){
+                for(auto ch:curr->children){
+                    if(ch && ch->search(word.substr(i+1))) return true;
+                }
+                return false;
+            }
+            
+            if(curr->children[c-'a']==nullptr) return false;
+            curr=curr->children[c-'a'];
+        }
+        return curr && curr->isEndOfWord;
+    }
+};
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * WordDictionary* obj = new WordDictionary();
+ * obj->addWord(word);
+ * bool param_2 = obj->search(word);
+ */

Backtracking/Solve_Sudoku.cpp

@@ -0,0 +1,111 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define UNASSIGNED 0
+
+#define N 9
+
+bool FindUnassignedLocation(int grid[N][N],
+                            int &row, int &col);
+
+bool isSafe(int grid[N][N], int row,
+            int col, int num);
+
+bool SolveSudoku(int grid[N][N])
+{
+    int row, col;
+
+    if (!FindUnassignedLocation(grid, row, col))
+
+        return true;
+
+    for (int num = 1; num <= 9; num++)
+    {
+
+        if (isSafe(grid, row, col, num))
+        {
+            grid[row][col] = num;
+
+            if (SolveSudoku(grid))
+                return true;
+
+            grid[row][col] = UNASSIGNED;
+        }
+    }
+    return false;
+}
+
+bool FindUnassignedLocation(int grid[N][N],
+                            int &row, int &col)
+{
+    for (row = 0; row < N; row++)
+        for (col = 0; col < N; col++)
+            if (grid[row][col] == UNASSIGNED)
+                return true;
+    return false;
+}
+
+bool UsedInRow(int grid[N][N], int row, int num)
+{
+    for (int col = 0; col < N; col++)
+        if (grid[row][col] == num)
+            return true;
+    return false;
+}
+
+bool UsedInCol(int grid[N][N], int col, int num)
+{
+    for (int row = 0; row < N; row++)
+        if (grid[row][col] == num)
+            return true;
+    return false;
+}
+
+bool UsedInBox(int grid[N][N], int boxStartRow,
+               int boxStartCol, int num)
+{
+    for (int row = 0; row < 3; row++)
+        for (int col = 0; col < 3; col++)
+            if (grid[row + boxStartRow]
+                    [col + boxStartCol] == num)
+                return true;
+    return false;
+}
+
+bool isSafe(int grid[N][N], int row,
+            int col, int num)
+{
+    /
+            return !UsedInRow(grid, row, num) &&
+        !UsedInCol(grid, col, num) && !UsedInBox(grid, row - row % 3, col - col % 3, num) && grid[row][col] == UNASSIGNED;
+}
+
+void printGrid(int grid[N][N])
+{
+    for (int row = 0; row < N; row++)
+    {
+        for (int col = 0; col < N; col++)
+            cout << grid[row][col] << " ";
+        cout << endl;
+    }
+}
+
+int main()
+{
+    // 0 means unassigned cells
+    int grid[N][N] = {{3, 0, 6, 5, 0, 8, 4, 0, 0},
+                      {5, 2, 0, 0, 0, 0, 0, 0, 0},
+                      {0, 8, 7, 0, 0, 0, 0, 3, 1},
+                      {0, 0, 3, 0, 1, 0, 0, 8, 0},
+                      {9, 0, 0, 8, 6, 3, 0, 0, 5},
+                      {0, 5, 0, 0, 9, 0, 6, 0, 0},
+                      {1, 3, 0, 0, 0, 0, 2, 5, 0},
+                      {0, 0, 0, 0, 0, 0, 0, 7, 4},
+                      {0, 0, 5, 2, 0, 6, 3, 0, 0}};
+    if (SolveSudoku(grid) == true)
+        printGrid(grid);
+    else
+        cout << "No solution exists";
+
+    return 0;
+}

Backtracking/rat_in_a _maze.cpp

@@ -0,0 +1,85 @@
+#include <bits/stdc++.h>
+
+#define N 4
+
+bool solveMazeUtil(
+    int maze[N][N], int x,
+    int y, int sol[N][N]);
+
+void printSolution(int sol[N][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+            printf(" %d ", sol[i][j]);
+        printf("\n");
+    }
+}
+
+bool isSafe(int maze[N][N], int x, int y)
+{
+    if (
+        x >= 0 && x < N && y >= 0 && y < N && maze[x][y] == 1)
+        return true;
+
+    return false;
+}
+
+bool solveMaze(int maze[N][N])
+{
+    int sol[N][N] = {{0, 0, 0, 0},
+                     {0, 0, 0, 0},
+                     {0, 0, 0, 0},
+                     {0, 0, 0, 0}};
+
+    if (solveMazeUtil(
+            maze, 0, 0, sol) == false)
+    {
+        printf("Solution doesn't exist");
+        return false;
+    }
+
+    printSolution(sol);
+    return true;
+}
+
+bool solveMazeUtil(
+    int maze[N][N], int x,
+    int y, int sol[N][N])
+{
+    if (
+        x == N - 1 && y == N - 1 && maze[x][y] == 1)
+    {
+        sol[x][y] = 1;
+        return true;
+    }
+
+    if (isSafe(maze, x, y) == true)
+    {
+        sol[x][y] = 1;
+
+        if (solveMazeUtil(
+                maze, x + 1, y, sol) == true)
+            return true;
+
+        if (solveMazeUtil(
+                maze, x, y + 1, sol) == true)
+            return true;
+
+        sol[x][y] = 0;
+        return false;
+    }
+
+    return false;
+}
+
+int main()
+{
+    int maze[N][N] = {{1, 0, 0, 0},
+                      {1, 1, 0, 1},
+                      {0, 1, 0, 0},
+                      {1, 1, 1, 1}};
+
+    solveMaze(maze);
+    return 0;
+}

BinarySearchTree/(LEETCODE)RandomPickWIthWeight.cpp

@@ -0,0 +1,20 @@
+class Solution {
+    vector<int> cum;
+    int csum;
+public:
+    Solution(vector<int>& w) {
+        csum=0;
+        for(int x : w){
+            csum += x;
+            cum.push_back(csum); 
+        }
+                
+    }
+    
+    int pickIndex() {
+        int idx = rand() % csum;
+        int res = upper_bound(cum.begin(),cum.end(),idx) - cum.begin(); 
+        return res;
+       // return binarySearch(idx+1);
+    }  
+};