🚀 01-Nov-2020

Author: sureshmangs

competitive programming/leetcode/1290. Convert Binary Number in a Linked List to Integer.cpp

@@ -0,0 +1,78 @@
+Given head which is a reference node to a singly-linked list. The value of each node in the linked list is either 0 or 1. The linked list holds the binary representation of a number.
+
+Return the decimal value of the number in the linked list.
+
+
+
+Example 1:
+
+
+Input: head = [1,0,1]
+Output: 5
+Explanation: (101) in base 2 = (5) in base 10
+Example 2:
+
+Input: head = [0]
+Output: 0
+Example 3:
+
+Input: head = [1]
+Output: 1
+Example 4:
+
+Input: head = [1,0,0,1,0,0,1,1,1,0,0,0,0,0,0]
+Output: 18880
+Example 5:
+
+Input: head = [0,0]
+Output: 0
+
+
+Constraints:
+
+The Linked List is not empty.
+Number of nodes will not exceed 30.
+Each node's value is either 0 or 1.
+   Hide Hint #1
+Traverse the linked list and store all values in a string or array. convert the values obtained to decimal value.
+   Hide Hint #2
+You can solve the problem in O(1) memory using bits operation. use shift left operation ( << ) and or operation ( | ) to get the decimal value in one operation.
+
+
+
+
+
+
+
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    int getDecimalValue(ListNode* head) {
+        int len=0;
+        ListNode *curr=head;
+        while(curr){
+            len++;
+            curr=curr->next;
+        }
+        curr=head;
+        len--;
+        int res=0;
+
+        while(curr){
+            res+=curr->val*pow(2, len);
+            len--;
+            curr=curr->next;
+        }
+        return res;
+    }
+};

competitive programming/leetcode/1624. Largest Substring Between Two Equal Characters.cpp

@@ -0,0 +1,63 @@
+Given a string s, return the length of the longest substring between two equal characters, excluding the two characters. If there is no such substring return -1.
+
+A substring is a contiguous sequence of characters within a string.
+
+
+
+Example 1:
+
+Input: s = "aa"
+Output: 0
+Explanation: The optimal substring here is an empty substring between the two 'a's.
+Example 2:
+
+Input: s = "abca"
+Output: 2
+Explanation: The optimal substring here is "bc".
+Example 3:
+
+Input: s = "cbzxy"
+Output: -1
+Explanation: There are no characters that appear twice in s.
+Example 4:
+
+Input: s = "cabbac"
+Output: 4
+Explanation: The optimal substring here is "abba". Other non-optimal substrings include "bb" and "".
+
+
+Constraints:
+
+1 <= s.length <= 300
+s contains only lowercase English letters.
+
+
+
+
+
+class Solution {
+public:
+    int maxLengthBetweenEqualCharacters(string s) {
+        vector<int> first(26, -1);
+        vector<int> last(26, -1);
+
+        int n=s.length();
+
+        for(int i=0;i<n;i++){
+            if(first[s[i]-'a']==-1)
+                first[s[i]-'a']=i;
+        }
+
+        for(int i=0;i<n;i++){
+            last[s[i]-'a']=i;
+        }
+
+        int maxi=-1;
+
+        for(int i=0;i<26;i++){
+            maxi=max(maxi, last[i]-first[i]-1);
+        }
+
+        return maxi;
+    }
+};

competitive programming/leetcode/1629. Slowest Key.cpp

@@ -0,0 +1,65 @@
+A newly designed keypad was tested, where a tester pressed a sequence of n keys, one at a time.
+
+You are given a string keysPressed of length n, where keysPressed[i] was the ith key pressed in the testing sequence, and a sorted list releaseTimes, where releaseTimes[i] was the time the ith key was released. Both arrays are 0-indexed. The 0th key was pressed at the time 0, and every subsequent key was pressed at the exact time the previous key was released.
+
+The tester wants to know the key of the keypress that had the longest duration. The ith keypress had a duration of releaseTimes[i] - releaseTimes[i - 1], and the 0th keypress had a duration of releaseTimes[0].
+
+Note that the same key could have been pressed multiple times during the test, and these multiple presses of the same key may not have had the same duration.
+
+Return the key of the keypress that had the longest duration. If there are multiple such keypresses, return the lexicographically largest key of the keypresses.
+
+
+
+Example 1:
+
+Input: releaseTimes = [9,29,49,50], keysPressed = "cbcd"
+Output: "c"
+Explanation: The keypresses were as follows:
+Keypress for 'c' had a duration of 9 (pressed at time 0 and released at time 9).
+Keypress for 'b' had a duration of 29 - 9 = 20 (pressed at time 9 right after the release of the previous character and released at time 29).
+Keypress for 'c' had a duration of 49 - 29 = 20 (pressed at time 29 right after the release of the previous character and released at time 49).
+Keypress for 'd' had a duration of 50 - 49 = 1 (pressed at time 49 right after the release of the previous character and released at time 50).
+The longest of these was the keypress for 'b' and the second keypress for 'c', both with duration 20.
+'c' is lexicographically larger than 'b', so the answer is 'c'.
+Example 2:
+
+Input: releaseTimes = [12,23,36,46,62], keysPressed = "spuda"
+Output: "a"
+Explanation: The keypresses were as follows:
+Keypress for 's' had a duration of 12.
+Keypress for 'p' had a duration of 23 - 12 = 11.
+Keypress for 'u' had a duration of 36 - 23 = 13.
+Keypress for 'd' had a duration of 46 - 36 = 10.
+Keypress for 'a' had a duration of 62 - 46 = 16.
+The longest of these was the keypress for 'a' with duration 16.
+
+
+Constraints:
+
+releaseTimes.length == n
+keysPressed.length == n
+2 <= n <= 1000
+1 <= releaseTimes[i] <= 109
+releaseTimes[i] < releaseTimes[i+1]
+keysPressed contains only lowercase English letters.
+
+
+
+
+
+
+class Solution {
+public:
+    char slowestKey(vector<int>& releaseTimes, string keysPressed) {
+        int n=releaseTimes.size();
+        int maxi=releaseTimes[0];
+        int index=0;
+        for(int i=1;i<n;i++){
+            if(releaseTimes[i]-releaseTimes[i-1] >=maxi){
+                maxi=releaseTimes[i]-releaseTimes[i-1] ;
+                index=i;
+            }
+        }
+        return keysPressed[index];
+    }
+};

competitive programming/leetcode/1630. Arithmetic Subarrays.cpp

@@ -0,0 +1,80 @@
+A sequence of numbers is called arithmetic if it consists of at least two elements, and the difference between every two consecutive elements is the same. More formally, a sequence s is arithmetic if and only if s[i+1] - s[i] == s[1] - s[0] for all valid i.
+
+For example, these are arithmetic sequences:
+
+1, 3, 5, 7, 9
+7, 7, 7, 7
+3, -1, -5, -9
+The following sequence is not arithmetic:
+
+1, 1, 2, 5, 7
+You are given an array of n integers, nums, and two arrays of m integers each, l and r, representing the m range queries, where the ith query is the range [l[i], r[i]]. All the arrays are 0-indexed.
+
+Return a list of boolean elements answer, where answer[i] is true if the subarray nums[l[i]], nums[l[i]+1], ... , nums[r[i]] can be rearranged to form an arithmetic sequence, and false otherwise.
+
+
+
+Example 1:
+
+Input: nums = [4,6,5,9,3,7], l = [0,0,2], r = [2,3,5]
+Output: [true,false,true]
+Explanation:
+In the 0th query, the subarray is [4,6,5]. This can be rearranged as [6,5,4], which is an arithmetic sequence.
+In the 1st query, the subarray is [4,6,5,9]. This cannot be rearranged as an arithmetic sequence.
+In the 2nd query, the subarray is [5,9,3,7]. This can be rearranged as [3,5,7,9], which is an arithmetic sequence.
+Example 2:
+
+Input: nums = [-12,-9,-3,-12,-6,15,20,-25,-20,-15,-10], l = [0,1,6,4,8,7], r = [4,4,9,7,9,10]
+Output: [false,true,false,false,true,true]
+
+
+Constraints:
+
+n == nums.length
+m == l.length
+m == r.length
+2 <= n <= 500
+1 <= m <= 500
+0 <= l[i] < r[i] < n
+-105 <= nums[i] <= 105
+
+
+
+
+
+
+
+class Solution {
+public:
+
+    bool isArithmetic(vector<int> tmp){
+        int n=tmp.size();
+        sort(tmp.begin(), tmp.end());
+        if(n<=1) return false;
+        int cd=tmp[1]-tmp[0];
+        for(int i=0;i<n-1;i++){
+            if(tmp[i+1]-tmp[i]!=cd) return false;
+        }
+
+        return true;
+    }
+
+    vector<bool> checkArithmeticSubarrays(vector<int>& nums, vector<int>& l, vector<int>& r) {
+        vector<bool> res;
+        int n=nums.size();
+        int m=l.size();
+        for(int i=0;i<m;i++){
+            int start=l[i];
+            int end=r[i];
+            vector<int> tmp;
+            for(int j=start;j<=end;j++)
+                tmp.push_back(nums[j]);
+
+            res.push_back(isArithmetic(tmp));
+
+        }
+
+        return res;
+
+    }
+};

competitive programming/leetcode/198. House Robber.cpp

@@ -57,3 +57,33 @@ Step 3. Recursive + memo (top-down).
 
 
 //Sourece:   https://leetcode.com/problems/house-robber/discuss/156523/From-good-to-great.-How-to-approach-most-of-DP-problems.
+
+*/
+
+
+
+
+
+
+
+
+// Optimized
+
+class Solution {
+public:
+
+    int robUtil(vector<int> &nums, int l, int r){
+        int prev=0, curr=0;
+        for(int i=l;i<=r;i++){
+            int tmp=max(prev+nums[i], curr);
+            prev=curr;
+            curr=tmp;
+        }
+        return curr;
+    }
+
+    int rob(vector<int>& nums) {
+        int n=nums.size();
+        return robUtil(nums, 0, n-1);
+    }
+};