Added tasks 2185, 2186.

Author: javadev

README.md

@@ -1377,6 +1377,8 @@ implementation 'com.github.javadev:leetcode-in-java:1.10'
 | 2190 |[Most Frequent Number Following Key In an Array](src/main/java/g2101_2200/s2190_most_frequent_number_following_key_in_an_array/Solution.java)| Easy | Array, Hash_Table, Counting | 1 | 100.00
 | 2188 |[Minimum Time to Finish the Race](src/main/java/g2101_2200/s2188_minimum_time_to_finish_the_race/Solution.java)| Hard | Array, Dynamic_Programming | 15 | 93.69
 | 2187 |[Minimum Time to Complete Trips](src/main/java/g2101_2200/s2187_minimum_time_to_complete_trips/Solution.java)| Medium | Array, Binary_Search | 187 | 95.03
+| 2186 |[Minimum Number of Steps to Make Two Strings Anagram II](src/main/java/g2101_2200/s2186_minimum_number_of_steps_to_make_two_strings_anagram_ii/Solution.java)| Medium | String, Hash_Table, Counting | 22 | 77.11
+| 2185 |[Counting Words With a Given Prefix](src/main/java/g2101_2200/s2185_counting_words_with_a_given_prefix/Solution.java)| Easy | Array, String | 0 | 100.00
 | 2183 |[Count Array Pairs Divisible by K](src/main/java/g2101_2200/s2183_count_array_pairs_divisible_by_k/Solution.java)| Hard | Array, Math, Number_Theory | 849 | 44.54
 | 2182 |[Construct String With Repeat Limit](src/main/java/g2101_2200/s2182_construct_string_with_repeat_limit/Solution.java)| Medium | String, Greedy, Heap_Priority_Queue, Counting | 26 | 96.11
 | 2181 |[Merge Nodes in Between Zeros](src/main/java/g2101_2200/s2181_merge_nodes_in_between_zeros/Solution.java)| Medium | Simulation, Linked_List | 6 | 96.26

src/main/java/g2101_2200/s2185_counting_words_with_a_given_prefix/Solution.java

@@ -0,0 +1,15 @@
+package g2101_2200.s2185_counting_words_with_a_given_prefix;
+
+// #Easy #Array #String #2022_06_08_Time_0_ms_(100.00%)_Space_43.9_MB_(15.40%)
+
+public class Solution {
+ public int prefixCount(String[] words, String pref) {
+ int count = 0;
+ for (String s : words) {
+ if (s.startsWith(pref)) {
+ count++;
+ }
+ }
+ return count;
+ }
+}

src/main/java/g2101_2200/s2185_counting_words_with_a_given_prefix/readme.md

@@ -0,0 +1,31 @@
+2185\. Counting Words With a Given Prefix
+
+Easy
+
+You are given an array of strings `words` and a string `pref`.
+
+Return _the number of strings in_ `words` _that contain_ `pref` _as a **prefix**_.
+
+A **prefix** of a string `s` is any leading contiguous substring of `s`.
+
+**Example 1:**
+
+**Input:** words = ["pay","**at**tention","practice","**at**tend"], `pref` \= "at"
+
+**Output:** 2
+
+**Explanation:** The 2 strings that contain "at" as a prefix are: "**at**tention" and "**at**tend". 
+
+**Example 2:**
+
+**Input:** words = ["leetcode","win","loops","success"], `pref` \= "code"
+
+**Output:** 0
+
+**Explanation:** There are no strings that contain "code" as a prefix. 
+
+**Constraints:**
+
+* `1 <= words.length <= 100`
+* `1 <= words[i].length, pref.length <= 100`
+* `words[i]` and `pref` consist of lowercase English letters.

src/main/java/g2101_2200/s2186_minimum_number_of_steps_to_make_two_strings_anagram_ii/Solution.java

@@ -0,0 +1,20 @@
+package g2101_2200.s2186_minimum_number_of_steps_to_make_two_strings_anagram_ii;
+
+// #Medium #String #Hash_Table #Counting #2022_06_08_Time_22_ms_(77.11%)_Space_70.1_MB_(39.92%)
+
+public class Solution {
+ public int minSteps(String s, String t) {
+ int[] a = new int[26];
+ for (int i = 0; i < s.length(); i++) {
+ a[s.charAt(i) - 'a']++;
+ }
+ for (int i = 0; i < t.length(); i++) {
+ a[t.charAt(i) - 'a']--;
+ }
+ int sum = 0;
+ for (int j : a) {
+ sum += Math.abs(j);
+ }
+ return sum;
+ }
+}

src/main/java/g2101_2200/s2186_minimum_number_of_steps_to_make_two_strings_anagram_ii/readme.md

@@ -0,0 +1,40 @@
+2186\. Minimum Number of Steps to Make Two Strings Anagram II
+
+Medium
+
+You are given two strings `s` and `t`. In one step, you can append **any character** to either `s` or `t`.
+
+Return _the minimum number of steps to make_ `s` _and_ `t` _**anagrams** of each other._
+
+An **anagram** of a string is a string that contains the same characters with a different (or the same) ordering.
+
+**Example 1:**
+
+**Input:** s = "**lee**tco**de**", t = "co**a**t**s**"
+
+**Output:** 7
+
+**Explanation:**
+
+- In 2 steps, we can append the letters in "as" onto s = "leetcode", forming s = "leetcode**as**".
+
+- In 5 steps, we can append the letters in "leede" onto t = "coats", forming t = "coats**leede**".
+
+"leetcodeas" and "coatsleede" are now anagrams of each other.
+
+We used a total of 2 + 5 = 7 steps.
+
+It can be shown that there is no way to make them anagrams of each other with less than 7 steps. 
+
+**Example 2:**
+
+**Input:** s = "night", t = "thing"
+
+**Output:** 0
+
+**Explanation:** The given strings are already anagrams of each other. Thus, we do not need any further steps. 
+
+**Constraints:**
+
+* <code>1 <= s.length, t.length <= 2 * 10<sup>5</sup></code>
+* `s` and `t` consist of lowercase English letters.

src/test/java/g2101_2200/s2185_counting_words_with_a_given_prefix/SolutionTest.java

@@ -0,0 +1,24 @@
+package g2101_2200.s2185_counting_words_with_a_given_prefix;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void prefixCount() {
+ assertThat(
+ new Solution()
+ .prefixCount(new String[] {"pay", "attention", "practice", "attend"}, "at"),
+ equalTo(2));
+ }
+
+ @Test
+ void prefixCount2() {
+ assertThat(
+ new Solution()
+ .prefixCount(new String[] {"leetcode", "win", "loops", "success"}, "code"),
+ equalTo(0));
+ }
+}

src/test/java/g2101_2200/s2186_minimum_number_of_steps_to_make_two_strings_anagram_ii/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2101_2200.s2186_minimum_number_of_steps_to_make_two_strings_anagram_ii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void minSteps() {
+ assertThat(new Solution().minSteps("leetcode", "coats"), equalTo(7));
+ }
+
+ @Test
+ void minSteps2() {
+ assertThat(new Solution().minSteps("night", "thing"), equalTo(0));
+ }
+}