# Substrings With Concatenation Of All Words Program Solution

Problem Statement

You are given a string `s` and an array of strings `words`. All the strings of `words` are of the same length.

concatenated substring in `s` is a substring that contains all the strings of any permutation of `words` concatenated.

• For example, if `words = ["ab","cd","ef"]`, then `"abcdef"``"abefcd"``"cdabef"``"cdefab"``"efabcd"`, and `"efcdab"` are all concatenated strings. `"acdbef"` is not a concatenated substring because it is not the concatenation of any permutation of `words`.
• We at gradjobopenings.com provide free job alerts of freshers job drives. In this website we list on campus job openings for freshers and off campus job openings for freshers and also work from home job openings. This is the best website to apply for off campus drive in India. Visit our website for government job alerts and private job alerts. We also list free interview notes and study materials, one of the best interview study website.comfortable to face the interviews:

Return the starting indices of all the concatenated substrings in `s`. You can return the answer in any order.

Example 1:

```Input: s = "barfoothefoobarman", words = ["foo","bar"]
Output: [0,9]
Explanation: Since words.length == 2 and words[i].length == 3, the concatenated substring has to be of length 6.
The substring starting at 0 is "barfoo". It is the concatenation of ["bar","foo"] which is a permutation of words.
The substring starting at 9 is "foobar". It is the concatenation of ["foo","bar"] which is a permutation of words.
The output order does not matter. Returning [9,0] is fine too.
```

Example 2:

```Input: s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
Output: []
Explanation: Since words.length == 4 and words[i].length == 4, the concatenated substring has to be of length 16.
There is no substring of length 16 is s that is equal to the concatenation of any permutation of words.
We return an empty array.
```

Example 3:

```Input: s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
Output: [6,9,12]
Explanation: Since words.length == 3 and words[i].length == 3, the concatenated substring has to be of length 9.
The substring starting at 6 is "foobarthe". It is the concatenation of ["foo","bar","the"] which is a permutation of words.
The substring starting at 9 is "barthefoo". It is the concatenation of ["bar","the","foo"] which is a permutation of words.
The substring starting at 12 is "thefoobar". It is the concatenation of ["the","foo","bar"] which is a permutation of words.
```

Constraints:

• `1 <= s.length <= 104`
• `1 <= words.length <= 5000`
• `1 <= words[i].length <= 30`
• `s` and `words[i]` consist of lowercase English letters.
• Time: O(|\texttt{s}||\texttt{words}||\texttt{words[0]}|)
• Space: O(\Sigma |\texttt{words[i]}|)O(Σ∣words[i]∣)

### SUBSTRING WITH CONCATENATION OF ALL WORDS Program Solution in C++

``````class Solution {
public:
vector<int> findSubstring(string s, vector<string>& words) {
if (s.empty() || words.empty())
return {};

const int k = words.size();
const int n = words[0].length();
vector<int> ans;
unordered_map<string, int> count;

for (const string& word : words)
++count[word];

for (int i = 0; i < s.length() - k * n + 1; ++i) {
unordered_map<string, int> seen;
int j;
for (j = 0; j < k; ++j) {
const string& word = s.substr(i + j * n, n);
if (++seen[word] > count[word])
break;
}
if (j == k)
ans.push_back(i);
}

return ans;
}
};
``````

### SUBSTRING WITH CONCATENATION OF ALL WORDS Program Solution in JAVA

``````class Solution {
public List<Integer> findSubstring(String s, String[] words) {
if (s.isEmpty() || words.length == 0)
return new ArrayList<>();

final int k = words.length;
final int n = words[0].length();
List<Integer> ans = new ArrayList<>();
Map<String, Integer> count = new HashMap<>();

for (final String word : words)
count.put(word, count.getOrDefault(word, 0) + 1);

for (int i = 0; i <= s.length() - k * n; ++i) {
Map<String, Integer> seen = new HashMap<>();
int j = 0;
for (; j < k; ++j) {
final String word = s.substring(i + j * n, i + j * n + n);
seen.put(word, seen.getOrDefault(word, 0) + 1);
if (seen.get(word) > count.getOrDefault(word, 0))
break;
}
if (j == k)
}

return ans;
}
}
``````

### SUBSTRING WITH CONCATENATION OF ALL WORDS Program Solution in Python

``````class Solution:
def findSubstring(self, s: str, words: List[str]) -> List[int]:
if len(s) == 0 or words == []:
return []

k = len(words)
n = len(words[0])
ans = []
count = Counter(words)

for i in range(len(s) - k * n + 1):
seen = defaultdict(int)
j = 0
while j < k:
word = s[i + j * n: i + j * n + n]
seen[word] += 1
if seen[word] > count[word]:
break
j += 1
if j == k:
ans.append(i)

return ans
``````
error: Content is protected !!