蓝桥杯部分题型（奇怪的比赛，电话号码，palindrome）

未完待续！

2. 奇怪的比赛

某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪：
每位选手需要回答10个问题（其编号为1到10），越后面越有难度。答对的，
当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按
错误处理）。
每位选手都有一个起步的分数为10分。
某获胜选手最终得分刚好是100分，如果不让你看比赛过程，你能推断出他
（她）哪个题目答对了，哪个题目答错了吗？
如果把答对的记为1，答错的记为0，则10个题目的回答情况可以用仅含有1和
0的串来表示。例如：0010110011 就是可能的情况。
你的任务是算出所有可能情况。每个答案占一行。

参考答案：
1011010000
0111010000
0010110011

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/**
 * @author guorui
 * @date 2020-06-25 16:23
 * @ 2. 奇怪的比赛
 * 某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪：
 * 每位选手需要回答10个问题（其编号为1到10），越后面越有难度。答对的，
 * 当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按
 * 错误处理）。
 * 每位选手都有一个起步的分数为10分。
 * 某获胜选手最终得分刚好是100分，如果不让你看比赛过程，你能推断出他
 * （她）哪个题目答对了，哪个题目答错了吗？
 * 如果把答对的记为1，答错的记为0，则10个题目的回答情况可以用仅含有1和
 * 0的串来表示。例如：0010110011 就是可能的情况。
 * 你的任务是算出所有可能情况。每个答案占一行。
 * 

 * 参考答案：
 * 1011010000
 * 0111010000
 * 0010110011
 */
public class WeirdGame {

    /**
     * 将输入的数字传入，转化为所有全排列种数，将其转化为二进制形式，在for循环中，先将所有种类数字代表二进制算出，而一开始将种数最大值
     * 的二进制的位数算出，用最大的位数减去每个种数对应的二进制位数，所得结果先导0的个数。将先导0放在每个种类数字对应的二进制前面
     *
     * @param number
     * @return
     */
    public static List calculator(int number) {
        List allKind = new ArrayList();
        int allKinds = calculate(number);
        String maxBinary = Integer.toBinaryString(allKinds);
        int maxDigit = maxBinary.length();
        for (int i = 1; i <= allKinds; i++) {
            String everyBinary = Integer.toBinaryString(i);
            int leadingZero = maxDigit - everyBinary.length();
            String zero = "";
            for (int j = 0; j < leadingZero - 1; j++) {
                zero += "0";
            }
            String finalarr = zero + everyBinary;
            allKind.add(finalarr);
        }
        return allKind;
    }

    /**
     * 将集合中的每一个位置上的内容按为拆开。单独保存在新的集合中
     *
     * @param
     */
    public static List split(String str) {
        List list = Arrays.asList(str.split(""));
        return list;
    }

    /**
     *
     */
    public static void cal(List list,int finalGrade) {


        for (String i : list) {

            List intList = new ArrayList();
            List str = WeirdGame.split(i);
            //将集合（每个位置上只有一个元素的）遍历，赋值整形集合
            for (String j : str) {
                intList.add(Integer.parseInt(j));
            }
//            System.out.println("整形集合为："+intList.toString());
            //遍历每个位置上元素，计算成绩
            int grade = 10;
            for (int i1 = 0; i1 < intList.size(); i1++) {

                int number = intList.get(i1);
                if (number == 1) {
                    grade *= 2;
                }
                if (number == 0) {
                    grade -= i1 + 1;
                }
//                if(i1 == intList.size()-1){
//                    System.out.println("得分是："+grade);
//                }
            }
            if (grade == finalGrade) {
                System.out.println(i + "的成绩是"+finalGrade);
            }
//            else{
//                System.out.println("均无");
//            }
        }

    }

    /**
     * 返回有多少种可能的排列种类，即2的多少次方
     *
     * @param capacity
     * @return
     */
    private static int calculate(int capacity) {
        if (capacity == 0) {
            return 1;
        }
        return 2 * calculate(capacity - 1);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        List list = new ArrayList();
        System.out.println("请输入需要答题的个数：");
        list = WeirdGame.calculator(sc.nextInt());
        System.out.println("请输入要统计的分数：");
        WeirdGame.cal(list,sc.nextInt());
//        System.out.println(list.toString());
//        System.out.println(list.size());
    }
}

输入10，表示2^10次共1024种可能的情况，将这些0和1的字符串放在集合中，再将集合中的每一位字符串拆开放在新集合中（此集合为Integer），逻辑判断得分即可

3. palindrome

Statement of the Problem We say that a number is a palindrome if it is the sane when read from left to right or from right to left. For example, the number 75457 is a palindrome. Of course, the property depends on the basis in which is number is represented. The number 17 is not a palindrome in base 10, but its representation in base 2 (10001) is a palindrome. The objective of this problem is to verify if a set of given numbers are palindromes in any basis from 2 to 16. Input Format Several integer numbers comprise the input. Each number 0 < n < 50000 is given in decimal basis in a separate line. The input ends with a zero. Output Format
11
Your program must print the message Number i is palindrome in basis where I is the given number, followed by the basis where the representation of the number is a palindrome. If the number is not a palindrome in any basis between 2 and 16, your program must print the message Number i is not palindrome.

先来一段自己的翻译

我们把从左往右和从右往左念起来相同的数字叫做回文数。例如，75457就是一个回文数。

当然某个数用某个进制表示不是回文数，但是用别的进制表示可能就是回文数。

例如，17是用十进制表示的数，显然它不是一个回文数，但是将17用二进制表示出来是10001，显然在二进制下它是一个回文数。

现在给你一个用十进制表示的数，请你判断它在2~16进制下是否是回文数。

输入：输入包含多组测试数据。每组输入一个用十进制表示的正整数n（0

输出：对于每组输入，如果n在2~16进制中的某些进制表示下是回文数，则输出“Number i is palindrom in basis ”，在后面接着输出那些进制。其中i用n的值代替，后面输出的进制中，每两个数字之间空一个。

如果n在2~16进制的表示下都不为回文数，则输出“Number i is not palindrom”，其中i用n的值代替。

样例输入

17

19

0

样例输出

Number 17 is palindrome in basis 2 4 16

Number 19 is not palindrome

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @author guorui
 * @date 2020-06-20 15:21
 * 我们把从左往右和从右往左念起来相同的数字叫做回文数。例如，75457就是一个回文数。
 * 当然某个数用某个进制表示不是回文数，但是用别的进制表示可能就是回文数。
 * 例如，17是用十进制表示的数，显然它不是一个回文数，但是将17用二进制表示出来是10001，显然在二进制下它是一个回文数。
 * 现在给你一个用十进制表示的数，请你判断它在2~16进制下是否是回文数。
 * 输入
 * 输入包含多组测试数据。每组输入一个用十进制表示的正整数n（0 arr = new ArrayList();
        while (true) {
            System.out.println("请输入数字：");
            int number = sc.nextInt();
            if (number == 0) {
                System.out.println("输入结束");
                break;
            } else if (number > 50000 || number < 0) {
                System.out.println("对不起，您输入的数字超出范围，请重试！");
                continue;
            }
            arr.add(number);

        }
        Palindrome t1 = new Palindrome();
        t1.iterator(arr);
    }

    /**
     * 遍历list中每一个输入元素
     *
     * @param arr
     */
    public void iterator(List arr) {

        for (Object number : arr) {
            int count = 0;
            for (int basis = 2; basis <= 16; basis++) {
                StringBuffer finalNumber = new StringBuffer(Integer.toString((int) number, basis));
                StringBuffer finalCount = new StringBuffer(finalNumber);
                finalNumber.reverse();
                if (finalNumber.toString().equals(finalCount.toString())) {
                    if (count == 0) {
                        System.out.print("Number " + number + " is palindrom in basis ");
                    }
                    System.out.print(basis + "\t");
                    count++;
                }
//                System.out.println(number+"的"+basis+"进制"+"的数字是："+finalCount+",其回文为："+finalNumber);
            }
            if (count == 0) {
                System.out.println("\nNumber " + number + " is not palindrome ");
            }
        }
    }
}

4. 电话号码(其他来源，请参考)

辉子最近接到了一个棘手的任务，他们公司有一个电话簿，但是这是一个奇
怪的电话簿，因为它不是用数字记录电话号码，而是用数字键上所对应的字母来
记录电话号码（2-abc,3-def,4-ghi,5-jkl,6-mno,7-pqrs,8-tuv,9-wxyz）,电话号
码只有11位。现在你的任务就是帮辉子写一个程序来把这些字母的电话号码转化
成数字的电话号码。
输入：
第一行输入一个正整数T(0 有一行，输入一串字符（字符长度为11）。
输出：
每组输出占一行，输出数字的电话号码。
例如：
样例输入
3
phqghumeayl
nlfdxfircvs
cxggbwkfnqd

样例输出
74744863295
65339347287
29442953673

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/**
 * @author Sun Weifeng
 * @date 2020-06-25 16:21
 */
public class PhoneNumber {

    public static void main(String[] args) {
        new init();
    }

}

/**
 * 启动按键内部类
 */
class init{
    public init(){
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        List stringList = new ArrayList<>();

        for (int i = 0; i < num; i++) {
            String string = scanner.next();
            if (string.length() == 11) {
                String finalString =  iterator(string);
                stringList.add(finalString);
            } else {
                System.out.println("你输入的不是11位，请重新运行程序");
            }
        }
        for (String s : stringList) {
            System.out.println(s);
        }
    }


    /**
     * 解析字符串方法
     * @param string
     * @return
     */
    public String iterator(String string) {
        List list = Arrays.asList(string.split(""));
        StringBuffer stringBuffer = new StringBuffer();
        for (String s : list) {
            if (s.equals("a") || s.equals("b") || s.equals("c")) {
                stringBuffer.append(2);
            } else if (s.equals("d") || s.equals("e") || s.equals("f")) {
                stringBuffer.append(3);
            } else if (s.equals("g") || s.equals("h") || s.equals("i")) {
                stringBuffer.append(4);
            } else if (s.equals("j") || s.equals("k") || s.equals("l")) {
                stringBuffer.append(5);
            } else if (s.equals("m") || s.equals("n") || s.equals("o")) {
                stringBuffer.append(6);
            } else if (s.equals("p") || s.equals("q") || s.equals("r") || s.equals("s")) {
                stringBuffer.append(7);
            } else if (s.equals("t") || s.equals("u") || s.equals("v")) {
                stringBuffer.append(8);
            } else if (s.equals("w") || s.equals("x") || s.equals("y") || s.equals("z")) {
                stringBuffer.append(9);
            }
        }
        return stringBuffer.toString();
    }

}