7218

Author: sk-g

C++/142. Linked List Cycle II.cpp

@@ -0,0 +1,31 @@
+//142. Linked List Cycle II
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *detectCycle(ListNode *head) {
+        ListNode* fast = head;
+        ListNode* slow = head;
+        ListNode* entry = head;
+        while(slow && fast && fast->next){
+            slow = slow->next;
+            fast = fast->next->next;
+            if(slow == fast){
+                while(slow!=entry){
+                    slow = slow->next;
+                    entry = entry->next;
+                }
+                return entry;
+            }
+        }
+        return NULL;    
+        
+    }
+};

C++/234. Palindrome Linked List.cpp

@@ -0,0 +1,39 @@
+
+//234. Palindrome Linked List
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool isPalindrome(ListNode* head) {
+        if(head == NULL || head->next == NULL) return true;
+        return find(head,head->next)!=NULL?true:false;
+    }
+    ListNode* find(ListNode* head,ListNode* nex) {
+        
+        //If only one element
+        if(nex==NULL) return head;
+        
+        //If you reach the last element
+        if(nex->next==NULL)
+            return head->val==nex->val ? head->next : NULL;
+        
+        //Recursively call till you reach last element.
+        //As soon as you reach the last element, Just return the next of the head
+        //So that previous calls can use that refernce and compare with the second last and so on
+        
+        ListNode* checkhead = find(head,nex->next);
+        
+        if(checkhead==NULL) return NULL;
+
+        return checkhead->val==nex->val?checkhead->next:NULL;
+        
+    }
+	    
+};

C++/261. Graph Valid Tree.cpp

@@ -0,0 +1,23 @@
+//261. Graph Valid Tree
+
+class Solution {
+public:
+    bool validTree(int n, vector<pair<int, int>>& edges) {
+        vector<int> nodes(n,0);
+        for(int i=0;i<nodes.size();++i){
+            nodes[i] = i;
+        }
+        for(int i=0;i<edges.size();++i){
+            int root1 = edges[i].first;
+            int root2 = edges[i].second;
+            while(nodes[root1]!=root1)
+                root1 = nodes[root1];
+            while(nodes[root2]!=root2)
+                root2 = nodes[root2];
+            if(root1==root2)
+                return false;
+            nodes[root2] = root1;
+        }
+        return  edges.size() == n-1;
+    }
+};

C++/674. Longest Continuous Increasing Subsequence.cpp

@@ -0,0 +1,35 @@
+/*
+        674. Longest Continuous Increasing Subsequence
+
+        if len(nums) < 1:
+            return 0
+        cur_len = 1
+        max_len = 1
+        for i in range(1,len(nums)):
+            if nums[i] > nums[i-1]:
+                cur_len = cur_len + 1
+            else:
+                cur_len = 1
+                
+            if cur_len > max_len:
+                max_len = cur_len
+        return max_len
+
+*/
+static int x = []() { std::ios::sync_with_stdio(false); cin.tie(NULL); return 0; }();
+
+class Solution {
+public:
+    int findLengthOfLCIS(vector<int>& nums) {
+        if(nums.size()<1){
+            return 0;
+        }
+        int current = 1;
+        int max = 1;
+        for(int i=1;i<nums.size();++i){
+            current = (nums[i]>nums[i-1])?current+1:1;
+            max = (current>max)?current:max;
+        }
+        return max;
+    }
+};

python/209. Minimum Size Subarray Sum.py

@@ -0,0 +1,21 @@
+#209. Minimum Size Subarray Sum
+# same two pointer idea as mentioned in solution
+# main idea is to precompute sums and then change 
+# it on the go as per required.
+class Solution:
+    def minSubArrayLen(self, s, nums):
+        n = len(nums)
+        ans = float('inf')
+        left = 0
+        presum = 0
+        for i in range(n):
+            presum += nums[i]
+            while (presum>=s):
+                ans = min(ans,i-left+1)
+                presum -= nums[left]
+                left += 1
+        if ans == float('inf'):
+            return 0
+        else:
+            return ans
+