【竞赛】第四届蓝桥杯JAVAC组省赛题解

最新推荐文章于 2024-09-28 21:38:36 发布

全码之劳

最新推荐文章于 2024-09-28 21:38:36 发布

阅读量569

点赞数

分类专栏：竞赛

本文链接：https://blog.csdn.net/weixin_42354651/article/details/112691188

版权

竞赛专栏收录该内容

7 篇文章 1 订阅

订阅专栏

文章目录

前言
标题：猜年龄
标题: 组素数
标题: 马虎的算式
标题: 第39级台阶
标题：有理数类
标题：逆波兰表达式
标题：核桃的数量
标题：打印十字图
标题：买不到的数目
标题：剪格子

前言

如果有什么好的建议或者想探讨的问题记得私信我，我会努力改进自己的博客，你们的三连（点赞，收藏，评论）是我最大的动力，你们敢打赏我就敢肝

标题：猜年龄

美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。他曾在1935~1936年应邀来中国清华大学讲学。

一次，他参加某个重要会议，年轻的脸孔引人注目。于是有人询问他的年龄，他回答说：

“我年龄的立方是个4位数。我年龄的4次方是个6位数。这10个数字正好包含了从0到9这10个数字，每个都恰好出现1次。”

请你推算一下，他当时到底有多年轻。

通过浏览器，直接提交他那时的年龄数字。
注意：不要提交解答过程，或其它的说明文字。

import java.util.Arrays;
public class Main {

    public static void main(String[] args) {
    // write your code here
        for(int i=10;i<=99;i++){
            int a=i*i*i;
            int b=i*i*i*i;
            if(i*i*i>=1000&&i*i*i<=9999&&i*i*i*i>=100000&&i*i*i*i<=999999){
                String res=""+a+b;
                char[] temp=res.toCharArray();
                Arrays.sort(temp);
                boolean test=true;
                for(int j=0;j<9;j++){
                    if(temp[j]!=(char)(48+j)){
                        test=false;
                        continue;
                    }
                }
                if(test){
                    System.out.println(i);
                }
            }
        }
    }
}

标题: 组素数

素数就是不能再进行等分的数。比如：2 3 5 7 11 等。
9 = 3 * 3 说明它可以3等分，因而不是素数。

我们国家在1949年建国。如果只给你 1 9 4 9 这4个数字卡片，可以随意摆放它们的先后顺序（但卡片不能倒着摆放啊，我们不是在脑筋急转弯！），那么，你能组成多少个4位的素数呢？

比如：1949，4919 都符合要求。

请你提交：能组成的4位素数的个数，不要罗列这些素数!!

注意：不要提交解答过程，或其它的辅助说明文字。

考点：全排列+素数判断

import java.util.*;
public class Main {
    public static Set<String> set=new HashSet<>();
    public static void recursionArrange(char[] res,int start, int end){
        if(end<=1)
            return;
        if(start!=end){
            for(int i=start;i<=end;i++){
                swap(res,i,start);
                recursionArrange( res, start+1, end);
                swap(res,i,start);
            }
        }else{
            String temp="";
            for(int i=0;i<res.length;i++) {
                temp+=res[i];
            }
            if(test(Integer.parseInt(temp))){
                set.add(temp);
            }
        }
    }
    public static boolean test(int res){
        if(res==2){
            return true;
        }
        for(int i=2;i<res;i++){
            if(res%i==0){
                return false;
            }
        }
        return true;
    }
    public static void swap(char[] res,int m, int n){
        char temp=res[m];
        res[m]=res[n];
        res[n]=temp;
    }
    public static void main(String[] args) {
    // write your code here
       String A="1949";
       char[] res=A.toCharArray();
       recursionArrange(res,0,res.length-1);
       System.out.println(set.size());
    }
}

标题: 马虎的算式

小明是个急性子，上小学的时候经常把老师写在黑板上的题目抄错了。

有一次，老师出的题目是：36 x 495 = ?

他却给抄成了：396 x 45 = ?

但结果却很戏剧性，他的答案竟然是对的！！

因为 36 * 495 = 396 * 45 = 17820

类似这样的巧合情况可能还有很多，比如：27 * 594 = 297 * 54

假设 a b c d e 代表1~9不同的5个数字（注意是各不相同的数字，且不含0）

能满足形如： ab * cde = adb * ce 这样的算式一共有多少种呢？

请你利用计算机的优势寻找所有的可能，并回答不同算式的种类数。

满足乘法交换律的算式计为不同的种类，所以答案肯定是个偶数。

答案直接通过浏览器提交。
注意：只提交一个表示最终统计种类数的数字，不要提交解答过程或其它多余的内容。

考点：暴力枚举

public class Main {
    public static void main(String[] args) {
    // write your code here
        int num=0;
      for(int a=1;a<=9;a++){
          for(int b=1;b<=9;b++){
              for(int c=1;c<=9;c++){
                  for(int d=1;d<=9;d++){
                      for(int e=1;e<=9;e++){
                            if(a!=b&&a!=c&&a!=d&&a!=e&&
                               b!=c&&b!=d&&b!=e&&
                               c!=d&&c!=e&&
                               d!=e){
                                int i=a*10+b;
                                int j=c*100+d*10+e;
                                int k=a*100+d*10+b;
                                int l=c*10+e;
                                if(i*j==k*l){
                                    num++;
                                }
                            }
                      }
                  }
              }
          }
      }
        System.out.println(num);
    }
}

标题: 第39级台阶

小明刚刚看完电影《第39级台阶》，离开电影院的时候，他数了数礼堂前的台阶数，恰好是39级!

站在台阶前，他突然又想着一个问题：

如果我每一步只能迈上1个或2个台阶。先迈左脚，然后左右交替，最后一步是迈右脚，也就是说一共要走偶数步。那么，上完39级台阶，有多少种不同的上法呢？

请你利用计算机的优势，帮助小明寻找答案。

要求提交的是一个整数。
注意：不要提交解答过程，或其它的辅助说明文字。

考点：斐波那契数列+变量追踪

public class Main {
static int answer=0;
public static void main(String[] args) {
// write your code here
stair(39,0);
System.out.println(answer);
}
public static void stair(int n,int step){
if(n<0){
return ;
}
if(n0&&step%20){
answer++;
}
stair(n-1,step+1);
stair(n-2,step+1);
}
}

标题：有理数类

有理数就是可以表示为两个整数的比值的数字。一般情况下，我们用近似的小数表示。但有些时候，不允许出现误差，必须用两个整数来表示一个有理数。

这时，我们可以建立一个“有理数类”，下面的代码初步实现了这个目标。为了简明，它只提供了加法和乘法运算。

class Rational
{
private long ra;
private long rb;

private long gcd(long a, long b){
if(b0) return a;
return gcd(b,a%b);
}
public Rational(long a, long b){
ra = a;
rb = b;
long k = gcd(ra,rb);
if(k>1){ //需要约分
ra /= k;
rb /= k;
}
}
// 加法
public Rational add(Rational x){
return ________________________________________; //填空位置
}
// 乘法
public Rational mul(Rational x){
return new Rational(rax.ra, rbx.rb);
}
public String toString(){
if(rb1) return “” + ra;
return ra + “/” + rb;
}
}

使用该类的示例：
Rational a = new Rational(1,3);
Rational b = new Rational(1,6);
Rational c = a.add(b);
System.out.println(a + “+” + b + “=” + c);

请分析代码逻辑，并推测划线处的代码，通过网页提交
注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！

考点：逻辑考点

new Rational(this.ra*x.rb+x.ra*this.rb,this.rb*x.rb);

标题：逆波兰表达式

正常的表达式称为中缀表达式，运算符在中间，主要是给人阅读的，机器求解并不方便。

例如：3 + 5 * (2 + 6) - 1

而且，常常需要用括号来改变运算次序。

相反，如果使用逆波兰表达式（前缀表达式）表示，上面的算式则表示为：

- 3 * 5 + 2 6 1

不再需要括号，机器可以用递归的方法很方便地求解。

为了简便，我们假设：

只有 + - * 三种运算符
每个运算数都是一个小于10的非负整数

下面的程序对一个逆波兰表示串进行求值。
其返回值为一个数组：其中第一元素表示求值结果，第二个元素表示它已解析的字符数。

static int[] evaluate(String x)
{
if(x.length()==0) return new int[] {0,0};

char c = x.charAt(0);
if(c>=‘0’ && c<=‘9’) return new int[] {c-‘0’,1};

int[] v1 = evaluate(x.substring(1));
int[] v2 = __________________________________________; //填空位置

int v = Integer.MAX_VALUE;
if(c==’+’) v = v1[0] + v2[0];
if(c==’*’) v = v1[0] * v2[0];
if(c==’-’) v = v1[0] - v2[0];

return new int[] {v,1+v1[1]+v2[1]};
}
请分析代码逻辑，并推测划线处的代码，通过网页提交。
注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！

答案：待完善

标题：核桃的数量

小张是软件项目经理，他带领3个开发组。工期紧，今天都在加班呢。为鼓舞士气，小张打算给每个组发一袋核桃（据传言能补脑）。他的要求是：

各组的核桃数量必须相同
各组内必须能平分核桃（当然是不能打碎的）
尽量提供满足1,2条件的最小数量（节约闹革命嘛）

程序从标准输入读入：
a b c
a,b,c都是正整数，表示每个组正在加班的人数，用空格分开（a,b,c<30）

程序输出：
一个正整数，表示每袋核桃的数量。

例如：
用户输入：
2 4 5

程序输出：
20

再例如：
用户输入：
3 1 1

程序输出：
3

资源约定：
峰值内存消耗（含虚拟机） < 64M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

考点：最小公倍数

import java.util.*;
public class Main {
    public static void main(String[] args) {
        // write your code here
        Scanner scan=new Scanner(System.in);
        int a=scan.nextInt();
        int b=scan.nextInt();
        int c=scan.nextInt();
        int res1=lcm(a,b);
        System.out.println(lcm(c,res1));

    }
    public static int gcd(int a,int b){
        while(b>0){
            int temp=a%b;
            a=b;
            b=temp;
        }
        return a;
    }
    public static int lcm(int a,int b){
        int gcd=gcd(a,b);
        return a*b/gcd;
    }
}

标题：打印十字图

小明为某机构设计了一个十字型的徽标（并非红十字会啊），如下所示(可参见p1.jpg)

对方同时也需要在电脑dos窗口中以字符的形式输出该标志，并能任意控制层数。

为了能准确比对空白的数量，程序要求对行中的空白以句点（.）代替。

输入格式：

一个正整数 n (n<30) 表示要求打印图形的层数

输出：

对应包围层数的该标志。

请仔细观察样例，尤其要注意句点的数量和输出位置。

资源约定：

峰值内存消耗（含虚拟机） < 64M

CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。

import java.util.*;
public class Main {
    public static void main(String[] args) {
        // write your code here
        Scanner scan=new Scanner(System.in);
        int n=scan.nextInt();
        int num=4*n+5;
        String res[][]=new String[4*n+5][4*n+5];
        for(int i=0;i<4*n+5;i++){
            for(int j=0;j<4*n+5;j++){
                res[i][j]=".";
            }
        }
        //中间十字
        for(int i=0;i<=2;i++) {
            res[2 * n + 2 - i][2 * n + 2] = "$";
            res[2 * n + 2 + i][2 * n + 2] = "$";
            res[2 * n + 2][2 * n + 2 - i] = "$";
            res[2 * n + 2][2 * n + 2 + i] = "$";
        }
        //外左外右
        for(int t = 0; t < n; t++) {
            for (int i = 2*(t+1); i < num - 2*(t+1); i++) {
                res[2*t+2][0 + 2 * t + 1] = "$";
                res[2*t+2][0 + 2 * t + 2] = "$";
                res[num-1-2*t-2][0 + 2 * t + 1] = "$";
                res[num-1-2*t-2][0 + 2 * t + 2] = "$";
                res[i][0 + 2 * t] = "$";//左边外框
                res[i][num - 0 - 1 - 2 * t] = "$";//右边外框
                res[2*t+2][num - 0 - 1 - 2 * t - 1] = "$";
                res[2*t+2][num - 0 - 1 - 2 * t - 2] = "$";
                res[num-1-2*t-2][num - 0 - 1 - 2 * t - 1] = "$";
                res[num-1-2*t-2][num - 0 - 1 - 2 * t - 2] = "$";
            }
        }
        //外上外下
        for(int t = 0; t < n; t++) {
            for (int i = 2*(t+1); i < num - 2*(t+1); i++) {
                res[0 + 2 * t +1][2*t+2] = "$";
                res[0 + 2 * t +1][num-1-2*t-2] = "$";
                res[num-1-(0 + 2 * t +1)][2*t+2] = "$";
                res[num-1-(0 + 2 * t +1)][num-1-2*t-2] = "$";
                res[0 + 2 * t][i] = "$";
                res[num - 0 - 1 - 2 * t][i] = "$";
            }
        }

        for(int i=0;i<4*n+5;i++){
            for(int j=0;j<4*n+5;j++){
                System.out.print(res[i][j]);
            }
            System.out.println();
        }
    }
}