Java 将单词一分为二并检查是否存在逗号分隔的字符串序列

我有一个字符串数组，例如：

new String[] = {"powerhouse", "p, pow, power, house, pose, poser"};

我的目标是将数组中的第一个条目（在本例中为

powerion

）拆分为任意两个单词，并与用作单词词典的第二个条目进行对比检查

以下是我目前的实施情况：

public static String[] convertWordsToArray(String input){
  String[] wordArr = null;
  wordArr = input.split(",");
  return wordArr;
}

public static String splitEm(String[] strArr) {
    String fw = strArr[0];
    String sw = strArr[1];

    String[] arrOne = convertWordsToArray(fw);
    System.out.println(arrOne.length);

    String[] dict = convertWordsToArray(sw);
    System.out.println(dict.length);

    for(int i = 0; i < dict.length - 1; i++) {
         String mWord = fw.split(i, i + 1);
         System.out.println(mWord);
    }

    // Edit Starts Here, tried to substring it but nothing prints in log
      for(int i = 0; i < arrOne.length; i++) {
        String mWord = fw.substring(0, i);
        System.out.println(mWord);
      }

    return ""; // empty for now
}

公共静态字符串[]convertWordsToArray（字符串输入）{
字符串[]wordArr=null；
wordArr=input.split（“，”）；
返回字arr；
}
公共静态字符串splitEm（字符串[]strArr）{
字符串fw=strArr[0]；
字符串sw=strArr[1]；
字符串[]arrOne=convertWordsToArray（fw）；
系统输出打印长度（arrOne.length）；
字符串[]dict=convertWordsToArray（sw）；
系统输出打印长度（dict.length）；
for（int i=0；i

---

我被困在第一个单词必须分开的地方。我应该使用两个循环，一个用于第一个单词，另一个用于字典吗？我知道，为了使用

.contains（）

方法，字典必须以某种方式转换为列表或数组列表。我该怎么办？谢谢。

你需要这样的东西吗

String s = "powerhouse";
List<String> list = new ArrayList<String>();
for(int i = 0; i < s.length(); i++){
    for(int j = i+1; j <= s.length(); j++){
        list.add(s.substring(i,j));
    }
}

System.out.println(list);

---

根据您的描述，“xyz”不是有效的子部分/子字符串，因此第一种情况打印为true，第二种情况打印为false

String s = "powerhouse";
List<String> list = new ArrayList<String>();
for(int i = 0; i < s.length(); i++){
    for(int j = i+1; j <= s.length(); j++){
        list.add(s.substring(i,j));
    }
}

System.out.println(list);

根据您的描述，“xyz”不是有效的子部分/子字符串，因此第一种情况打印为true，第二种情况打印为false

public class Stack {
    public static void main(String[] args) {

        String[] str = {"powerhouse", "p, pow, power, house, pose, poser"};
        String firstPart = str[0];
        String secondPart = str[1];
        boolean contain = isContain(firstPart, secondPart);
        System.out.println(contain);
    }

    private static boolean isContain(String firstPart, String secondPart) {

        for (int i = 0; i < firstPart.length(); i++) {
            String firstWord = firstPart.substring(0, i);
            String secondWord = firstPart.substring(i, firstPart.length());
            List<String> strings = Arrays.asList(secondPart.trim().split("\\s*,\\s*"));              
            if (strings.contains(firstWord) && strings.contains(secondWord)) return true; if you want to check both words use this
            //if (strings.contains(firstWord) || strings.contains(secondWord)) return true; if you want to check any(one) word from two words use this
        }
        return false;
    }
}

公共类堆栈{
公共静态void main（字符串[]args）{
String[]str={“发电站”、“发电站”、“发电站”、“发电站”、“发电站”、“房子”、“姿势”、“装腔作势”}；
字符串firstPart=str[0]；
字符串secondPart=str[1]；
布尔包含=isContain（第一部分，第二部分）；
系统输出打印项次（包含）；
}
私有静态布尔值包含（字符串第一部分，字符串第二部分）{
对于（int i=0；i

试试这个：

public class Stack {
    public static void main(String[] args) {

        String[] str = {"powerhouse", "p, pow, power, house, pose, poser"};
        String firstPart = str[0];
        String secondPart = str[1];
        boolean contain = isContain(firstPart, secondPart);
        System.out.println(contain);
    }

    private static boolean isContain(String firstPart, String secondPart) {

        for (int i = 0; i < firstPart.length(); i++) {
            String firstWord = firstPart.substring(0, i);
            String secondWord = firstPart.substring(i, firstPart.length());
            List<String> strings = Arrays.asList(secondPart.trim().split("\\s*,\\s*"));              
            if (strings.contains(firstWord) && strings.contains(secondWord)) return true; if you want to check both words use this
            //if (strings.contains(firstWord) || strings.contains(secondWord)) return true; if you want to check any(one) word from two words use this
        }
        return false;
    }
}

公共类堆栈{
公共静态void main（字符串[]args）{
String[]str={“发电站”、“发电站”、“发电站”、“发电站”、“发电站”、“房子”、“姿势”、“装腔作势”}；
字符串firstPart=str[0]；
字符串secondPart=str[1]；
布尔包含=isContain（第一部分，第二部分）；
系统输出打印项次（包含）；
}
私有静态布尔值包含（字符串第一部分，字符串第二部分）{
对于（int i=0；i

如果有人想要PHP语言的解决方案，那么您可以使用以下代码：

function ArrayChallenge($strArr) {

  $dictWords = explode( ',', $strArr[1] );
  $strLength = strlen($strArr[0]);

  $output = 'not possible';

  for( $i = 1; $i < $strLength; $i++ ){

    $firstStr = substr($strArr[0], 0, $i);
    $lastStr = substr($strArr[0], $i, $strLength);

    if ( in_array( $firstStr, $dictWords ) && in_array( $lastStr, $dictWords ) ) {
      $output = $firstStr . ',' . $lastStr;
      break;
    }
    
  }

  return $output;
}

函数阵列挑战（$strArr）{
$dictWords=explode（'，'，$strArr[1]）；
$strLength=strlen（$strArr[0]）；
$output='不可能'；
对于（$i=1；$i<$strLength；$i++）{
$FIRSTSR=substr（$strArr[0]，0，$i）；
$lastStr=substr（$strArr[0]，$i，$strLength）；
if（in_数组（$firstStr，$dictWords）&&in_数组（$lastStr，$dictWords））{
$output=$firstStr.，'.$lastStr；
打破
}
}
返回$output；
}

如果有人想要PHP语言的解决方案，那么您可以使用以下代码：

function ArrayChallenge($strArr) {

  $dictWords = explode( ',', $strArr[1] );
  $strLength = strlen($strArr[0]);

  $output = 'not possible';

  for( $i = 1; $i < $strLength; $i++ ){

    $firstStr = substr($strArr[0], 0, $i);
    $lastStr = substr($strArr[0], $i, $strLength);

    if ( in_array( $firstStr, $dictWords ) && in_array( $lastStr, $dictWords ) ) {
      $output = $firstStr . ',' . $lastStr;
      break;
    }
    
  }

  return $output;
}

函数阵列挑战（$strArr）{
$dictWords=explode（'，'，$strArr[1]）；
$strLength=strlen（$strArr[0]）；
$output='不可能'；
对于（$i=1；$i<$strLength；$i++）{
$FIRSTSR=substr（$strArr[0]，0，$i）；
$lastStr=substr（$strArr[0]，$i，$strLength）；
if（in_数组（$firstStr，$dictWords）&&in_数组（$lastStr，$dictWords））{
$output=$firstStr.，'.$lastStr；
打破
}
}
返回$output；
}

我不清楚您想要实现什么目标。在本例中，将数组中的第一个条目拆分为任意两个单词是什么意思？我的意思是，您有一个包含两个条目的数组。第一个条目需要拆分为两个单词，并与作为列表/词典的第二个条目进行检查。例如，在《发电厂房》（第一个条目）中，当分解为任意两个单词时，我们可以得到power、house（或pose），并且这些单词已经出现在SE（第二个条目/词典）中。我的问题是如何将第一个条目分解为任意两个单词。谢谢“pwhse”和“hrwp”也是有效的子字符串吗？意思是要检查

字符串[0]

是否包含

字符串[1]

中存在的所有字符，以及除了空格和逗号之外的所有字符？否，唯一有效的子字符串应该是SE/字典中的子字符串。我不清楚你想达到什么目的。将数组中的第一个条目拆分为任意两个单词是什么意思？我的意思是，您有一个包含两个条目的数组..第一个条目nee