🚀 18-Sep-2020

Author: sureshmangs

competitive programming/leetcode/1041. Robot Bounded In Circle.cpp

@@ -0,0 +1,82 @@
+On an infinite plane, a robot initially stands at (0, 0) and faces north.  The robot can receive one of three instructions:
+
+"G": go straight 1 unit;
+"L": turn 90 degrees to the left;
+"R": turn 90 degress to the right.
+The robot performs the instructions given in order, and repeats them forever.
+
+Return true if and only if there exists a circle in the plane such that the robot never leaves the circle.
+
+
+
+Example 1:
+
+Input: "GGLLGG"
+Output: true
+Explanation:
+The robot moves from (0,0) to (0,2), turns 180 degrees, and then returns to (0,0).
+When repeating these instructions, the robot remains in the circle of radius 2 centered at the origin.
+Example 2:
+
+Input: "GG"
+Output: false
+Explanation:
+The robot moves north indefinitely.
+Example 3:
+
+Input: "GL"
+Output: true
+Explanation:
+The robot moves from (0, 0) -> (0, 1) -> (-1, 1) -> (-1, 0) -> (0, 0) -> ...
+
+
+Note:
+
+1 <= instructions.length <= 100
+instructions[i] is in {'G', 'L', 'R'}
+   Hide Hint #1
+Calculate the final vector of how the robot travels after executing all instructions once - it consists of a change in position plus a change in direction.
+   Hide Hint #2
+The robot stays in the circle iff (looking at the final vector) it changes direction (ie. doesn't stay pointing north), or it moves 0.
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    bool isRobotBounded(string instructions) {
+        int n=instructions.length();
+        int dir=0; // 0-N, 1-E, 2-S, 3-W
+        int x=0, y=0;
+        for(int i=0;i<n;i++){
+            if(instructions[i]=='G'){
+                if(dir==0) y++;
+                else if(dir==1) x--;
+                else if(dir==2) y--;
+                else x++;
+            } else if(instructions[i]=='L'){
+                if(dir==0) dir=1;
+                else if(dir==1) dir=2;
+                else if(dir==2) dir=3;
+                else dir=0;
+            } else if(instructions[i]=='R'){
+                if(dir==0) dir=3;
+                else if(dir==1) dir=0;
+                else if(dir==2) dir=1;
+                else dir=2;
+            }
+        }
+
+
+        if(x==0 && y==0) return true;
+        else if(dir!=0) return true;
+        else return false;
+    }
+};

competitive programming/leetcode/1470. Shuffle the Array.cpp

@@ -0,0 +1,48 @@
+Given the array nums consisting of 2n elements in the form [x1,x2,...,xn,y1,y2,...,yn].
+
+Return the array in the form [x1,y1,x2,y2,...,xn,yn].
+
+
+
+Example 1:
+
+Input: nums = [2,5,1,3,4,7], n = 3
+Output: [2,3,5,4,1,7]
+Explanation: Since x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 then the answer is [2,3,5,4,1,7].
+Example 2:
+
+Input: nums = [1,2,3,4,4,3,2,1], n = 4
+Output: [1,4,2,3,3,2,4,1]
+Example 3:
+
+Input: nums = [1,1,2,2], n = 2
+Output: [1,2,1,2]
+
+
+Constraints:
+
+1 <= n <= 500
+nums.length == 2n
+1 <= nums[i] <= 10^3
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<int> shuffle(vector<int>& nums, int n) {
+        vector<int> res;
+        for(int i=0;i<n;i++){
+            res.push_back(nums[i]);
+            res.push_back(nums[n+i]);
+        }
+        return res;
+    }
+};

competitive programming/leetcode/2020-September-Challenge/Day-17-Robot Bounded In Circle.cpp

@@ -0,0 +1,82 @@
+On an infinite plane, a robot initially stands at (0, 0) and faces north.  The robot can receive one of three instructions:
+
+"G": go straight 1 unit;
+"L": turn 90 degrees to the left;
+"R": turn 90 degress to the right.
+The robot performs the instructions given in order, and repeats them forever.
+
+Return true if and only if there exists a circle in the plane such that the robot never leaves the circle.
+
+
+
+Example 1:
+
+Input: "GGLLGG"
+Output: true
+Explanation:
+The robot moves from (0,0) to (0,2), turns 180 degrees, and then returns to (0,0).
+When repeating these instructions, the robot remains in the circle of radius 2 centered at the origin.
+Example 2:
+
+Input: "GG"
+Output: false
+Explanation:
+The robot moves north indefinitely.
+Example 3:
+
+Input: "GL"
+Output: true
+Explanation:
+The robot moves from (0, 0) -> (0, 1) -> (-1, 1) -> (-1, 0) -> (0, 0) -> ...
+
+
+Note:
+
+1 <= instructions.length <= 100
+instructions[i] is in {'G', 'L', 'R'}
+   Hide Hint #1
+Calculate the final vector of how the robot travels after executing all instructions once - it consists of a change in position plus a change in direction.
+   Hide Hint #2
+The robot stays in the circle iff (looking at the final vector) it changes direction (ie. doesn't stay pointing north), or it moves 0.
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    bool isRobotBounded(string instructions) {
+        int n=instructions.length();
+        int dir=0; // 0-N, 1-E, 2-S, 3-W
+        int x=0, y=0;
+        for(int i=0;i<n;i++){
+            if(instructions[i]=='G'){
+                if(dir==0) y++;
+                else if(dir==1) x--;
+                else if(dir==2) y--;
+                else x++;
+            } else if(instructions[i]=='L'){
+                if(dir==0) dir=1;
+                else if(dir==1) dir=2;
+                else if(dir==2) dir=3;
+                else dir=0;
+            } else if(instructions[i]=='R'){
+                if(dir==0) dir=3;
+                else if(dir==1) dir=0;
+                else if(dir==2) dir=1;
+                else dir=2;
+            }
+        }
+
+
+        if(x==0 && y==0) return true;
+        else if(dir!=0) return true;
+        else return false;
+    }
+};

competitive programming/leetcode/2020-September-Challenge/Day-18-Best Time to Buy and Sell Stock.cpp

@@ -0,0 +1,40 @@
+Say you have an array for which the ith element is the price of a given stock on day i.
+
+If you were only permitted to complete at most one transaction (i.e., buy one and sell one share of the stock), design an algorithm to find the maximum profit.
+
+Note that you cannot sell a stock before you buy one.
+
+Example 1:
+
+Input: [7,1,5,3,6,4]
+Output: 5
+Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
+             Not 7-1 = 6, as selling price needs to be larger than buying price.
+Example 2:
+
+Input: [7,6,4,3,1]
+Output: 0
+Explanation: In this case, no transaction is done, i.e. max profit = 0.
+
+
+
+
+
+
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int n=prices.size();
+        if(n==0) return 0;
+        int res=0;
+        int mini=prices[0];
+        for(int i=1;i<n;i++){
+            if(prices[i]<mini){
+                mini=prices[i];
+            } else {
+                res=max(res, prices[i]-mini);
+            }
+        }
+        return res;
+    }
+};