Question

我需要比较两个不同字符数组中的字符，以找到用户输入的隐藏字。

目标是输入2个字符串并找到在另一个字符串中加扰的字。防爆。单词＆＃34; tot＆＃34;在＃34;番茄＆＃34;这个词中被炒作

在论坛的一些人的帮助下，我已经实现了字符数组来存储用户字符串，但我不知道如何检查每个数组中所需的字符。我已经尝试了下面的代码，但它总是导致程序无法找到该单词。如果有人能提供更好的方法或解决方案，我会非常感激。

public static void main(String[] args) {
    input = new Scanner(System.in);

    System.out.println("Please enter a word"); 
    String word = input.next();
    char[] charOfWrds = word.toCharArray();

    System.out.println("Please enter a hidden word you would like to search for");
    String search = input.next();
    char[] charOfSrch = search.toCharArray();

    if (isContains(charOfWrds, charOfSrch))   
    { 
        System.out.print("The word " + search + " is found in the word " + word);
    } 
    else 
    {
        System.out.print("The word was not found in " + word); 
    }
}
public static Boolean isContains(char[] charOfWrds, char[] charOfSrch) {
    int count = 0;
    for (char cha : charOfWrds) 
    {
        for (char chaaa : charOfSrch) 
        {
            if (cha == chaaa)
                count++;
        }
    }
    if (count == charOfSrch.length)
    {
        return true;
    }
    return false;
}

Answer 1

采取

番茄作为charOfWrds

tot as charOfSrch

isContains会计算6，因为当你在第二个单词中找到第一个单词的字母时你不会退出。

t：两次

o：两次

t：两次

试试这个：

if (cha == chaaa){
    count++;
    break;
}

但是为了完成这项工作，您需要删除从第二个字符串中找到的字母，因为如果您要查找的字词是＆＃34; tttt＆＃34;，那么此代码将为您提供真实的如果不是，但是如果你在找到它时删除了它，那么就应该这样做。

我不知道这对你来说是否足够清楚。

这是代码：

public static Boolean isContains(char[] charOfWrds, char[] charOfSrch) {
    int count = 0;
    for (int i=0; i<charOfWrds.length;i++){
        for (int j=0;j<charOfSrch.length;j++){
            if (charOfWrds[i] == charOfSrch[j]){
                count++;
                charOfSrch[j]=' ';
                break;
            }
        }
    }
    if (count == charOfSrch.length)
    {
        return true;
    }
    return false;
}

它正在工作，我试着用它：

String word = "tomato";
char[] charOfWrds = word.toCharArray();


String search = "tot";
char[] charOfSrch = search.toCharArray();

但这很难看，你应该尝试使用java Api，除非你真的必须使用数组。

Answer 2

public static Boolean isContains(char[] charOfWords, char[] charOfSrch) {
    List<Character> searchFor = new ArrayList<>();
    List<Character> searchMe=new ArrayList<>();
    for(char c:charOfWords)
        searchFor.add(c);
    for(char c:charOfSrch)
        searchMe.add(c);

    for(int x=searchFor.size()-1;x>=0;x--){
        if(searchMe.contains(searchFor.get(x)){
            searchMe.remove(searchFor.get(x));
            searchFor.remove(x);//line A
        }                
    }
    return searchFor.size()==0;
}

快速概述这一点。我将两个字符数组转换为Lists，以便我可以使用List方法。然后，我遍历了你需要找到的单词中的每个字符，如果我能在另一个单词中找到它，我将它从两个单词中删除，这意味着如果所有单词都从需要查找的单词中删除，这个词在另一个词中找到;否则就不是。

我认为您无法在第二个单词中重复使用字母，但如果可以，则只需删除A行。

Answer 3

你应该尝试正则表达而不是试图写一个算法。使用用户输入构建表达式，然后匹配所需的单词。

Answer 4

我的想法类似于@kirbyquerby所提供的，只是它有一些优化。

在将每个单词（针和大海捞针）转换为列表后，我们不再使用线性搜索，而是对这些列表进行排序。这允许我们使用二进制搜索，其将搜索复杂度从O（n ^ 2）改变为O（n log n）。

此外，无需从针列表中删除字符，因为我们可以跟踪已找到的针数字符数。完成搜索后，我们只需将找到的针数字符数与针数字符总数进行比较即可。如果他们是平等的，我们找到了针。最后，如果找不到针头字符，我们可以立即停止搜索，因为我们知道大海捞针内不存在整个针头。

package hiddenword;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class HiddenWord {
    public static void main(final String args[]) {
        final String haystack = "Tomato";
        final String needle = "tot";

        if (contains(haystack, needle)) {
            System.out.println(haystack + " contains " + needle);
        } else {
            System.out.println(haystack + " does not contain " + needle);
        }
    }

    private static boolean contains(final String haystack, final String needle) {
        // Convert each word to lowercase and into a List.
        final List<Character> haystackChars = toSortedCharacterList(haystack.toLowerCase());
        final List<Character> needleChars = toSortedCharacterList(needle.toLowerCase());
        int foundNeedleChars = 0;

        for (final Character c : needleChars) {
            // Using sorted lists, our search time is be O(n log n) by using
            // binary search instead of O(n^2) using linear search.
            int index = Collections.binarySearch(haystackChars, c);

            // A needle character has been found, remove it from the haystack
            // and increment the count
            if (index >= 0) {
                haystackChars.remove(index);
                ++foundNeedleChars;
            }
            // A needle character was not found. This means that the haystack
            // doesn't contain every character of the needle and we
            // can quit early
            else {
                return false;
            }
        }

        // If we've found all the needle characters, the needle word exists in
        // the haystack word.
        return foundNeedleChars == needleChars.size();
    }

    private static List<Character> toSortedCharacterList(final String input) {
        final List<Character> list = new ArrayList<Character>();

        // Convert primitive array to List
        for (final char c : input.toCharArray()) {
            list.add(c);
        }

        // Sort that thang
        Collections.sort(list);

        return list;
    }
}

Answer 5

您可以执行此操作，而无需将字符串转换为具有以下内容的数组：

static boolean containsScrambled(String word, String search){
    //loop through each character of the word whose characters we are searching for
    for(int x = 0; x<search.length(); x++){
        //find the current character to check
        String c = search.substring(x, x+1);

        if(word.indexOf(c) >= 0){
            //if the character is in the word, remove the first instance of it
            //as we cannot use that character again
            word.replaceFirst(c, "");
        }else{
            //if the character is not in the word, fail and return false
            return false;
        }
    }

    //if we made it here, all of the characters existed, return true
    return true;
}

如何在Java中的Character数组中找到某个单词的字母？

5 个答案: