如何在Java中检查两个句子之间删除的单词

如果要检查从句子B中的句子A中删除的单词，Java中最好的方法是什么。例如：

a b a
a

我想删除这个简单句子中不必要的词

我想删除这个句子中的单词

输出：我想删除这个（简单）句子中的（不必要的）单词

---

括号内的单词是从句子A中删除的单词。

假设顺序无关紧要：使用commons collections

使用

String.split（）

将两个句子拆分为单词数组

使用commons collections'

CollectionUtils.addAll

将每个数组添加到空的

集合中

使用commons collections'

CollectionUtils.subtract

方法获得A-B

---

假设顺序无关紧要：使用commons集合

使用

String.split（）

将两个句子拆分为单词数组

使用commons collections'

CollectionUtils.addAll

将每个数组添加到空的

集合中

使用commons collections'

CollectionUtils.subtract

方法获得A-B

---

这基本上是一个不同点，看看这个：

根算法：

下面是一个示例Java实现：

private static String deletedWords(String s1, String s2) {
    StringBuilder sb = new StringBuilder();
    String[] words1 = s1.split("\\s+");
    String[] words2 = s2.split("\\s+");
    int i1, i2;
    i1 = i2 = 0;
    while (i1 < words1.length) {
        if (words1[i1].equals(words2[i2])) {
            sb.append(words1[i1]);
            i2++;
        } else {
            sb.append("(" + words1[i1] + ")");
        }
        if (i1 < words1.length - 1) {
            sb.append(" ");
        }
        i1++;
    }
    return sb.toString();
}

它比较线条。你唯一需要做的事情是按单词而不是按行分开，或者把两个句子的每个单词放在一行

例如，在Linux上，在编写任何代码之前，您都可以使用

diff

程序本身查看后一选项的结果，请尝试以下操作：

$ echo "I want to delete unnecessary words on this simple sentence."|tr " " "\n" > 1
$ echo "I want to delete words on this sentence."|tr " " "\n" > 2
$ diff -uN 1 2
--- 1   2012-10-01 19:40:51.998853057 -0400
+++ 2   2012-10-01 19:40:51.998853057 -0400
@@ -2,9 +2,7 @@
 want
 to
 delete
-unnecessary
 words
 on
 this
-simple
 sentence.

前面有

-

的行是不同的（或者，如果在句子B中添加了不在句子A中的行，则会显示

+

）。试试看这是否适合你的问题

---

希望这能有所帮助。

这基本上是一个不同点，看看这个：

根算法：

下面是一个示例Java实现：

private static String deletedWords(String s1, String s2) {
    StringBuilder sb = new StringBuilder();
    String[] words1 = s1.split("\\s+");
    String[] words2 = s2.split("\\s+");
    int i1, i2;
    i1 = i2 = 0;
    while (i1 < words1.length) {
        if (words1[i1].equals(words2[i2])) {
            sb.append(words1[i1]);
            i2++;
        } else {
            sb.append("(" + words1[i1] + ")");
        }
        if (i1 < words1.length - 1) {
            sb.append(" ");
        }
        i1++;
    }
    return sb.toString();
}

它比较线条。你唯一需要做的事情是按单词而不是按行分开，或者把两个句子的每个单词放在一行

例如，在Linux上，在编写任何代码之前，您都可以使用

diff

程序本身查看后一选项的结果，请尝试以下操作：

$ echo "I want to delete unnecessary words on this simple sentence."|tr " " "\n" > 1
$ echo "I want to delete words on this sentence."|tr " " "\n" > 2
$ diff -uN 1 2
--- 1   2012-10-01 19:40:51.998853057 -0400
+++ 2   2012-10-01 19:40:51.998853057 -0400
@@ -2,9 +2,7 @@
 want
 to
 delete
-unnecessary
 words
 on
 this
-simple
 sentence.

前面有

-

的行是不同的（或者，如果在句子B中添加了不在句子A中的行，则会显示

+

）。试试看这是否适合你的问题

---

希望这有帮助。

假设顺序和位置很重要，这看起来像是最长公共子序列问题的一种变体，一种动态规划解决方案

wikipedia在这个主题上有一个很棒的页面，这里有太多我无法概括的内容

---

假设顺序和位置很重要，这看起来像是最长公共子序列问题的一种变体，一种动态规划解决方案

wikipedia在这个主题上有一个很棒的页面，这里有太多我无法概括的内容

---

其他所有人都在使用非常重的算法来解决一个非常简单的问题。可以使用最长的公共子序列来解决这个问题，但这是一个非常受限的版本。这不是完全不同；它只包括删除。不需要动态规划或类似的东西。下面是一个20行的实现：

private static String deletedWords(String s1, String s2) {
    StringBuilder sb = new StringBuilder();
    String[] words1 = s1.split("\\s+");
    String[] words2 = s2.split("\\s+");
    int i1, i2;
    i1 = i2 = 0;
    while (i1 < words1.length) {
        if (words1[i1].equals(words2[i2])) {
            sb.append(words1[i1]);
            i2++;
        } else {
            sb.append("(" + words1[i1] + ")");
        }
        if (i1 < words1.length - 1) {
            sb.append(" ");
        }
        i1++;
    }
    return sb.toString();
}

---

可能是

a（b）（a）

或

（a）（b）a

，可能对于这个问题的某些版本，这些解决方案中的一个更可能是“实际”解决方案，而对于那些需要某种递归或动态编程方法的解决方案。。。但我们不要让它比以色列佐藤最初要求的复杂得多

对于一个非常简单的问题，其他人都在使用非常重的算法。可以使用最长的公共子序列来解决这个问题，但这是一个非常受限的版本。这不是完全不同；它只包括删除。不需要动态规划或类似的东西。下面是一个20行的实现：

private static String deletedWords(String s1, String s2) {
    StringBuilder sb = new StringBuilder();
    String[] words1 = s1.split("\\s+");
    String[] words2 = s2.split("\\s+");
    int i1, i2;
    i1 = i2 = 0;
    while (i1 < words1.length) {
        if (words1[i1].equals(words2[i2])) {
            sb.append(words1[i1]);
            i2++;
        } else {
            sb.append("(" + words1[i1] + ")");
        }
        if (i1 < words1.length - 1) {
            sb.append(" ");
        }
        i1++;
    }
    return sb.toString();
}

String a = "I want to delete unnecessary words on this simple sentence.";
String b = "I want to delete words on this sentence.";

String[] aWords = a.split(" ");
String[] bWords = b.split(" ");
List<String> missingWords = new ArrayList<String> ();

int x = 0;
for(int i = 0 ; i < aWords.length; i++) {
  String aWord = aWords[i];
  if(x < bWords.length) {
    String bWord = bWords[x];
    if(aWord.equals(bWord)) {
        x++;
    } else {
        missingWords.add(aWord);
    }
   } else {
      missingWords.add(aWord);
   }
}

可能是

a（b）（a）

或

（a）（b）a

，可能对于这个问题的某些版本，这些解决方案中的一个更可能是“实际”解决方案，而对于那些需要某种递归或动态编程方法的解决方案。。。但我们不要让它比以色列佐藤最初要求的复杂得多

String a=“我想删除这个简单句子中不必要的单词。”；
String a = "I want to delete unnecessary words on this simple sentence.";
String b = "I want to delete words on this sentence.";

String[] aWords = a.split(" ");
String[] bWords = b.split(" ");
List<String> missingWords = new ArrayList<String> ();

int x = 0;
for(int i = 0 ; i < aWords.length; i++) {
  String aWord = aWords[i];
  if(x < bWords.length) {
    String bWord = bWords[x];
    if(aWord.equals(bWord)) {
        x++;
    } else {
        missingWords.add(aWord);
    }
   } else {
      missingWords.add(aWord);
   }
}

String b=“我想删除这个句子中的单词。”；
字符串[]aWords=a.split（“”）；
字符串[]bWords=b.split（“”）；
List missingWords=newarraylist（）；
int x=0；
for（int i=0；i

String a=“我想删除这个简单句子中不必要的单词。”；
String b=“我想删除这个句子中的单词。”；
字符串[]aWords=a.split（“”）；
字符串[]bWords=b.split（“”）；
List missingWords=newarraylist（）；
int x=0；
for（int i=0；i

这很有效……对于更新的字符串也很有效
用方括号括起来的更新字符串

import java.util.*;
class Sample{
public static void main(String[] args){
    Scanner sc=new Scanner(System.in);  

    String str1 = sc.nextLine();
    String str2 = sc.nextLine();
    List<String> flist = Arrays.asList(str1.split("\\s+"));
    List<String> slist = Arrays.asList(str2.split("\\s+"));
    List<String> completedString = new ArrayList<String>();
    String result="";
    String updatedString = "";
    String deletedString = "";
    int i=0;
    int startIndex=0;
    int endIndex=0;
    for(String word: slist){
        if(flist.contains(word)){
            endIndex = flist.indexOf(word);
            if(!completedString.contains(word)){
                if(deletedString.isEmpty()){
                    for(int j=startIndex;j<endIndex;j++){
                        deletedString+= flist.get(j)+" ";
                    }
                }
            }
            startIndex=endIndex+1;
            if(!deletedString.isEmpty()){
                result += "("+deletedString.substring(0,deletedString.length()-1)+") ";
                deletedString="";
            }
            if(!updatedString.isEmpty()){
                result += "["+updatedString.substring(0,updatedString.length()-1)+"] ";
                updatedString="";
            }
            result += word+" ";
            completedString.add(word);
            if(i==slist.size()-1){
                endIndex = flist.size();
                for(int j=startIndex;j<endIndex;j++){
                    deletedString+= flist.get(j)+" ";
                }
                startIndex = endIndex+1;
            }
        }
        else{
            if(i == 0){
                boolean boundaryCheck = false;
                for(int j=i+1;j<slist.size();j++){
                    if(flist.contains(slist.get(j))){
                        endIndex=flist.indexOf(slist.get(j));
                        boundaryCheck=true;
                        break;
                    }
                }
                if(!boundaryCheck){
                    endIndex = flist.size();
                }
                if(!completedString.contains(word)){
                    for(int j=startIndex;j<endIndex;j++){
                        deletedString+= flist.get(j)+" ";
                    }
                }
                startIndex = endIndex+1;
            }else if(i == slist.size()-1){
                endIndex = flist.size();
                if(!completedString.contains(word)){
                    for(int j=startIndex;j<endIndex;j++){
                        deletedString+= flist.get(j)+" ";
                    }
                }
                startIndex = endIndex+1;
            }               
            updatedString += word+" ";
            completedString.add(word);
        }
        i++;
    }
    if(!deletedString.isEmpty()){
        result += "("+deletedString.substring(0,deletedString.length()-1)+") ";
    }
    if(!updatedString.isEmpty()){
        result += "["+updatedString.substring(0,updatedString.length()-1)+"] ";
    }
    System.out.println(result);
}

import java.util.*；
类样本{
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
字符串str1=sc.nextLine（）；
字符串str2