622

Author: NeoYY

19. Remove Nth Node From End of List.cpp

@@ -0,0 +1,74 @@
+/*
+
+Given a linked list, remove the n-th node from the end of list and return its head.
+
+Example:
+
+Given linked list: 1->2->3->4->5, and n = 2.
+
+After removing the second node from the end, the linked list becomes 1->2->3->5.
+Note:
+
+Given n will always be valid.
+
+Follow up:
+
+Could you do this in one pass?
+
+
+Solution one need to go through the list and record the length O(N);
+Solution two using fast and slow 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* removeNthFromEnd(ListNode* head, int n) {
+        ListNode *temp = head, *prev = nullptr;
+        int i = 0, j = 0;
+        while ( temp != nullptr )
+        {
+            temp = temp->next;
+            ++i;
+        }
+        temp = head;
+        if ( i == n ) return temp->next;
+        while ( j++ < i - n )
+        {
+            prev = temp;
+            temp = temp->next;
+        }
+        prev->next = temp->next;
+        return head;
+    }
+};
+
+
+class Solution {
+public:
+    ListNode* removeNthFromEnd(ListNode* head, int n) {
+        ListNode *temp = head, *prev = head;
+        for ( int i = 0; i < n; ++i )
+        {
+            temp = temp->next;
+        }
+        if ( !temp ) return head->next;
+        while ( temp->next )
+        {
+            prev = prev->next;
+            temp = temp->next;
+        }
+        prev->next = prev->next->next;
+        return head;
+    }
+};

22. Generate Parentheses.cpp

@@ -0,0 +1,67 @@
+/*
+Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
+
+For example, given n = 3, a solution set is:
+
+[
+  "((()))",
+  "(()())",
+  "(())()",
+  "()(())",
+  "()()()"
+]
+
+Solution one is DFS, recursive
+Two using set to get rid of repeated element
+
+*/
+
+class Solution {
+public:
+    vector<string> generateParenthesis(int n) {
+        vector<string> res;
+        if ( n == 0 ) return res;
+        AddP( n, n , "", res );
+        return res;
+    }
+    void AddP( int l, int r, string out, vector<string>& res )
+    {
+        if ( l > r ) return;
+        if ( l == 0 && r == 0 )
+        {
+            res.push_back( out );
+            return;
+        }
+        if ( l > 0 ) AddP( l - 1, r, out + '(', res );
+        if ( r > 0 ) AddP( l, r - 1, out + ')', res );
+    }
+};
+
+
+class Solution {
+public:
+    vector<string> generateParenthesis(int n) {
+        set<string> res;
+        if ( n == 0 ) res.insert( "" );
+        else
+        {
+            vector<string> temp( generateParenthesis( n - 1 ) );
+            for ( auto &a: temp )
+            {
+                for ( int j = 0; j < a.size(); ++j )
+                {
+                    if ( a[j] == '(' )
+                    {
+                        a.insert(a.begin() + j + 1, '(' );
+                        a.insert(a.begin() + j + 2, ')' );
+                        res.insert( a );
+                        a.erase( a.begin() + j + 1, a.begin() + j + 3 );
+                    }
+
+                }
+                res.insert( "()" + a );
+            }
+        }
+        return vector<string>( res.begin(), res.end() );
+    }
+};

344. Reverse String.cpp

@@ -0,0 +1,47 @@
+/*
+Write a function that reverses a string. The input string is given as an array of characters char[].
+
+Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
+
+You may assume all the characters consist of printable ascii characters.
+
+
+
+Example 1:
+
+Input: ["h","e","l","l","o"]
+Output: ["o","l","l","e","h"]
+Example 2:
+
+Input: ["H","a","n","n","a","h"]
+Output: ["h","a","n","n","a","H"]
+
+First solution using swap from start -> mid
+Solution two using XOR
+*/
+class Solution {
+public:
+    void reverseString(vector<char>& s) {
+        int i = 0, j = s.size() - 1;
+        while ( i < j )
+        {
+            swap( s[i++], s[j--] );
+        }
+
+    }
+};
+
+class Solution {
+public:
+    void reverseString(vector<char>& s) {
+        int i = 0, j = s.size() - 1;
+        while ( i < j )
+        {
+            s[i] = s[i] ^ s[j];
+            s[j] = s[i] ^ s[j];
+            s[i] = s[i] ^ s[j];
+            ++i; --j;
+        }
+
+    }
+};

345. Reverse Vowels of a String.cpp

@@ -0,0 +1,52 @@
+/*
+Write a function that takes a string as input and reverse only the vowels of a string.
+
+Example 1:
+
+Input: "hello"
+Output: "holle"
+Example 2:
+
+Input: "leetcode"
+Output: "leotcede"
+Note:
+The vowels does not include the letter "y".
+
+
+Create a dictionary to check whether it is a vowel;
+*/
+// a e i o u
+class Solution {
+public:
+    string reverseVowels(string s) {
+        int i = 0, j = s.size() - 1;
+        unordered_set<char> s1 = { 'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U' };
+        while ( i < j )
+        {
+            if ( s1.count( s[i] ) > 0 && s1.count( s[j] ) > 0 )
+            {
+                swap( s[i], s[j] );
+                ++i; --j;
+            }
+            while ( s1.count( s[i] ) == 0 && i < j) ++i;
+            while ( s1.count( s[j] ) == 0 && i < j) --j;
+        }
+        return s;
+    }
+};
+
+
+// a e i o u
+class Solution {
+public:
+    string reverseVowels(string s) {
+        int i = 0, j = s.size() - 1;
+        while ( i < j )
+        {
+            i = s.find_first_of( "aeiouAEIOU", i );
+            j = s.find_last_of( "aeiouAEIOU", j );
+            if ( i < j ) swap( s[i++], s[j--]);
+        }
+        return s;
+    }
+};

541. Reverse String II.cpp

@@ -0,0 +1,60 @@
+/*
+
+Given a string and an integer k, you need to reverse the first k characters for every 2k characters counting from the start of the string. If there are less than k characters left, reverse all of them. If there are less than 2k but greater than or equal to k characters, then reverse the first k characters and left the other as original.
+Example:
+Input: s = "abcdefg", k = 2
+Output: "bacdfeg"
+Restrictions:
+The string consists of lower English letters only.
+Length of the given string and k will in the range [1, 10000]
+
+Solution discuss different possibilities
+*/
+class Solution {
+public:
+    string reverseStr(string s, int k) {
+        int i = 0, size = s.size() - 1;
+        if ( size < k )
+        {
+            while( i < size ) swap( s[i++], s[size--] );
+            return s;
+        }
+        if ( size < 2 * k )
+        {
+            size = k - 1;
+            while( i < size ) swap( s[i++], s[size--] );
+            return s;
+        }
+        for ( int j = 0; j < size; j += 2 * k )
+        {
+            i = j;
+            int b = min ( size, j + k - 1 );
+            while ( i < b )
+            {
+                swap( s[i++], s[b--] );
+            }
+
+        }
+        return s;
+    }
+};
+
+
+//Optimized, first couple of lines are redundant
+class Solution {
+public:
+    string reverseStr(string s, int k) {
+        int i = 0, size = s.size() - 1;
+        for ( int j = 0; j < size; j += 2 * k )
+        {
+            i = j;
+            int b = min ( size, j + k - 1 );
+            while ( i < b )
+            {
+                swap( s[i++], s[b--] );
+            }
+
+        }
+        return s;
+    }
+};

557. Reverse Words in a String III.cpp

@@ -0,0 +1,46 @@
+/*
+Given a string, you need to reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.
+
+Example 1:
+Input: "Let's take LeetCode contest"
+Output: "s'teL ekat edoCteeL tsetnoc"
+Note: In the string, each word is separated by single space and there will not be any extra space in the string.
+
+Solution one using iterative
+Solution two using istringstream
+*/
+class Solution {
+public:
+    string reverseWords(string s) {
+        if ( s == "" ) return s;
+        for ( int i = 0; i < s.size() - 1; ++i )
+        {
+            int j = i;
+            while ( s[i] != ' ' && i != s.size() - 1 ) ++i;
+            if ( s[i] == ' ' ) reverse( s.begin() + j, s.begin() + i );
+            else reverse( s.begin() + j, s.end() );
+        }
+        return s;
+    }
+};
+
+class Solution {
+public:
+    string reverseWords(string s) {
+        if ( s == "" ) return s;
+        string res = "", t = "";
+        istringstream is( s );
+        while ( is >> t )
+        {
+            int size = t.size() - 1;
+            int i = 0;
+            while ( i < size )
+            {
+                swap( t[i++], t[size--] );
+            }
+            res = res + t + " ";
+        }
+        res.pop_back();
+        return res;
+    }
+};