基于收缩滑动窗口/二维数组的分裂字符串

Question

我试图在多个分隔符上创建字符串的片段。例如，我有以下字符串。

慢性淋巴细胞白血病:小淋巴细胞性淋巴瘤

我需要首先根据这个分隔符拆分字符串：

那部分很简单。

从每个子字符串(术语)中，我需要根据以下规则生成片段

由单词A、B和C组成的术语，即'A B C‘(0)、'A B’(1)、'B C‘(2)、'A’(3)、'B‘(4)、'C’(5)。

术语长度不是固定的。它可以是三个词或更多或更少。

逻辑是，在收缩窗口逻辑中，术语中的每个单词只应该连接到数组中的下一个单词。所以第一个词是A，后面是B，C。所以组合是A，B，然后窗口从右到左缩小，所以下一个组合体是A，B，下一个是C。

因此，在A，B，C，D项的情况下，输出片段将是

‘B，C，D’

‘B，C'，

‘B'，

‘’，

“b C D”，

“B C”，

“b”，

“c D”，

“c”，

德‘

对于一个术语A，B，C，D，E，输出片段是

'B C D E‘、'A B C D’、'A B‘、'A B’、'B‘C D’、'B C D‘、'B C’、‘B’‘、'C _D’、‘C_D’、'C‘、'D’、'D‘、'E’

以上“慢性淋巴细胞白血病”和“小淋巴细胞性淋巴瘤”是两个术语。

我需要的慢性淋巴细胞白血病的输出是

慢性淋巴细胞白血病

慢性淋巴细胞

慢性

淋巴细胞白血病

淋巴细胞性

白血病

我试图将它分割成一个2D数组，然后迭代它们，并尝试将它们连接起来，但是我碰到了一个路障。

String str="Chronic Lymphocytic Leukemia :: Small Lymphocytic Lymphoma";
String[] rows=str.split("::");
String[][] table=new String[rows.length][];
for (int i=0; i<rows.length;i++)
  {
     table[i]=rows[i].split(" ");
  }

for (int i=0;i<table.length;i++)
  {
    for(int j=0;j<table[i].length;j++)
      {
        System.out.println(table[i][j]);
      }
  }

你知道我怎么做到的吗？

Answer 1

几乎笔直向前：

• 选择第一单词的循环；
• 第一个循环中的第二个循环，它选择最后一个单词，然后向后移动。
• 在该循环中，只需将单词“添加到结果”中加入即可。

类似于：

List<String> fragments(String[] words) {
    var result = new ArrayList<String>();
    for (var i = 0; i < words.length; i++) {
        for (var j = words.length; j > i; j--) {
            result.add(Arrays.stream(words, i, j).collect(Collectors.joining(" ")));
        }
    }
    // result.remove(0);  // if you don't want the whole sequence inside the result
    return result;
}

如果由于某种原因，stream不是一个选项，则需要第三个循环来收集单词：

List<String> fragments(String[] words) {
    var result = new ArrayList<String>();
    for (var i = 0; i < words.length; i++) {
        for (var j = words.length; j > i; j--) {
            var fragment = new StringBuilder();
            for (var k = i; k < j; k++) {
                if (k > i) {
                    fragment.append(" ");
                }
                fragment.append(words[k]);
            }
            result.add(fragment.toString());
        }
    }
    // result.remove(0);  // if you dont want the whole sequence inside the result
    return result;
}

Answer 2

这是答案

import java.util.*;

public class MyClass {
    public static void main(String args[]) {
      String[] array= {"a","b","c","d", "e"};
      HashSet<String> result = new HashSet<>(); 

       for (int i=0; i<array.length  ; i++){ 

           addWords(array, i, result);
       }
    }

    public static void addWords(String[]array, int n, Set<String> result){
         int wordSize = array.length - n;
         //need to loop wordSize number of times.
        int numberOfLoops = array.length -wordSize +1 ;

         System.out.println("Handling n="+n+" wordsize="+wordSize+", numLoops="+numberOfLoops);

         for (int i = 0; i< numberOfLoops; i++){
             String word ="";
             for(int j = i; j<wordSize+i; j++){
                 word+=array[j]+" ";
             } 
             result.add(word.trim());

             System.out.println("Adding: "+ word);
         }
    }
}

预期结果如下。

Handling n=0 wordsize=5, numLoops=1
Adding: a b c d e 
Handling n=1 wordsize=4, numLoops=2
Adding: a b c d 
Adding: b c d e 
Handling n=2 wordsize=3, numLoops=3
Adding: a b c 
Adding: b c d 
Adding: c d e 
Handling n=3 wordsize=2, numLoops=4
Adding: a b 
Adding: b c 
Adding: c d 
Adding: d e 
Handling n=4 wordsize=1, numLoops=5
Adding: a 
Adding: b 
Adding: c 
Adding: d 
Adding: e 

Answer 3

Regex替换在这里可能会非常有用。我们可以尝试在单独的捕获组( $1、$2和$3 )中捕获这三个术语。然后，使用所需的逻辑和顺序替换这些捕获的术语。

String str = "Chronic Lymphocytic Leukemia :: Small Lymphocytic Lymphoma";
String[] rows = str.split("\\s+::\\s+");

for (String row : rows) {
    String output = row.replaceAll("(\\S+) (\\S+) (\\S+)", "$1 $2 $3 $1 $2 $2 $3 $1 $2 $3");
    System.out.println(output);
}

这些指纹：

Chronic Lymphocytic Leukemia Chronic Lymphocytic Lymphocytic Leukemia Chronic Lymphocytic Leukemia
Small Lymphocytic Lymphoma Small Lymphocytic Lymphocytic Lymphoma Small Lymphocytic Lymphoma