字符串通配符

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String reg = in.nextLine().toLowerCase();
        String str = in.nextLine().toLowerCase();
        reg = reg.replaceAll("\\*+","[a-z0-9]*").replaceAll("\\?","[a-z0-9]");
        System.out.println(str.matches(reg));
    }
}

// 用正则替换
public static boolean resolve(String s, String content) {
    s = s.toLowerCase();
    content = content.toLowerCase();
    // 多个*相当于一个*
    s = s.replaceAll("\\*+", "*");
    // *?*或*?或?*相当于匹配至少一个字符
    s = s.replaceAll("\\*\\?\\*|\\*\\?|\\?\\*", "[0-9a-z]+");
    s = s.replaceAll("\\*", "[0-9a-z]*");
    s = s.replaceAll("\\?", "[0-9a-z]{1}");
    s = "^" + s + "$";
    return content.matches(s);
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            String tpstr = sc.nextLine().toLowerCase();//通配符
            String needstr = sc.nextLine().toLowerCase();//需要被匹配的
            System.out.println(isMatch(tpstr,needstr));
        }
    }

    public static boolean isMatch(String s, String p) {
        //只向右向下向右下
        boolean[][] dp=new boolean[s.length()+1][p.length()+1];
        dp[0][0]=true;
        //第一行为'*'则一行都为true；
        for(int i=1;i<=p.length();i++){
                if(s.charAt(0)=='*'){
                    dp[1][i]=true;
                } 
            }
        for(int i=1;i<=s.length();i++){
            for(int j=1;j<=p.length();j++){
                if(s.charAt(i-1)==p.charAt(j-1)){
                    dp[i][j]=dp[i-1][j-1]||dp[i-1][j];
                }
                if(s.charAt(i-1)=='?'&&((p.charAt(j-1)>='a'&&p.charAt(j-1)<='z')||(p.charAt(j-1)>='0'&&p.charAt(j-1)<='9'))){
                    dp[i][j]=dp[i-1][j-1];
                }
                if(s.charAt(i-1)=='*'&&((p.charAt(j-1)>='a'&&p.charAt(j-1)<='z')||(p.charAt(j-1)>='0'&&p.charAt(j-1)<='9'))){
                    dp[i][j]=dp[i-1][j]||dp[i][j-1]||dp[i-1][j-1];
                }
            }
        }
        return dp[s.length()][p.length()];
    }

}

import java.util.*;
//用正则表达式打败模糊匹配！
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String matchRule = in.next().toLowerCase(Locale.ROOT);//将字符串中的大写字母转小写
        String scStr = in.next().toLowerCase(Locale.ROOT);
        matchRule = matchRule.replaceAll("\\*+", "[a-z0-9]*");//替换1个或多个*
        matchRule = matchRule.replaceAll("\\?", "[a-z0-9]");//替换问号
        System.out.print(scStr.matches(matchRule));
    }
}

// 和普通的区别是， * 和 ？ 只能表数字和字母（所以要加上额外判断）
// 注意： * 表 0 个时不需要是数字或者字母
import java.lang.String;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String pattern;
        while ((pattern = br.readLine()) != null) {
            pattern = toLowerStr(pattern.trim());
            String str = toLowerStr(br.readLine().trim());
            System.out.println(isMatch(str, pattern));
        }
    }

    public static String toLowerStr(String str) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < str.length(); i++) {
            if (Character.isUpperCase(str.charAt(i))) {
                sb.append(Character.toLowerCase(str.charAt(i)));
            } else {
                sb.append(str.charAt(i));
            }
        }
        return sb.toString();
    }

    public static boolean isMatch(String s, String p) {
        int m = s.length();
        int n = p.length();
        boolean[][] dp = new boolean[m + 1][n + 1];
        dp[0][0] = true;
        for (int i = 1; i <= n; ++i) {
            if (p.charAt(i - 1) == '*') {
                dp[0][i] = true;
            } else {
                break;
            }
        }
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (s.charAt(i - 1) == p.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    boolean isLetterOrDigit = Character.isLetter(s.charAt(i - 1)) ||
                                              Character.isDigit(s.charAt(i - 1));
                    if (p.charAt(j - 1) == '*') {
                        // 表 0 个时不需要是数字或者字母
                        dp[i][j] = (dp[i - 1][j] && isLetterOrDigit) || dp[i][j - 1];
                    } else if (p.charAt(j - 1) == '?' && isLetterOrDigit) {
                        dp[i][j] = dp[i - 1][j - 1];
                    }
                }
            }
        }
        return dp[m][n];
    }


}

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String regex = in.next().toLowerCase();
            String target = in.next().toLowerCase();
            
            boolean dp[][]=new boolean[target.length() + 1][regex.length() + 1];
            dp[0][0]=true;
            for(int i = 1; i <= target.length(); i++){
                if (regex.charAt(i - 1) == '*') {
                dp[0][i] = true;
                } else {
                    break;
                }
            }

            for(int i = 1; i <= target.length(); i++){
                for(int j = 1 ; j <= regex.length(); j++){
                    if (target.charAt(i - 1) == regex.charAt(j - 1)) {
                        dp[i][j]=dp[i-1][j-1];
                    } else if (Character.isDigit(target.charAt(i - 1)) || Character.isLetter(target.charAt(i - 1))) {
                        if (regex.charAt(j - 1) == '*') {
                            dp[i][j] = dp[i - 1][j - 1] || dp[i - 1][j] || dp[i][j - 1];
                        } else if (regex.charAt(j - 1) == '?') {
                            dp[i][j] = dp[i - 1][j - 1];
                        }
                    }
                }
            }
            System.out.println(dp[target.length()][regex.length()]);
        }
    }
}

import java.util.Scanner;


public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String regex=sc.nextLine();
        String str=sc.nextLine();
        System.out.println(match(regex,str));
    }
    public static boolean match(String regex,String str){
        int m=str.length();
        int n =regex.length();
        char[] strs=str.toCharArray();
        char[] regexs=regex.toCharArray();
        boolean[][] dp=new boolean[n+1][m+1];
        dp[0][0]=true;
        for (int i=0;i<m;i++){
            if(Character.isLetter(strs[i])) strs[i]=Character.toLowerCase(strs[i]);
        }
        for(int i=1;i<=n;i++){
            if(regexs[i-1]=='*')dp[i][0]=dp[i-1][0];
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(!isWord(strs[j-1])){
//                    如果是特殊字符，必须这个值相等才能匹配上，否则直接为false
                    if(regexs[i-1]==strs[j-1])dp[i][j]=dp[i-1][j-1];
                    continue;
                };
                char c=strs[j-1];
//                如果不是特殊字符，是*的情况则只要dp[i-1][j]||dp[i-1][j-1]||dp[i][j-1]=true都能匹配上
                if(regexs[i-1]=='*')dp[i][j]=dp[i-1][j]||dp[i-1][j-1]||dp[i][j-1];
//                如果不是特殊字符，是？或相等的情况只要dp[i-1][j-1]=true就能匹配上
                else if(regexs[i-1]=='?'||Character.toLowerCase(regexs[i-1])==c)dp[i][j]=dp[i-1][j-1];

            }
        }

import java.io.IOException;
import java.util.Scanner;

public class Main {
//https://www.nowcoder.com/practice/43072d50a6eb44d2a6c816a283b02036?tpId=37&tqId=21294&rp=1&ru=/exam/oj/ta&qru=/exam/oj/ta&sourceUrl=%2Fexam%2Foj%2Fta%3Fdifficulty%3D3%26page%3D1%26pageSize%3D50%26search%3D%26tpId%3D37%26type%3D37&difficulty=3&judgeStatus=undefined&tags=&title=
    public static void main(String[] args) throws IOException {
        Scanner scan = new Scanner(System.in);
        String regex = scan.nextLine();
        String s = scan.nextLine();
        regex = regex.toLowerCase();
        s = s.toLowerCase();
        int i1 = 0, i2= 0;
        int m = s.length();
        int n = regex.length();
        boolean[][] dp = new boolean[m+1][n+1];
        dp[0][0] = true;
        for (int i = 1; i <= n; i++) {
            if(regex.charAt(i-1)=='*'){
                dp[0][i] = true;
            }else{
                break;
            }
        }
        for (int i = 1; i <=m ; i++) {
            for (int j = 1; j <=n ; j++) {
                //字符合法
                if(legal(s.charAt(i-1))){
                    //当表达式为‘*’时，可以匹配多个字符
                    if(regex.charAt(j-1)=='*'){
                        //由上一个字符是否匹配这个位置（匹配字符数>1）以及前一个匹配符是否和当前字符匹配(匹配字符数=0)共同决定
                        dp[i][j] = dp[i][j-1]||dp[i-1][j];
                    }else if(regex.charAt(j-1)=='?'||s.charAt(i-1)==regex.charAt(j-1)){
                        //如果是相等或者是==？的情况，则交给字符以及匹配符各自的前一位决定
                        dp[i][j] = dp[i-1][j-1];
                    }
                }else{
                    //字符不合法
                    //相等则当前匹配，情况交给字符以及匹配符各自的前一位决定
                    if(s.charAt(i-1)==regex.charAt(j-1)){
                        dp[i][j] = dp[i-1][j-1];
                        //不相等则看前面的匹配符有没有匹配到过的dp[i][j-1]
                    }else{
                        dp[i][j] = dp[i][j-1];
                    }
                }
            }
        }
        System.out.println(dp[m][n]);

    }
    //判断字符是否为合法字符
    public static boolean legal(char c){
        return c>='0'&&c<='9'||c>='a'&&c<='z';
    }
}