【蓝桥杯javaB2014真题】

波克比~

已于 2022-04-18 11:59:05 修改

阅读量570

点赞数 1

分类专栏：蓝桥杯javaB 文章标签：蓝桥杯 java

于 2022-04-16 21:25:43 首次发布

本文链接：https://blog.csdn.net/weixin_55054681/article/details/124220467

版权

蓝桥杯javaB 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

本文介绍了七道有趣的算法和数学题目，包括武功秘籍问题、面条切割、猜字母序列、大衍数列、圆周率计算、奇怪的分式和扑克序列排列。这些问题涉及到了基本的数学推理、递归计算、字符串操作和排列组合，展示了数学和算法在解决趣味问题中的应用。

摘要由CSDN通过智能技术生成

第一题：武功秘籍
题目描述
小明到X山洞探险，捡到一本有破损的武功秘籍（2000多页！当然是伪造的）。他注意到：书的第10页和第11页在同一张纸上，
但第11页和第12页不在同一张纸上。小明只想练习该书的第81页到第92页的武功，又不想带着整本书。请问他至少要撕下多少张纸带走？
这是个整数，请通过浏览器提交该数字，不要填写任何多余的内容。

答案：7

解释：口算即可

第二题：切面条
题目描述
一根高筋拉面，中间切一刀，可以得到2根面条。
如果先对折1次，中间切一刀，可以得到3根面条。
如果连续对折2次，中间切一刀，可以得到5根面条。
那么，连续对折10次，中间切一刀，会得到多少面条呢？
答案是个整数，请通过浏览器提交答案。不要填写任何多余的内容

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int res = (int)(Math.pow(2,n)+1);
        System.out.println(res);
    }
}

答案：1025

第三题.猜字母
把abcd…s共19个字母组成的序列重复拼接106次，得到长度为2014的串。接下来删除第1个字母（即开头的字母a），
以及第3个，第5个等所有奇数位置的字母。得到的新串再进行删除奇数位置字母的动作。如此下去，最后只剩下一个字母
，请写出该字母。

public class Main {
    static int thesum = 0;

    public static void main(String args[]) {
        StringBuffer temp = new StringBuffer("abcdefghijklmnopqrs");
        StringBuffer data = new StringBuffer("abcdefghijklmnopqrs");
        System.out.println(data);
        System.out.println("==========");
        for (int i = 0; i < 106; i++)
            data = data.append(temp.toString());
        char a[] = new char[2014];
        for (int i = 0; i < 2014; i++)
            a[i] = data.charAt(i);
        System.out.println(data);


        int lenth = a.length;
        while (lenth != 1) {//这是经典啊
            int k = 0;
            for (int i = 1; i < lenth; i += 2) {
                a[k++] = a[i];//这也是
            }
            lenth = k;//这是最关键的（间接的起了缩短了数组但是实际上并没有）
        }


        System.out.println(a[0]);

    }
}

答案：q；

第四题.大衍数列

中国古代文献中，曾记载过“大衍数列”, 主要用于解释中国传统文化中的太极衍生原理。
它的前几项是：0、2、4、8、12、18、24、32、40、50 …

其规律是：对偶数项，是序号平方再除2，奇数项，是序号平方减1再除2。
以下的代码打印出了大衍数列的前 100 项。

for(int i=1; i<100; i++)
{
    if(____i%2==0____________)  //填空
        System.out.println(i*i/2);
    else
        System.out.println((i*i-1)/2);

答案：

i*2%2==0

第五题：圆周率
题目描述
数学发展历史上，圆周率的计算曾有许多有趣甚至是传奇的故事。其中许多方法都涉及无穷级数。
图1.png中所示，就是一种用连分数的形式表示的圆周率求法。
下面的程序实现了该求解方法。实际上数列的收敛对x的初始值并不敏感。
结果打印出圆周率近似值（保留小数点后4位，并不一定与圆周率真值吻合）。

    double x = 111;
    for(int n = 10000; n>=0; n--){
        int i = 2 * n + 1;
        x = 2 + (i*i / x);
    }

System.out.println(Str

ing.format("%.4f", ______________));

答案：

4/(x-1)

第六题：奇怪的分式
题目描述
上小学的时候，小明经常自己发明新算法。一次，老师出的题目是：
1/4 乘以 8/5
小明居然把分子拼接在一起，分母拼接在一起，答案是：18/45 （参见图1.png）
老师刚想批评他，转念一想，这个答案凑巧也对啊，真是见鬼！
对于分子、分母都是 1~9 中的一位数的情况，还有哪些算式可以这样计算呢？
请写出所有不同算式的个数（包括题中举例的）。
显然，交换分子分母后，例如：4/1 乘以 5/8 是满足要求的，这算做不同的算式。
但对于分子分母相同的情况，2/2 乘以 3/3 这样的类型太多了，不在计数之列!

14
注意：答案是个整数（考虑对称性，肯定是偶数）。请通过浏览器提交。不要书写多余的内容。

public class Main {
        public static void main(String[] args) {
        int k=0;
        for (int i = 1; i <10 ; i++) {
            for (int j = 1; j < 10; j++) {

                if (i != j) {
                    for (int r = 1; r < 10; r++) {
                        for (int l = 1; l < 10; l++) {
                            if (r != l) {
                                //

                                    double a = (double) (i * r) / (j * l);
                                    double b = (double) (i * 10 + r) / (j * 10 + l);
                                    if (a==b)
                                    k++;
                                }
                            }
                        }
                    }
                }
            }

            System.out.println(k);
        }
    }

答案：14

第七题：扑克序列
题目描述
A A 2 2 3 3 4 4，一共4对扑克牌。请你把它们排成一行。
要求：两个A中间有1张牌，两个2之间有2张牌，两个3之间有3张牌，两个4之间有4张牌。
请填写出所有符合要求的排列中，字典序最小的那个。
例如：22AA3344 比 A2A23344 字典序小。当然，它们都不是满足要求的答案。
请通过浏览器提交答案。“A”一定不要用小写字母a，也不要用“1”代替。字符间一定不要留空格。

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.Vector;

public class Main {
    public static void main(String[] args) {
        char[] a = {'A', 'A', '2', '2', '3', '3', '4', '4'};
        f(a, 0);
        for (String s : set) {
            System.out.println(set);

        }
    }

    static Set<String> set = new HashSet<String>();

    private static void f(char[] a, int k) {
        if (k == a.length) {
            String s = new String(a);
            if (check(s)) {
//              System.out.println(s);
                set.add(s);
            }
        }
        for (int i = k; i < a.length; i++) {
            char t = a[k];
            a[k] = a[i];
            a[i] = t;
            f(a, k + 1);
            t = a[k];
            a[k] = a[i];
            a[i] =t;

        }
    }

    private static boolean check(String s) {
        if (s.lastIndexOf('A') - s.indexOf('A') == 2
                && s.lastIndexOf('2') - s.indexOf('2') == 3
                && s.lastIndexOf('3') - s.indexOf('3') == 4
                && s.lastIndexOf('4') - s.indexOf('4') == 5) {
            return true;
        }
        return false;
    }
}

//        public static void main(String[] args) {
//            char [] a = {'A', 'A', '2', '2', '3', '3', '4', '4'};
//            f(a,0);
//            for (String s : set) {//遍历set集合，结果不多的话可以人工判断
//                System.out.println(set);
//            }
//        }
//
//        //Set集合用于去重
//        static Set<String> set = new HashSet<String>();
//
//        //求字符串的全排列
//        private static void f(char[] a, int k) {
//            if(k == a.length) {
//                String s = new String(a);
//                if (check(s)) {
//                    //System.out.println(s);
//                    set.add(s);
//                }
//            }
//            for (int i = k; i < a.length; i++) {
//                char t = a[k];
//                a[k] = a[i];
//                a[i] = t;
//
//                f(a, k+1);
//
//                t = a[k];
//                a[k] = a[i];
//                a[i] = t;
//            }
//        }
//
//        //判断是否符合条件
//        private static boolean check(String s) {
//            if (s.lastIndexOf('A') - s.indexOf('A') == 2 &&
//                    s.lastIndexOf('2') - s.indexOf('2') == 3 &&
//                    s.lastIndexOf('3') - s.indexOf('3') == 4 &&
//                    s.lastIndexOf('4') - s.indexOf('4') == 5) {
//                return true;
//            }
//            return false;
//        }
//
//    }
//
//


//    public static int a[] = {1, 2, 3, 4};
//    public static int b[] = new int[8];
//
//    public static void main(String args[]) {
//        for (int i = 0; i < 8; i++) {
//            b[i] = 0;
//        }
//        fun(0);
//    }
//
//    public static void fun(int n) {
//        for (int i = 0; i < 8; i++) {
//            if (b[i] == 0 && (i + a[n] + 1) < 8 && b[i + a[n] + 1] == 0) {
//                b[i] = b[i + a[n] + 1] = a[n];
//                if (n == 3) {
//                    for (int j = 0; j < 8; j++) {
//                        System.out.print(b[j] + " ");
//                    }
//                    System.out.println();
//                } else fun(n + 1);
//                b[i] = b[i + a[n] + 1] = 0;
//            }
//        }
//    }