solved older leetcode 150

Author: Ayush Ganguly

Best_Time_To_Buy_Stocks.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int cost = 0;
+        int acc_cost = 0;
+        int min = prices[0];
+
+        for (int i = 1; i < prices.size(); i++) {
+            if (min > prices[i]) {
+                min = prices[i];
+            }
+            cost = prices[i] - min;
+
+            if (cost > acc_cost){
+                acc_cost = cost;
+            }
+
+        }
+        return acc_cost;
+   }
+};

First_Occurrence_String.cpp

@@ -0,0 +1,42 @@
+using namespace std;
+
+class Solution {
+public:
+    int strStr(string haystack, string needle) {
+        if ((needle == " ") || (haystack == " ") || (needle.length() > haystack.length())){
+            return -1;
+        }
+        char first_letter = needle[0];
+        //first occurrance
+        int fo = 0;
+        int traverse = 0;
+        while ((abs(fo) < haystack.length()) && (traverse < haystack.length())) {
+            // cout << "1 " << fo << endl;
+            // cout << "traverse " << traverse << endl;
+            // cout << haystack[traverse] << " == " << first_letter << endl;
+            if (haystack[traverse] == first_letter){
+                int temp_traverse = traverse;
+                fo = traverse;
+                for (int i = 0; i < needle.length(); ++i){
+                    if (haystack[temp_traverse] != needle[i]){
+                        fo = -1;
+                        break;
+                    }
+                    temp_traverse++;
+                }
+                if (fo != -1){
+                    return fo;
+                } else {
+                    traverse = traverse + 1;
+                    // cout << "2 " << fo << endl;
+                }
+            } else {
+                traverse++;
+            }
+           
+        }
+        // cout << (fo < haystack.length()) << endl;
+        // cout << haystack.length() << " fo " << fo << " traverse " << traverse << endl;
+        return -1;
+    }
+};

Length_of_last_word.cpp

@@ -0,0 +1,20 @@
+using namespace std;
+class Solution {
+public:
+    int lengthOfLastWord(string s) {
+        int count_lword = 0;
+        int str_len = s.length();
+        int lw_index = 0;
+        for (int i = 1; i < str_len; i++) {
+            if ((s[i - 1] == ' ') && (s[i] != ' ')) {
+                lw_index = i;
+            }
+        }
+        while ((s[lw_index] != ' ') && (lw_index < str_len)) {
+            count_lword++;
+            lw_index++;
+        }
+        
+        return count_lword;
+    }
+};

Valid_Palindrome.cpp

@@ -0,0 +1,32 @@
+using namespace std;
+class Solution {
+public:
+    bool isPalindrome(string s) {
+        string check_valid = "";
+        for (char letter : s) {
+            if ((int(letter) >= 65) && (int(letter) <= 90)) {
+                check_valid += tolower(letter); 
+            } else if ((int(letter) >= 97) && (int(letter) <= 122)) {
+                check_valid += letter;
+            } else if ((int(letter) >= 48) && (int(letter) <= 57)) {
+                check_valid += letter;
+            }
+        }
+
+        if (check_valid == "") {
+            return true;
+        }
+        int front = 0;
+        int back =  check_valid.length() - 1;
+
+        while (front <= back) {
+            if (check_valid[front] != check_valid[back]) {
+                return false;
+            }
+            front++;
+            back--;
+        }
+        return true;
+
+    }
+};

is_Subsequence.cpp

@@ -0,0 +1,27 @@
+class Solution {
+public:
+    bool isSubsequence(string s, string t) {
+        if (s.length() > t.length()) {
+            return false;
+        }
+        int s_curr = 0;
+        int t_traverse = 0;
+        while ((t_traverse < t.length()) && (s_curr < s.length())) {
+            if (s[s_curr] == t[t_traverse]) {
+                s_curr++;
+                t_traverse++;
+            } else if (t[t_traverse] != s[s_curr]) {
+                if (t_traverse == t.length() - 1) {
+                    return false;
+                }
+                t_traverse++;
+            }
+        }
+
+        //Have not finished iterating through all of s
+        if (s_curr != s.length()) {
+            return false;
+        }
+        return true;
+    }
+};

majority_element.cpp

@@ -0,0 +1,51 @@
+using namespace std;
+
+class Solution {
+public:
+    int majorityElement(vector<int>& nums) {
+
+        // My Solution - does not work for insanity tests
+        // int index = 0;
+        // int curr = nums[index];
+        // int count = 0;
+        // if (nums.size() == 1) {
+        //     return nums[0]; 
+        // }
+        // while (count <  nums.size() / 2){
+        //     for (int traverse = index; traverse < nums.size(); traverse++) {
+        //         if (nums[traverse] == curr){
+        //             count++;
+        //         }
+        //     }
+        //     if (count > nums.size() / 2){
+        //         return curr;
+        //     } else {
+        //         count = 0;
+        //         index++;
+        //         curr = nums[index];
+        //     }
+        // }
+        // return 0;
+        
+        // Sort the array and return the element at index n/2 since element appears more than n/2 times.
+        // int length = nums.size(); 
+        // sort(nums.begin(), nums.end());
+        // return nums[length / 2];
+
+        // Moore Voting Algorithm
+        int count = 0;
+        int candidate = 0;
+
+        for (int i = 0; i < nums.size(); i++){
+            if (count == 0){
+                candidate = nums[i];
+                count++;   
+            } else if (nums[i] == candidate){
+                count++;
+            } else {
+                count--;
+            }
+        }
+        return candidate;
+    }
+};