编写一个程序，根据输入的年份（包括四位数和两位数），准确地判断它是否为普通闰年（能被4整除但不能被100整除，或者能被400整除）或是世纪闰年（能被400整除）。请提供相应的逻辑规则并实现代码示例。

在Python中，你可以编写如下的函数来判断一个年份是否是普通闰年或世纪闰年：

def is_leap_year(year):
    if isinstance(year, int):  # 检查输入是否为整数
        if year < 0:  # 负数年份不是闰年
            return "负数年份不是闰年"
        elif len(str(year)) == 2:  # 两位数年份直接按普通闰年计算
            return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
        else:  # 四位数年份按照闰年的规则判断
            return year % 4 == 0 and (year % 100 > 0 or year % 400 == 0)
    else:
        return "输入的不是整数"

# 测试函数
print(is_leap_year(2000))  # 输出：True，因为2000年是世纪闰年
print(is_leap_year(2022))  # 输出：False，因为2022年不是闰年
print(is_leap_year(-1900))  # 输出：负数年份不是闰年

在这个函数中，我们首先检查输入的年份是否为整数，然后根据年份的位数来判断它是普通闰年还是世纪闰年。如果输入不符合条件，我们会返回相应的提示信息。

相关问题

编写程序运行后用户输入4位。整数作为年份，判断其是否为闰年，如果年份能被400整除，则为闰年，如果年份能被四整除，但不能被100整除，也为闰年。请用【java】帮我写一段快排代码，并帮我讲解下实现逻辑

在Java中，我们可以编写一个简单的函数来判断闰年的条件，然后利用快速排序算法对年份数组进行排序。这里是一个基本的示例：

import java.util.Arrays;
import java.util.Scanner;

public class LeapYearSort {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一组四位数的年份，用逗号分隔：");
        String input = scanner.nextLine();
        String[] years = input.split(",");
        int[] yearArray = new int[years.length];
        for (int i = 0; i < years.length; i++) {
            yearArray[i] = Integer.parseInt(years[i]);
        }

        quickSort(yearArray, 0, yearArray.length - 1);

        // 判断并打印闰年
        for (int num : yearArray) {
            if (isLeapYear(num)) {
                System.out.printf("%d is a leap year.\n", num);
            }
        }
    }

    // 快速排序函数
    public static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(array, low, high); // 分区操作
            quickSort(array, low, pivotIndex - 1); // 对左半部分递归排序
            quickSort(array, pivotIndex + 1, high); // 对右半部分递归排序
        }
    }

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

    // 快速排序的分区操作
    private static int partition(int[] array, int low, int high) {
        int pivot = array[high]; // 选择最后一个元素作为基准
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (array[j] <= pivot) { // 将小于或等于基准的元素放到左边
                i++;
                swap(array, i, j);
            }
        }
        swap(array, i + 1, high); // 将基准放到正确的位置
        return i + 1;
    }

    // 交换两个元素的函数
    private static void swap(int[] array, int index1, int index2) {
        int temp = array[index1];
        array[index1] = array[index2];
        array[index2] = temp;
    }
}

**实现逻辑：**
1. 用户首先输入一组四位数的年份。
2. 读取输入并将字符串转换为整数数组。
3. 使用快速排序（`quickSort`）算法将年份数组从小到大排列。
4. 遍历排序后的数组，对于每个年份调用`isLeapYear`函数检查是否为闰年。
5. 根据判断结果输出相应的信息。

**相关问题--:**
1. 快速排序的基本思想是什么？
2. `partition`函数在快速排序中的作用是什么？
3. 如果输入的年份中有负数，上述代码会如何处理？

在oj平台上编写判断是否为闰年的程序，并且输入一个分数输出对应的等级

当然，我可以帮你分别介绍如何编写两个独立的程序。

首先，对于判断是否为闰年的程序，根据公历规则，闰年满足以下条件之一：

1. 年份能被4整除但不能被100整除（除非同时也能被400整除）。
2. 对于世纪年（即以00结尾的年份），只有能够被400整除的才是闰年。

下面是Java代码示例：

import java.util.Scanner;

public class LeapYear {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个四位数年份：");
        int year = scanner.nextInt();
        if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) {
            System.out.println(year + " 是闰年。");
        } else {
            System.out.println(year + " 不是闰年。");
        }
    }
}