Merge branch 'smv1999:master' into integer-to-roman

Author: ishikasinha-d

Backtracking/Knight's_Tour.py

@@ -0,0 +1,85 @@
+'''
+Aim: To check whether it is possible for a Knight to visit each
+         cell of the N*N chessboard without visiting any cell
+         twice starting from (X, Y) position.
+Intution: To visit each and every positions which are available from
+          the current position and recursively repeat this until
+          all the cells are covered.
+        
+'''
+
+from time import time
+
+
+def move_Knight(n, pos, move, ans, step):
+    x, y = pos
+
+    # Base Case
+    if step == n * n:
+        return ans
+    for i in move:
+        r = x + i[0]
+        c = y + i[1]
+        if 0 <= r < n and 0 <= c < n and not ans[r][c]:
+            ans[r][c] = step + 1
+            temp = move_Knight(n, (r, c), move, ans, step + 1)
+            if temp is not False:
+                return temp
+            ans[r][c] = 0
+    return False
+
+
+def Knight_Tour(n, pos):
+    x, y = pos
+
+    # All valid moves that a Knight can make
+    move = [[2, 1], [2, -1], [-2, 1], [-2, -1],
+            [1, 2], [1, -2], [-1, 2], [-1, -2]]
+
+    # To keep a track of already visited cells and
+    # Answer Matrix
+    answer = [[0]*n for i in range(n)]
+
+    # To mark (X, Y) cell as visited
+    answer[x][y] = 1
+
+    return move_Knight(n, pos, move, answer, 1)
+
+
+# ------------------------DRIVER CODE ------------------------
+
+if __name__ == "__main__":
+
+    # Input the initial Position of the Knight
+    N = int(input("Enter the size of the Chessboard: "))
+    X, Y = map(int, input("Enter Initial Position of the Knight: ").split())
+    start = time()
+    ans_mat = Knight_Tour(N, (X-1, Y-1))
+    if ans_mat is False:
+        print("Knight's Tour form the given initial position is not possible")
+    else:
+        print("The desired Knight's Tour :")
+        for i in ans_mat:
+            print("\t\t", *i)
+    print("Time taken: ", time()-start)
+
+'''
+
+Sample Working:
+    
+Enter the size of the Chessboard: 5
+Enter the Initial Position of the Knight: 1 1
+The desired Knight's Tour :
+                1 6 15 10 21
+                14 9 20 5 16
+                19 2 7 22 11
+                8 13 24 17 4
+                25 18 3 12 23
+Time taken:  0.10171318054199219
+
+COMPLEXITY:
+    
+     Time Complexity ->  O(8^N)
+     Space Complexity -> O(N^2)
+
+'''

Recursion/Possible_Words_From_Phone_Digits.cpp

@@ -0,0 +1,115 @@
+/*
+Possible Words From Phone Digits
+Medium Accuracy: 51.47% Submissions: 11922 Points: 4
+Given a keypad as shown in the diagram, and an N digit number which is represented by array a[ ], the task is to list all words which are possible by pressing these numbers.
+
+
+Example 1:
+
+Input: N = 3, a[] = {2, 3, 4}
+Output:
+adg adh adi aeg aeh aei afg afh afi
+bdg bdh bdi beg beh bei bfg bfh bfi
+cdg cdh cdi ceg ceh cei cfg cfh cfi
+Explanation: When we press 2,3,4 then
+adg, adh, adi, ... cfi are the list of
+possible words.
+Example 2:
+
+Input: N = 3, a[] = {3, 4, 5}
+Output:
+dgj dgk dgl dhj dhk dhl dij dik dil
+egj egk egl ehj ehk ehl eij eik eil
+fgj fgk fgl fhj fhk fhl fij fik fil
+Explanation: When we press 3,4,5 then
+dgj, dgk, dgl, ... fil are the list of
+possible words.
+Your Task:
+You don't need to read input or print anything. You just need to complete the function possibleWords() that takes an array a[ ] and N as input parameters and returns an array of all the possible words in lexicographical increasing order.
+
+Expected Time Complexity: O(4N * N).
+Expected Auxiliary Space: O(N).
+
+Constraints:
+1 ≤ N ≤ 10
+2 ≤ a[i] ≤ 9
+*/
+
+//Initial Template for C++
+
+#include <bits/stdc++.h>
+#include <string>
+
+using namespace std;
+
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution
+{
+    public:
+    //Function to find list of all words possible by pressing given numbers.
+
+
+    void formstring(int a[], int N, string s, vector<string>&v, int i,map<int, vector<char>>m){
+        if(i == N){
+            v.push_back(s);
+            return;
+        }
+        int pos = a[i];
+        for(auto j : m[pos]){
+            formstring(a,N,s+j,v,i+1,m);
+        }
+    }
+    vector<string> possibleWords(int a[], int N)
+    {
+        map<int, vector<char>>m;
+        int k = 0;
+        for(int i = 2;i<=6;i++){
+            int j = 0;
+            while(j<3){
+                m[i].push_back('a'+ j + k);
+                j++;
+            }
+            k+=3;
+        }
+        m[7] = {'p','q','r','s'};
+        m[8] = {'t','u','v'};
+        m[9] = {'w','x','y','z'};
+
+        vector<string>ans;
+        formstring(a,N,"",ans,0,m);
+        return ans;
+    }
+};
+
+
+// { Driver Code Starts.
+
+int main() {
+
+	int T;
+
+	cin >> T; //testcases
+
+	while(T--){ //while testcases exist
+	   int N;
+
+	   cin >> N; //input size of array
+
+	   int a[N]; //declare the array
+
+	   for(int i =0;i<N;i++){
+	       cin >> a[i]; //input the elements of array that are keys to be pressed
+	   }
+
+	   Solution obj;
+
+	  vector <string> res = obj.possibleWords(a,N);
+	  for (string i : res) cout << i << " ";
+	   cout << endl;
+	}
+
+	return 0;
+}  // } Driver Code Ends

Strings/string_permutations.cpp

@@ -0,0 +1,45 @@
+// Problem: Print all permutations of string
+
+// Input: ABC
+// Output: ABC ACB BAC BCA CBA CAB
+
+// Concept: Backtracking
+
+#include<bits/stdc++.h>
+#define fl(i,a,b) for(i=a;i<b;i++)
+#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
+using namespace std;
+typedef long long int ll;
+vector<string> permutations;
+
+vector<string> permute(string str, ll l, ll r)
+{
+   if(l==r)
+      {
+         permutations.push_back(str);
+         return permutations;
+      }
+   for(ll i=l; i<=r; i++)
+   {
+      swap(str[l], str[i]);
+      permute(str, l+1, r);
+      swap(str[l], str[i]);
+   }
+   return permutations;
+}
+
+int main()
+{ 
+   fast;
+
+string str;
+cin>>str;
+
+vector <string> ans= permute(str, 0, str.length()-1);
+
+for(auto x: ans)
+   cout<<x<<" ";
+
+return 0;
+
+}