Java机试常见题——编程题（中）

冷不防 2021-07-24 12:12 514阅读 0赞

**名字的漂亮度**

1 程序

import java.util.*;
    
    public class Main{
        public static void main(String[] args)
        {
            Scanner scan = new Scanner(System.in);
            int num = 0;
            boolean flag = true;
            while(scan.hasNextLine())
            {
                StringBuilder sb = new StringBuilder();
                num = Integer.parseInt(scan.nextLine());   //输入名字个数
                for(int i=0;i<num-1;i++){
                    sb.append(scan.nextLine());
                    sb.append(',');
                }
                sb.append(scan.nextLine());
                outPutBeauty(sb.toString());
            }
        }
    
        public static void outPutBeauty(String string)    // 多个名字
        {
            String[] result = string.split(",");    // 多个名字放到数组中
            for(String tmp:result)
                System.out.println(getBeauty(tmp));
        }
        public static int getBeauty(String name)   // 一个名字
        {
            char[] chs = name.toLowerCase().toCharArray();    // 变成小写字符数组
            int[] target = new int[26];   // 用于记录每个字符出现的次数
            for(int i=0;i<chs.length;i++)    // 遍历名字
                target[chs[i] - 'a']++;
            Arrays.sort(target);    //排序
            int res = 0;
            for(int i=25;i>=0;i--)
                res += target[i] *(i+1);     //计算名字的漂亮度
            return res;
        }
    }

2 测试

2
    zhangsan
    lisi
    192
    101

**按字节截取字符串**

1 程序

import java.util.*;
    //截取字符串，汉字不能输出一半
    /*
    AABCADEF
    6
    AABCAD
    * */
    public class Main {
    
        public static void main(String[] args)  {
            Scanner scan = new Scanner(System.in);
            String str;
            while (scan.hasNextLine()){
                str = scan.nextLine();
                String[] tmp=str.split(" ");
                String chars=tmp[0];                    // 字符串
                int len=Integer.parseInt(tmp[1]);       // 截取的字符个数
    
                int count=0, i=0;
                for (;i<chars.length();i++){
                    char c=chars.charAt(i);
                    if (c>='a'&&c<='z'||c>='A'&&c<='Z')
                        count+=1;
                    else count+=2;
                    if (count>len) {             // 注意，这里是>号。如果有=号，还会再循环一次，i要多加一次
                        break;
                    }
                }
                System.out.println(chars.substring(0,i));
            }
    
        }
    }

2 测试

我ABC汉DEF 6
    我ABC

**多线程**

1 程序

import java.util.*;
     
    public class Main {
        public static void main(String[] args)  {
            Scanner scan = new Scanner(System.in);    
            while(scan.hasNext()){                 // 如果下面是nextInt ，则这里要用hasNext
                int N = scan.nextInt();
                StringBuffer sb = new StringBuffer();
                for (int i = 0; i < N; i++) {
                    sb.append("ABCD");
                }
                System.out.println(sb);
            }
        }
    }

2 测试

4
    ABCDABCDABCDABCD

**输出单向链表中倒数第k个结点**

1 程序

import java.util.Scanner;
     
    public class Main {
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            while(sc.hasNext()){
                int n = sc.nextInt();
                int[] arr = new int[n+1];
                for(int i = 0; i < n; i++){
                    arr[i] = sc.nextInt();
                }
                int k = sc.nextInt();
                //倒数的第k个，正数的是n-k+1，注意数组下标从0开始，因此是n-k
                System.out.println(arr[n-k]);
            }
            sc.close();  // 注意这里关闭下
        }
    }

2 测试

8
    1 2 3 4 5 6 7 8
    5
    3

**iNOC产品部-杨辉三角的变形**

1 程序

import java.util.*;
    /*
                    1                                 第一行没有，输出为-1
                 1  1  1                              第二行没有，输出为-1
              1  2  3  2  1                           奇数行，是2个数
           1  3  6  7  6  3  1                        4的倍数的偶数是第3个
        1  4  10 16 19 16 10  4  1                    奇数行，是2个数
    1   5  15 20 45 51 45 30  15 5  1                 非4的倍数的偶数是第4个
    */
    public class Main{
        public static void main(String[] args){
            Scanner in = new Scanner(System.in);
            while(in.hasNext()){
                int n = in.nextInt();           // 输入的行号
                // 如果n小于等于2，则没有偶数，为-1
                if(n<=2)
                    System.out.println(-1);
                // 如果是奇数行，则是第2个数
                else if(n%2==1){
                    System.out.println(2);
                }else{
                    // 如果是偶数行，且能被4整除，则是第3个数
                    if(n%4==0)
                        System.out.println(3);
                    // 如果是偶数行，但不能被4整除，则是第4个数
                    else
                        System.out.println(4);
                }
            }
            in.close();
        }
    }

2 测试

4
    3

**（练习用）挑7**

1 程序

import java.util.*;
     
    public class Main{
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            while(scan.hasNext()){
                int num = scan.nextInt();
                int count=0;
                for(int i=1;i<=num;i++){
                    if(i%7==0){     // 7的倍数计数
                        count++;
                    }else if(String.valueOf(i).contains("7"))    // 该字符串含7计数
                    {
                        count++;
                    }
                }
                System.out.println(count);
            }
            scan.close();
        }
    }

2 测试

20
    3

**iNOC产品部--完全数计算**

1 程序

import java.util.*;
    public class Main{
        public static void main(String [] args){
            Scanner in = new Scanner(System.in);
            while(in.hasNext()){
                int n = in.nextInt();   // 输入一个自然数
                int count = 0;
                //1不是完备数，从2开始遍历
                for(int i=2;i<=n;i++){
                    if(isPerfect(i)){         // 对完备数进行计数
                        count++;
                    }
                }
                System.out.println(count);
            }
        }
        
        private static boolean isPerfect(int src){
            int sum = 1;  // 注意1要加进来，sum是满足条件的约数
            // 注意这里的条件i*i
            for(int i =2;i*i<=src;i++){     //注意这里从2开始，另外质数的判断条件是i*i<=src
                if(src%i==0){   // 必须能除断
                    sum +=i;        // 加第1约数
                    sum+=src/i;     // 加第2个约数
                }
            }
            if(sum==src){
                return true;
            }
            return false;
        }
    
    }

2 测试

1000
    3

**无线OSS－高精度整数加法**

1 程序

import java.util.*;
    import java.math.*;
     
    public class Main{
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            while(scan.hasNextLine()){
                String str=scan.nextLine();
                BigInteger a = new BigInteger(str.trim());   // 读入第一个大数
                BigInteger b = new BigInteger(scan.nextLine().trim());     // 读入第二个大数
                System.out.println(a.add(b).toString());          // 两个大数的相加还是大数
            }
            scan.close();
        }
    }

2 测试

9876543210
    1234567890
    11111111100

**输入n个整数，输出其中最小的k个**

1 程序

import java.util.*;
    public class Main{
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            while(scan.hasNext()){
                int count =scan.nextInt();
                int k =scan.nextInt();
                int[] num= new int[count];
                for(int i=0;i<count;i++){
                    num[i]=scan.nextInt();
                }
                StringBuffer sb = new StringBuffer();   // 一般放到StringBuffer中输出，不然会报错
                Arrays.sort(num);    // 从小到大的排序
                for(int j=0;j<k-1;j++){
                    sb.append(num[j]+ " ");    // 先加前k-1个数
                }
                sb.append(num[k-1]);    // 再加最后一个数
                System.out.println(sb.toString());
            }
            scan.close();
        }
    }

2 测试

5 2
    1 3 4 7 2
    1 2

**找出字符串中第一个只出现一次的字符**

1 程序

import java.util.*;
     
     
    public class Main{
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            String str;
            while(scan.hasNextLine()) {
                str = scan.nextLine();
                char[] c = str.toCharArray();            //转数组
                int num[] = new int[128];                //用于计数每个字符
                for(int i = 0;i<str.length();i++){       // 对某个字符计数
                    num[str.charAt(i)]++;
                }
                for(int i = 0;i<c.length;i++){       // 遍历字符数组
                    if(num[c[i]]==1){                 //如果该字符只出现一次，打印该字符，并跳出
                        System.out.println(c[i]);
                        break;
                    }
                    if(i==(c.length-1))
                        System.out.println(-1);       //如果找不到就打印-1
                }
            }
        }
    }

2 测试

asdfasdfo
    o

**查找组成一个偶数最接近的两个素数**

1 程序

import java.util.Scanner;
    
    public class Main{
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            while(scan.hasNext()){
                int num = scan.nextInt();
                int n = num/2;       // 第一个数
                int m = num - n;     // 第二个数
                boolean flag1 = false;   
                boolean flag2 = false;
                do{
                    flag1 = issushu(n);   // 第一个数是否是素数
                    flag2 = issushu(m);   // 第二个数是否是素数
                    if(flag1&&flag2){
                        System.out.println(m+"\n"+n);
                        break ;
                    }
                    else{
                        n = n+1;
                        m = num -n;
                    }
                }while(n<num);
                
            }
        }
        
        private static boolean issushu(int num){      // 为素数就返回true，否则返回false
            for(int i=2;i<num;i++){           //2 到num-1 看是否能除尽，能除尽就是素数
                if(num%i==0){
                    return false;
                }
            }
            return true;
        }
    }

2 测试

54
    23
    31

**查找输入整数二进制中1的个数**

1 程序

import java.util.Scanner;
    
    public class Main{
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            int num;
            while(scan.hasNext()){
                num = scan.nextInt();   // 输入整数
                int m =0;
                m = findNumberOf1(num);  //查找二进制串中1的个数
                System.out.println(m);
            }
        }
        
        public   static   int  findNumberOf1( int num){
            String binaryString = Integer.toBinaryString(num);   // 将一个整数转为二进制字符串
            int count = 0;
            for(int i=0;i<binaryString.length();i++){
                if(binaryString.substring(i,i+1).equals("1")){   // 依次判断串的每一位是否为1
                    count++;
                }
            }
            return count;
        }
    }

2 测试

2567237
    10

**查找两个字符串a,b中的最长公共子串**

1 程序

import java.util.Scanner;
     
    public class Main{
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            while(scan.hasNextLine()){
                String str1 = scan.nextLine();
                String str2 = scan.nextLine();
                String shortStr = "";
                String longStr = "";
                if(str1.length()<str2.length()){
                    shortStr = str1;
                    longStr = str2;
                }else{
                    shortStr = str2;
                    longStr = str1;
                }
                System.out.println(findLongStr(shortStr,longStr));
            }
        }
        // 第一个参数是短串，第二个参数是长串
        /*
        abcd   length = 4  abcd  abc bcd  ab bc cd a b c d  就是这样去找短串的子串
        abcde
        */
        private static String findLongStr(String shortStr,String longStr) {
            int length = shortStr.length();   // 短串长度
            String subShortStr;    //短串的子串 
            // 第1轮  ，长度为length的短串，循环1次
            // 第2轮  ，长度为length-1的短串，循环2次
            // 第i轮  ，长度为length-i+1的短串，循环i次
            // 第length轮，长度为1的短串，循环length次
            for(int i=1;i<=length;i++){  // 所以，外层循环从1开始，循环length次
                for(int j=0;j<=i-1;j++){   // 所以，内层循环从0开始，循环i次  ，其中j代表短子串首字符的位置
                    subShortStr = shortStr.substring(j,j+(length-i+1));  
                    if(longStr.contains(subShortStr)){
                        return subShortStr;
                    }
                }
            }
            return "";
        }
    }

2 测试

abcdefghijklmnop
    abcsafjklmnopqrstuvw
    jklmnop

**成绩排序**

1 程序

import java.util.*;
    import java.io.IOException;
    
    public class Main{
    
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            while(scan.hasNextLine()){
                String str=scan.nextLine();
                //获取要排序的人的个数
                int count = Integer.parseInt(str);
                //获取输入的排序方法(升序还是降序) 0是降序 1是升序
                int sortType = Integer.parseInt(scan.nextLine());
                String[] users = new String[count];   // 姓名
                int[] scores = new int[count];        // 分数
                for(int i=0;i<count;i++){     // i代表插入前的数组，下标分别是[0,1,2,...  i-1]
                    String line = scan.nextLine();    //姓名 分数
                    String[] parts = line.split(" "); //[姓名,分数]
                    String user = parts[0];                       // 姓名
                    int score = Integer.parseInt(parts[1]);       // 分数
                    // 插入排序的思想，一个个插入
                    if(sortType==0){          // 降序 
                        int j = 0;
                        for(j=i-1;j>=0;j--){
                            if(scores[j]<score){            // 降序和升序就这里不一样
                                scores[j+1] = scores[j];
                                users[j+1] = users[j];
                            }
                            else{
                                break;
                            }
                        }
                        scores[j+1] = score;
                        users[j+1] = user;
                    }
                    else{
                        int j = 0;
                        for(j=i-1;j>=0;j--){       // 下标分别是[0,1,2,...  i-1]  插入前，从后往前比较，j代表比较下标
                            if(scores[j]>score){
                                scores[j+1] = scores[j];
                                users[j+1] = users[j];
                            }
                            else{   // 插入的数就是最大，不用比较了，直接跳出
                                break;
                            }
                        }
                        scores[j+1] = score;  // 这里的j加1，是因为循环跳出时，减去了1
                        users[j+1] = user;
                    }
                }
                for(int i=0;i<count;i++){
                    System.out.println(users[i]+" "+scores[i]);
                }
            }
        }
    
    }

2 测试

3
    0
    fang 90
    yang 50
    ning 70
    fang 90
    ning 70
    yang 50

**字符串通配符**

1 程序

import java.util.*;
    public class Main {
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            while(scan.hasNextLine()) {
                String line = scan.nextLine();
                String str1=line;                   // 含有通配的字符串
                String str2=scan.nextLine();        // 完整字符串
                System.out.println(isMatch(str1, str2));
            }
        }
        
        public static boolean isMatch(String str1,String str2) {
            // sta1 = te?t*.*
            // replaceAll第一个是正则表达，第二个是正则表达是被替换的串
            str1=str1.replaceAll("\\?", "[0-9a-zA-Z]"); // 匹配一个字符
            str1=str1.replaceAll("\\*","[0-9a-zA-Z]*"); // 匹配0个或1个字符
            // 运行到这里  str1 = te[0-9a-zA-Z]t[0-9a-zA-Z]*.[0-9a-zA-Z]*
            // matches 参数是正则表达式
            if(str2.matches(str1))  return true;
            return false;
        }
    
    }

2 测试

te?t*.*
    txt12.xls
    false

**三一 百钱买百鸡问题**

1 程序

import java.util.Scanner;
    
    /*
    x:公鸡
    y：母鸡
    100-x-y为小鸡
    y=25-7x/4
    */
    public class Main {
        public static void main( String[] args ) {
            Scanner scan = new Scanner(System.in);
            int num;
            while (scan.hasNext()) {
                num=scan.nextInt();
                int y = 0;
                for (int x = 0; ; x = x + 4) {
                    int[] list = new int[3];   //分别放公鸡，母鸡，小鸡
                    y = 25 - 7 * x / 4;
                    list[0] = x;
                    list[1] = y;
                    list[2] = 100 - x - y;
                    if (list[2] < 0 || list[1] < 0) {         // 母鸡和小鸡任何一个小于0，就跳出
                        break;
                    } else {
                        System.out.println(list[0] + " " + list[1] + " " + list[2]);   // 输出各种情况
                    }
                }
            }
        }
    }

2 测试

1
    0 25 75
    4 18 78
    8 11 81
    12 4 84

**三二 计算日期到天数转换**

1 程序

//输入年月日，返回天数
    //1-31 2-28 3-31 4-30 5-31 6-30 7-31 8-31 9-30 10-31 11-30 12-31
    import java.util.*;
    public class Main {
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            while(scan.hasNextLine()) {
                String line=scan.nextLine();
                String[] lineary=line.split(" ");
                int year=Integer.valueOf(lineary[0]);      // 年
                int month=Integer.parseInt(lineary[1]);    // 月
                int day=Integer.valueOf(lineary[2]);       // 日
                System.out.println(getAllDay(year, month, day));
            }
             
        }
        public static int getAllDay(int year,int month,int day) {
            int[] dayary= {31,28,31,30,31,30,31,31,30,31,30,31};
            //判断闰年
            if(year%4==0) dayary[1]=29;
            int total=0;
            for(int i=0;i<month-1;i++) {
                total+=dayary[i];             // 1到month-1月的天数
            }
            total+=day;                       // month月的天数
            return total;
        }
    
    }

2 测试

2012
    12
    31
    366

**公共字串计算**

1 程序

import java.util.Scanner;
     
     
    public class Main{
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            while(scan.hasNextLine()){
                String str1 = scan.nextLine();
                String str2 = scan.nextLine();
                String shortStr = "";
                String longStr = "";
                if(str1.length()<str2.length()){
                    shortStr = str1;
                    longStr = str2;
                }else{
                    shortStr = str2;
                    longStr = str1;
                }
                System.out.println(findLongStr(shortStr.toLowerCase(),longStr.toLowerCase()));
            }
        }
        // 第一个参数是短串，第二个参数是长串
        /*
        abcd   length = 4  abcd  abc bcd  ab bc cd a b c d  就是这样去找短串的子串
        abcde
        */
        private static int findLongStr(String shortStr,String longStr) {
            int length = shortStr.length();   // 短串长度
            String subShortStr;    //短串的子串 
            // 第1轮  ，长度为length的短串，循环1次
            // 第2轮  ，长度为length-1的短串，循环2次
            // 第i轮  ，长度为length-i+1的短串，循环i次
            // 第length轮，长度为1的短串，循环length次
            for(int i=1;i<=length;i++){  // 所以，外层循环从1开始，循环length次
                for(int j=0;j<=i-1;j++){   // 所以，内层循环从0开始，循环i次  ，其中j代表短子串首字符的位置
                    subShortStr = shortStr.substring(j,j+(length-i+1));  
                    if(longStr.contains(subShortStr)){
                        return subShortStr.length();
                    }
                }
            }
            return 0;
        }
    }

2 测试

hdfjkf
    fdjsl
    1

**尼科彻斯定理**

1 程序

import java.util.Scanner;
    
    public class Main{
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            while(scan.hasNext()){
                // 输入的数n
                int n  = scan.nextInt();
                GetSequeOddNum(n);
            }
        }
        
        public static void GetSequeOddNum(int n){
            int temp = 0;
            // 经过数学计算，第1个奇数为n*n-n+1
            StringBuffer br = new StringBuffer();
            int m = n*n-n+1;
            for(int i = 0;i<n-1;i++){
                temp = m+2*i;
                br.append(temp).append("+");   // 注意，这里要用StringBuffer，否则通不过
                
            }
            br.append(temp+2);
            System.out.println(br.toString());
        }
    }

2 测试

8
    57+59+61+63+65+67+69+71

**超长正整数相加**

1 程序

import java.util.*;
    import java.math.*;
    
    public class Main{
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            while(scan.hasNextLine()){
                String str=scan.nextLine();
                BigInteger a = new BigInteger(str.trim());   // 读入第一个大数
                BigInteger b = new BigInteger(scan.nextLine().trim());     // 读入第二个大数
                System.out.println(a.add(b).toString());          // 两个大数的相加还是大数
            }
            scan.close();
        }
    }

2 测试

53478
    546546545
    546600023

**整形数组合并**

1 程序

import java.util.*;
    
    public class Main{
        public static void main(String[] args){
            Scanner scan = new Scanner(System.in);
            while(scan.hasNextInt()){
                TreeSet<Integer> list = new TreeSet<Integer>();  // 这句必须放在while循环内，否则运行错误
                StringBuffer sb= new StringBuffer();            // 这句必须放在while循环内，否则运行错误
                int n1 = scan.nextInt();   // 第一个数的个数
    
                for(int i=0;i<n1;i++){
                    int curr = scan.nextInt();     // 第一组数
                    list.add(curr);
                }
    
                int n2 = scan.nextInt();     //第二个数的个数
                for(int i=0;i<n2;i++){
                    int curr = scan.nextInt();     // 第二组数
                    list.add(curr);
                }
                for(Integer c:list){
                    sb.append(c);           // 一定要用StringBuffer，否则编译不过
                }
                System.out.println(sb);
    
            }
            scan.close();
        }
    }

2 测试

3
    1 2 5
    4
    -1 0 3 2
    -101235