🚀 02-Aug-2020

Author: sureshmangs

competitive programming/leetcode/2020-August-Challenge/Day-01-Detect Capital.cpp

@@ -0,0 +1,51 @@
+Given a word, you need to judge whether the usage of capitals in it is right or not.
+
+We define the usage of capitals in a word to be right when one of the following cases holds:
+
+All letters in this word are capitals, like "USA".
+All letters in this word are not capitals, like "leetcode".
+Only the first letter in this word is capital, like "Google".
+Otherwise, we define that this word doesn't use capitals in a right way.
+
+
+Example 1:
+
+Input: "USA"
+Output: True
+
+
+Example 2:
+
+Input: "FlaG"
+Output: False
+
+
+Note: The input will be a non-empty word consisting of uppercase and lowercase latin letters.
+
+
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    bool detectCapitalUse(string word) {
+        int n=word.length();
+        int sm=0, bg=0;
+        for(int i=0;i<n;i++){
+            if(word[i]>='a' && word[i]<='z') sm++;
+            else bg++;
+        }
+        if(bg==n) return true;
+        if(sm==n) return true;
+        if((word[0]>='A' && word[0]<='Z') && sm==n-1) return true;
+        return false;
+    }
+};

competitive programming/leetcode/2020-July-Challenge/Day-31-Climbing Stairs.cpp

@@ -0,0 +1,79 @@
+You are climbing a stair case. It takes n steps to reach to the top.
+
+Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+
+Example 1:
+
+Input: 2
+Output: 2
+Explanation: There are two ways to climb to the top.
+1. 1 step + 1 step
+2. 2 steps
+Example 2:
+
+Input: 3
+Output: 3
+Explanation: There are three ways to climb to the top.
+1. 1 step + 1 step + 1 step
+2. 1 step + 2 steps
+3. 2 steps + 1 step
+
+
+Constraints:
+
+1 <= n <= 45
+   Hide Hint #1
+To reach nth step, what could have been your previous steps? (Think about the step sizes)
+
+
+
+
+
+
+
+
+
+
+
+
+// recursive (TLE)
+
+class Solution {
+public:
+
+    int rec(int n){
+        if(n<=1) return 1;    // Only one way to reach
+        return rec(n-1) + rec(n-2);
+    }
+
+    int climbStairs(int n) {
+        return rec(n);
+    }
+};
+
+
+
+
+
+
+
+// Memoization
+
+class Solution {
+public:
+
+    int rec(int n, int dp[]){
+       if(n<=1) return 1;
+        if(dp[n]!=-1) return dp[n];
+        dp[n-1]=rec(n-1, dp);
+        dp[n-2]=rec(n-2, dp);
+        dp[n]=dp[n-1]+dp[n-2];
+        return dp[n];
+    }
+
+    int climbStairs(int n) {
+        int dp[n+1];
+        fill(dp, dp+n+1, -1);
+        return rec(n, dp);
+    }
+};

competitive programming/leetcode/520. Detect Capital.cpp

@@ -0,0 +1,51 @@
+Given a word, you need to judge whether the usage of capitals in it is right or not.
+
+We define the usage of capitals in a word to be right when one of the following cases holds:
+
+All letters in this word are capitals, like "USA".
+All letters in this word are not capitals, like "leetcode".
+Only the first letter in this word is capital, like "Google".
+Otherwise, we define that this word doesn't use capitals in a right way.
+
+
+Example 1:
+
+Input: "USA"
+Output: True
+
+
+Example 2:
+
+Input: "FlaG"
+Output: False
+
+
+Note: The input will be a non-empty word consisting of uppercase and lowercase latin letters.
+
+
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    bool detectCapitalUse(string word) {
+        int n=word.length();
+        int sm=0, bg=0;
+        for(int i=0;i<n;i++){
+            if(word[i]>='a' && word[i]<='z') sm++;
+            else bg++;
+        }
+        if(bg==n) return true;
+        if(sm==n) return true;
+        if((word[0]>='A' && word[0]<='Z') && sm==n-1) return true;
+        return false;
+    }
+};

competitive programming/leetcode/70. Climbing Stairs.cpp

@@ -0,0 +1,78 @@
+You are climbing a stair case. It takes n steps to reach to the top.
+
+Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+
+Example 1:
+
+Input: 2
+Output: 2
+Explanation: There are two ways to climb to the top.
+1. 1 step + 1 step
+2. 2 steps
+Example 2:
+
+Input: 3
+Output: 3
+Explanation: There are three ways to climb to the top.
+1. 1 step + 1 step + 1 step
+2. 1 step + 2 steps
+3. 2 steps + 1 step
+
+
+Constraints:
+
+1 <= n <= 45
+
+
+
+
+
+
+
+
+
+
+
+
+
+// recursive (TLE)
+
+class Solution {
+public:
+
+    int rec(int n){
+        if(n<=1) return 1;    // Only one way to reach
+        return rec(n-1) + rec(n-2);
+    }
+
+    int climbStairs(int n) {
+        return rec(n);
+    }
+};
+
+
+
+
+
+
+
+// Memoization
+
+class Solution {
+public:
+
+    int rec(int n, int dp[]){
+       if(n<=1) return 1;
+        if(dp[n]!=-1) return dp[n];
+        dp[n-1]=rec(n-1, dp);
+        dp[n-2]=rec(n-2, dp);
+        dp[n]=dp[n-1]+dp[n-2];
+        return dp[n];
+    }
+
+    int climbStairs(int n) {
+        int dp[n+1];
+        fill(dp, dp+n+1, -1);
+        return rec(n, dp);
+    }
+};