如何用python和java分别写出10道经典题(含代码)
作者：钰札镠.
1.求第100项之和
已知1、1、2、3、5、8、13......就是从第三项开始，每一项等于前两项之和。求第100项。
斐波那契数列 第100项
数列：1, 1, 2, 3, 5, 8, 13, …从第三项起，每一项等于前两项之和。求第100项的值。
用两个变量 a 和 b 分别 表示当前项的前两项从第3项开始循环，每次计算 c = a+b ,更新 a = b , b = c循环结束 后 b 就是 第 100 项
100 项 数值很大 python 整数无上限 ，java 需要使用 BigInteger
python 代码
a,b = 1,1
for i in range(3,101):
c = a+b
a = b
b = c
print(c)java 代码
package a;
//数列：1, 1, 2, 3, 5, 8, 13, …
//从第三项起，每一项等于前两项之和。求第100项的值。
import java.math.BigInteger;
public class Tm1 {
public static void main(String[] args) {
BigInteger a = BigInteger.ONE;
BigInteger b = BigInteger.ONE;
for (int i = 3; i <= 100; i++) {
BigInteger c = a.add(b); //c = a+b
a = b; //更新a
b = c; //更新b
}
System.out.println("第100项是:" + b);
}
}
2、物不知数
”出自《孙子算经》。
题目为:今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问物几何?”。意思是说有一些物品，不知道有多少个，3个3个数的话，还多出2个;5个5个数则多出3个;7个7个数也会多出2个。现假设物品总数不超过n(n<=1000)，请编程计算满足条件的物品个数并输出。
一个数x, 满足：x 除以 3 余 2x 除以 5 余 3x 除以 7 余 2给定上限 n (n ≤ 1000)，求出所有不超过 n 的 x。x <=1000，可以用 暴力枚举 每个数是否同时满足三个余数条件
python 代码
n = int(input("请输入物品总数上限 n (n <=1000):"))
# 遍历 1 到 n
for i in range(1, n+1):
# 同时满足三个条件
if i % 3==2 and i % 5==3 and i % 7==2:
print(i, end=" ")
print()
java 代码
package a;
import java.util.Scanner;
public class Tm2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入上限 n (<=1000)");
int n = sc.nextInt();
// 遍历 1 到 n
for (int i = 1; i <=n; i++) {
//同时满足三个余数条件
if(i %3 ==2 && i%5 ==3 && i%7==2){
System.out.println(i + " ");
}
}
sc.close();
}
}
3、完数
一个数如果恰好等于不包含它本身所有因子之和，这个数就称为"完数”。例如，6的因子为1、2、3，而6=1+2+3，因此6是"完数”。编程序找出100之内的所有完数。遍历 2 到100（1，不是完数）,对每个数 i,找出所有小于i 的因子,求和，若和等于i，则输出。
完数：
一个数如'它的所有真因子（除了它自己以外的因数）加起来，刚好等于它自己 '，那它 就是完数。一个数的因子（除了它自己），最大不可能超过他的一半
python 代码
#完数
# 遍历 2 到 100（1 不是完数）。
#
# 对每个数 num，用内层循环找出所有小于 num 的因子（即 num % i == 0），累加。
#
# 若累加和等于 num，则输出。
for num in range(2, 101):
factor_sum = 0
for i in range(1,num):
if num % i == 0:
factor_sum += i
if factor_sum == num:
print(i, end=" ")
print()
java 代码
package a;
public class Tm3 {
public static void main(String[] args) {
for (int num = 2; num <= 100; num++) {
int factorSum = 0; // 因子和初始为0
// 找所有真因子（1到num-1）
for (int i = 1; i < num; i++) {
if (num % i == 0) { // i是num的因子
factorSum += i; // 累加
}
}
if (factorSum == num) { // 因子和等于自身，输出
System.out.print(num + " ");
}
}
}
}
4、编程:求100到200之间的素数，并统计其个数。
判断素数时，只需检查从 2 到 sqrt(n) 是否有因子。
注意 1 不是素数，但范围从 100 开始，所以没问题。
素数（也叫质数）：一个大于 1 的整数，如果只能被 1 和它自己整除，那它就是素数。
换句话说，它找不到其他的因子。
python 代码
# 100 ~ 200 之间的素数
# 找出 100 到 200之间的素数，并统计个数。
# 素数 只能被 1 和本身整除的数
import math
#初始化 一个计数器 变量
count = 0
#循环 让变量 num 从100遍历到200，
# range 包头不包尾 所以写201
for num in range(100, 201):
# 设置一个标志位 先假设当前的num是素数
isprime = True
# 计算当前数字的平方根，取整后加1
limit = int(math.sqrt(num))+1
# 内层循环 ：试除 从2开始到 limit 结束
for i in range(2, limit):
if num % i == 0:
isprime = False
break
#若 num 能被 i 整除 余数为0 说明 它不是素数 跳出内层循环
# 检查标志位
if isprime:
# 打印这个素数，不换行
print(num,end=' ')
# 找到一个计数器+1
count += 1
print(f"\n一共有{count}")
java 代码
package a;
public class Tm4 {
public static void main(String[] args) {
int count =0;
System.out.println("100到200之间的素数有：");
for (int n = 100; n <=200 ; n++) {
boolean isPrime = true;
// 假设当前的 n 是 素数
for (int i = 2; i <=Math.sqrt(n); i++) {
if(n %i ==0){
isPrime = false;
break;
}
}
if(isPrime){
System.out.print(n+" ");
count++;
}
}
System.out.println("\n\n素数的总个数" +count);
}
}
5、编程:显示前100个回文素数。
每行显示10个素数。(回文素数是指一个数是素数也是回文数。例如:131既是素数也是回文数。)回文素数是指既是素数又是回文数（正读反读相同）的数。例如 131。输出前100个回文素数，每行显示10个。
6、利用循环程序打印如下三角形程序
外层循环控制行数：从 5 到 1 递减。
内层循环打印星号：每行星号个数等于当前行号
python 代码
# 打印 倒三角形
row = 5
# i 从 5 降到1，步长-1
for i in range(row,0,-1):
# 打印 i 个 * 号
print("*" * i)
print()
java 代码
package a;
public class Tm6 {
public static void main(String[] args) {
int row = 5;
for (int i = row; i >=1; i--) {
for (int j = 1; j <=i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
7、九九乘法表
外层循环 i 从 1 到 9（表示第二个乘数）。
内层循环 j 从 1 到 i（表示第一个乘数）。
输出 j × i = i*j，用制表符 \t 分隔。
python 代码
# 第7题：九九乘法表
# 外层循环 i 从1到9 表示第二个乘数
for i in range(1,10): #i= 1..9
#内层循环 j 从1到i 表示第一个乘数
for j in range(1,i+1): #j = 1..i
# 输出 j x i = i*j 用制表符 \t 分隔
print(f"{i}*{j} = {j*i}",end= '\t')
print() #内层循环结束换行
java 代码
package a;
public class Tm7 {
public static void main(String[] args) {
for (int i = 1; i <=9; i++) { //i 是第二个乘数
for (int j = 1; j <=i ; j++) { //j 是第一个乘数
System.out.print(j + "*" + j + "=" +(i * j) +"\t");
}
System.out.println(); //每一行结束 换行
}
}
}
8、利用循环程序，打印如下图形。
A
BB
CCC
DDDD
EEEEE
FFFFFF
第 i 行打印 i 次同一个字母。字母 = 'A' + i - 1（利用 ASCII 码）
ASCII码
可以理解为 计算机里的“字符身份证号码”计算机只认识数字，不认识字母。字母‘A’ 的身份证号码（ASCII码） 是 65字母‘B’是 66字母‘C’是 67...以此类推
十进制 | 十六进制 | 字符 | 说明 |
0 | 0x00 | NUL | 空字符（Null） |
7 | 0x07 | BEL | 响铃（Bell） |
8 | 0x08 | BS | 退格（Backspace） |
9 | 0x09 | HT | 水平制表符（Horizontal Tab） |
10 | 0x0A | LF | 换行（Line Feed） |
13 | 0x0D | CR | 回车（Carriage Return） |
32 | 0x20 | 空格 | 可见为空格 |
48 | 0x30 | 0 | 数字0起始 |
65 | 0x41 | A | 大写字母A起始 |
97 | 0x61 | a | 小写字母a起始 |
127 | 0x7F | DEL | 删除（Delete） |
python 代码
# 第8题 打印怎么三角形
# 第 i 行 打印 i 次 同一个字母
# 字母 = 'A' + i - 1 (利用ASCII码)
row = 6
for i in range(1,row+1): #i = 1到6
# 计算行应打印的字母： ord('A') = 65,加 (
ch = chr(ord("A")+i-1)
print(ch*i)
java 代码
package a;
public class Tm8 {
public static void main(String[] args) {
// 外层循环 决定字母是什么 现在在第几行
int row = 6;
for (int i = 1; i <=row; i++) {
// (char) 将算出来的数字强行变成字符
char ch = (char)('A'+ i -1);
// 计算字母 利用ASCII码,算出当前字母
// ord('A') 得到 65
// i = 1 时；65 +0 = 65->char(65)->'A'
// i = 2 时；65 +1 = 66->char(66)->'B'
// 内层循环 将当前字母重复打印 N 次
for (int j = 1; j <=i; j++) {
System.out.print(ch); //打印字母不换行
}
System.out.println(); //换行
}
}
}
9、输入一段字符串，统计其中大写字母、小写字母、数字、空格和其它字符的个数。
将字符串转换成字符数组（或使用 charAt）
遍历每个字符，根据 ASCII 范围（或字符比较）分类：
大写：
'A' ~ 'Z'小写：
'a' ~ 'z'数字：
'0' ~ '9'空格：
' '其他：剩下的
每类对应一个计数器，最终输出。
python 代码
# 输入一段字符串，统计其中大写字母、小写字母、数字、空格、其他字符的个数。
s = input("请输入一段字符串：")
# 初始化5个计数器
upper = lower = digit = space = other = 0
# 遍历字符串中的每个字符
for ch in s:
if 'A' <= ch <= 'Z': # 大写字母
upper += 1
elif 'a' <= ch <= 'z': # 小写字母
lower += 1
elif '0' <= ch <= '9': # 数字
digit += 1
elif ch == ' ': # 空格
space += 1
else: # 其他字符
other += 1
# 输出结果
print(f"大写字母: {upper}, 小写字母: {lower}, 数字: {digit}, 空格: {space}, 其他: {other}")
java 代码
package a;
import java.util.Scanner;
public class Tm9 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("请输入一段字符串：");
String str = sc.nextLine(); // 读取整行，包含空格
// 五个计数器，初始都为 0
int upper = 0; // 大写字母个数
int lower = 0; // 小写字母个数
int digit = 0; // 数字个数
int space = 0; // 空格个数
int other = 0; // 其他字符个数
// 使用 toCharArray() 获得字符数组，然后用增强 for 循环遍历
// 这样不用关心下标，非常直观
for (char ch : str.toCharArray()) {
// 判断大写字母：ASCII 中 'A' 到 'Z'
if (ch >= 'A' && ch <= 'Z') {
upper++;
}
// 判断小写字母：'a' 到 'z'
else if (ch >= 'a' && ch <= 'z') {
lower++;
}
// 判断数字：'0' 到 '9'
else if (ch >= '0' && ch <= '9') {
digit++;
}
// 判断空格：直接比较字符是否为空格
else if (ch == ' ') {
space++;
}
// 其余一律算作其他字符
else {
other++;
}
}
// 打印统计结果
System.out.println("大写字母: " + upper);
System.out.println("小写字母: " + lower);
System.out.println("数字: " + digit);
System.out.println("空格: " + space);
System.out.println("其他字符: " + other);
sc.close();
}
}10、统计各色色块的数量
编程:已知有三种色块(红(“red”)、绿(“green”)、蓝(“blue”))，现随机生成50个色块，编程统计各种色块的数量，并按从大到小排序输出。
随机生成 + 字典计数 + 排序
随机：从颜色列表中用
random.choice抽取。计数：用字典（HashMap）存储每种颜色出现次数。
排序：将字典条目按值降序排序，可用
sorted或list.sort。
有 3 种色块 red green blue
要随机生成 50个
要统计 各种色块的数量
从大到小 排序 输出
python 代码
import random
from collections import Counter # 专门用来计数的工具
#定义颜色
colors = ["red", "green", "blue"]
# 生成50个随机颜色
random_colors = [random.choice(colors) for _ in range(50)]
# Counter自动统计每个颜色出现次数
counter = Counter(random_colors)
# 此时 counter 的样子大概是：{'red': 18, 'green': 15, 'blue': 17}
# 按数量从大到小排序
sorted_items = sorted(counter.items(), key=lambda x: x[1], reverse=True)
#items()返回(颜色,数量)对，
#key=lambda x: x[1]表示按 数量 排序，
#reverse=True降序 False 是 升序
# 循环输出
for color, count in sorted_items:
print(f"{color}: {count}")
java 代码
两种方法 排序的方式有不同
方法1的：
是升序
list.sort((a1,a2) -> a1.getValue() - a2.getValue());
实际意思：
如果结果是负数，说明 a1 小，排前面（升序）。
如果结果是正数，说明 a1 大，排后面。弱点：
这种写法不安全。如果数字非常大（比如几亿），两个大数相减可能会导致“溢出”（结果算错了），虽然这道题只有 50 个球不会溢出，但在专业开发中这是被禁止的写法
方法2的：
list.sort((e1, e2) -> e2.getValue().compareTo(e1.getValue()));实际意思：
直接调用 Java 自带的“比较”功能
优点：
安全： 不会出现计算错误。
直观： compareTo 就是“比较”的意思，语义更清晰。
灵活： 注意看这里写的是 e2 比 e1，这直接实现了从大到小（降序）。
方法1
package a;
import java.util.*;
//编程:已知有三种色块(红(“red”)、绿(“green”)、蓝(“blue”))，
//现随机生成50个色块，编程统计各种色块的数量，并按从大到小排序输出。
// 有 3 种色块 red green blue
// 要随机生成 50个
// 要统计 各种色块的数量
// 从大到小 排序 输出
public class Tm10 {
public static void main(String[] args) {
// 颜色
String [] color = {"red","green","blue"};
// 计数 key 颜色 value 次数
HashMap<String,Integer> map = new HashMap<>();
// 初始化：先把红绿蓝都放进去，次数设为0
for (String s :color){
map.put(s,0);
}
Random ran = new Random();
for (int i = 0; i < 50; i++) {
// 生成 0-2 的随机数 ，对应数组的下标
int index = ran.nextInt(color.length);
String chosen = color[index]; //拿到颜色名字
map.put(chosen,map.get(chosen)+1);
}
// 准备排序 转换成 list 列表
// HashMap 本身不能排序，需要将它转换成 list 列表
List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
// 排序
list.sort((a1,a2) -> a1.getValue() - a2.getValue());
// 循环打印 列表中每个颜色和数量 getKey 颜色 getValue 数量
for (Map.Entry<String,Integer>entry :list) {
System.out.println(entry.getKey() + ":" +entry.getValue());
}
}
}方法2
import java.util.*;
public class ColorStatistics {
public static void main(String[] args) {
String[] colors = {"red", "green", "blue"};
Random rand = new Random();
Map<String, Integer> map = new HashMap<>();
// 初始化
for (String c : colors) map.put(c, 0);
// 随机50次
for (int i = 0; i < 50; i++) {
int idx = rand.nextInt(colors.length);
String chosen = colors[idx];
map.put(chosen, map.get(chosen) + 1);
}
// 转换成List以便排序
List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
// 按值降序排序
list.sort((e1, e2) -> e2.getValue().compareTo(e1.getValue()));
// 输出
for (Map.Entry<String, Integer> e : list) {
System.out.println(e.getKey() + ": " + e.getValue());
}
}
}总结
到此这篇关于如何用python和java分别写出10道经典题的文章就介绍到这了,更多相关python和java经典题内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！