Question

我正在尝试编写一个程序，允许用户通过键入常用单词的缩写来制作短博客条目。完成输入后，程序将根据定义的词典扩展缩写。

条件

替换字必须是可以通过在缩写中添加零个或多个字母（或标点符号）而形成的最短字。
如果通过添加相同数量的字母可以形成两个或更多个唯一字，则应按原样打印缩写。

输入

输入分为两部分。第一部分是词典本身，第二部分是用户的博客条目，需要扩展。这些部分由一个|分开字符。

例如： -

输出

我已经为此编写了程序并在本地测试了许多不同的测试用例并且成功但是在提交给测试服务器时失败了。

自动测试套件运行以验证程序在提交给测试服务器时的输出。如果失败，则无法看到失败的测试用例/案例的详细信息。

以下是程序

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;


public class BlogEntry {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[][] info = readInput();
        String[] output = inputExpander(info[0],info[1]);
        //System.out.println();
        for(int i = 0; i < output.length; ++i)  {
            if(i!=0)
                System.out.print(" ");

            System.out.print(output[i]);
        }
    }
    public static String[][] readInput() {
        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(
                System.in));
        String input = null;
        String[][] info = new String[2][];
        String[] text;
        String[] abbr;
        try {
            input = bufferReader.readLine();
            StringTokenizer st1 = new StringTokenizer(input, "|");
            String first = "", second = "";
            int count = 0;
            while (st1.hasMoreTokens()) {
                ++count;
                if(count == 1)
                    first  = st1.nextToken();
                if(count == 2)
                    second = st1.nextToken();
            }
            st1 = new StringTokenizer(first, " ");
            count = st1.countTokens();
            text = new String[count];
            count = 0;
            while (st1.hasMoreTokens()) {
                text[count] = st1.nextToken();
                count++;
            }

            st1 = new StringTokenizer(second, " ");
            count = st1.countTokens();
            abbr = new String[count];
            count = 0;
            while (st1.hasMoreTokens()) {
                abbr[count] = st1.nextToken();
                count++;
            }
            info[0] = text;
            info[1] = abbr;

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return info;
    }
    public static String[] inputExpander(String[] text, String[] abbr) {
        String[] output = new String[abbr.length];

        boolean result;
        for (int i = 0; i < abbr.length; ++i) {
            String abbrToken = abbr[i];
            char[] char_abbr_token = abbrToken.toCharArray();
            for (int j = 0; j < text.length; ++j) {
                String textToken = text[j];
                boolean flag2 = false;
                if ((char_abbr_token[char_abbr_token.length - 1] == '!')
                        || (char_abbr_token[char_abbr_token.length - 1] == '?')
                        || (char_abbr_token[char_abbr_token.length - 1] == ',')
                        || (char_abbr_token[char_abbr_token.length - 1] == ';')) {
                    flag2 = true;
                }
                char[] char_text_token = textToken.toCharArray();
                result = ifcontains(char_text_token, char_abbr_token);
                if (result) {
                    int currentCount = textToken.length();
                    int alreadyStoredCount = 0;

                    if (flag2)
                        textToken = textToken
                                + char_abbr_token[char_abbr_token.length - 1];

                    if (output[i] == null)
                        output[i] = textToken;
                    else {
                        alreadyStoredCount = output[i].length();
                        char[] char_stored_token = output[i].toCharArray();
                        if ((char_stored_token[char_stored_token.length - 1] == '!')
                                || (char_stored_token[char_stored_token.length - 1] == '?')
                                || (char_stored_token[char_stored_token.length - 1] == ',')
                                || (char_stored_token[char_stored_token.length - 1] == ';')) {
                            alreadyStoredCount -= 1;
                        }
                        if (alreadyStoredCount > currentCount) {
                            output[i] = textToken;
                        } else if (alreadyStoredCount == currentCount) {
                            output[i] = abbrToken;
                        }
                    }
                }
            }
            if(output[i] == null)
                output[i] = abbrToken;
        }
        return output;
    }
    public static boolean ifcontains(char[] char_text_token,
                                     char[] char_abbr_token) {
        int j = 0;
        boolean flag = false;
        for (int i = 0; i < char_abbr_token.length; ++i) {
            flag = false;
            for (; j < char_text_token.length; ++j) {
                if ((char_abbr_token[i] == '!') || (char_abbr_token[i] == '?')
                        || (char_abbr_token[i] == ',')
                        || (char_abbr_token[i] == ';')) {
                    flag = true;
                    break;
                }
                if (char_abbr_token[i] == char_text_token[j]) {
                    flag = true;
                    break;
                }
            }
            if (!flag)
                return flag;
        }
        //System.out.println("match found" + flag);
        return flag;
    }
}

有人可以直接/提示我/关于我可能在实施中遗漏的可能用例吗？提前谢谢。

Answer 1

我将如何解决这个问题：

解析输入，对词典和文本进行标记。
对于choc之类的每个（可能是缩写的）令牌，将其转换为.*c.*h.*o.*c.*等正则表达式。
搜索与此正则表达式匹配的最短词典单词。如果找到一个文本标记，则替换文本标记，否则不管它。

如果不仔细调试，很难说你的代码有什么问题。很难理解代码的一个或另一个部分是什么，它不是很明显。

Answer 2

在输入（词典）中输入重复的单词。当在词典中重复一个单词时，它不会被扩展，因为检查仅在存储单词的长度（第112行）上而不是其内容。

我认为您需要检查： -

如果同一个词出现不止一次，请展开。
如果出现2个或更多相同长度的独特单词，请将其缩短。

给定词典的缩写扩展器

2 个答案: