n

Author: hitzzc

README.md

@@ -266,6 +266,13 @@ Golang solution for leetcode. For each problem, there is a simple *_test.go to t
 #### [386. Lexicographical Numbers](https://github.com/hitzzc/go-leetcode/tree/master/lexicographical_numbers)
 #### [387. First Unique Character in a String](https://github.com/hitzzc/go-leetcode/tree/master/first_unique_character_in_a_string)
 #### [388. Longest Absolute File Path](https://github.com/hitzzc/go-leetcode/tree/master/longest_absolute_file_path)
+#### [389. Find the Difference](https://github.com/hitzzc/go-leetcode/tree/master/find_the_difference)
+#### [390. Elimination Game](https://github.com/hitzzc/go-leetcode/tree/master/elimination_game)
+#### [391. Is Subsequence](https://github.com/hitzzc/go-leetcode/tree/master/is_subsequence)
+#### [394. Decode String](https://github.com/hitzzc/go-leetcode/tree/master/decode_string)
+#### [395. Longest Substring with At Least K Repeating Characters](https://github.com/hitzzc/go-leetcode/tree/master/longest_substring_with_at_least_k_repeating_characters)
+#### [396. Rotate Function](https://github.com/hitzzc/go-leetcode/tree/master/rotate_function)
+#### [400. Nth Digit](https://github.com/hitzzc/go-leetcode/tree/master/nth_digit)
 
 
 

decode_string/decode_string.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    string decodeString(string s) {
+    	int i = 0;
+    	return decode(s, i);
+    }
+
+    string decode(string& s, int& idx) {
+    	string ret;
+    	while (idx < s.size() && s[idx] != ']') {
+    		if (s[idx] < '0' || s[idx] > '9') {
+    			ret += s[idx++];
+    		} else {
+    			int num = 0;
+    			while (s[idx] != '[') {
+    				num = 10*num + s[idx++] - '0';
+    			}
+    			++idx;
+    			string tmp = decode(s, idx);
+    			while (num-- > 0) {
+    				ret += tmp;
+    			}
+    			++idx;
+    		}
+    	}
+    	return ret;
+    }
+};

elimination_game/elimination_game.cpp

@@ -0,0 +1,6 @@
+class Solution {
+public:
+    int lastRemaining(int n) {
+        return n == 1 ? 1 : 2*(n/2 + 1 - lastRemaining(n/2));
+    }
+};

find_the_difference/find_the_difference.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    char findTheDifference(string s, string t) {
+        vector<int> vec(26, 0);
+        for (auto& c: s) {
+        	++vec[c-'a'];
+        }
+        char ret;
+        for (auto& c: t) {
+        	if (vec[c-'a'] == 0) {
+        		ret = c;
+        		break;
+        	}
+        	--vec[c-'a'];
+        }
+        return ret;
+    }
+};

is_subsequence/is_subsequence.cpp

@@ -0,0 +1,11 @@
+class Solution {
+public:
+    bool isSubsequence(string s, string t) {
+    	if (s.size() == 0) return true;
+        int ps = 0, pt = 0;
+        for (; pt < t.size() && ps < t.size(); ++pt) {
+        	if (s[ps] == t[pt]) ++ps;
+        }
+        return ps == s.size();
+    }
+};

longest_substring_with_at_least_k_repeating_characters/longest_substring_with_at_least_k_repeating_characters.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int longestSubstring(string s, int k) {
+    	int ret = 0;
+    	int i = 0;
+        while (i+k < s.size()) {
+        	int mask = 0, i_max = i;
+        	vector<int> cnt(26, 0);
+        	for (int j = i; j < s.size(); ++j) {
+        		int idx = s[j] - 'a';
+        		++cnt[idx];
+        		if (cnt[idx] < k) mask |= (1 << idx);
+        		else mask &= ~(1 << idx); 
+        		if (mask == 0) {
+        			ret = max(ret, j-i+1);
+        			i_max = j;
+        		}
+        	}
+        	i = i_max + 1;
+        }
+        return ret;
+    }
+};

nth_digit/nth_digit.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int findNthDigit(int n) {
+        long len = 1;
+        long count = 9;
+        long start = 1;
+        while (n > len*count) {
+            n -= len*count;
+        	start += count;
+        	++len;
+        	count *= 10;
+        }
+        return to_string(start + (n-1)/len)[(n-1)%len] - '0';
+    }
+};

rotate_function/rotate_function.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+    int maxRotateFunction(vector<int>& A) {
+    	if (A.size() == 0) return 0;
+        int sum = 0;
+        int pre = 0;
+        for (int i = 0; i < A.size(); ++i) {
+        	sum += A[i];
+        	pre += i * A[i];
+        }
+        int ret = pre;
+        int len = A.size();
+        for (int i = 0; i < len-1; ++i) {
+        	pre = pre - sum + len*A[i];
+        	ret = max(ret, pre);
+        }
+        return ret;
+    }
+};