May 6, 2018

Author: Xuemeng Zhang

137_Single_Number_II.cpp

@@ -0,0 +1,36 @@
+/*
+Given a non-empty array of integers, every element appears three times except for one, which appears exactly once. Find that single one.
+
+Note:
+
+Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+
+Example 1:
+
+Input: [2,2,3,2]
+Output: 3
+Example 2:
+
+Input: [0,1,0,1,0,1,99]
+Output: 99
+*/
+#include <vector>
+using namespace std;
+
+class Solution {
+public:
+    int singleNumber(vector<int>& nums) {
+		int output = 0;
+		for(size_t i=0; i<32; ++i){
+			int cnt = 0;
+			for(size_t j=0; j<nums.size(); ++j){
+				if( (nums[j]>>i) & 0x1 ){
+					cnt++;
+					cnt %= 3;
+				}
+			}
+			if(cnt) output |= (1<<i);
+		}
+		return output;
+    }
+};

201_Bitwise_AND_of_Numbers_Range.cpp

@@ -0,0 +1,25 @@
+/*
+Given a range [m, n] where 0 <= m <= n <= 2147483647, return the bitwise AND of all numbers in this range, inclusive.
+
+Example:
+
+Input: [5,7]
+Output: 4
+*/
+
+class Solution {
+public:
+    int rangeBitwiseAnd(int m, int n) {
+		int output = 0;
+
+		for(int i=0; i<31; ++i){
+			int bit_mask = 1<<i;
+			if( (m&bit_mask) && \
+					(n&bit_mask) && \
+					((n-m)<bit_mask) ) 
+				output |= bit_mask;
+		}
+
+		return output;
+    }
+};

260_Single_Number_III.cpp

@@ -0,0 +1,40 @@
+/*
+Given an array of numbers nums, in which exactly two elements appear only once and all the other elements appear exactly twice.
+Find the two elements that appear only once.
+
+For example:
+
+Given nums = [1, 2, 1, 3, 2, 5], return [3, 5].
+
+Note:
+The order of the result is not important. So in the above example, [5, 3] is also correct.
+Your algorithm should run in linear runtime complexity. Could you implement it using only constant space complexity?
+*/
+#include <vector>
+using namespace std;
+
+class Solution {
+public:
+    vector<int> singleNumber(vector<int>& nums) {
+		int temp = 0;
+		size_t bit_pos = 0;
+		for(size_t i=0; i<nums.size(); ++i) temp ^= nums[i];
+		for(size_t i=0; i<32; ++i){
+			if(temp&(1<<i)){
+				bit_pos = i;
+				break;
+			}
+		}
+		int mask = 1<<bit_pos;
+		int temp1 = 0, temp2 = 0;
+		for(size_t i=0; i<nums.size(); ++i){
+			if(nums[i]&mask) temp1 ^= nums[i];
+			else temp2 ^= nums[i];
+		}
+
+		vector<int> output;
+		output.push_back(temp1);
+		output.push_back(temp2);
+		return output;
+    }
+};

338_Counting_Bits.cpp

@@ -0,0 +1,37 @@
+/*
+Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num
+calculate the number of 1's in their binary representation and return them as an array.
+
+Example:
+For num = 5 you should return [0,1,1,2,1,2].
+
+Follow up:
+
+It is very easy to come up with a solution with run time O(n*sizeof(integer)). But can
+you do it in linear time O(n) /possibly in a single pass? Space complexity should be O(n).
+Can you do it like a boss? Do it without using any builtin function like __builtin_popcount
+in c++ or in any other language.
+*/
+#include <vector>
+using namespace std;
+
+class Solution {
+public:
+    vector<int> countBits(int num) {
+		vector<int> output;
+		int lead_one_bit = 0;
+
+		for(int i=0; i<=num; ++i){
+			if(0==i) output.push_back(0);
+			else if(1==i) output.push_back(1);
+			else{
+				if( i==(1<<(lead_one_bit+1)) )
+						lead_one_bit++;
+				int temp = 1 + output[i-(1<<lead_one_bit)];
+				output.push_back(temp);
+			}
+		}
+
+		return output;
+    }
+};

397_Integer_Replacement.cpp

@@ -0,0 +1,45 @@
+/*
+Given a positive integer n and you can do operations as follow:
+
+If n is even, replace n with n/2.
+If n is odd, you can replace n with either n + 1 or n - 1.
+What is the minimum number of replacements needed for n to become 1?
+
+Example 1:
+
+Input:
+8
+
+Output:
+3
+
+Explanation:
+8 -> 4 -> 2 -> 1
+Example 2:
+
+Input:
+7
+
+Output:
+4
+
+Explanation:
+7 -> 8 -> 4 -> 2 -> 1
+or
+7 -> 6 -> 3 -> 2 -> 1
+*/
+#include "limits.h"
+
+class Solution {
+public:
+    int integerReplacement(int n) {
+		if(1==n) return 0;
+		else if(n%2){
+			int temp1 = (n==INT_MAX) ? 2 + integerReplacement(1<<30) : \
+						2 + integerReplacement((n+1)/2);
+			int temp2 = 2 + integerReplacement((n-1)/2);
+			return (temp1<temp2)?temp1:temp2;
+		}
+		return 1 + integerReplacement(n/2);
+    }
+};