java经典练习题

 

1.1 问题

　　实现两个变量间的数据交换，例如：有两个整数类型变量a和b，现需要使变量a的值和变量b的值进行交换。例如： a的原值为100，b的原值为200，交换后a的值为200，b的值为100。

　　不使用中间变量来实现数据交换程序，即实现两个变量值的交换。可以先把a+b值赋给a，接着把a-b的值赋给b，最后把a-b的值在赋给a，请看如下代码：

public class SwapExt {
    public static void main(String[] args) {
        int a = 100;
        int b = 200;
        System.out.println("a=" + a + ", b=" + b);
        a = a + b;
        b = a - b;
        a = a - b;
        System.out.println("a=" + a + ", b=" + b);
    }
}

2.1 问题

　　使用交互的方式计算*落体运动中物体的位置。用户从控制台输入*落体的时间t，系统计算经过时间t物体的*落体位移。计算结果保留一位小数并且输出到控制台。*落体位移公式为： s = 1/2 × g × t2 ，其中：

s (位移（m）

t (时间（s）

g (重力加速度（9.8m/s2）

import java.util.Scanner;
public class FreeFall {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double g = 9.80;
        System.out.println("请输入*下落的时间（秒）：");
        double t = scanner.nextDouble();
        double s = 0.5 * g * t * t;
        s = Math.round(10 * s) / 10.0;//保留一位小数
        System.out.println(t + "秒后，物体*下落了" + s + "米");
    }
}

3.1 问题

　　系统使用交互的方式给三个数字进行排序。例如：接收用户输入的三个整数a，b，c，a的原值是20，b的原值是5，c的原值是10，排序后a的值为5，b的值为10，c的值为20。

1. import java.util.Scanner;
2. public classMaxofThree {
3.     public static void main(String[] args) {
4.         Scannerscanner = new Scanner(System.in);
5.         System.out.println("请依次输入三个整数：a，b，c（以空格隔开）");
6.         int a = scanner.nextInt();
7.         int b = scanner.nextInt();
8.         int c = scanner.nextInt();
9.         scanner.close();
10.         System.out.println("a=" + a + ", b=" + b + ", c=" + c);
11.         int temp = 0;
12.         if (a > b) {
13.             temp = a;
14.             a = b;
15.             b = temp;
16.         }
17.         if (a > c) {
18.             temp = a;
19.             a = c;
20.             c = temp;
21.         }
22.         if (b > c) {
23.             temp = b;
24.             b = c;
25.             c = temp;
26.         }
27.         System.out.println("a=" + a + ", b=" + b + ", c=" + c);
28.     }
29. }

水仙花数问题

import java.util.Scanner;
public class Test { 
    /**
     * 业务要求：计算某个范围内所有水仙花数
     * 分析：1、找某个范围的水仙花数需要把这个范围内的每个数取出来判断，所以需要一个for循环取数，
     *         从1开始到控制台输入的值（定义为range）。
     *         2、判断某个数是不是水仙花数需要将该数的每一位都取出来，取出来的方法是定义一个变量last，
     *         用来存这个数对10的余数，然后该数/10再对10取余数。。。这也是个循环，直到这个数变成零循环
     *         停止。所以我们定义一个变量num用来存取出来的i的值，每次取余后都对num进行/10操作，当
     *         num==0时循环停止，便可以写出for(int num=i;num>0;num/=10){}，取出来的每一位都要
     *         求出自己的三次幂，再求和
     *         3、得到的和sum需要与i比较，若相等，则打印出来
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入查找水仙花的范围：0~");
        int range = in.nextInt();
        in.close();
        for (int i = 1; i < range; i++) {
            int sum = 0;// 注意变量定义和赋初值的位置
            for (int num = i; num > 0; num /= 10) {
                int last = num % 10;
                sum += last * last * last;// 每一轮开始sum都要清零
            }
            if (sum == i) {
                System.out.println(i + "是水仙花数");
            }
        }
    }
}

计算百钱买百鸡的问题

public class Test { 
    /**
     * 业务要求：计算百钱买百鸡
     * 分析：假设公鸡x只，母鸡y只，小鸡z只，那么必须满足x+y+z=100,5x+3y+z/3=100，并且z能整除3。
     *      用穷举法，从0开始一个一个带入去试，能满足条件就输出。
     *      如果都是公鸡的话，100钱只能买20只，所以0<=x<20
     *      如果是母鸡的话，100钱只能买30只，所以0<=y<300
     *      如果是小鸡的话，就是100只减去x再减去y
     */
    public static void main(String[] args) {
        for(int x=0;x<20;x++){
            for(int y=0;y<30;y++){
                int z = 100-x-y;
                if((z%3==0)&&(5*x+3*y+z/3==100)){
                    System.out.println("公鸡："+x+"，母鸡："+y+"，小鸡："+z);
                }
            }
        }        
    }
}

猜字母游戏

import java.util.Random;
import java.util.Scanner;

public class Test {
    /**
     * 业务要求：猜字母游戏
     *         系统随机产生5个不重复的字符，然后由用户输入一个5个字符的字符串，由程序判断这5个字符
     *         和系统产生的5是否相同（字母和位置均相同）。如果相同，程序结束，如果不相同， 则输出比较结果以提示用户继续游戏。 
     * 分析： 
     *         1) char[] answer 被猜测字母序列 
     *        2) char[] input 用输入的字母序列 
     *        3) int count 猜测次数 
     *        4) int[] result = {字符匹配数量，匹配成功位置} 用户输入的序列和被猜测序列的比较结果 
     *功能分析设计：
     *   1）随机生成 (generate)
     *      方法算法功能描述：生成n个不重复的大写字母
     *      char[] generate(int n)
     *   2）用户输入(Input)
     *          方法算法功能描述：从控制台读取输入，返回5个大写字符
     *      char[] userInput()
     *   3）检查(check)用户输入
     *   方法算法功能描述：检查标准答案（answer）和用户输入
     *   （input），返回结果：{字符匹配数量，匹配成功位置} 
     *      int[] check(char[] answer, char[] input)
     *   4）提示猜中情况
     *     void show(int count, int[] result)
     *   5) main 方法完成猜测流程控制
     *         1）"生成答案"字符序列：5个字符
     *         2）等待用户的答案输入
     *         3）"检查用户输入"的答案，检查结果包含 匹配数量和匹配位置
     *         4) 统计回答数量
     *         5) 提示检查结果, 返回 (2)
     */
    public static void main(String[] args) {
        char[] answer;
        char[] input;
        int count=0;
        int[] result;
        answer = generate(5);//1)“生成答案”字符序列：5个字符
        System.out.println(answer);
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
        System.out.println("\t欢迎使用猜字母游戏");
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
        while (true) {
            input = userInput();//2)等待用户的答案输入
            result = check(answer,input);//“检查用户输入”的答案
            count++;
            show(count, result);//提示检查结果
            if(result[0]==5&&result[1]==5){
                break;//猜对退出
            }
        }
    }
    public static char[] generate(int n) {
        Random r = new Random();
        char[] letter = new char[26];
        char[] answer = new char[5];
        boolean[] used = new boolean[letter.length];
        for (int i = 0; i < 26; i++) {
            letter[i] = (char) (i + 65);
        }
        int num,index=0;
        do{
            num = r.nextInt(letter.length);
            if(used[num]){
                continue;
            }
            answer[index++] = letter[num];
            used[num] = true;
        }while(index!=n);
        return answer;
    }
    public static char[] userInput() {
        Scanner in = new Scanner(System.in);
        char[] input = new char[5];
        String str = in.nextLine();
        while (str.length() != 5) {
            System.out.println("您输入的字母长度不对，请重新输入");
            str = in.nextLine();
        }
        input = str.toCharArray();
        return input;
    }
    public static int[] check(char[] answer, char[] input) {
        int[] result = new int[2];
        for (int i = 0; i < answer.length; i++) {
            for (int j = 0; j < input.length; j++) {
                if (input[j] == answer[i]) {
                    result[0]++;
                    if (j == i) {
                        result[1]++;
                    }
                    break;//一旦找到一样的，就不用继续比对了
                }
            }
        }
        return result;
    }
    public static void show(int count,int[] result) {
        System.out.println("猜测"+count+"次");
        System.out.println("你猜对了" + result[0] + "个字符，其中" + result[1]
                + "个字符位置正确");
        if(result[0]==5&&result[1]==5){
            System.out.println("恭喜，猜中！");
        }
    }
}

求质数

public class Test {
    /**
     * 业务要求：求某个范围内的所有质数
     *         质数是只有1和自己本身两个约数的整数
     * 
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入查找质数的范围：2~");
        int num = in.nextInt();
        in.close();
        for(int i=2;i<num;i++){
            boolean isPrime = true;
            for(int j=2;j<=(int)Math.sqrt(i);j++){
                System.out.println("......"+(int)Math.sqrt(i));
                if(i%j==0){
                    isPrime = false;
                    break;
                }
            }    
            if(isPrime){
                System.out.println(i+"是质数");}
        }
    }
}

求两个整数的最大公约数

import java.util.Scanner;
public class CommonDivisor  {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int first = scanner.nextInt();
        System.out.println("请输入第二个整数：");
        int second = scanner.nextInt();
        scanner.close();
        // 从两个整数中较小的数开始
        int start = first > second ? second : first;
        int n = 1;
        for (n = start; n >= 1; n--) {
            // 判断n是否是两个整数的约数
            if ((first % n == 0) && (second % n == 0))
                break;
        }
        System.out.println(first + "和" + second
                    + "的最大公约数为：" + n);
   }
}