Question

在我的国家有一个名为Slagalica的游戏节目，其中一个任务是找到12个字母数组中最长的单词。最长单词的大小始终为10,11或12.

我的文件包含我用作数据库的语言。其中包含10,11或12个字母的单词我已保存在List（listWordSize10_11_12）中。当我输入混乱的单词[12个字母]我希望从我的程序中找到最初的单词。我知道当混乱的单词是12个单词时，如何使它工作，但是当它不那么时我无法解决它。

示例：10个字母单词混乱+ 2个随机字母目标是以原始状态识别和打印该10个字母的单词。

我做了什么：

    // un-jumbling word
    System.out.println("Unesite rijec koja treba da se desifruje: ");
    String jumbledWord = tast.nextLine();
    char[] letter = jumbledWord.toCharArray();
    Arrays.sort(letter);
    String sorted_Mistery_Word = new String(letter);


    for (int i = 0; i < listWordSize10_11_12.size(); i++) {   
        int exception = 0;
        char[] letter_2 = listWordSize10_11_12.get(i).toCharArray();
        Arrays.sort(letter_2);
        String longWords = new String(letter_2);
        int j = i;
        while(longWords.length()>i){
        if(sorted_Mistery_Word.charAt(j)!=longWords.charAt(i)){
              exception++;
              j++;
        }
        }
        if(exception < 3){
            System.out.println("Your word is: "+listWordSize10_11_12.get(i));
            break;                
        }
    }

谢谢！附：这不是一个家庭作业或一些工作，只是我一直在做的项目！

感谢大家的帮助，我学到了很多东西！

Answer 1

这是解决问题的唯一方法。让我们说（因为没有提供示例输入），有3个字符串[]＆＃39; arr3（代表你有10个字母的单词），{{ 1}}（代表你有11个字母的单词），arr4（你猜对了，代表你有12个字母的单词）。这就是我为那些人做的：

arr5

因此，根据您所说的内容，如果我们获得String[] arr3 = { "map", "cat", "dog" }; String[] arr4 = { "four", "five", "nine" }; String[] arr5 = { "funny", "comma", "brace" };的输入，我们需要pam的输出。如果我们得到了map的输入，那么我们需要enni的输出。如果我们得到nine的输入，我们需要yfunn的输出。那么如何去做呢？我喜欢@ cricket_007提到的关于使用地图的内容。但首先，让我们放下permutations。

基于链接的SO问题，我想出了这个修改后的变体来获取混乱的文本：

funny

这段代码将让我们轻松构建一个地图，让我们将混乱的文本存储为一个键，并将该混乱的文本作为一个值的答案。

总之，最终代码如下所示：

public static List<String> jumble(String str) {
    List<String> result = new ArrayList<String>();
    permutation(result, "", str);
    return result;
}
private static void permutation(List<String> l, String prefix, String s) {
    int n = s.length();
    if (n == 0) {
        l.add(prefix);
    } else {
        for (int i = 0; i < n; i++)
            permutation(l, prefix + s.charAt(i), s.substring(0, i) + s.substring(i + 1, n));
    }
}

其结果为：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Appy {
    public static void main(String[] args) {
        String[] arr3 = { "map", "cat", "dog" };
        String[] arr4 = { "four", "five", "nine" };
        String[] arr5 = { "funny", "comma", "brace" };
        List<String> permutations = new ArrayList<String>();
        Map<String, String> map = new HashMap<String, String>();
        for (String s : arr3) {
            permutations = jumble(s);
            for (String str : permutations)
                map.put(str, s);
        }
        for (String s : arr4) {
            permutations = jumble(s);
            for (String str : permutations)
                map.put(str, s);
        }
        for (String s : arr5) {
            permutations = jumble(s);
            for (String str : permutations)
                map.put(str, s);
        }
        System.out.println("test = 'pam' -> " + map.get("pam"));
        System.out.println("test = 'enni' -> " + map.get("enni"));
        System.out.println("test = 'yfunn' -> " + map.get("yfunn"));
    }
    public static List<String> jumble(String str) {
        List<String> result = new ArrayList<String>();
        permutation(result, "", str);
        return result;
    }
    private static void permutation(List<String> l, String prefix, String s) {
        int n = s.length();
        if (n == 0) {
            l.add(prefix);
        } else {
            for (int i = 0; i < n; i++)
                permutation(l, prefix + s.charAt(i), s.substring(0, i) + s.substring(i + 1, n));
        }
    }
}

现在应用这个逻辑，适应10,11和12个字母单词的情况应该相对简单。干杯！

Answer 2

12个字符的基本方法，我将其描述为指纹识别，也适用于10或11个字母单词并进行一些修改。

也就是说，只需在检查每个候选词时对每个候选词中的字母进行排序以创建指纹，预处理阵列以创建每个词的小（ish）指纹为byte[]。例如，使用英文字母并忽略大小写，您可以为每个单词创建一个26字节的数组，其中每个字节位置包含单词中每个字母的计数。

即fingerprint[0]包含单词中'a'个字符的数量，fingerprint[25]包含'z'个字符的数量。

然后用一个循环替换你的sorted_Mistery_Word.charAt(j)!=longWords.charAt(i)检查，该循环为神秘词中的每个字母增加一个临时数组。最后，检查临时数组是否至少每个位置的值相同。类似的东西：

byte [] makeFingerprint(String s) {
  byte[] fingerprint = new byte[26];
  for (char c : letter_2) {
    fingerprint[c - 'a']++;
  }

  return fingerprint;
}

/** determine if sub is a subset of super */
boolean isSubset(byte[] sub, byte[] super) {
  for (int i=0; i < sub.length; i++) {
    if (sub[i] > super[i]) 
      return false;
  }
  return true;
}

void findMatch(String jumbledWord) {

  byte[] fingerprint = makeFingerprint(jumbledWord);

  for (byte[] candidate : fingerprintList) {   
        if (isSubset(fingerprint, candidate)) {
            System.out.println("Your word is: " + ...);
            break;                
        }
    }
}

这里我省略了fingerprintList的创建 - 但它只涉及指纹每个单词。

有很多可能的优化，但这应该比你的版本快得多（并且在主循环中是＆＃34;无垃圾＆＃34;）。它可以处理任何长度的候选人（不仅仅是10-12个字符）。如果要检查多个单词，最大的优化是尝试使用＆＃34; fingerpint＆＃34;作为直接查找的关键。对于12个字符的情况，这是微不足道的（直接查找），但对于10和11或者你可能不得不使用技术类型进行更高维度的搜索 - locality sensitive hashing似乎很自然。

Java：找到混乱的词

2 个答案: