子字符串是字符串中连续的字符序列。它本质上是字符串的开始索引和结束索引的一部分。在本文中，我们将从 Java 中的字符串生成所有子字符串。
例如，如果输入字符串是“ABCD”，那么第一个字符是“A”，我们需要提取长度为1,2,3,4的子串。长度 1 = ‘A’，长度 2 = ‘AB’，长度 3 = “ABC”，长度 4 = “ABCD”。对于下一个字符，即“B”（ i = 1 ），我们需要提取长度为 1,2,3 的子字符串。我们将对剩下的继续这样做。
在每个子字符串形成步骤中，我们可以将提取的子字符串添加到结果列表中。
伪代码：
for each character
- iterate over all the remaining string starting from the selected character
- extract the substring of length 1,2,3 ... until string is finished
------------------------------------------------------------------
for each character:
for(int i = 0; i< inputString.length(); i++){}
iterating over all the string starting from selected character i and
finishing at the end of string:
for(int j = i+1; j<= inputString.length(); j++){ }
extracting substring of length 1,2,3 ..so on :
res.add(inputString.substring(i, j));
|
代码
- 正如伪代码中所讨论的，我们对每个字符进行迭代，这本质上意味着我们从每个字符开始提取子字符串。一个简单的 for 循环就足以达到目的。
- 接下来，我们可以从所选字符开始迭代每个字符。在这种情况下，我们的窗口将是由 i 索引定义的选定字符，并跨越到字符串末尾。 j 索引用于从 i开始扩展窗口。
- 对于每个窗口，我们提取长度为 (i,j) 的子字符串，即窗口的长度。因此，对于 i=0，j=1，我们提取长度为 1 的子字符串，对于 i=0，j=2，我们提取长度为 2 的子字符串..依此类推
Java代码：
public void generateSubStringsUsingForLoop(String inputString, List<String> res) {
for(int i = 0; i< inputString.length(); i++){
for(int j = i+1; j<= inputString.length(); j++){
res.add(inputString.substring(i, j));
}
}
}
|
Python代码：
使用迭代方法从字符串生成所有子字符串涉及使用两个嵌套循环来迭代起始索引和结束索引的所有可能组合。这是 Python 中的一个简单示例：
def generate_substrings(s):
substrings = []
n = len(s)
for i in range(n):
for j in range(i + 1, n + 1):
substring = s[i:j]
substrings.append(substring)
return substrings
# Example usage:
input_string = "abc"
result = generate_substrings(input_string)
print(result)
输出：
|
['a', 'ab', 'abc', 'b', 'bc', 'c']
此代码定义了一个函数generate_substrings，该函数接受字符串s作为输入并返回所有可能子字符串的列表。两个嵌套循环（for i 和 for j）迭代所有起始索引和结束索引，并使用切片获取子字符串（s[i:j] ）。Rust代码：
fn generate_substrings(s: &str) -> Vec<&str> {
let mut substrings = Vec::new();
for i in 0..s.len() {
for j in i + 1..=s.len() {
substrings.push(&s[i..j]);
}
}
substrings
}
fn main() {
let input_string = "abc";
let result = generate_substrings(input_string);
println!("{:?}", result);
}
|
在 Rust 中，我们使用切片 (&str) 来表示子字符串。 generate_substrings 函数获取对字符串的引用并返回字符串切片向量。
Go代码：
package main
import "fmt"
func generateSubstrings(s string) []string {
var substrings []string
for i := 0; i < len(s); i++ {
for j := i + 1; j <= len(s); j++ {
substrings = append(substrings, s[i:j])
}
}
return substrings
}
func main() {
inputString := "abc"
result := generateSubstrings(inputString)
fmt.Println(result)
}
|
在 Go 中，我们使用切片 ([]string) 来存储子字符串。 generateSubstrings 函数接受一个字符串并返回一个字符串切片