6/13

Author: NeoYY

Diff for: 191. Number of 1 Bits.cpp

@@ -0,0 +1,47 @@
+/*
+Write a function that takes an unsigned integer and return the number of '1' bits it has (also known as the Hamming weight).
+
+
+
+Example 1:
+
+Input: 00000000000000000000000000001011
+Output: 3
+Explanation: The input binary string 00000000000000000000000000001011 has a total of three '1' bits.
+Example 2:
+
+Input: 00000000000000000000000010000000
+Output: 1
+Explanation: The input binary string 00000000000000000000000010000000 has a total of one '1' bit.
+Example 3:
+
+Input: 11111111111111111111111111111101
+Output: 31
+Explanation: The input binary string 11111111111111111111111111111101 has a total of thirty one '1' bits.
+
+
+Note:
+
+Note that in some languages such as Java, there is no unsigned integer type. In this case, the input will be given as signed integer type and should not affect your implementation, as the internal binary representation of the integer is the same whether it is signed or unsigned.
+In Java, the compiler represents the signed integers using 2's complement notation. Therefore, in Example 3 above the input represents the signed integer -3.
+
+
+Follow up:
+
+If this function is called many times, how would you optimize it?
+
+Solution one using brute force
+*/
+
+class Solution {
+public:
+    int hammingWeight(uint32_t n) {
+        int count = 0;
+        while ( n )
+        {
+            if ( n & 1 ) count++;
+            n = n >> 1;
+        }
+        return count;
+    }
+};

Diff for: 193. Valid Phone Numbers.bash

@@ -0,0 +1,21 @@
+Given a text file file.txt that contains list of phone numbers (one per line), write a one liner bash script to print all valid phone numbers.
+
+You may assume that a valid phone number must appear in one of the following two formats: (xxx) xxx-xxxx or xxx-xxx-xxxx. (x means a digit)
+
+You may also assume each line in the text file must not contain leading or trailing white spaces.
+
+Example:
+
+Assume that file.txt has the following content:
+
+987-123-4567
+123 456 7890
+(123) 456-7890
+Your script should output the following valid phone numbers:
+
+987-123-4567
+(123) 456-7890
+
+
+# Read from the file file.txt and output all valid phone numbers to stdout.
+grep -oP '^[0-9]{3}-[0-9]{3}-[0-9]{4}$|^\([0-9]{3}\) [0-9]{3}-[0-9]{4}$' file.txt

Diff for: 195. Tenth Line.bash

@@ -0,0 +1,32 @@
+Given a text file file.txt, print just the 10th line of the file.
+
+Example:
+
+Assume that file.txt has the following content:
+
+Line 1
+Line 2
+Line 3
+Line 4
+Line 5
+Line 6
+Line 7
+Line 8
+Line 9
+Line 10
+Your script should output the tenth line, which is:
+
+Line 10
+Note:
+1. If the file contains less than 10 lines, what should you output?
+2. There's at least three different solutions. Try to explore all possibilities.
+
+# Read from the file file.txt and output the tenth line to stdout.
+awk 'NR == 10' file.txt
+
+sed -n '10p' file.txt
+
+line=$(cat file.txt | wc -l)
+if [ "$line" -ge 10 ] ; then
+  cat file.txt | head -n 10 | tail -n 1
+fi

Diff for: 196. Delete Duplicate Emails.sql

@@ -0,0 +1,41 @@
+/*
+
+Write a SQL query to delete all duplicate email entries in a table named Person, keeping only unique emails based on its smallest Id.
+
++----+------------------+
+| Id | Email            |
++----+------------------+
+| 1  | [email protected] |
+| 2  | [email protected]  |
+| 3  | [email protected] |
++----+------------------+
+Id is the primary key column for this table.
+For example, after running your query, the above Person table should have the following rows:
+
++----+------------------+
+| Id | Email            |
++----+------------------+
+| 1  | [email protected] |
+| 2  | [email protected]  |
++----+------------------+
+Note:
+
+Your output is the whole Person table after executing your sql. Use delete statement.
+
+*/
+
+# Write your MySQL query statement below
+
+# This using DELETE
+DELETE FROM Person WHERE Id NOT IN (
+        SELECT TempId FROM (
+            SELECT MIN(Id) AS TempId FROM Person GROUP BY Email
+        )AS minId
+    );
+
+SELECT
+    MIN(Id) AS Id,
+    Email
+FROM Person
+GROUP BY Email
+ORDER BY 1 ASC

Diff for: 197. Rising Temperature.sql

@@ -0,0 +1,26 @@
+/*
+Given a Weather table, write a SQL query to find all dates' Ids with higher temperature compared to its previous (yesterday's) dates.
+
++---------+------------------+------------------+
+| Id(INT) | RecordDate(DATE) | Temperature(INT) |
++---------+------------------+------------------+
+|       1 |       2015-01-01 |               10 |
+|       2 |       2015-01-02 |               25 |
+|       3 |       2015-01-03 |               20 |
+|       4 |       2015-01-04 |               30 |
++---------+------------------+------------------+
+For example, return the following Ids for the above Weather table:
+
++----+
+| Id |
++----+
+|  2 |
+|  4 |
++----+
+*/
+
+# Write your MySQL query statement below
+SELECT b.Id FROM
+Weather a, Weather b
+WHERE a.RecordDate = date_sub( b.RecordDate, INTERVAL 1 day )
+AND a.Temperature < b.Temperature;

Diff for: 198. House Robber.cpp

@@ -0,0 +1,44 @@
+/*
+You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.
+
+Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.
+
+
+
+Example 1:
+
+Input: nums = [1,2,3,1]
+Output: 4
+Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
+             Total amount you can rob = 1 + 3 = 4.
+Example 2:
+
+Input: nums = [2,7,9,3,1]
+Output: 12
+Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
+             Total amount you can rob = 2 + 9 + 1 = 12.
+
+
+Constraints:
+
+0 <= nums.length <= 100
+0 <= nums[i] <= 400
+
+Solution using DP
+*/
+class Solution {
+public:
+    int rob(vector<int>& nums) {
+        int size = nums.size();
+        if ( size == 0 ) return size;
+        int new_sum = nums[0];
+        int old_sum = 0;
+        for ( int i = 1; i < size; ++i )
+        {
+            int temp = new_sum;
+            new_sum = max( old_sum + nums[i], new_sum );
+            old_sum = temp;
+        }
+        return max( old_sum, new_sum );
+    }
+};

Diff for: 202. Happy Number.cpp

@@ -0,0 +1,41 @@
+/*
+Write an algorithm to determine if a number n is "happy".
+
+A happy number is a number defined by the following process: Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers.
+
+Return True if n is a happy number, and False if not.
+
+Example:
+
+Input: 19
+Output: true
+Explanation:
+1^2 + 9^2 = 82
+8^2 + 2^2 = 68
+6^2 + 8^2 = 100
+1^2 + 0^2 + 0^2 = 1
+*/
+
+//Solution using unordered_map, set, unordered_map can also do this
+
+class Solution {
+private:
+    vector<int> square = { 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 };
+public:
+    bool isHappy(int n) {
+        unordered_map<int, int> temp;
+        while ( n != 1 )
+        {
+            int res = 0;
+            while ( n )
+            {
+                res += square[n % 10];
+                n = n / 10;
+            }
+            temp[res]++;
+            if ( temp[res] > 1 ) return false;
+            n = res;
+        }
+        return true;
+    }
+};

Diff for: 203. Remove Linked List Elements.cpp

@@ -0,0 +1,77 @@
+/*
+Remove all elements from a linked list of integers that have value val.
+
+Example:
+
+Input:  1->2->6->3->4->5->6, val = 6
+Output: 1->2->3->4->5
+*/
+
+/**
+ * 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:
+    ListNode* removeElements(ListNode* head, int val) {
+        if ( !head ) return nullptr;
+        ListNode *curr = head;
+        ListNode *fast = head->next;
+        while ( curr && curr->val == val )
+        {
+            curr = curr->next;
+            if ( curr ) fast = curr->next;
+            head = curr;
+        }
+        while ( curr && fast )
+        {
+            while ( fast && fast->val == val )
+            {
+                fast = fast->next;
+                curr->next = fast;
+            }
+            curr = curr->next;
+            if ( curr ) fast = curr->next;
+        }
+        return head;
+    }
+};
+
+
+
+//Clearer version, using one less pointer
+/**
+ * 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:
+    ListNode* removeElements(ListNode* head, int val) {
+        if ( !head ) return nullptr;
+        ListNode *curr = head;
+        ListNode *fast = head->next;
+        while ( curr && curr->val == val )
+        {
+            curr = curr->next;
+        }
+        head = curr;
+        while ( curr && curr->next )
+        {
+            if ( curr->next->val == val ) curr->next = curr->next->next;
+            else curr = curr->next;
+        }
+        return head;
+    }
+};

Diff for: 204. Count Primes.cpp

@@ -0,0 +1,62 @@
+/*
+Count the number of prime numbers less than a non-negative number, n.
+
+Example:
+
+Input: 10
+Output: 4
+Explanation: There are 4 prime numbers less than 10, they are 2, 3, 5, 7.
+
+Solution one using brute force
+
+Notes: No overthinking, overwise will not pass.
+
+
+Solution two use sqrt can reduce the computation time, this work, but will not work on leetcode.
+*/
+
+class Solution {
+public:
+    int countPrimes(int n) {
+        vector<bool> temp( n, 1 );
+        int res = 0;
+        for ( int i = 2; i < n; i++ )
+        {
+            if ( !temp[i] ) continue;
+            res++;
+            for ( int j = 2; i * j < n; j++ )
+            {
+                temp[i * j] = 0;
+            }
+        }
+        return res;
+    }
+};
+
+//This is the best, wiredly not work on leetcode.s
+class Solution {
+public:
+    int countPrimes(int n) {
+        vector<bool> temp( n, 0 );
+        int res = 0;
+        temp[0] = 1;
+        temp[1] = 1;
+        for ( int i = 2; i <= sqrt( n ); ++i )
+        {
+            if ( temp[i] )
+            {
+                continue;
+            }
+            for ( int k = i * i; k < n; k += i )
+            {
+                temp[k] = 1;
+            }
+
+        }
+        for ( int i = 0; i < temp.size(); i++ )
+        {
+            if ( !temp[i] ) res++;
+        }
+        return res;
+    }
+};