#include<iostream>
#include <cstring>
using namespace std;

bool check1(char x[],char y[]){//大小写敏感的 
    int len = strlen(x);
    int yLen = strlen(y);

    for(int j=0;j<=yLen-len;j++){   // 确保不会越界
        if(y[j]==x[0]){
         bool flag = true;
            for(int k=j+1;k<=j+len-1;k++){//j+1 到 j+4 
                if(y[k]!=x[k-j]){//有一个错就不行
                    flag=false;
                    break;//有错的 那么这层k的for就不必做了回到j的for向后看走?         
                }
            }//如果这个k的for走完了那么说明就有了
            if(flag) return true;//有了直接返回 后面就算了
        }
}
     return false; // 未找到匹配 一直没有进入y[j]==x[0]过
}
/*
bool check1(char x[],char y[]){//大小写敏感的 
    int len=0;
    for(int i=0;x[i]!='\0';i++){
        len++;
    }//len返回的是x串的长度 
    bool flag=false;
    for(int j=0;y[j]!='\0';j++){
        if(y[j]==x[0]){
            flag=true;
            for(int k=j+1;k<=j+len-1;k++){//j+1 到 j+4 
                if(y[k]!=x[k-j]){//有一个错就不行
                    flag=false;
                }
            }//如果这个走完flag=true 那么就是有了
        }
}
     return flag;
}
HiHiHelloHiHi
本来这个思路错在：
虽然确实：y[4] == 'H'，并且 k 应该从 5 到 8 比较 ello 和 ello
但是原始代码并没有在找到完全匹配后返回 true，而是继续执行后面的外层循环
那么最后就会因为Hello后面还有两个H 还能进入二级循环但是又匹配不成功 全部返回false
*/
/*
bool check2(char x[],char y[]){//大小写不敏感的 全部转化成大写之后处理 错误

    for(int i=0;x[i]!='\0';i++){
        if(x[i]>=97&&x[i]<=122){
            x[i]-=32;
        }
    }
    for(int i=0;y[i]!='\0';i++){
        if(y[i]>=97&&y[i]<=122){
            y[i]-=32;
        }
    }
    return check1(x,y);
} 
这么写会导致 最后要输出的时候全部都输出大写后的
所以建议在函数里操作的时候用另一个数组
（用另一个upper数组 但不用const char*) 可以
(用const char*但不用upper数组）不好操作-32了因为是常值 所以还是要upper数组
*/

//bool check2(char x[],char y[]){//大小写不敏感的 全部转化成大写之后处理 正确
//  char upperX[110], upperY[110];
//    // 转换 x 到大写
//    for (int i = 0; x[i] != '\0'; i++) {
//        upperX[i] = (x[i] >= 'a' && x[i] <= 'z') ? (x[i] - 32) : x[i];
//    }
//    upperX[strlen(x)] = '\0';
//
//    // 转换 y 到大写
//    for (int i = 0; y[i] != '\0'; i++) {
//        upperY[i] = (y[i] >= 'a' && y[i] <= 'z') ? (y[i] - 32) : y[i];
//    }
//    upperY[strlen(y)] = '\0';
//
//    return check1(upperX, upperY);
//} 

bool check2(const char* x, const char* y) { // 大小写不敏感的  正确
    char upperX[110], upperY[110];
    // 转换 x 到大写
    for (int i = 0; x[i] != '\0'; i++) {
        upperX[i] = (x[i] >= 'a' && x[i] <= 'z') ? (x[i] - 32) : x[i];
    }
    upperX[strlen(x)] = '\0';

    // 转换 y 到大写
    for (int i = 0; y[i] != '\0'; i++) {
        upperY[i] = (y[i] >= 'a' && y[i] <= 'z') ? (y[i] - 32) : y[i];
    }
    upperY[strlen(y)] = '\0';

    return check1(upperX, upperY);
} 
int main(){
    char str[110];
    scanf("%s",str);
    int op;
    cin>>op;
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        char a[110];
        scanf("%s",a);
        if(op==0){//大小写不敏感 如果有check2(char x[],char y[])，会被统一改为大写输出就不对了
           if(check2(str,a)){
            printf("%s\n",a);
           }
        }else if(op==1){//大小写敏感
            if(check1(str,a)){
                printf("%s\n",a);
            }
        }
    }
    return 0;
} 
/*
使用 const char* 作为参数有几个好处：

保护原始数据：

声明为 const 意味着在函数内部不会修改传入的字符串。这是一个好的编程习惯，可以防止意外更改原始数据，特别是当我们只需要读取这些字符串时。
语义清晰：

使用 const 提高了代码的可读性，明确表明这个函数不会改变输入的字符串。这使得调用者更容易理解该函数的行为。
可以接受字符串字面量：

字符串字面量（如 "Hello"）是常量，不能被修改。如果参数类型是 char*，会导致编译错误。而 const char* 允许你传入这些字符串字面量。
潜在的优化：

编译器可以在知道数据不会被修改的情况下进行某些优化，因此使用 const 可能会在某些情况下提高性能。
总结
在这种情况下，使用 const char* 是一种更安全、更清晰的做法。它确保了输入字符串在函数内不会被修改，并且可以接受更广泛的输入，包括字符串字面量。虽然在功能上使用 char* 也能正常工作，但使用 const 是一种更好的编程实践。
*/