找工作 50道编程题Java实现（32-50）

 

程序32 左移右移

题目：取一个整数a从右端开始的4～7位。
分析：比如取123456789从右端开始的4～7位即：3456

package test50;
/*
 * 题目：取一个整数a从右端开始的4～7位。
 * 分析：比如取123456789从右端开始的4～7位即：6543
 */
public class test32 {

    public static void main(String[] args) {
        long num=123456789;
        quzhi(num);
    }
    
    public static void quzhi(long number){
        String s =Long.toString(number);//将Long型转化成字符串
        char[] arr=s.toCharArray();//将字符串转化成数组
        if(arr.length<7){
            System.out.print("输入整数不满足条件");
        }
        for(int i=arr.length-4;i>=arr.length-7;i--){
            System.out.print(arr[i]+" ");
        }
    }
}

程序33 杨辉三角

题目：打印出杨辉三角形（要求打印出10行如下图）

package test50;
/*
 * ％4d代表在4个空格内打印数字。我们选择4，因为我们知道10行杨辉三角形的最大数字的最大位数是3位数。
 * System.out.format("%24s: %s%n", "fefe","fwefrr");
   "%24s: %s%n"的解释：
   %24s:表示输出24个空格，s为替换的字符串
   %s：表示字符串，即替换的内容
   %n：表示换行
 */
public class test33 {

    public static void main(String[] args) {
        int rows = 10;
        for(int i =0;i<rows;i++) {
            int number = 1;
            //打印空格字符串
17             System.out.format("%"+(rows-i)*2+"s","");
            for(int j=0;j<=i;j++) {//打印每一行得数字
                System.out.format("%4d",number);//打印当前数字
20                 number = number * (i - j) / (j + 1);//计算下一位数字
                }
            System.out.println();//换行
            }
        }
    }

程序34 三个数排序

略

程序35 最大最小交换

题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
分析: 例如输入6 4 8 3 9 7
交换后输出9 4 8 7 6 3

package test50;

import java.util.Scanner;

/*
 * 题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
 * 分析: 例如输入6 4 8 3 9 7
 * 交换后输出9 4 8 7 6 3
 */
public class test35 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input=new Scanner(System.in);
        System.out.println("请输入数组元素个数：");
        int num=input.nextInt();
        System.out.print("请输入数组：");
        int[] arr=new int[num];
        for(int i =0;i<num;i++) {
             arr[i]=input.nextInt();
        }
        input.close();
        arrchange(arr);
    }
    
    public static void arrchange(int[] arr){
        int temp=0;
        int max=arr[0]; int min=arr[0];
        int maxIndex=0; int minIndex=0;
        //找出原数组arr的最大值、最小值位置
        for(int i =0;i<arr.length;i++){
            if(max<arr[i]){//找到数组的最大值索引
                max=arr[i];
                maxIndex=i;
            }
            if(min>arr[i]){//找到数组的最小值索引
                min=arr[i];
                minIndex=i;
            }
        }
        if(arr[0]!=max){//如果最大值不是第一个
            arr[maxIndex]=arr[0];
            arr[0]=max;
        }
        if(arr[arr.length-1]!=min){//如果最小值不是最后一个
            arr[minIndex]=arr[arr.length-1];
            arr[arr.length-1]=min;
        }
        for(int k=0;k<arr.length;k++){
            System.out.print(arr[k]+" ");
        }
    }
    
}

程序36 移动位置

题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
分析:比如有4个数n=4;
1 2 3 4
各个数向后移动2位m=2，变为
    1 2 3 4
将最后m个数，即将最后2个数变成前面的2个数变为
3 4 1 2

package test50;
/*
 * 题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
 */
import java.util.Scanner;
public class test36 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入数组的长度：");//定义数组长度
        int num = input.nextInt();
        int [] arr = new int[num];
        System.out.println("请输入数组元素：");//键入数组元素
        for (int i = 0; i < num; i++) {
            arr[i] = input.nextInt();
        }
        System.out.println("您输入的数组是：");//打印数组
        for (int j = 0; j < arr.length; j++) {
            System.out.print(arr[j] + " " );
        }
        System.out.println("请输入移动的位数：");//获取移动位数
        int m = input.nextInt();
        int [] arr2 = new int[num]; 
        for (int k = 0; k < m; k++) {//把向前移动的转移进新数组
            arr2[k] = arr[num - m + k];
        }
        for (int k2 = 0; k2 < num - m; k2++) {//把向后移的插入到新数组
            arr2[m+k2] = arr[k2];
        }
        System.out.println("移动后的数组为：");
        for (int l = 0; l < arr2.length; l++) {
            System.out.println(arr2[l]);
        }
    }
}

程序37 报数*****

* 题目：有n个人围成一圈，顺序排号。
* 从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
* 分析：最后留下的是第n号那位

package test50;
/*
 * 题目：有n个人围成一圈，顺序排号。
 * 从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
 * 分析：最后留下的是第n号那位
 */

import java.util.Scanner;
public class test37 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入总人数：");//定义数组长度
        int num = input.nextInt();
        //定义数组，用其中的元素标记是否已经被淘汰，0表示为被淘汰
        int [] arr = new int[num];
        for (int i = 0; i < num; i++) {//初始化数组元素都是1
            arr[i] = 1;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        int index = 0;
        int sum = 0;
        while(num > 1 )//用来控制剩余的人数
        {
            if (arr[index] == 1) {  //第index位置有人报数，如果arr[index]！= 1，表示index位置的人已经退出圈子
                sum++;  //有人报数，sum就要加1
                if (sum == 3) {//如果是3，则重新记，从1开始
                    sum = 0; 
                    arr[index] = 0; 
                    num-- ;//满足3个，总人数就减1
                }
            }
        index++ ;//指向下一个位置
        if (index == arr.length) {//如果索引是数组的长度，则从0开始,（实际上，索引数最大为arr.length-1）
            index = 0 ;//实际上实现了循环遍历。如有人甲乙丙丁戊。当index=4时，下一次索引就指向0，让甲报数，而甲可能退出圈子，可能还在
        }
        }//while(num > 1 )结束
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 1) {
                System.out.println("第"+(i+1)+"留了下来");
            }
        }
    }
}

程序38 求字符串长度

题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。

package test50;
/*
 * 题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。
 */

import java.util.Scanner;
public class test38 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = input.nextLine();
        System.out.println("该字符串的长度是："+getArrLength(str));
    }
    public static int getArrLength(String str)
    {
        char[] charStr = str.toCharArray();
        return charStr.length;
    }
}

程序39 分数累加

题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n,当输入n为奇数时，调用函数1/1+1/3+...+1/n

递归如何实现

package test50;

import java.util.Scanner;

/*
 * 编写一个函数，输入 n 为偶数时，调用函数求 1/2+1/4+...+1/n,当输入 n 为奇数时，调用函数 1/1+1/3+...+1/n
 */
public class test39 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int num = input.nextInt();
        double sum=0.0;
        System.out.println(getsum(num,sum));
        }
    
    public static double getsum(int number,double sum){
        while(number>0){
            sum+=(double)1/number;
            number=number-2;
            getsum(number,sum);
        }
        return sum;
   }
        

}

程序40

题目：根据字符串内字符的ASCII码值对字符串数组进行排序。

package test50;
/*
 * 题目：根据字符串内字符的ASCII码值对字符串数组进行排序。
分析：字符串用ASCII码比较大小，规则是：
1、比较首字母的ASCII码大小
2、若是前面的字母相同，则比较之后的字母的ASCII码值
3、若是一个字符串从首字母开始包含另一个字符串，则认为字符串长度较长的大；例 ：ab > a
备注：Java中String类有一个compareTo方法，该方法返回一个int类型的数据。
其比较规则是：拿出字符串的第一个字符与参数的第一个字符进行比较，
如果两者不等，比较结束，返回两者的ascii差，即字符串的第一个字符减去参数的第一个字符的ascii码值.
如果相等，则比较第二个字符，以此类推。比较到最后还是相等的，方法返回值为0。
比如下面的代码：“abc”.compareTo(“cad”)==-2
这里有一点需要注意：如果两个字符串的长度不同，并且一个字符串与另一个字符串的前面N个字符相等，那么这个方法返回返回两个字符串长度之差。
比如下面的代码：“fa”.compareTo(“f”)==1
 */

public class test40 {

    public static void main(String[] args) {
        String[] str = {"abc","cad","m","fa","f"};
        for(int i=str.length-1;i>=1;i--){
            for(int j=0;j<=i-1;j++){
                //注意compareTo函数在这里的作用
                if(str[j].compareTo(str[j+1])<0){
                    String temp = str[j];
                    str[j] = str[j+1];
                    str[j+1] = temp;
                }
            }
        }
        //此处使用了增强for循环遍历数组元素
        for(String subStr:str)//定义了一个String类型的变量接收遍历后的数组元素
            System.out.print(subStr+" ");//将遍历后的数组元素依次输出
    }
}

题目41：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。
* 第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，
* 第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？

采用递归

public class Prog41 {
    public static void main(String[] args) {
        //第一只猴子分桃时,调用函数fun(1)求得桃数
        System.out.println("最初海滩上共有"+fun(1)+"个桃子");
    }
    //递归函数
    public static int fun(int i) {
        if(i==5) {
            return 6;//轮到第五只猴子分桃时，至少得6个桃
        }else {
            return fun(i+1)*5+1;
        }
    }
}
/*运行结果
最初海滩上共有3906个桃子
*/

冒泡

package test50;
/*
 * 题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。
 * 第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，
 * 第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？
 * 分析：求最少的桃子数，则第五个猴子分桃时，手上一共有6个桃
 * 利用递归法可求得最初的桃数
 */
public class test41 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int sum5=6;//求最少的桃子数，则第五个猴子分桃时，手上一共有6个桃
        System.out.print("海滩上原来最少有多少个桃子:"+getsum(sum5));

    }
    public static int getsum(int sum){
        for(int i=4;i>=1;i--){
            sum=sum*5+1;
        }
        return sum;
    }

}

题目42：809*??=800*??+9*??+1其中??代表两位数，若有这样得数，求??代表的两位数

package test50;
/*
 * 809*??=800*??+9*??+1其中??代表两位数，若有这样得数，求??代表的两位数
 */
public class test42 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        boolean  flag=false;
        int n=0;
        for(int i=10;i<=99;i++){
            if(809*i==800*i+9*i+1){
                flag=true;
                n=i;
                break;
                }
            }
        if(flag){
            System.out.print("有这样得数:"+n);
        }else 
            System.out.print("不存在这样得数");

    }

}

题目43：求0—7所能组成的奇数个数,奇数中不包含重复数字。

package test50;
/*
 * 题目：求0—7所能组成的奇数个数,奇数中不包含重复数字。
 */
public class test43 {
    public static void main(String[] args) {
        //0-7能组成的所有不重复的数的最大值是76543210
        //0-76543210中所有的奇数个数为76543210/2
        String[] s=new String[76543210/2];//定义一个字符串数组存储0-7能组成的所有奇数
        int n=0;//定义一个变量为满足条件的奇数计数
        int count=0;
        //将所有奇数转换成字符串存入字符串数组s中
        for(int i=1;i<=76543210;i++) {
            if((i+1)%2==0) {
                s[n]=String.valueOf(i);
                n++;
            }
        }
        //将所有的字符串数组中的元素取出分别存入一个字符数组c中
        for(int j=0;j<n;j++) {
            char[] c= s[j].toCharArray();
            outer:for(int k=0;k<c.length;k++) {
                for(int m=1;m<c.length;m++) {
                    if(c[k]==c[m]) {//将字符数组中的每个元素取出，一旦发现重复值退出循环
                        break outer;//一个break语句只能跳出一个for循环,因此这里使用 break outer,跳到28行
                    }
                }
                count++;//若该字符数组中不存在重复的元素，则该奇数为满足条件的奇数
            }
        }
        System.out.println("0-7所能组成的不包含重复数字的奇数个数共有："+count+"个");
    }
}
/*运行结果
0-7所能组成的不包含重复数字的奇数个数共有：18567220个
*/

题目44：一个偶数总能表示为两个素数之和。

package test50;

import java.util.Scanner;

/*
 * 题目：一个偶数总能表示为两个素数之和。
 * 分析：一个偶数可能会有不止一对两个素数之和的情况
 * 例如：20=3+17 20=7+13

 */
public class test44 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input=new Scanner(System.in);
        System.out.print("请输入一个偶数num：");
        int num=input.nextInt();
        if(num%2!=0){
            System.out.print("输入的数不是偶数");
            return;
        }
        for(int i=2;i<num;i++){
            if(isPrimeNumber(i) && isPrimeNumber(num-i)){
                System.out.println(num+"="+i+"+"+(num-i));
            }
        }

    }
    
    public static boolean isPrimeNumber(int n){
        if(n < 2) return false;; 
        for(int i=2;i<=n/2;i++){
            if(n%i==0){
                return false;//不是素数
            }
        }
        return true;
    }

}

题目45：判断一个素数能被几个9整除
分析：素数只能被1和其本身整除，不能被9整除，所以返回false

import java.util.Scanner;
public class Prog45{
    public static void main(String[] args){
        System.out.print("请输入一个素数：");
        Scanner scan = new Scanner(System.in);
        int n=scan.nextInt();
        if(!isPrime(n)) {
            System.out.println("你输入的不是素数，请重新输入");
            n=scan.nextInt();
        }
        scan.close();
        System.out.println("素数"+n+"能被9整除吗？"+zhengchu(n));
    }
    //判断素数是否能被9整除
    private static boolean zhengchu(int n) {
        return n%9==0;
    }
    //判断输入的数是否是素数
    private static boolean isPrime(int n){
        boolean flag = true;
        for(int i=2;i<Math.sqrt(n)+1;i++){
            if(n%i==0){
                flag = false;
                break;
            }
        }
        return flag;
    }
}
/*运行结果
请输入一个素数：11
素数11能被9整除吗？false
*/

程序46 字符串连接*

题目：编写一个两个字符串连接的程序

package test50;

import java.util.Scanner;

/*
 * 题目：编写一个两个字符串连接的程序
 */
public class test46 {
     public static void main(String[] args){
         Scanner input=new Scanner(System.in);
         System.out.print("输入2个字符串：");
         String s1=input.nextLine();
         String s2=input.nextLine();
         input.close();
         String s3=s1+s2;
         System.out.print("连接后的字符串："+s3);
        
     }

程序47 输入数字打印星号

题目：读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的＊。

package test50;

import java.util.Scanner;

/*
 * 题目：读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的＊。
 */
public class test47 {
    public static void main(String[] args){
         System.out.print("请输入7个整数(1-50)：");
         Scanner scan = new Scanner(System.in);
         int n1 = scan.nextInt();
         int n2 = scan.nextInt();
         int n3 = scan.nextInt();
         int n4 = scan.nextInt();
         int n5 = scan.nextInt();
         int n6 = scan.nextInt();
         int n7 = scan.nextInt();
         scan.close();
         printStar(n1);
         printStar(n2);
         printStar(n3);
         printStar(n4);
         printStar(n5);
         printStar(n6);
         printStar(n7);
    }
    static void printStar(int m){
        System.out.println(m);
        for(int i=0;i<m;i++)
            System.out.print("*");
        System.out.println();
    }


}

package test50;

import java.util.Scanner;

/**
 * @author VellBibi
 *【程序47】 TestPrint.java
 *题目：读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的＊。
 */
public class TestPrint {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int[] a = new int[7];
        for(int i=0; i<7; i++){
            System.out.print("输入第"+(i+1)+"个整数：");
            a[i] = s.nextInt();
        }
        
        for(int i=0; i<7; i++){
            for(int j=0; j<a[i]; j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }

}

程序48 数字加密

题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，
加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。
分析：例如原始数据是： 6 7 8 9（原始数据）
每个数加上5后为：11 12 13 14
除以10后为： 1 2 3 4
交换位置之后 4 3 2 1（加密后的数据）

package test50;

import java.util.Scanner;

/*
 * 题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，
 * 加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。
 * 分析：例如原始数据是： 6 7 8 9（原始数据）
 * 每个数加上5后为：11 12 13 14
 * 除以10后为： 1 2 3 4
 * 交换位置之后 4 3 2 1（加密后的数据）
 */
public class test48 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int temp=0;
         System.out.println("请输入0到9间的4个整数:");
         Scanner scan = new Scanner(System.in);
         int[] arr=new int[4];
         for(int i=0;i<=3;i++){
             arr[i]=scan.nextInt();
         }
         scan.close();
         for(int i=0;i<=3;i++){
             arr[i]=(arr[i]+5)%10;
         }
         //将第一位和第四位交换
         temp=arr[0];
         arr[0]=arr[3];
         arr[3]=temp;
         //第二位和第三位交换
         temp=arr[2];
         arr[2]=arr[1];
         arr[1]=temp;
         
         for(int i=0;i<=3;i++){
             System.out.print(arr[i]+" ");
         }
    }

}

程序49 子串出现的个数

题目：计算首末不含空格各个子串之间只含一个空格的字符串中子串出现的次数
分析：例如输入的字符串为"I come from County DingYuan Province AnHui."
空格隔断的即为字符子串，所以上述字符串的子串个数有7个

package test50;
/*
 * 题目：计算首末不含空格各个子串之间只含一个空格的字符串中子串出现的次数
 * 分析：例如输入的字符串为"I come from County DingYuan Province AnHui."
 * 空格隔断的即为字符子串，所以上述字符串的子串个数有7个
 */
public class test49{
    public static void main(String[] args){
        String str="I come from County DingYuan Province AnHui.";
        int count=0;
        char[] ch=str.toCharArray();//将字符串转换成字符数组
        for(int i=0;i<ch.length;i++) {
            if(ch[i]==' ')//计算字符串中的空格个数
                count++;
        }
        count++;//字符串中子串的个数=空格数+1
        System.out.println("共有"+count+"个字符子串");
    }
}
/*运行结果
共有7个字符子串
*/

思路：转换成数组，利用

 if(ch[i]==' ')

计算空格数

程序50 文件IO

题目：有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），计算出平均成绩，将原有的数据和计算出的平均分数存放在磁盘文件"stud"中。

package test50;

import java.io.*;
public class test50{
    //定义学生模型
    String[] number = new String[5];
    String[] name = new String[5];
    float[][] grade = new float[5][3];
    float[] sum = new float[5];
    public static void main(String[] args) throws Exception{
        test50 stud = new test50();
        stud.input();
        stud.output();
    }
    //输入学号、姓名、成绩
    void input() throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //录入状态标识
        boolean isRecord = true;
        while(isRecord){
            try{
                for(int i=0;i<5;i++){
                    System.out.print("请输入学号：");
                    number[i] = br.readLine();
                    System.out.print("请输入姓名：");
                    name[i] = br.readLine();
                    for(int j=0;j<3;j++){
                        System.out.print("请输入第"+(j+1)+"门课成绩：");
                        grade[i][j] = Integer.parseInt(br.readLine());
                    }
                    System.out.println();
                    sum[i] = grade[i][0]+grade[i][1]+grade[i][2];
                }
                isRecord = false;
            }catch(NumberFormatException e){
                System.out.println("请输入一个数字！");
            }
        }
    }
    //输出文件
    void output() throws IOException{
        FileWriter fw = new FileWriter("D:\JavaEE\Code\Java基础50道经典练习题\src//stud.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write("No.  "+"Name  "+"grade1  "+"grade2  "+"grade3  "+"average");
        bw.newLine();
        for(int i=0;i<5;i++){
            bw.write(number[i]);
            bw.write("  "+name[i]);
            for(int j=0;j<3;j++)
                bw.write("  "+grade[i][j]);
            bw.write("  "+(sum[i]/5));
            bw.newLine();
        }
        bw.close();
    }
}