# Solution For Number Of Ways To Split A String

The “Number Of Ways To Split A String” problem on LeetCode asks us to find the number of ways to split a string into three non-empty parts, such that each part contains the same number of distinct characters. In other words, for each position of splitting, we need to check if the number of distinct characters in the left part, center part, and right part are the same.

For example, for the string “abacbc”, we can split it into (“a”, “ba”, “cbc”), (“ab”, “a”, “cbc”), (“ab”, “ac”, “bc”), (“aba”, “cbc”, “”), or (“a”, “bac”, “bc”), which gives us a total of 5 valid splits.

To solve this problem, we can start by counting the number of distinct characters in the string. If the number of distinct characters is less than 3, then we cannot split the string into three parts with equal number of distinct characters. Otherwise, we can loop over all possible positions to split the string into three parts and check if each part has the same number of distinct characters.

Here is the detailed solution:

1. Count the number of distinct characters in the string using a set.

“`
def countDistinct(s):
return len(set(s))

dist_count = countDistinct(s)
“`

1. If the number of distinct characters is less than 3, return 0 as we cannot split the string into three parts with equal number of distinct characters.

`if dist_count < 3: return 0`

1. Initialize a counter variable `ans` to keep track of the number of valid splits.

`ans = 0`

1. Loop over all possible positions to split the string into three parts. The range of the loop can be from 1 to n-2, where n is the length of the string.

`for i in range(1, n-1):`

1. Initialize two sets `left` and `right` to keep track of the distinct characters in the left and right parts respectively.

`left = set(s[:i]) right = set(s[i:])`

1. Check if the number of distinct characters in the left and right parts is the same. If not, continue to the next iteration of the loop.

`if len(left) != len(right): continue`

1. Loop over all possible positions to split the center part, which can be from j=i+1 to n-1-i. Initialize a set `center` to keep track of the distinct characters in the center part.

`for j in range(i+1, n-i): center = set(s[i:j])`

1. Check if the number of distinct characters in the center part is the same as the number of distinct characters in the left and right parts. If not, continue to the next iteration of the loop.

`if len(center) != len(left): continue`

1. If all three parts have the same number of distinct characters, increment the counter variable `ans`.

`ans += 1`

1. Return the value of `ans`.

`return ans`

The time complexity of this solution is O(n^3) as we are looping over all possible positions to split the string and checking the number of distinct characters in each part. However, we can optimize this solution further by precomputing the number of distinct characters in each prefix and suffix of the string, which reduces the time complexity to O(n^2).

Here is the optimized solution:

1. Count the number of distinct characters in the string using a set.

“`
def countDistinct(s):
return len(set(s))

dist_count = countDistinct(s)
“`

1. If the number of distinct characters is less than 3, return 0 as we cannot split the string into three parts with equal number of distinct characters.

`if dist_count < 3: return 0`

1. Initialize a counter variable `ans` to keep track of the number of valid splits.

`ans = 0`

1. Initialize two lists `left` and `right` to keep track of the number of distinct characters in each prefix and suffix respectively.

“`
left =  * (n+1)
right =  * (n+1)

for i in range(1, n+1):
left[i] = left[i-1] + (s[i-1] not in left_set)
right[n-i] = right[n-i+1] + (s[n-i] not in right_set)
“`

1. Loop over all possible positions to split the string into three parts. The range of the loop can be from 1 to n-2, where n is the length of the string.

`for i in range(1, n-1):`

1. Check if the number of distinct characters in the left and right parts is the same. If not, continue to the next iteration of the loop.

`if left[i] != right[i]: continue`

1. Loop over all possible positions to split the center part, which can be from j=i+1 to n-1-i.

`for j in range(i+1, n-i):`

1. Check if the number of distinct characters in the center part is the same as the number of distinct characters in the left and right parts. If not, continue to the next iteration of the loop.

`if left[j] - left[i] != left[i]: continue`

1. If all three parts have the same number of distinct characters, increment the counter variable `ans`.

`ans += 1`

1. Return the value of `ans`.

`return ans`

The time complexity of the optimized solution is O(n^2) as we are precomputing the number of distinct characters in each prefix and suffix of the string and checking it in constant time.

## Step by Step Implementation For Number Of Ways To Split A String

```class Solution {
public int numWays(String s) {
int n = s.length();
int[] dp = new int[n + 1];
dp = 1;

for (int i = 1; i <= n; i++) {
if (s.charAt(i - 1) == '0') {
dp[i] = 0;
} else {
dp[i] = dp[i - 1];
}

if (i > 1) {
int num = Integer.parseInt(s.substring(i - 2, i));
if (num >= 10 && num <= 26) {
dp[i] += dp[i - 2];
}
}
}

return dp[n];
}
}```
```def numWays(s):

# keep track of number of ways to split the string
# as we iterate through the string
num_ways = 0

# iterate through the string
for i in range(len(s) - 1):

# if the current character is a 1,
# then we can split the string at this point
if s[i] == '1':
num_ways += 1

# return the total number of ways to split the string
return num_ways```
```There are several ways to solve this problem. One approach would be to use a regular expression to split the string into an array of substrings, then iterate over that array to count the number of ways to split it.

var numWaysToSplit = function(s) {
// Use a regular expression to split the string into an array of substrings
var substrings = s.split(/[^0-9]/);

// Iterate over the array, counting the number of ways to split each substring
var count = 0;
for (var i = 0; i < substrings.length; i++) {
var substring = substrings[i];
// If the substring is empty, we can't split it, so skip it
if (substring === '') continue;

// If the substring has only one character, there's only one way to split it
if (substring.length === 1) {
count++;
continue;
}

// If the substring has more than one character, we can split it in multiple ways
// For example, "12" can be split as "1" + "2" or "12"
for (var j = 1; j < substring.length; j++) {
var left = substring.substring(0, j);
var right = substring.substring(j);
// If the left and right substrings are both non-empty, we've found a valid split
if (left !== '' && right !== '') {
count++;
}
}
}

return count;
};```
```There are several ways to solve this problem. One approach is to use a hash map to keep track of the number of ways to split a string at each index. Another approach is to use a dynamic programming approach, keeping track of the number of ways to split a string at each index in an array.

We will use the hash map approach in this solution.

First, we create a map to keep track of the number of ways to split a string at each index. Then, we iterate through the string, updating the map as we go. If we encounter a character that has already been seen, we know that we can split the string at that point. Otherwise, we update the map with the current number of ways to split the string.

For example, consider the string "abcdef". We can split it at the following indices:

0: "abcdef"
1: "ab", "cdef"
2: "ab", "cd", "ef"
3: "abc", "def"
4: "abcd", "ef"
5: "abcde", "f"

Thus, there are 6 ways to split the string "abcdef".```
```public class Solution {
public int NumWays(string s) {
int result = 0;
int count = s.Count(x => x == '1');
// if the number of 1's is not divisible by 3 then it's not possible to split the string into 3 parts
if(count == 0 || count % 3 != 0) {
return result;
}
int ones = 0;
int first = 0;
int second = 0;
// iterate over the string and find the first and second partitions
for(int i = 0; i < s.Length; i++) {
if(s[i] == '1') {
ones++;
}
if(ones == count/3) {
first = i;
break;
}
}
ones = 0;
for(int i = s.Length-1; i >= 0; i--) {
if(s[i] == '1') {
ones++;
}
if(ones == count/3) {
second = i;
break;
}
}
// the number of ways to split the string is equal to the number of 0's between the first and second partitions
for(int i = first+1; i < second; i++) {
if(s[i] == '0') {
result++;
}
}
return result;
}
}```
Scroll to Top

## Top 100 Leetcode Practice Problems In Java

Get 30% Off Instantly!
[gravityforms id="5" description="false" titla="false" ajax="true"]