Added tasks 466, 467.

Author: ThanhNIT

src/main/java/g0401_0500/s0466_count_the_repetitions/Solution.java

@@ -0,0 +1,37 @@
+package g0401_0500.s0466_count_the_repetitions;
+
+// #Hard #String #Dynamic_Programming
+
+public class Solution {
+ public int getMaxRepetitions(String s1, int n1, String s2, int n2) {
+ int n = s2.length();
+ char[] ss1 = s1.toCharArray();
+ char[] ss2 = s2.toCharArray();
+ int[][] memo = new int[n][];
+ int[] s2CountMap = new int[n + 1];
+ int s1Count = 0;
+ int s2Count = 0;
+ int s2Idx = 0;
+ while (memo[s2Idx] == null) {
+ memo[s2Idx] = new int[] {s1Count, s2Count};
+ for (char c1 : ss1) {
+ if (c1 == ss2[s2Idx]) {
+ s2Idx++;
+ if (s2Idx == n) {
+ s2Count++;
+ s2Idx = 0;
+ }
+ }
+ }
+ s1Count++;
+ s2CountMap[s1Count] = s2Count;
+ }
+
+ int n1Left = n1 - memo[s2Idx][0];
+ int matchedPatternCount = n1Left / (s1Count - memo[s2Idx][0]) * (s2Count - memo[s2Idx][1]);
+ n1Left = n1Left % (s1Count - memo[s2Idx][0]);
+ int leftS2Count = s2CountMap[memo[s2Idx][0] + n1Left] - memo[s2Idx][1];
+ int totalCount = leftS2Count + matchedPatternCount + memo[s2Idx][1];
+ return totalCount / n2;
+ }
+}

src/main/java/g0401_0500/s0466_count_the_repetitions/readme.md

@@ -0,0 +1,33 @@
+466\. Count The Repetitions
+
+Hard
+
+We define `str = [s, n]` as the string `str` which consists of the string `s` concatenated `n` times.
+
+* For example, `str == ["abc", 3] =="abcabcabc"`.
+
+We define that string `s1` can be obtained from string `s2` if we can remove some characters from `s2` such that it becomes `s1`.
+
+* For example, `s1 = "abc"` can be obtained from `s2 = "ab**dbe**c"` based on our definition by removing the bolded underlined characters.
+
+You are given two strings `s1` and `s2` and two integers `n1` and `n2`. You have the two strings `str1 = [s1, n1]` and `str2 = [s2, n2]`.
+
+Return _the maximum integer_ `m` _such that_ `str = [str2, m]` _can be obtained from_ `str1`.
+
+**Example 1:**
+
+**Input:** s1 = "acb", n1 = 4, s2 = "ab", n2 = 2
+
+**Output:** 2
+
+**Example 2:**
+
+**Input:** s1 = "acb", n1 = 1, s2 = "acb", n2 = 1
+
+**Output:** 1
+
+**Constraints:**
+
+* `1 <= s1.length, s2.length <= 100`
+* `s1` and `s2` consist of lowercase English letters.
+* <code>1 <= n1, n2 <= 10<sup>6</sup></code>

src/main/java/g0401_0500/s0467_unique_substrings_in_wraparound_string/Solution.java

@@ -0,0 +1,27 @@
+package g0401_0500.s0467_unique_substrings_in_wraparound_string;
+
+// #Medium #String #Dynamic_Programming
+
+public class Solution {
+ public int findSubstringInWraproundString(String p) {
+ char[] str = p.toCharArray();
+ int n = str.length;
+ int[] map = new int[26];
+ int len = 0;
+ for (int i = 0; i < n; i++) {
+ if (i > 0 && ((str[i - 1] + 1 == str[i]) || (str[i - 1] == 'z' && str[i] == 'a'))) {
+ len += 1;
+ } else {
+ len = 1;
+ }
+ // we are storing the max len of string for each letter and then we will count all these
+ // length.
+ map[str[i] - 'a'] = Math.max(map[str[i] - 'a'], len);
+ }
+ int answer = 0;
+ for (int num : map) {
+ answer += num;
+ }
+ return answer;
+ }
+}

src/main/java/g0401_0500/s0467_unique_substrings_in_wraparound_string/readme.md

@@ -0,0 +1,36 @@
+467\. Unique Substrings in Wraparound String
+
+Medium
+
+We define the string `s` to be the infinite wraparound string of `"abcdefghijklmnopqrstuvwxyz"`, so `s` will look like this:
+
+* `"...zabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd...."`.
+
+Given a string `p`, return _the number of **unique non-empty substrings** of_ `p` _are present in_ `s`.
+
+**Example 1:**
+
+**Input:** p = "a"
+
+**Output:** 1 Explanation: Only the substring "a" of p is in s.
+
+**Example 2:**
+
+**Input:** p = "cac"
+
+**Output:** 2
+
+**Explanation:** There are two substrings ("a", "c") of p in s.
+
+**Example 3:**
+
+**Input:** p = "zab"
+
+**Output:** 6
+
+**Explanation:** There are six substrings ("z", "a", "b", "za", "ab", and "zab") of p in s.
+
+**Constraints:**
+
+* <code>1 <= p.length <= 10<sup>5</sup></code>
+* `p` consists of lowercase English letters.

src/test/java/g0401_0500/s0466_count_the_repetitions/SolutionTest.java

@@ -0,0 +1,18 @@
+package g0401_0500.s0466_count_the_repetitions;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void getMaxRepetitions() {
+ assertThat(new Solution().getMaxRepetitions("acb", 4, "ab", 2), equalTo(2));
+ }
+
+ @Test
+ void getMaxRepetitions2() {
+ assertThat(new Solution().getMaxRepetitions("acb", 1, "acb", 1), equalTo(1));
+ }
+}

src/test/java/g0401_0500/s0467_unique_substrings_in_wraparound_string/SolutionTest.java

@@ -0,0 +1,23 @@
+package g0401_0500.s0467_unique_substrings_in_wraparound_string;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void findSubstringInWraproundString() {
+ assertThat(new Solution().findSubstringInWraproundString("a"), equalTo(1));
+ }
+
+ @Test
+ void findSubstringInWraproundString2() {
+ assertThat(new Solution().findSubstringInWraproundString("cac"), equalTo(2));
+ }
+
+ @Test
+ void findSubstringInWraproundString3() {
+ assertThat(new Solution().findSubstringInWraproundString("zab"), equalTo(6));
+ }
+}