Correct some problems

addiegupta · addiegupta · commit ee30d47347d7 · 2019-03-06T23:18:46.000+05:30
diff --git a/Arrays/Add One To Number.cpp b/Arrays/Add One To Number.cpp
@@ -30,28 +30,52 @@ Q : Can the output have 0’s before the most significant digit? Or in other wor
 A : For the purpose of this question, NO. Even if the input has zeroes before the most significant digit.
 
 */
+vector<int> newSolution(vector<int> &A);
+vector<int> initialSolution(vector<int> &A);
 
 vector<int> Solution::plusOne(vector<int> &A) {
+    
+    // return initialSolution(A);
+    return newSolution(A);
+}
+
+// Much cleaner code but requires additional O(n) space
+vector<int> newSolution(vector<int> &A){
+    // Reverse the digits
+    reverse(A.begin(),A.end());
+    vector<int> ans;
+    // Initial carry = 1 i.e. 1 is to be added
+    int carry = 1;
+    int n = A.size();
+    int sum;
+    
+    // add carry 
+    for(int i=0;i<n;i++){
+        sum = A[i] + carry;
+        ans.push_back(sum%10);
+        carry = sum/10;
+    }
+
+    // remaining carry
+    if(carry)  ans.push_back(carry);
+    
+    // remove additional zeroes
+    while(ans[ans.size()-1]==0 && ans.size()>1) ans.pop_back();
+
+    // reverse again to get answer
+    reverse(ans.begin(),ans.end());
+    return ans;
+}
+vector<int> initialSolution(vector<int> &A){
     int n = A.size();
-    int carry=0;
+    int carry=1;
     for(int i=n-1;i>=0;i--){
-        if(i==n-1){
-            if(A[i]==9){
-                A[i]=0;
-                carry=1;
-            }
-            else A[i]++;
-        }
-        else if(carry ==0)break;
-        else{
-            A[i]+=carry;
-            carry=0;
-            if(A[i]==10){
-                A[i]=0;
-                carry=1;
-            }
-        }
+        if(carry==0)break;
+
+        A[i]+=carry%10;
+        carry /=10;        
     }
+    // O(n) additional space only needed if another digit is to be added at start
     if(carry==1){
         int temp=1,newTemp;
         for(int i=0;i<n;i++){
@@ -61,17 +85,16 @@ vector<int> Solution::plusOne(vector<int> &A) {
         }
         A.push_back(temp);
     }
+
+    // Remove extra zeroes at start
     int i =0;
     while(A[i]==0)i++;
-
     if(i>0){
         vector<int>::iterator it1,it2;
         it1=A.begin();
         it2 = it1 + i;
         A.erase(it1,it2);
-
     } 
 
     return A;
-
-}
+}
diff --git a/Binary Search/Matrix Median.cpp b/Binary Search/Matrix Median.cpp
@@ -0,0 +1,55 @@
+/*
+InterviewBit : Matrix Median
+
+Link : https://www.interviewbit.com/problems/matrix-median/
+
+Given a N cross M matrix in which each row is sorted, find the overall median of the matrix. Assume N*M is odd.
+
+For example,
+
+Matrix=
+[1, 3, 5]
+[2, 6, 9]
+[3, 6, 9]
+
+A = [1, 2, 3, 3, 5, 6, 6, 9, 9]
+
+Median is 5. So, we return 5.
+Note: No extra memory is allowed.
+
+*/
+int Solution::findMedian(vector<vector<int>> &A){
+
+	int max=INT_MIN,min=INT_MAX;// max element will be right extreme while min will be on leftmost col
+    int row = A.size();
+    int col = A[0].size();
+    // Get maximum and minimum values
+    for(int i=0;i<row;i++){
+        if(max < A[i][col-1])
+            max = A[i][col-1];
+        if(min > A[i][0])
+            min = A[i][0];
+    }
+    
+    // now we have max and min (why? because median will be somewhat around it)
+    // median will be at position where exactly N/2 element will be less than it
+    // so 
+    // we can find how much element less than than specified element with upper bound
+    int desired = (row*col+1)/2;
+    int mid,less_than;
+    while(min < max){
+        mid = min + (max-min)/2;
+        less_than = 0;
+        for(int i=0;i<row;i++){
+            less_than += (upper_bound(A[i].begin(),A[i].end(),mid)-A[i].begin());
+        }
+        if(less_than < desired){
+            min = mid+1;
+        }
+        else{
+            max = mid;
+        }
+    }
+    return min; // (why min? as we want just N/2 element for which it is greater than)
+
+}
diff --git a/Linked Lists/Insertion Sort List.cpp b/Linked Lists/Insertion Sort List.cpp
@@ -30,19 +30,66 @@ Return 1 -> 2 -> 3
  *     ListNode(int x) : val(x), next(NULL) {}
  * };
  */
+ListNode* initialSolution(ListNode* A);
+ListNode* newSolution(ListNode* A);
+
 ListNode* Solution::insertionSortList(ListNode* A) {
 
     if(!A ||!A->next)return A;
 
+    // return initialSolution(A);
+    return newSolution(A);
+}
+// Lesser memory required
+ListNode* newSolution(ListNode* A){
+    ListNode* sorted = NULL;
+    ListNode* list = A;
+    ListNode* curr;
+  
+    // Traverse over the list
+    while(list){
+        //get first node; this node will be inserted in sorted list
+        curr = list;
+
+        // Detach this node from list
+        list=list->next;
+        curr->next=NULL;
+
+        // Sorted list has not been created || this value is smaller than first node in sorted list
+        if(!sorted || sorted->val > curr->val){
+            curr->next = sorted;
+            sorted = curr;
+        }
+        // Node will be inserted inside list
+        else{
+        
+            // traversal pointer
+            ListNode* s = sorted;
+            // Traverse till correct insertion position is found
+            while(s->next && s->next->val < curr->val) s=s->next;
+            
+            // Insert the node in the list
+            ListNode* temp = s->next;
+            s->next = curr;
+            curr->next =temp;
+        }
+    }
+    return sorted;
+}
+ListNode* initialSolution(ListNode* A){
+
+
     ListNode* ans = new ListNode(0);
-    // ListNode* trav = A;
     ListNode* trav = ans;
+
     while(A){
         int val = A->val;
         trav = ans;
+        // Find correct insertion place in sorted list
         while(trav->next && val>trav->next->val){
             trav=trav->next;
         }
+        // Copy the node in sorted list
         ListNode *temp = trav->next;
         trav->next  = new ListNode(val);
         trav = trav->next;
diff --git a/Strings/Longest Common Prefix.cpp b/Strings/Longest Common Prefix.cpp
@@ -28,15 +28,29 @@ The answer would be “a”.
 
 */
 string Solution::longestCommonPrefix(vector<string> &A) {
+
+	// Stores longest common prefix
 	string ans;
+	
 	int n = A.size();
+	char c;
+	
+	// Entire string is answer
 	if(n==1)return A[0];
+
 	for(int i=0;i<A[0].length();i++){
-		if(i>=A[0].length())return ans;
-		char c = A[0][i];
-		for(int j=1;j<n;j++){
+	
+		// Traverse over the strings
+		for(int j=0;j<n;j++){
+			
+			// Length of string is shorter than required index
 			if(i>=A[j].length())return ans;
-			if(A[j][i]!=c)return ans;
+			
+			// Get character at index i in first string
+			if(j==0)c=A[0][i];
+			
+			// Different character found
+			if(j!=0 && A[j][i]!=c)return ans;
 		}
 		ans.append(1,c);
 	}
diff --git a/Strings/Minimum Characters required to make a String Palindromic.cpp b/Strings/Minimum Characters required to make a String Palindromic.cpp
@@ -0,0 +1,90 @@
+/*
+
+InterviewBit : Minimum Characters required to make a String Palindromic
+
+Link : https://www.interviewbit.com/problems/minimum-characters-required-to-make-a-string-palindromic/
+
+You are given a string. The only operation allowed is to insert characters in the beginning of the string. How many minimum characters are needed to be inserted to make the string a palindrome string
+
+Example:
+Input: ABC
+Output: 2
+Input: AACECAAAA
+Output: 2
+
+
+*/
+
+/** Problem is solved using KMP pattern matching
+
+Answer to the problem is |S| - |LPP|.
+Where |S| is the length of the input string and |LPP| is the length of longest palindromic prefix of the input string.
+
+Why? Let’s assume we have string of the form S = PR, where P is longest possible palindrome and R is the rest of the string.
+To transform S into palindrome we should insert R characters at the beginning of the string. So finally string will have form RPR.
+For example, let’s consider AACECAAAA string. Longest palindromic prefix is AACECAA. The rest of the characters are AA.
+So to make full string palindromic we should add AA at the beginning of the string, ie final string = AA + AACECAA + AA.
+
+But how to find length of longest palindromic prefix?
+Let’s calculate LSP for string of the form S + ‘#’ + reversed S, for example: AACECAAAA#AAAACECAA.
+Last element of LSP is the length of longest prefix-suffix of the entire string (AACECAA in our case -> AACECAA|AA#AA|AACECAA).
+But it is also length of longest palindromic prefix of input string.
+First part of the combined string is input string and the second part is reversed string.
+So when some prefix is the suffix of the entire string it means that the prefix is palindromic.
+
+Finally, we calculated |LPP|, so we can return answer as |S| - |LPP|.
+
+
+*/
+void computeKmpLps(int lps[],string x);
+int Solution::solve(string A) {
+
+
+	int n = A.length();
+
+	string B = A + '$';
+	reverse(A.begin(),A.end());
+	
+    B+=A;
+	
+    int lps[n*2 + 1];
+	
+    computeKmpLps(lps,B);
+	
+    return n - lps[n*2];
+}
+void computeKmpLps(int lps[], string x){
+    int i=1,m=x.length(),len=0;
+
+    lps[0] = 0; // lps[0] is always 0 
+  
+    // the loop calculates lps[i] for i = 1 to M-1 
+    while (i < m) 
+    { 
+        if (x[i] == x[len]) 
+        { 
+            len++; 
+            lps[i] = len; 
+            i++; 
+        } 
+        else // (str[i] != str[len]) 
+        { 
+            // This is tricky. Consider the example. 
+            // AAACAAAA and i = 7. The idea is similar 
+            // to search step. 
+            if (len != 0) 
+            { 
+                len = lps[len-1]; 
+  
+                // Also, note that we do not increment 
+                // i here 
+            } 
+            else // if (len == 0) 
+            { 
+                lps[i] = 0; 
+                i++; 
+            } 
+        } 
+    } 
+
+}
