🚀 26-Sep-2020

Author: sureshmangs

competitive programming/leetcode/1385. Find the Distance Value Between Two Arrays.cpp

@@ -0,0 +1,64 @@
+Given two integer arrays arr1 and arr2, and the integer d, return the distance value between the two arrays.
+
+The distance value is defined as the number of elements arr1[i] such that there is not any element arr2[j] where |arr1[i]-arr2[j]| <= d.
+
+
+
+Example 1:
+
+Input: arr1 = [4,5,8], arr2 = [10,9,1,8], d = 2
+Output: 2
+Explanation:
+For arr1[0]=4 we have:
+|4-10|=6 > d=2
+|4-9|=5 > d=2
+|4-1|=3 > d=2
+|4-8|=4 > d=2
+For arr1[1]=5 we have:
+|5-10|=5 > d=2
+|5-9|=4 > d=2
+|5-1|=4 > d=2
+|5-8|=3 > d=2
+For arr1[2]=8 we have:
+|8-10|=2 <= d=2
+|8-9|=1 <= d=2
+|8-1|=7 > d=2
+|8-8|=0 <= d=2
+Example 2:
+
+Input: arr1 = [1,4,2,3], arr2 = [-4,-3,6,10,20,30], d = 3
+Output: 2
+Example 3:
+
+Input: arr1 = [2,1,100,3], arr2 = [-5,-2,10,-3,7], d = 6
+Output: 1
+
+
+Constraints:
+
+1 <= arr1.length, arr2.length <= 500
+-10^3 <= arr1[i], arr2[j] <= 10^3
+0 <= d <= 100
+
+
+
+
+
+class Solution {
+public:
+    int findTheDistanceValue(vector<int>& arr1, vector<int>& arr2, int d) {
+        int res=0;
+
+        for(auto x: arr1){
+            bool flag=true;
+            for(auto y: arr2){
+                if(abs(x-y)<=d){
+                    flag=false; break;
+                }
+            }
+            if(flag) res++;
+        }
+
+        return res;
+    }
+};

competitive programming/leetcode/2020-September-Challenge/Day-26-Teemo Attacking.cpp

@@ -0,0 +1,76 @@
+In LOL world, there is a hero called Teemo and his attacking can make his enemy Ashe be in poisoned condition. Now, given the Teemo's attacking ascending time series towards Ashe and the poisoning time duration per Teemo's attacking, you need to output the total time that Ashe is in poisoned condition.
+
+You may assume that Teemo attacks at the very beginning of a specific time point, and makes Ashe be in poisoned condition immediately.
+
+Example 1:
+
+Input: [1,4], 2
+Output: 4
+Explanation: At time point 1, Teemo starts attacking Ashe and makes Ashe be poisoned immediately.
+This poisoned status will last 2 seconds until the end of time point 2.
+And at time point 4, Teemo attacks Ashe again, and causes Ashe to be in poisoned status for another 2 seconds.
+So you finally need to output 4.
+
+
+Example 2:
+
+Input: [1,2], 2
+Output: 3
+Explanation: At time point 1, Teemo starts attacking Ashe and makes Ashe be poisoned.
+This poisoned status will last 2 seconds until the end of time point 2.
+However, at the beginning of time point 2, Teemo attacks Ashe again who is already in poisoned status.
+Since the poisoned status won't add up together, though the second poisoning attack will still work at time point 2, it will stop at the end of time point 3.
+So you finally need to output 3.
+
+
+Note:
+
+You may assume the length of given time series array won't exceed 10000.
+You may assume the numbers in the Teemo's attacking time series and his poisoning time duration per attacking are non-negative integers, which won't exceed 10,000,000.
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int findPoisonedDuration(vector<int>& timeSeries, int duration) {
+        int n=timeSeries.size();
+
+        if(n==0) return 0;
+
+        int res=0;
+
+        res+=duration;
+
+        for(int i=1;i<n;i++){
+            if(timeSeries[i]-timeSeries[i-1]>=duration)
+                res+=duration;
+            else res+=timeSeries[i]-timeSeries[i-1];
+        }
+
+        return res;
+    }
+};
+
+
+
+
+
+
+
+class Solution {
+public:
+    int findPoisonedDuration(vector<int>& timeSeries, int duration) {
+       int n=timeSeries.size();
+        if(n==0) return 0;
+        int res=duration;
+        for(int i=1;i<n;i++)
+            res+=min(timeSeries[i]-timeSeries[i-1], duration);
+
+        return res;
+    }
+};

competitive programming/leetcode/495. Teemo Attacking.cpp

@@ -0,0 +1,76 @@
+In LOL world, there is a hero called Teemo and his attacking can make his enemy Ashe be in poisoned condition. Now, given the Teemo's attacking ascending time series towards Ashe and the poisoning time duration per Teemo's attacking, you need to output the total time that Ashe is in poisoned condition.
+
+You may assume that Teemo attacks at the very beginning of a specific time point, and makes Ashe be in poisoned condition immediately.
+
+Example 1:
+
+Input: [1,4], 2
+Output: 4
+Explanation: At time point 1, Teemo starts attacking Ashe and makes Ashe be poisoned immediately.
+This poisoned status will last 2 seconds until the end of time point 2.
+And at time point 4, Teemo attacks Ashe again, and causes Ashe to be in poisoned status for another 2 seconds.
+So you finally need to output 4.
+
+
+Example 2:
+
+Input: [1,2], 2
+Output: 3
+Explanation: At time point 1, Teemo starts attacking Ashe and makes Ashe be poisoned.
+This poisoned status will last 2 seconds until the end of time point 2.
+However, at the beginning of time point 2, Teemo attacks Ashe again who is already in poisoned status.
+Since the poisoned status won't add up together, though the second poisoning attack will still work at time point 2, it will stop at the end of time point 3.
+So you finally need to output 3.
+
+
+Note:
+
+You may assume the length of given time series array won't exceed 10000.
+You may assume the numbers in the Teemo's attacking time series and his poisoning time duration per attacking are non-negative integers, which won't exceed 10,000,000.
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int findPoisonedDuration(vector<int>& timeSeries, int duration) {
+        int n=timeSeries.size();
+
+        if(n==0) return 0;
+
+        int res=0;
+
+        res+=duration;
+
+        for(int i=1;i<n;i++){
+            if(timeSeries[i]-timeSeries[i-1]>=duration)
+                res+=duration;
+            else res+=timeSeries[i]-timeSeries[i-1];
+        }
+
+        return res;
+    }
+};
+
+
+
+
+
+
+
+class Solution {
+public:
+    int findPoisonedDuration(vector<int>& timeSeries, int duration) {
+       int n=timeSeries.size();
+        if(n==0) return 0;
+        int res=duration;
+        for(int i=1;i<n;i++)
+            res+=min(timeSeries[i]-timeSeries[i-1], duration);
+
+        return res;
+    }
+};

competitive programming/leetcode/893. Groups of Special-Equivalent Strings.cpp

@@ -0,0 +1,58 @@
+You are given an array A of strings.
+
+A move onto S consists of swapping any two even indexed characters of S, or any two odd indexed characters of S.
+
+Two strings S and T are special-equivalent if after any number of moves onto S, S == T.
+
+For example, S = "zzxy" and T = "xyzz" are special-equivalent because we may make the moves "zzxy" -> "xzzy" -> "xyzz" that swap S[0] and S[2], then S[1] and S[3].
+
+Now, a group of special-equivalent strings from A is a non-empty subset of A such that:
+
+Every pair of strings in the group are special equivalent, and;
+The group is the largest size possible (ie., there isn't a string S not in the group such that S is special equivalent to every string in the group)
+Return the number of groups of special-equivalent strings from A.
+
+
+Example 1:
+
+Input: ["abcd","cdab","cbad","xyzz","zzxy","zzyx"]
+Output: 3
+Explanation:
+One group is ["abcd", "cdab", "cbad"], since they are all pairwise special equivalent, and none of the other strings are all pairwise special equivalent to these.
+
+The other two groups are ["xyzz", "zzxy"] and ["zzyx"].  Note that in particular, "zzxy" is not special equivalent to "zzyx".
+Example 2:
+
+Input: ["abc","acb","bac","bca","cab","cba"]
+Output: 3
+
+
+Note:
+
+1 <= A.length <= 1000
+1 <= A[i].length <= 20
+All A[i] have the same length.
+All A[i] consist of only lowercase letters.
+
+
+
+
+
+class Solution {
+public:
+    int numSpecialEquivGroups(vector<string>& A) {
+        set<pair<string, string> > s;
+
+        for(auto str: A){
+            pair<string, string> p;
+            for(int i=0;i<str.length();i++){
+                if(i%2==0) p.first+=str[i];
+                else p.second+=str[i];
+            }
+            sort(p.first.begin(), p.first.end());
+            sort(p.second.begin(), p.second.end());
+            s.insert(p);
+        }
+        return s.size();
+    }
+};

competitive programming/leetcode/999. Available Captures for Rook.cpp

@@ -0,0 +1,91 @@
+On an 8 x 8 chessboard, there is one white rook.  There also may be empty squares, white bishops, and black pawns.  These are given as characters 'R', '.', 'B', and 'p' respectively. Uppercase characters represent white pieces, and lowercase characters represent black pieces.
+
+The rook moves as in the rules of Chess: it chooses one of four cardinal directions (north, east, west, and south), then moves in that direction until it chooses to stop, reaches the edge of the board, or captures an opposite colored pawn by moving to the same square it occupies.  Also, rooks cannot move into the same square as other friendly bishops.
+
+Return the number of pawns the rook can capture in one move.
+
+
+
+Example 1:
+
+
+
+Input: [[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".","R",".",".",".","p"],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]
+Output: 3
+Explanation:
+In this example the rook is able to capture all the pawns.
+Example 2:
+
+
+
+Input: [[".",".",".",".",".",".",".","."],[".","p","p","p","p","p",".","."],[".","p","p","B","p","p",".","."],[".","p","B","R","B","p",".","."],[".","p","p","B","p","p",".","."],[".","p","p","p","p","p",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]
+Output: 0
+Explanation:
+Bishops are blocking the rook to capture any pawn.
+Example 3:
+
+
+
+Input: [[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".","p",".",".",".","."],["p","p",".","R",".","p","B","."],[".",".",".",".",".",".",".","."],[".",".",".","B",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".",".",".",".",".","."]]
+Output: 3
+Explanation:
+The rook can capture the pawns at positions b5, d6 and f5.
+
+
+Note:
+
+board.length == board[i].length == 8
+board[i][j] is either 'R', '.', 'B', or 'p'
+There is exactly one cell with board[i][j] == 'R'
+
+
+
+
+
+class Solution {
+public:
+    int numRookCaptures(vector<vector<char>>& board) {
+        int cnt=0;
+
+        int n=board.size();
+
+        int rx, ry;
+
+        for(int i=0;i<n;i++)
+            for(int j=0;j<n;j++)
+                if(board[i][j]=='R'){
+                    rx=i;
+                    ry=j;
+                }
+
+        for(int j=ry;j>=0;j--){
+            if(board[rx][j]=='B') break;
+            if(board[rx][j]=='p'){
+                cnt++; break;
+            }
+        }
+
+        for(int j=ry;j<n;j++){
+            if(board[rx][j]=='B') break;
+            if(board[rx][j]=='p'){
+                cnt++; break;
+            }
+        }
+
+        for(int i=rx;i>=0;i--){
+            if(board[i][ry]=='B') break;
+            if(board[i][ry]=='p'){
+                cnt++; break;
+            }
+        }
+
+        for(int i=rx;i<n;i++){
+            if(board[i][ry]=='B') break;
+            if(board[i][ry]=='p'){
+                cnt++; break;
+            }
+        }
+
+        return cnt;
+    }
+};