Java循环结构基础题

1、编写一个Java程序，计算1到100以内的所有素数和，并输出结果。

public class PrimeNumberSum {
    public static void main(String[] args) {
        int sum = 0;
        
        for (int number = 2; number <= 100; number++) {
            if (isPrime(number)) {
                sum += number;
            }
        }
        
        System.out.println("1到100以内的所有素数的和为：" + sum);
    }
    
    private static boolean isPrime(int number) {
        if (number <= 1) {
            return false;
        }
        
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0) {
                return false;
            }
        }
        
        return true;
    }
}

在上述代码中，我们首先定义了一个整数变量 sum，用于存储素数的和，并初始化为0。

然后，我们使用一个外层循环，从2开始遍历到100。

在每次循环中，我们调用 isPrime 方法来判断当前的数 number 是否为素数。如果是素数，则将其加到 sum 中。

在 isPrime 方法中，我们首先判断 number 是否小于等于1，若是，则直接返回 false，因为小于等于1的数不是素数。

然后，通过一个内层循环，从2遍历到 number 的平方根，逐个判断 number 是否能被这些数整除。如果能够整除，则 number 不是素数，返回 false。如果找不到能够整除的数，则 number 是素数，返回 true。

最后，我们在主方法中打印输出素数的和。

运行上述代码，将会得到1到100以内所有素数的和，输出为：1060。

也可以根据实际需求修改代码中的范围，例如计算1到200的素数和，只需将循环条件修改为 number <= 200 即可。

2、编写一个Java程序，输出所有的水仙花数。

（水仙花数：指一个三位数，它的每个位数上的数字的3次幂之和等于它本身）

public class NarcissisticNumber {
    public static void main(String[] args) {
        System.out.println("所有的水仙花数为：");
        for (int number = 100; number <= 999; number++) {
            if (isNarcissistic(number)) {
                System.out.println(number);
            }
        }
    }
    
    private static boolean isNarcissistic(int number) {
        int originalNumber = number;
        int n = String.valueOf(number).length();
        int sum = 0;
        
        while (number > 0) {
            int digit = number % 10;
            sum += Math.pow(digit, n);
            number /= 10;
        }
        
        return originalNumber == sum;
    }
}

在上述代码中，我们使用一个外层循环，从 100 开始遍历到 999。

在每次循环中，我们调用 isNarcissistic 方法来判断当前的数 number 是否为水仙花数。如果是水仙花数，则将其输出。

在 isNarcissistic 方法中，我们首先将原始的数 number 保存在 originalNumber 变量中，以便最后进行比较。

然后，我们计算 number 的位数 n，通过将其转换为字符串，获取字符串的长度。

接下来，我们使用一个循环，从 number 的个位数开始逐个提取每一位的数字，计算每一位的 n 次幂之和。在每一次循环中，我们使用取模运算和除法运算对数字进行提取和更新。

最后，我们将计算出的 sum 和原始的 number 进行比较。如果相等，则 number 是水仙花数，返回 true。否则，返回 false。

3、编写一个Java程序，生成一个斐波那契数列，并将前n个数字输出，斐波那契数列的前两个数字是1和1，后续的数字是前两个数字之和。

（斐波那契数列：又称黄金分割数列，因数学家莱昂纳多.斐波那契以兔子繁殖为例子而引入，故又称“兔子数列”，其数值为：1、1、2、3、5、8、13、21、34......）

public class FibonacciSeries {
    public static void main(String[] args) {
        int n = 10; // 前n个斐波那契数字
        
        System.out.println("斐波那契数列的前 " + n + " 个数字为：");
        generateFibonacci(n);
    }
    
    private static void generateFibonacci(int n) {
        int firstNum = 1;
        int secondNum = 1;
        
        System.out.print(firstNum + " " + secondNum + " ");
        
        for (int i = 3; i <= n; i++) {
            int nextNum = firstNum + secondNum;
            System.out.print(nextNum + " ");
            
            firstNum = secondNum;
            secondNum = nextNum;
        }
    }
}

 

在上述代码中，我们首先定义了整数变量 n，表示要输出斐波那契数列的前 n 个数字。

然后，在主方法中，我们调用 generateFibonacci 方法，并将 n 作为参数传递。该方法将会生成斐波那契数列并输出前 n 个数字。

在 generateFibonacci 方法中，我们首先定义了斐波那契数列的前两个数字 firstNum 和 secondNum，并初始化为1。

然后，我们打印输出前两个数字 firstNum 和 secondNum。

接下来，我们使用一个循环，从第三个数字开始生成斐波那契数列，直到第 n 个数字。在每次循环中，我们将第一个数字 firstNum 和第二个数字 secondNum 相加，得到下一个数字 nextNum，并打印输出。

然后，我们将 firstNum 更新为原来的 secondNum，将 secondNum 更新为原来的 nextNum，以便继续生成下一个数字。

最后，我们将得到的斐波那契数列的前 n 个数字输出。

4、李四每天跑步，第一周第一天跑一百米，周二到周天每天比前一天多100米，往后每周比前一周周一多100米，请问李四n（控制台输入）天跑了多少米？

import java.util.Scanner;

public class RunningDistance {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入天数n：");
        int n = scanner.nextInt();
        scanner.close();

        int distance = calculateDistance(n);
        System.out.println("李四在" + n + "天内跑了" + distance + "米");
    }

    private static int calculateDistance(int n) {
        int distance = 0;
        int day = 1; // 第一天
        int increment = 100; // 每天的距离递增值
        int week = 1; // 第一周

        for (int i = 1; i <= n; i++) {
            distance += increment;
            day++;

            if (week > 1 && day > 7) {
                // 每周的第一天距离递增100米
                increment += 100;
                week++;
                day = 1;
            } else if (day > 7) {
                week++;
                day = 1;
            }
        }

        return distance;
    }
}

 

在上述代码中，我们首先向用户请求输入一个整数 n，表示天数。

然后，我们调用 calculateDistance 方法，将用户输入的天数作为参数传递。该方法将返回李四在 n 天内跑的总距离。

在 calculateDistance 方法中，我们定义一个整数变量 distance，用于存储总距离，并初始化为0。另外，我们定义 day、increment 和 week 三个变量用于辅助计算。

然后，我们使用一个循环进行 n 次迭代，每次迭代计算当天的距离，并将其加到 distance 中。在每次迭代中，day 加1，表示过了一天。

如果当前是第二周或以上，并且 day 大于7，说明跑完一周，我们将 increment 增加100米，并更新 week 和 day 的值，以便记录新的一周的状态。

最后，我们返回计算得到的 distance。

最后，我们将在控制台打印输出李四在 n 天内跑的总距离。

5、输入一个数字，和位数，判断这个数是否回文数字？（1221就是回文数字）

import java.util.Scanner;

public class PalindromeNumber {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个数字：");
        int number = scanner.nextInt();
        System.out.print("请输入数字的位数：");
        int digits = scanner.nextInt();
        scanner.close();

        boolean isPalindrome = checkPalindrome(number, digits);

        if (isPalindrome) {
            System.out.println(number + " 是回文数字");
        } else {
            System.out.println(number + " 不是回文数字");
        }
    }

    private static boolean checkPalindrome(int number, int digits) {
        int reverse = 0;
        int temp = number;

        for (int i = 0; i < digits; i++) {
            int digit = temp % 10;
            reverse = reverse * 10 + digit;
            temp /= 10;
        }

        return number == reverse;
    }
}

 

在上述代码中，我们首先通过使用 Scanner 类，从控制台获取输入的数字和位数。

然后，我们调用 checkPalindrome 方法，并将获取的数字和位数作为参数传递。该方法将返回一个布尔值，表示给定的数字是否为回文数字。

在 checkPalindrome 方法中，我们定义了两个整数变量 reverse 和 temp。reverse 用于存储反转后的数字，temp 用于存储临时的数字。

接下来，我们使用一个循环迭代计算数字的每一位，并将其反转。循环的次数由位数 digits 决定。在每次循环中，我们提取 temp 的个位数，并将其加到 reverse 的末尾，然后将 temp 除以10向右移位。

最后，我们比较原始的数字 number 和反转后的数字 reverse 是否相等。如果相等，则给定的数字是回文数字，返回 true。否则，返回 false。

最后，我们根据返回的结果在控制台打印输出相应的判断结果。