passwordtry

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void async function () {
    // // Write your code here
    // while(line = await readline()){
    //     let tokens = line.split(' ');
    //     let a = parseInt(tokens[0]);
    //     let b = parseInt(tokens[1]);
    //     console.log(a + b);
    // }

    let n = parseInt(await readline())
    let correct = await readline()
    let test = []
    for(let i = 0; i < n; i++){
        test.push(await readline())
    }
    // console.log(test)
    let qpl = []
    let arr = []
    let idxarr = new Array(test.length).fill(0)
    // console.log(idxarr)
    const permute = (test) => {
    let result = [];  // 用于存放最终的所有排列
    let arr = [];     // 当前的排列结果
    let used = new Array(test.length).fill(false);  // 标记哪些元素已经使用过

    const backtracking = () => {
        // 当排列长度等于输入数组长度时，表示找到一个完整的排列
        if (arr.length === test.length) {
            result.push(arr.slice());  // 将当前排列的拷贝加入结果
            return;
        }

        // 遍历数组中的每一个元素
        for (let i = 0; i < test.length; i++) {
            // 如果当前元素已经使用过，跳过
            if (used[i]) continue;

            // 将当前元素加入排列，并标记为已使用
            arr.push(test[i]);
            used[i] = true;

            // 递归调用，继续生成下一个元素的排列
            backtracking();

            // 回溯：撤销当前的选择，恢复状态
            arr.pop();
            used[i] = false;
        }
    };

    backtracking();  // 开始回溯
    return result;   // 返回所有生成的排列
};

// 示例调用
let permutations = permute(test);
// console.log(permutations);
// 将permutations数组按字符串长度从小到大的顺序排序
//想要排序的对象：是 permutations 数组的排列，而不是排列内的元素。排序标准：是根据每个排列的长度（permutations[i].length），而不是排列内元素的大小。
for(let i = 0; i < permutations.length; i++){
    for( let j = permutations[i].length - 1; j > 0; j--){
        for( let k = 0; k < j; k++){
            if(permutations[i][k] .length> permutations[i][k+1].length){
                let temp = permutations[i][k];
                permutations[i][k] = permutations[i][k+1];
                permutations[i][k+1] = temp;
            }
        }
    }
}
// console.log(permutations)
let minTry = n
let maxTry = 1
for(let i = 0; i < permutations.length; i++){
    let currentTry = 0
    let wrongAnswer = []
    for( let j = 0; j < permutations[i].length ; j++){
        let flag1 = false
        for(let k = 0; k < wrongAnswer.length; k++){
            if(permutations[i][j] == wrongAnswer[k]){
                flag1 = true;
                break
            }
        }
        if(flag1){
            continue;
        }
        currentTry++;
        if(permutations[i][j] == correct){
            break;
        } else {
            wrongAnswer.push(permutations[i][j])
        }
    }
    if(currentTry < minTry){
        minTry = currentTry
    }
    if(currentTry > maxTry){
        maxTry = currentTry
    }
}
console.log(minTry,maxTry)
}()