Added tasks 345, 349.

src/main/java/g0301_0400/s0345_reverse_vowels_of_a_string/Solution.java

@@ -0,0 +1,35 @@
+package g0301_0400.s0345_reverse_vowels_of_a_string;
+
+// #Easy #String #Two_Pointers
+
+public class Solution {
+    private boolean isVowel(char c) {
+        return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'A' || c == 'E'
+                || c == 'I' || c == 'O' || c == 'U';
+    }
+
+    private StringBuilder swap(StringBuilder s, int l, int r) {
+        char tmp = s.charAt(l);
+        s.setCharAt(l, s.charAt(r));
+        s.setCharAt(r, tmp);
+        return s;
+    }
+
+    public String reverseVowels(String s) {
+        int l = 0;
+        int r = s.length() - 1;
+        StringBuilder res = new StringBuilder(s);
+        while (l < r) {
+            while (l < r && !isVowel(s.charAt(l))) {
+                l++;
+            }
+            while (l < r && !isVowel(s.charAt(r))) {
+                r--;
+            }
+            swap(res, l, r);
+            l++;
+            r--;
+        }
+        return res.toString();
+    }
+}

src/main/java/g0301_0400/s0345_reverse_vowels_of_a_string/readme.md

@@ -0,0 +1,24 @@
+345\. Reverse Vowels of a String
+
+Easy
+
+Given a string `s`, reverse only all the vowels in the string and return it.
+
+The vowels are `'a'`, `'e'`, `'i'`, `'o'`, and `'u'`, and they can appear in both cases.
+
+**Example 1:**
+
+**Input:** s = "hello"
+
+**Output:** "holle"
+
+**Example 2:**
+
+**Input:** s = "leetcode"
+
+**Output:** "leotcede"
+
+**Constraints:**
+
+*   1 <= s.length <= 3 * 105
+*   `s` consist of **printable ASCII** characters.

src/main/java/g0301_0400/s0349_intersection_of_two_arrays/Solution.java

@@ -0,0 +1,27 @@
+package g0301_0400.s0349_intersection_of_two_arrays;
+
+// #Easy #Array #Hash_Table #Sorting #Binary_Search #Two_Pointers
+
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+    public int[] intersection(int[] nums1, int[] nums2) {
+        boolean[] occ = new boolean[1001];
+        for (int i = 0; i < nums1.length; i++) {
+            occ[nums1[i]] = true;
+        }
+        List<Integer> res = new ArrayList<>();
+        for (int i = 0; i < nums2.length; i++) {
+            if (occ[nums2[i]]) {
+                occ[nums2[i]] = false;
+                res.add(nums2[i]);
+            }
+        }
+        int[] result = new int[res.size()];
+        for (int i = 0; i < res.size(); i++) {
+            result[i] = res.get(i);
+        }
+        return result;
+    }
+}

src/main/java/g0301_0400/s0349_intersection_of_two_arrays/readme.md

@@ -0,0 +1,24 @@
+349\. Intersection of Two Arrays
+
+Easy
+
+Given two integer arrays `nums1` and `nums2`, return _an array of their intersection_. Each element in the result must be **unique** and you may return the result in **any order**.
+
+**Example 1:**
+
+**Input:** nums1 = \[1,2,2,1\], nums2 = \[2,2\]
+
+**Output:** \[2\]
+
+**Example 2:**
+
+**Input:** nums1 = \[4,9,5\], nums2 = \[9,4,9,8,4\]
+
+**Output:** \[9,4\]
+
+**Explanation:** \[4,9\] is also accepted.
+
+**Constraints:**
+
+*   `1 <= nums1.length, nums2.length <= 1000`
+*   `0 <= nums1[i], nums2[i] <= 1000`

src/test/java/g0301_0400/s0345_reverse_vowels_of_a_string/SolutionTest.java

@@ -0,0 +1,18 @@
+package g0301_0400.s0345_reverse_vowels_of_a_string;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void reverseVowels() {
+        assertThat(new Solution().reverseVowels("hello"), equalTo("holle"));
+    }
+
+    @Test
+    void reverseVowels2() {
+        assertThat(new Solution().reverseVowels("leetcode"), equalTo("leotcede"));
+    }
+}

src/test/java/g0301_0400/s0349_intersection_of_two_arrays/SolutionTest.java

@@ -0,0 +1,22 @@
+package g0301_0400.s0349_intersection_of_two_arrays;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void intersection() {
+        assertThat(
+                new Solution().intersection(new int[] {1, 2, 2, 1}, new int[] {2, 2}),
+                equalTo(new int[] {2}));
+    }
+
+    @Test
+    void intersection2() {
+        assertThat(
+                new Solution().intersection(new int[] {4, 9, 5}, new int[] {9, 4, 9, 8, 4}),
+                equalTo(new int[] {9, 4}));
+    }
+}