密码攻击算法和解决方案,出了什么问题?

主要问题似乎是程序无法解密(或对最后一行输入执行任何操作)。这是因为循环条件 c.hasNextLine() 被评估 您已经阅读了循环迭代中要处理的行。

另外,我注意到你解决了一个与挑战不同的问题,尽管这是一个密切相关的问题。你应该

线

(强调了一下),但实际上你要做的是解密 文字

此外,虽然我倾向于将问题描述理解为字典中的单词单独在它们的行上,没有任何前导或尾随的空格,但如果事实并非如此,那么阅读它们的方法将包括它们的空格。只要 trim() 每个输入。

我最大的风格批评是: if 或 else ,即使这些实体只有一个语句。这样做会使您的代码更难阅读,并为将来的维护人员(包括将来的您)设置陷阱。在过去几年里,这种疏漏至少导致了一个引人注目的安全问题。

answer 以上是关于我愚蠢错误的更多细节:(在代码中)。

我现在发布代码的最终版本 . 所作的改进包括:

• 修复从输入流读取时的错误。
• 将keyrarray从2D数组更改为1D数组。
• 通过添加花括号和注释更多的行来美化代码。

代码在这里:

import java.util.*;

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

        Scanner c = new Scanner(System.in);
        int dictionarySize = c.nextInt();

        // this line is to flush out the input stream
        c.nextLine();

        // get the dictionary from the input stream:
        String[] words = new String[dictionarySize];
        for (int i = 0; i < words.length; i++) {
            words[i] = c.nextLine();
            // remove white spaces surrounding dictionary words if there is any
            words[i] = words[i].trim();
        }

        // get encrypted input
        String line;
        while (c.hasNextLine()) {
            line = c.nextLine();
            if (line.length() == 0) {
                System.out.println();
                continue;
            }

            // remove whitespaces
            String[] eWords = line.split(" ");
            for (int i = 0; i < eWords.length; i++) {
                eWords[i] = eWords[i].trim();
            }

            // decrypt words:
            String[] dWords = decryptWords(eWords, words);

            // print the decrypted line
            for (int i = 0; i < dWords.length; i++) {
                if (i != dWords.length - 1) {
                    System.out.print(dWords[i] + " ");
                } else {
                    System.out.println(dWords[i]);
                }
            }
        }

    }

    private static String[] decryptWords(String[] eWords, String[] words) {

        String[] dWords = new String[eWords.length];

        // get copy of the dWords so that the original version not destroyed
        String[] eWordsCopy = Arrays.copyOf(eWords, eWords.length);

        // sort by length from the greatest to the smallest
        Arrays.sort(eWordsCopy, new Comparator<String>() {
            @Override
            public int compare(String w1, String w2) {
                return Integer.compare(w2.length(), w1.length());
            }
        });

        // initialize a key array to hold decrypted letters:
        // for example: 'a' would be mapped to keyArray[0] and 'z' would be mapped to keyArray[25]
        char[] keyArray = new char[26];
        for (int i = 0; i < 26; i++) {
            // initialize the keyArray to '*'
            keyArray[i] = '*';
        }


        // restore keyArray original values if there is no solution to all words
        if (!matchWords(words, eWordsCopy, keyArray)) {
            for (int i = 0; i < 26; i++) {
                keyArray[i] = '*';
            }
        }

        // decrypt line using the mapping stored in keyArray
        for (int i = 0; i < eWords.length; i++) {
            StringBuilder temp = new StringBuilder();
            for (int j = 0; j < eWords[i].length(); j++) {
                temp.append(keyArray[eWords[i].charAt(j) - 97]);
            }
            dWords[i] = temp.toString();
        }
        return dWords;
    }

    private static boolean matchWords(String[] words, String[] eWords, char[] keyArray) {
        ArrayList<String> promisingWords = new ArrayList<>();
        String eWord = eWords[0];

        // store the current state of keyArray
        char[] originalKeyArray = new char[26];
        System.arraycopy(keyArray, 0, originalKeyArray, 0, originalKeyArray.length);

        // get promising words that may match
        for (String word : words) {
            if (word.length() == eWord.length()
                    && wordPattern(word).equals(wordPattern(eWord))) {
                promisingWords.add(word);
            }
        }

        for (String word : promisingWords) {
            if (mapWord(eWord, word, keyArray)) {
                if (eWords.length > 1) {
                    // recursive call:
                    if (matchWords(words, Arrays.copyOfRange(eWords, 1, eWords.length), keyArray))
                        return true;
                    else {
                        // remove the word from the dictionary [by restoring the keyArray original values]
                        // and try another one
                        System.arraycopy(originalKeyArray, 0, keyArray, 0, keyArray.length);
                    }
                } else // if there is no more decrypted words, then return true
                    return true;
            }
        }
        // if there is no suitable mapping, return false
        return false;
    }

    private static boolean mapWord(String eWord, String word, char[] keyArray) {
        // store the current state of keyArray
        char[] originalKeyArray = new char[26];
        System.arraycopy(keyArray, 0, originalKeyArray, 0, keyArray.length);

        // check one-to-one from the decrypted word to the dictionary word:
        for (int i = 0; i < eWord.length(); i++) {
            if ((keyArray[eWord.charAt(i) - 97] != word.charAt(i)
                    && keyArray[eWord.charAt(i) - 97] != '*')
                    || !isLetterMapped(eWord.charAt(i), word.charAt(i), keyArray)) {
                // restore original array back
                System.arraycopy(originalKeyArray, 0, keyArray, 0, keyArray.length);
                return false;
            }

            // update the key array:
            else {
                keyArray[eWord.charAt(i) - 97] = word.charAt(i);
            }
        }

        return true;
    }

    private static boolean isLetterMapped(char eLetter, char letter, char[] keyArray) {
        for (int i = 0; i < 26; i++) {
            if (keyArray[i] == letter && i != (eLetter - 97)) {
                return false;
            }
        }
        return true;
    }

    // generate a word pattern
    private static String wordPattern(String word) {
        if (word.length() > 0) {
            StringBuilder mapped = new StringBuilder();
            int count = 0;
            HashMap<Character, Character> mapping = new HashMap<>();
            for (int i = 0; i < word.length(); i++) {
                if (!mapping.containsKey(word.charAt(i))) {
                    mapping.put(word.charAt(i), (char) (48 + count++));
                }
            }
            for (int i = 0; i < word.length(); i++) {
                mapped.append(mapping.get(word.charAt(i)));
            }
            return mapped.toString();

        } else {
            return "";
        }
    }
}

如果你在这本书《编程挑战书》中遇到类似的问题,使用Java作为你的武器,你将非常欢迎路过并浏览 my repository 在那里我打算提出更多的解决方案和技巧。