🚀 04-Aug-2020

Author: sureshmangs

competitive programming/leetcode/125. Valid Palindrome.cpp

@@ -0,0 +1,46 @@
+Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
+
+Note: For the purpose of this problem, we define empty string as valid palindrome.
+
+Example 1:
+
+Input: "A man, a plan, a canal: Panama"
+Output: true
+Example 2:
+
+Input: "race a car"
+Output: false
+
+
+Constraints:
+
+s consists only of printable ASCII characters.
+
+
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+
+    bool isPalindrome(string s) {
+        int n=s.length();
+        int i=0, j=n-1;
+        while(i<j){
+            if(!isalnum(s[i])){ i++; continue; }
+            if(!isalnum(s[j])){ j--; continue; }
+            if(tolower(s[i])!=tolower(s[j])) return false;
+            i++;
+            j--;
+        }
+        return true;
+    }
+};

competitive programming/leetcode/2020-August-Challenge/Day-03-Valid Palindrome.cpp

@@ -0,0 +1,46 @@
+Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
+
+Note: For the purpose of this problem, we define empty string as valid palindrome.
+
+Example 1:
+
+Input: "A man, a plan, a canal: Panama"
+Output: true
+Example 2:
+
+Input: "race a car"
+Output: false
+
+
+Constraints:
+
+s consists only of printable ASCII characters.
+
+
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+
+    bool isPalindrome(string s) {
+        int n=s.length();
+        int i=0, j=n-1;
+        while(i<j){
+            if(!isalnum(s[i])){ i++; continue; }
+            if(!isalnum(s[j])){ j--; continue; }
+            if(tolower(s[i])!=tolower(s[j])) return false;
+            i++;
+            j--;
+        }
+        return true;
+    }
+};

competitive programming/leetcode/268. Missing Number.cpp

@@ -0,0 +1,30 @@
+Given an array containing n distinct numbers taken from 0, 1, 2, ..., n, find the one that is missing from the array.
+
+Example 1:
+
+Input: [3,0,1]
+Output: 2
+Example 2:
+
+Input: [9,6,4,2,3,5,7,0,1]
+Output: 8
+Note:
+Your algorithm should run in linear runtime complexity. Could you implement it using only constant extra space complexity?
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int missingNumber(vector<int>& nums) {
+        int res=0, n=nums.size();
+        for(int i=1;i<=n;i++) res^=i;
+        for(int x: nums)
+            res^=x;
+        return res;
+    }
+};

competitive programming/leetcode/287. Find the Duplicate Number.cpp

@@ -62,3 +62,39 @@ class Solution {
 };
 
 
+
+
+
+
+
+
+
+// Slow and Fast pointer technique (will also work for negatives)
+// D = distance from start till starting of loop
+//  K = distance start of loop till both pointers meet
+//   C = length of loop
+//   i, j   distance covered in loops by fast and slow pointer
+// distance covered by slow, N = D + K + C * i
+// distance covered by fast, 2N = D + K + C * j
+// subtracting we get D = C(j - 2*i ) - K
+// Place slow to start again, it covers D distance to reach start of loop
+//  Lets say fast makes x loops and still remains on the colliding position and now
+// if he has to reach the start of the loop he hast to go K steps backward
+
+class Solution {
+public:
+    int findDuplicate(vector<int>& nums) {
+        if(nums.size()<=0) return -1;
+        int slow=nums[0], fast=nums[0];
+        do{
+            slow=nums[slow];
+            fast=nums[nums[fast]];
+        }while(slow!=fast);
+        fast=nums[0];
+        while(slow!=fast){
+            slow=nums[slow];
+            fast=nums[fast];
+        }
+        return slow;
+    }
+};

competitive programming/leetcode/75. Sort Colors.cpp

@@ -35,3 +35,27 @@ class Solution {
         for(int i=zeros+ones;i<zeros+ones+twos;i++) nums[i]=2;
     }
 };
+
+
+
+
+
+// Dutch national Flag Algorithm
+
+class Solution {
+public:
+    void sortColors(vector<int>& nums) {
+        int n=nums.size();
+        int low=0, mid=0, high=n-1;
+        while(mid<=high){
+            if(nums[mid]==0){    // Step 1
+                swap(nums[low], nums[mid]);
+                low++; mid++;
+            } else if(nums[mid]==1) mid++;    // Step 2
+            else {
+                swap(nums[mid], nums[high]);    // Step 3
+                high--;
+            }
+        }
+    }
+};