LeetCode1023【Null】：驼峰式匹配

package leetcode.editor.cn;

//如果我们可以将小写字母插入模式串 pattern 得到待查询项 query，那么待查询项与给定模式串匹配。（我们可以在任何位置插入每个字符，也可以插入 0 
//个字符。） 
//
// 给定待查询列表 queries，和模式串 pattern，返回由布尔值组成的答案列表 answer。只有在待查项 queries[i] 与模式串 patt
//ern 匹配时， answer[i] 才为 true，否则为 false。 
//
// 
//
// 示例 1： 
//
// 输入：queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"]
//, pattern = "FB"
//输出：[true,false,true,true,false]
//示例：
//"FooBar" 可以这样生成："F" + "oo" + "B" + "ar"。
//"FootBall" 可以这样生成："F" + "oot" + "B" + "all".
//"FrameBuffer" 可以这样生成："F" + "rame" + "B" + "uffer". 
//
// 示例 2： 
//
// 输入：queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"]
//, pattern = "FoBa"
//输出：[true,false,true,false,false]
//解释：
//"FooBar" 可以这样生成："Fo" + "o" + "Ba" + "r".
//"FootBall" 可以这样生成："Fo" + "ot" + "Ba" + "ll".
// 
//
// 示例 3： 
//
// 输出：queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"]
//, pattern = "FoBaT"
//输入：[false,true,false,false,false]
//解释： 
//"FooBarTest" 可以这样生成："Fo" + "o" + "Ba" + "r" + "T" + "est".
// 
//
// 
//
// 提示： 
//
// 
// 1 <= queries.length <= 100 
// 1 <= queries[i].length <= 100 
// 1 <= pattern.length <= 100 
// 所有字符串都仅由大写和小写英文字母组成。 
// 
// Related Topics 字典树 字符串

// 思路：对需要查询的字符串Q，逐个删除模板字符串里面的字符，Q中剩余的字符串中有大写的就返回false
import java.util.ArrayList;
import java.util.List;

//Java：驼峰式匹配
public class P1023驼峰式匹配{
    public static void main(String[] args) {
        Solution solution = new P1023驼峰式匹配().new Solution();
        String[] in = {"FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"};
        List<Boolean> ans = solution.camelMatch(in, "FB");
        for (int i = 0; i < in.length; i++) {
            System.out.println(ans.get(i));
        }
        // TO TEST
    }
    //leetcode submit region begin(Prohibit modification and deletion)
    class Solution {
        public List<Boolean> camelMatch(String[] queries, String pattern) {
            List<Boolean> ans = new ArrayList<>();
            for (int i = 0; i < queries.length; ++i) {
                ans.add(deal(queries[i], pattern));
            }
            return ans;
        }

        public boolean deal(String quer, String pat) {
            int queLen = quer.length();
            int patLen = pat.length();
            int queIdx = 0;
            int patIdx = 0;
            StringBuilder sbOut = new StringBuilder();
            while (queIdx < queLen && patIdx < patLen) {
                char query = quer.charAt(queIdx);
                char patTemp = pat.charAt(patIdx);
                if (query == patTemp) {
                    queIdx++;
                    patIdx++;
                } else {
                    sbOut.append(query);
                    queIdx++;
                }
            }
            if (patIdx != patLen) {
                return false;
            }
            for (int i = queIdx; i < queLen; i++) {
                sbOut.append(quer.charAt(i));
            }
            if (!sbOut.toString().toLowerCase().equals(sbOut.toString())) {
                return false;
            }
            return true;
        }
    }
    // worng
        class Solution1 {
    public List<Boolean> camelMatch(String[] queries, String pattern) {
        List<Boolean> ans = new ArrayList<>();
        String[] pat = trans(pattern);
        int patLen = pat.length;
        for (int i = 0; i < queries.length; i++) {
            String[] temp = trans(queries[i]);
            if (temp.length != patLen) {
                ans.add(false);
                continue;
            }
            boolean isOK = true;
            for (int j = 0; j < patLen; j++) {
                if (!temp[j].contains(pat[j])) {
                    isOK = false;
                    break;
                }
            }
            ans.add(isOK);
        }
        return ans;
    }

    public String[] trans(String strIn) {
        List<Integer> list  = new ArrayList<>();
        String strCompar = strIn.toLowerCase();
        for (int i = 0; i < strIn.length(); i++) {
            if (strIn.charAt(i) != strCompar.charAt(i)) {
                list.add(i);
            }
        }
        String[] outStr = new String[list.size()];
        for (int i = 1; i < list.size(); ++i) {
            outStr[i - 1] = strIn.substring(list.get(i - 1), list.get(i));
        }
        outStr[list.size() - 1] = strIn.substring(list.get(list.size() - 1));
        return outStr;
    }

}
//leetcode submit region end(Prohibit modification and deletion)

}