HNU-Java程序设计基础训练-2023

浔笙°

已于 2024-01-06 17:19:48 修改

阅读量968

点赞数 24

分类专栏： Java学习文章标签： java 算法开发语言

于 2024-01-01 18:42:33 首次发布

本文链接：https://blog.csdn.net/hhxxttx_/article/details/135307525

版权

Java学习专栏收录该内容

17 篇文章 4 订阅

订阅专栏

1.DNA序列（Java）

【问题描述】

一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例（定义为GC-Ratio）是序列中G和C两个字母的总的出现次数除以总的字母数目（也就是序列长度）。在基因工程中，这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。

给定一个很长的DNA序列，以及要求的最小子序列长度，研究人员经常会需要在其中找出GC-Ratio最高的子序列。

【输入形式】输入一个string型基因序列，和int型子串的长度

【输出形式】找出GC比例最高的子串,如果有多个输出第一个的子串

【样例输入】AACTGTGCACGACCTGA 5

【样例输出】GCACG

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        String str= input.next();
        int n=input.nextInt();
        int num=0;
        int index=0;
        for (int i = 0; i < str.length()-n; i++) {
            int m=0;
            for (int j = i; j <i+n ; j++) {
                if (str.charAt(j)=='C'||str.charAt(j)=='G'){
                    m++;
                }
            }
            if (m>num){
                num=m;
                index=i;
            }
        }
        System.out.println(str.substring(index,index+n));
    }

}

2.求近似数（JAVA）

【问题描述】

写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。

【输入形式】

输入一个正浮点数值

【输出形式】

输出该数值的近似整数值

【样例输入】

5.5

【样例输出】

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        float num=input.nextFloat();
        System.out.println(getint(num));
    }
    public static int getint(float n){
        int a=(int) n;
        if ((n-a)>=0.5){
            a+=1;
        }
        return a;
    }

}

3. 密码检查(JAVA)

【问题描述】

开发一个密码检查软件，密码要求:

长度超过8位
包括大小写字母.数字.其它符号,以上四种至少三种
不能有相同长度大于或等于2的子串重复

【输入形式】

一组或多组长度超过2的子符串。每组占一行

【输出形式】

如果符合要求输出：OK，否则输出NG

【样例输入】

021Abc9000

021Abc9Abc1

021ABC9000

021$bc9000
【样例输出】

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        while (input.hasNext()){
            String str=input.next();
            int l=str.length();
            if (l<=8){
                System.out.println("NG");
                continue;
            }

            char[] chars = str.toCharArray();
            int countadz = 0;
            int countAdZ = 0;
            int count0d9 = 0;
            int countOthers = 0;
            for (int i = 0; i < l; i++) {
                if (Character.isDigit(chars[i])) count0d9=1;
                if (Character.isUpperCase(chars[i])) countAdZ=1;
                if (Character.isLowerCase(chars[i])) countadz=1;
                if ((Character.isLowerCase(chars[i])==false)&&(Character.isUpperCase(chars[i])==false)&&(Character.isDigit(chars[i])==false)) countOthers=1;
            }
            if (count0d9+countAdZ+countadz+countOthers<3) {
                System.out.println("NG") ;
                continue;
            }
            int flag=0;
            for (int i = 0; i < l - 2; i++) {
                String sub = str.substring(i, i+2);
                    if (str.substring(i+2,l).contains(sub)) {
                        flag=1;
                    }
            }
            if (flag==1) {
                System.out.println("NG");
            }else {
                System.out.println("OK");
            }
        }
    }

}

4. 选美比赛（Java）

【问题描述】在选美大奖赛的半决赛现场，有n名选手(2<n<100)参加比赛。比赛结束时，要在现场按照选手的出场顺序宣布最后名次，获得相同分数的选手具有相同的名次，名次连续编号，不用考虑同名次的选手人数。如： </div> <div> 选手数量： 7 选手得分： 5，3，4，7，3，5，6宣布名次： 3，5，4，1，5，3，2 请编程帮助大奖赛组委会完成半决赛的评分排名工作。

【输入形式】选手数量：7 选手得分：5;3;4;7;3;5;6

【输出形式】选手的排名：3 5 4 1 5 3 2

【样例输入】7 5 3 4 7 3 5 6

【样例输出】3 5 4 1 5 3 2

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[] arr=new int[n];
        int[] copy=new int[n]; //去重数组
        for(int i=0;i<n;i++){
            arr[i]=sc.nextInt();
            copy[i]=arr[i];
        }
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                if(arr[i]==copy[j]){
                    copy[j]=0; //置为0 ,去除重复元素
                }
            }
        }
        for(int i=0;i<n;i++){
            int tem=1;
            for(int j=0;j<n;j++){
                if(arr[i]<copy[j]){ //判断有几个比他大
                    tem++;
                }
            }
            System.out.print(tem+" ");
        }

    }
}

5. 情报加密（JAVA）

【问题描述】

在情报传递过程中，为了防止情报被截获，往往需要对情报用一定的方式加密，简单的加密算法虽然不足以完全避免情报被破译，但仍然能防止情报被轻易的识别。我们给出一种最简的的加密方法，对给定的一个字符串，把其中从a-y,A-Y的字母用其后继字母替代，把z和Z用a和A替代，则可得到一个简单的加密字符串。

【输入形式】

可能有多组测试数据。每组测试数据的第一行是字符串的数目n，其余n行每行一个字符串,每个字符串长度小于80个字符。

【输出形式】

对于每组数据，输出每行字符串的加密字符串。

【样例输入】

Hello! How are you!
【样例输出】

Ifmmp! Ipx bsf zpv!

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        sc.nextLine();
        for (int i = 0; i < n; i++) {
            char[] arr=sc.nextLine().toCharArray();
            for(int j=0;j<arr.length;j++){
                if(arr[j]=='z'){
                    arr[j]='a';
                }else if(arr[j]=='Z'){
                    arr[j]='A'; //特殊情况判断
                }else if((arr[j]>='a' && arr[j]<='z')||(arr[j]>='A' && arr[j]<='Z')){
                    arr[j]+=1; //确保是字母，然后后移 //字符与数字相加，会先将字符转换成ASCII然后相加
                }
            }
            System.out.println(arr);
        }
    }
}

6. 骰子问题旋转（java）

【问题描述】

骰子是个立方体每个面一个数字，初始为左1，右2，前3（观察者方向），后4，上5，下6，用123456表示这个状态。放置在平面上，用L表示向左翻转一次，用R表示向右翻转一次，用F表示向前翻转一次，用B表示向后翻转一次，用A表示逆时针旋转90度，用C表示顺时针旋转90度，现从初始状态开始，根据输入的动作序列，计算得到最终的状态。

【输入形式】输入只包含LRFBAC的字母序列，最大长度为50，可重复

【输出形式】输出经过一系列操作后的序列注：按左右前后上下顺序输出

【样例输入】LB

【样例输出】5 6 1 2 3 4

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char[] arr = sc.nextLine().toCharArray(); //字符数组
        int[] now = {1, 2, 3, 4, 5, 6};  // 当前状态数组
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 'C') {
                int t1=now[0];  //列出所有情况
                now[0]=now[2];
                now[2]=now[1];
                now[1]=now[3];
                now[3]=t1;
            }else if(arr[i]=='A'){
                int t1=now[0];
                now[0]=now[3];
                now[3]=now[1];
                now[1]=now[2];
                now[2]=t1;
            }else if(arr[i]=='F'){
                int t1=now[2];
                now[2]=now[4];
                now[4]=now[3];
                now[3]=now[5];
                now[5]=t1;
            }else if(arr[i]=='B'){
                int t1=now[2];
                now[2]=now[5];
                now[5]=now[3];
                now[3]=now[4];
                now[4]=t1;
            }else if(arr[i]=='L'){
                int t1=now[4];
                now[4]=now[1];
                now[1]=now[5];
                now[5]=now[0];
                now[0]=t1;
            }else if(arr[i]=='R'){
                int t1=now[4];
                now[4]=now[0];
                now[0]=now[5];
                now[5]=now[1];
                now[1]=t1;
            }
        }
        for(int i=0;i<6;i++){
            System.out.print(now[i]+" "); //输出状态
        }

    }
}

7.供应商问题（JAVA）

【问题描述】

有n个某种商品供应商，某地有m个商店，商店需要从供应商那里进货该商品，每个供应商的供应能力有上限，每个商店都有自己的商品需求量（need[i]:表示第i个商店的需求），每个供应商运送单位商品到商店需要一个运费。

【输入形式】

输入说明：第一行包含两个整数N，M

接下来N行包含三个整数，第一个数表示供应商编号，第二数表示供应能力上限，表示该供应商的供应量不能超过这个上限，第三个数表示运送单位商品到商店的运费。

接下来M行包含两个整数，第一个数表示商店编号，第二个数表示某种商品的需求量。

【输出形式】

输出说明：若可以满足所有商店需求，则输出格式如下：每行第一个数表示供应商编号，第二个数为商店编号，第三个数为供应量。

如：1 2 20

表示第1个供应商给第2个商店供应20个单位量的商品

按商店编号顺序，输出所有供应路径（最后一行无换行符）。

若不满足，输出-1

【样例输入】

4 4

0 20 8

1 15 3

2 55 6

3 40 10

0 28

1 36

2 49

3 12

【样例输出】

1 0 15

2 0 13

2 1 36

2 2 6

0 2 20

3 2 23

3 3 12

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int[][] supply=new int[n][3]; //记录供应方
        int[][] need=new int[m][2];//记录商家
        int s1=0;
        int s2=0;
        for(int i=0;i<n;i++){
            supply[i][0]=sc.nextInt();
            supply[i][1]=sc.nextInt();
            supply[i][2]=sc.nextInt();
            s1+=supply[i][1];
        }
        for(int i=0;i<m;i++){
            need[i][0]=sc.nextInt();
            need[i][1]=sc.nextInt();
            s2+=need[i][1];
        }
        if(s1<s2){ //供应量太少了
            System.out.println(-1);
            return;
        }
        for(int i=0;i<n;i++) {
            for (int j = i + 1; j < n; j++) {
                if (supply[i][2] > supply[j][2]) {
                    int[] temp = supply[i];
                    supply[i] = supply[j];
                    supply[j] = temp;
                }
            }//利用冒泡排序进行运费的排序
        }
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(need[i][1]<=0){
                    break;  //需求量够了
                }
                if(supply[j][1]>=need[i][1]){
                    System.out.println(""+supply[j][0]+" "+i+" "+need[i][1]);
                    supply[j][1]-=need[i][1]; //供应方多了，直接满足
                    need[i][1]=0;//需求量清零
                }else if(supply[j][1]>0){
                    System.out.println(""+supply[j][0]+" "+i+" "+supply[j][1]);
                    need[i][1]-=supply[j][1];//要继续寻找供应方
                    supply[j][1]=0;//供应方提供量清零

                }
            }
        }


    }
}

8.反转字符串（Java）

【问题描述】写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。

【输入形式】输入N个字符
【输出形式】输出该字符串反转后的字符串

【样例输入】

abcd
【样例输出】

dcba

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.next();
        StringBuilder sb=new StringBuilder(str).reverse();
        System.out.println(sb);

    }
}

9.找朋友（JAVA）

【问题描述】

两个人是朋友通常意味着他们存在着许多共同的兴趣。然而作为一个宅男，你发现自己与他人相互了解的机会并不太多。幸运的是，你意外得到了一份湖大图书馆的图书借阅记录，于是你挑灯熬夜地编程，想从中发现潜在的朋友。

首先你对借阅记录进行了一番整理，把N个读者依次编号为1,2,…,N，把M本书依次编号为1,2,…,M。同时，按照“臭味相投”的原则，和你喜欢读同一本书的人，就是你的潜在朋友。你现在的任务是从这份借阅记录中计算出每个人有几个潜在朋友。

【输入形式】

每个案例第一行两个整数N,M。接下来有N行，第i(i = 1,2,…,N)行每一行有一个数，表示读者i-1最喜欢的图书的编号P(1<=P<=M)

【输出形式】

每个案例包括N行，每行一个数，第i行的数表示读者i有几个潜在朋友。如果i和任何人都没有共同喜欢的书，则输出“BeiJu”（即悲剧，^ ^）

【样例输入】

4 5

【样例输出】

BeiJu

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int N = scanner.nextInt();
        int M = scanner.nextInt();
        int[] favoriteBooks = new int[N];

        for (int i = 0; i < N; i++) {
            favoriteBooks[i] = scanner.nextInt();
        }

        for (int i = 0; i < N; i++) {
            int num = 0; // 初始化共同喜好的读者数量

            for (int j = 0; j < N; j++) {
                if (i != j && favoriteBooks[i] == favoriteBooks[j]) {
                    num++;
                }
            }

            if (num > 0) {
                System.out.println(num);
            } else {
                System.out.println("BeiJu");
            }
        }
    }
}

10.进制转化（java）

【问题描述】写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。(多组同时输入)

【输入形式】输入一个十六进制的数值字符串。

【输出形式】输出该数值的十进制字符串。

【样例输入】0xA

【样例输出】10

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {
            String hexString = scanner.nextLine();
            // 移除十六进制前缀 "0x"（如果存在）
            if (hexString.startsWith("0x")) {
                hexString = hexString.substring(2);
            }

            // 使用parseInt方法将十六进制字符串转换为十进制整数
            int decimalValue = Integer.parseInt(hexString, 16);

            // 将整数转换为字符串并输出
            System.out.println(Integer.toString(decimalValue));
        }
    }
}

11.ip地址判定（Java）

【问题描述】现在IPV4下用一个32位无符号整数来表示，一般用点分方式来显示，点将IP地址分成4个部分，每个部分为8位，表示成一个无符号整数（因此不需要用正号出现），如10.137.17.1，是我们非常熟悉的IP地址，一个地址串中没有空格出现（因为要表示成一个32数字）。>现在需要你用程序来判断IP是否合法。

【输入形式】输入一个ip地址

【输出形式】返回判断的结果YES or NO

【样例输入】

10.138.15.1

【样例输出】

YES

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String ipAddress = scanner.nextLine();

        if (isValidIP(ipAddress)) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }

    public static boolean isValidIP(String ipAddress) {
        String[] parts = ipAddress.split("\\.");
        if (parts.length != 4) {
            return false;
        }

        for (String part : parts) {
            int num = Integer.parseInt(part);
            if (num < 0 || num > 255) {
                return false;
            }
        }

        return true;
    }
}

12.计算日期（JAVA）

【问题描述】

给出年分m和一年中的第n天，算出第n天是几月几号。

【输入形式】

输入包括两个整数y，n

【输出形式】

可能有多组测试数据，对于每组数据，按yyyy-mm-dd的格式将输入中对应的日期打印出来。
【样例输入】

2000 3

2000 31

2000 40

2000 60
【样例输出】

2000-01-03

2000-01-31

2000-02-09

2000-02-29

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {
            int y = scanner.nextInt(); // 输入年份
            int n = scanner.nextInt(); // 输入一年中的第n天

            int[] daysInMonth = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

            // 判断闰年，如果是闰年，2月天数加一
            if (isLeapYear(y)) {
                daysInMonth[2] = 29;
            }

            int month = 1;
            while (n > daysInMonth[month]) {
                n -= daysInMonth[month];
                month++;
            }

            // 打印日期

            System.out.printf("%d-%02d-%02d\n", y, month, n);
        }
    }

    // 判断是否为闰年
    public static boolean isLeapYear(int year) {
        return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
    }
}

注意，不能使用System.out.println(y+"-"+month+"-"+n);进行输出，该方法结果为2000-1-3，而非2000-01-03（月份和日期前面有补 0）

13.去重与排序（Java）

【问题描述】明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。Input Param n 输入随机数的个数 inputArray n 个随机整数组成的数组 Return Value OutputArray 输出处理后的随机整数

【输入形式】输入多行，先输入随机整数的个数n，再输入相应个数的整数

【输出形式】输出一行，处理后的结果

【样例输入】 11

10 20 40 32 67 40 20 89 300 400 15

【样例输出】10 15 20 32 40 67 89 300 400

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int m=sc.nextInt();
        ArrayList<Integer> arr=new ArrayList<>();
        for (int i = 0; i < m; i++) {
            arr.add(sc.nextInt());
        }
        HashSet<Integer> ha=new HashSet<>(arr);
        ArrayList<Integer> ar=new ArrayList<>(ha);
        Collections.sort(ar);
        for(int a:ar){
            System.out.print(a+" ");
        }
    }
}

14.跳跃最大长度（java）

【问题描述】给一个非负整数数组。假设你最初的位置为0，数组中每一个元素的值代表你能跳跃最大的长度，判断是否能达到数组的最后一个位置

【输入形式】第一行数组长度

第二行输入一个非负整数数组

【输出形式】布尔类型的值

【样例输入】

1 2 3 1 4

【样例输出】

true

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = scanner.nextInt();
        }

        int k = 0; // 最远可以达到的位置
        for (int i = 0; i < n; i++) {
            if (k < i) { // 判断是否没办法继续往下跳
                System.out.println("false");
                break;
            }
            k = Math.max(k, i + a[i]);
        }
        if (k >= n - 1) // k能到n-1
            System.out.println("true");
    }
}

15.输出较小数（Java）

【问题描述】输入n个整数，输出其中最小的k个。

【输入形式】输入说明 1输入两个整数（n k） 2输入一个整数数组

【输出形式】输出一个整数数组

【样例输入】

5 2

1 3 5 7 2

【样例输出】

1 2

（下面代码用了俩方法，输出也是两种方法）

用 ArrayList的方法通过下标访问要用 get()实现。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        int[] numbers = new int[n];
        //或者 ArrayList也可以
        ArrayList<Integer> arr=new ArrayList<>();
        for (int i = 0; i < n; i++) {
            numbers[i] = scanner.nextInt();
            arr.add(numbers[i]);
        }

        // 对数组进行排序
        Arrays.sort(numbers);
        Collections.sort(arr);
        // 输出最小的k个整数
        for (int i = 0; i < k; i++) {
            System.out.print(numbers[i] + " ");
        }
        System.out.println();
        //用 ArrayList的方法
        for (int i = 0; i < k; i++) {
            System.out.print(arr.get(i) + " ");
        }
    }
}

16.计算int型二进制1的个数（JAVA）

【问题描述】

输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。

【输入形式】

输入一个整数int类型
【输出形式】

这个数转换成2进制后，输出1的个数

【样例输入】

【样例输出】

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int m= scanner.nextInt();
        String s=Integer.toBinaryString(m);
        int num=0;
        for(int i=0;i<s.length();i++){
            if (s.charAt(i)=='1'){
                num++;
            }
        }
        System.out.println(num);
    }
}

字符串通过下标访问要用 chatAt()方法。

17.水瓶换水（java）

【问题描述】有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？

【输入形式】输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。

【输出形式】对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。

【样例输入】 3 10 81 0

【样例输出】 1 5 40

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (true){
            int m= scanner.nextInt();
            if (m==0) break;
            int count=0;
            while (m>=2){
                int n=0;
                n+=m/3;
                m=m%3+n;
                count+=n;
                if (m==2){
                    count++;
                    break;
                }
            }
            System.out.print(" "+count);
        }

    }
}

注意输出格式（" "+count）

18.导弹防御系统（Java）

【问题描述】某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，并观测到导弹依次飞来的高度，请计算这套系统最多能拦截多少导弹。拦截来袭导弹时，必须按来袭导弹袭击的时间顺序，不允许先拦截后面的导弹，再拦截前面的导弹。

【输入形式】每组输入有两行，第一行，输入雷达捕捉到的敌国导弹的数量k（k<=25），第二行，输入k个正整数，表示k枚导弹的高度，按来袭导弹的袭击时间顺序给出，以空格分隔。

【输出形式】每组输出只有一行，包含一个整数，表示最多能拦截多少枚导弹。

【样例输入】

300 207 155 300 299 170 158 65

【样例输出】 6

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int m= scanner.nextInt();
        int[] arr=new int[m];
        for (int i = 0; i < m; i++) {
            arr[i]= scanner.nextInt();
        }
        int[] dp=new int[m];
        for (int i = 0; i < m; i++) {
            dp[i]=1;
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < i; j++) {
                if (arr[i]<=arr[j]){
                    dp[i]=Math.max(dp[i],dp[j]+1);
                }
            }
        }
        int max=0;
        for (int i = 0; i < m; i++) {
            if (dp[i]>max) max=dp[i];
        }
        System.out.println(max);
    }
}

19.子网判断（Java）

【问题描述】子网掩码是用来判断任意两台计算机的IP地址是否属于同一子网络的根据。子网掩码与 IP 地址结构相同，是32 位二进制数，其中网络号部分全为 “1” 和主机号部分全为 “0” 。利用子网掩码可以判断两台主机是否中同一子网中。若两台主机的IP 地址分别与它们的子网掩码相 “与” 后的结果相同，则说明这两台主机在同一子网中。示例：IP 地址192.168.0.1子网掩码255.255.255.0转化为二进制进行运算：IP地址11010000.10101000.00000000.00000001子网掩码11111111.11111111.11111111.00000000 AND运算11010000.10101000.00000000.00000000转化为十进制后为：192.168.0.0 IP 地址 192.168.0.254子网掩码 255.255.255.0转化为二进制进行运算：IP地址11010000.10101000.00000000.11111110子网掩码11111111.11111111.11111111.00000000 AND运算11010000.10101000.00000000.00000000 转化为十进制后为：192.168.0.0 通过以上对两台计算机IP 地址与子网掩码的 AND 运算后，我们可以看到它运算结果是一样的。均为192.168.0.0，所以这二台计算机可视为是同一子网络。

【输入形式】输入子网掩码、两个地址

【输出形式】得到计算结果，如不在同一子网，则输出0

【样例输入】

255.255.255.0

192.168.224.254

192.168.10.4

【样例输出】

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        String subnetMask = scanner.nextLine();
        String ip1 = scanner.nextLine();
        String ip2 = scanner.nextLine();

        if (isSameSubnet(subnetMask, ip1, ip2)) {
            System.out.println('1');
        } else {
            System.out.println('0');
        }
    }

    private static boolean isSameSubnet(String subnetMask, String ip1, String ip2) {
        String[] subnetMaskParts = subnetMask.split("\\.");
        String[] ip1Parts = ip1.split("\\.");
        String[] ip2Parts = ip2.split("\\.");

        if (subnetMaskParts.length != 4 || ip1Parts.length != 4 || ip2Parts.length != 4) {
            return false; // 输入格式错误
        }

        for (int i = 0; i < 4; i++) {
            int subnetMaskPart = Integer.parseInt(subnetMaskParts[i]);
            int ip1Part = Integer.parseInt(ip1Parts[i]);
            int ip2Part = Integer.parseInt(ip2Parts[i]);

            if ((subnetMaskPart & ip1Part) != (subnetMaskPart & ip2Part)) {
                return false;
            }
        }

        return true;
    }
}

20.抽纸片（java）

【问题描述】你的朋友提议玩一个游戏：将写有数字的的n纸片放入口袋中，你可以从口袋中抽取三次纸片，每次记下纸片上的数字后都将其放回到口袋中，如果这三个数字的和是m，就是你赢，否则就是你朋友赢。请你编写一个程序，判断当纸片上所写的数字是k1，k2，…,kn时是否存在抽取三次之和为m的方案。

【输入形式】输入的第一行为一个正整数 n 表示口袋中纸片数目（int类型）第二行为一个正整数表示三个数字的和第三行为n个整数表示每个纸片上的数字（int类型）

【输出形式】如果存在符合要求的方案，输出Y，否则，输出N。

【样例输入】

2 3 5

【样例输出】

import java.util.Scanner;
public class Main
{	
	public static void main(String[] args)
	{
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();
		int K=s.nextInt();
		int[] arr=new int[n];
		for(int i=0;i<n;i++){
			arr[i]=s.nextInt();
		}
		boolean bool=false;
		for(int i=0;i<n;i++){
			for(int j=i+1;j<n;j++){
				for(int k=j+1;k<n;k++){
					if((arr[i]+arr[j]+arr[k]==K)){
						bool=true;
					}
				}
			}
		}
		if(bool){
			System.out.println("Y");
		}else{
			System.out.println("N");
		}
				
	}
}

21.学生成绩（java）

【问题描述】老师想知道从某某同学当中，分数最高的是多少，现在请你编程模拟老师的询问。当然，老师有时候需要更新某位同学的成绩.

【输入形式】输入包括多组测试数据。每组输入第一行是两个正整数N和M（0 < N <= 30000,0 < M < 5000）,分别代表学生的数目和操作的数目。学生ID编号从1编到N。第二行包含N个整数，代表这N个学生的初始成绩，其中第i个数代表ID为i的学生的成绩,接下来又M行，每一行有一个字符C（只取‘Q’或‘U’），和两个正整数A,B,当C为'Q'的时候, 表示这是一条询问操作，他询问ID从A到B（包括A,B）的学生当中，成绩最高的是多少,当C为‘U’的时候，表示这是一条更新操作，要求把ID为A的学生的成绩更改为B。

【输出形式】对于每一次询问操作，在一行里面输出最高成绩.

【样例输入】

5 7

1 2 3 4 5

Q 1 5

U 3 6

Q 3 4

Q 4 5

U 4 5

U 2 9

Q 1 5

【样例输出】5 6 5 9

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int N = scanner.nextInt();
        int M = scanner.nextInt();

        int[] scores = new int[N];

        for (int i = 0; i < N; i++) {
            scores[i] = scanner.nextInt();
        }

        for (int i = 0; i < M; i++) {
            char op = scanner.next().charAt(0);
            int A = scanner.nextInt();
            int B = scanner.nextInt();

            if (op == 'Q') {
                // 处理询问操作
                int maxScore = scores[A - 1];
                for (int j = A; j <= B - 1; j++) {
                    if (scores[j] > maxScore) {
                        maxScore = scores[j];
                    }
                }
                System.out.print(maxScore + " ");
            } else if (op == 'U') {
                // 处理更新操作
                scores[A - 1] = B;
            }
        }
    }
}

22.吸血鬼数字（Java）

【问题描述】吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘得到，这对数字各包含乘积的一半位数的数字，数字选取后可任意排序，例如： 1260=21×60 1827=21×87 2187=27×81。写出一个程序，找出4位数的所有吸血鬼数字。

【输入形式】无

【输出形式】输出所有的吸血鬼数字，数字之间已空格分隔。

【样例输入】无

【样例输出】1260 1395 1435 1530 1827 2187 6880

import java.util.*;
public class Main {
    public static void main(String[] args){
        for(int i=1000;i<10000;i++){
            int[] num=new int[4];
            int tem=i;
            for(int j=3;j>-1;j--){
                num[j]=tem%10;
                tem=tem/10;
            }
            int x1=num[0]*10+num[1];
            int y1=num[0]*10+num[2];
            int x2=num[0]*10+num[3];
            int y2=num[1]*10+num[0];
            int x3=num[1]*10+num[2];
            int y3=num[1]*10+num[3];
            int x4=num[2]*10+num[0];
            int y4=num[2]*10+num[1];
            int x5=num[2]*10+num[3];
            int y5=num[3]*10+num[0];
            int x6=num[3]*10+num[1];
            int y6=num[3]*10+num[2];
            if(x1*y6==i || x1*x5==i || y1*y3==i || y1*x6==i || x2*x3==i || x2*y4==i || y2*y6==i ||y2*x5==i){
                System.out.print(i+" ");
            }
            else if(x3*y5==i || x4*y3==i || x4*x6==i || y4*y5==i){
                System.out.print(i+" ");
            }
        }
    }
}

浔笙°

关注

24
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
HNU-Java程序设计基础训练-2023

如：选手数量： 7 选手得分： 5，3，4，7，3，5，6宣布名次： 3，5，4，1，5，3，2 请编程帮助大奖赛组委会完成半决赛的评分排名工作。骰子是个立方体每个面一个数字，初始为左1，右2，前3（观察者方向），后4，上5，下6，用123456表示这个状态。放置在平面上，用L表示向左翻转一次，用R表示向右翻转一次，用F表示向前翻转一次，用B表示向后翻转一次，用A表示逆时针旋转90度，用C表示顺时针旋转90度，现从初始状态开始，根据输入的动作序列，计算得到最终的状态。
复制链接

扫一扫

专栏目录