本文介绍了五个编程挑战：统计整数序列中相同数字的个数，计算陶陶能摘到的苹果数，书费计算，数组逆序重放，以及疾病与年龄分布。展示了如何通过编程解决这些问题，涉及输入处理、循环遍历和条件判断等基本算法。
01:与指定数字相同的数的个数
OpenJudge - 01:与指定数字相同的数的个数
http://noi.openjudge.cn/ch0106/01/
描述
输出一个整数序列中与指定数字相同的数的个数。
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//第一行为a，表示整数序列的长度
int a = scanner.nextInt();
int[] b = new int[a];
for (int i = 0; i < a; i++) {
//输入a个整数
b[i] = scanner.nextInt();
}
//为指定的整数c
int c = scanner.nextInt();
//计数器
int f=0;
for (int i = 0; i < a; i++) {
if (b[i]==c) f++;
}
//输出计数器
System.out.println(f);
}02:陶陶摘苹果
OpenJudge - 02:陶陶摘苹果http://noi.openjudge.cn/ch0106/02/
描述
陶陶家的院子里有一棵苹果树，每到秋天树上就会结出10个苹果。苹果成熟的时候，陶陶就会跑去摘苹果。陶陶有个30厘米高的板凳，当她不能直接用手摘到苹果的时候，就会踩到板凳上再试试。
现在已知10个苹果到地面的高度，以及陶陶把手伸直的时候能够达到的最大高度，请帮陶陶算一下她能够摘到的苹果的数目。假设她碰到苹果，苹果就会掉下来。
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 创建10个int类型的数组
int[] sum = new int[10];
for (int i = 0; i < 10; i++) {
sum[i] = scanner.nextInt();
}
// n表示陶陶把手伸直的时候能够达到的最大高度
int n = scanner.nextInt();
int f=0;
for (int i = 0; i < 10; i++) {
// n+30是陶陶站在凳子上把手伸直的时候能够达到的最大高度
if (sum[i]<=n+30) f++;
}
// 输出陶陶能够摘到的苹果的数目
System.out.println(f);
}03:计算书费
OpenJudge - 03:计算书费http://noi.openjudge.cn/ch0106/03/
描述
下面是一个图书的单价表：
计算概论 28.9 元/本
数据结构与算法 32.7 元/本
数字逻辑 45.6元/本
C++程序设计教程 78 元/本
人工智能 35 元/本
计算机体系结构 86.2 元/本
编译原理 27.8元/本
操作系统 43 元/本
计算机网络 56 元/本
JAVA程序设计 65 元/本
给定每种图书购买的数量，编程计算应付的总费用。
代码
public static void main(String[] args) {
// 导入书本的价格
double txt[] = {28.9,32.7,45.6,78,35,86.2,27.8,43,56,65};
Scanner scanner = new Scanner(System.in);
double sum=0;
for (int i = 0; i < 10; i++) {
// 输入a，代表购买的本数
int a = scanner.nextInt();
sum=sum+txt[i]*a;
}
// 输出表示应付的总费用。精确道小数点后一位
System.out.println(sum);
}04:数组逆序重放
OpenJudge - 04:数组逆序重放http://noi.openjudge.cn/ch0106/04/
描述
将一个数组中的值按逆序重新存放。例如，原来的顺序为8,6,5,4,1。要求改为1,4,5,6,8。
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 数组中元素的个数n
int n = scanner.nextInt();
// 创建有n个元素的数组
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
// 输入元素
arr[i] = scanner.nextInt();
}
for (int i = arr.length; i > 0; i--) {
// 输出逆序后数组的整数，每两个整数之间用空格分隔
System.out.print(arr[i-1]+" ");
}
}05:年龄与疾病
OpenJudge - 05:年龄与疾病http://noi.openjudge.cn/ch0106/05/
描述
某医院想统计一下某项疾病的获得与否与年龄是否有关，需要对以前的诊断记录进行整理，
按照0-18、19-35、36-60、61以上（含61）四个年龄段统计的患病人数占总患病人数的比例。
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 输入过往病人的数目n
int n = scanner.nextInt();
// 创建数组
int[] old = new int[n];
for (int i = 0; i < n; i++) {
// 输入每个病人患病时的年龄
old[i] = scanner.nextInt();
}
// s代表0-18、m代表19-35、b代表36-60、j代表61以上（含61）
int s=0,m=0,b=0,j=0;
// 累加器累加s、m、b、j
for (int i = 0; i < n; i++) {
if (old[i] >= 0 && old[i] <= 18) s++;
else if (old[i] >= 19 && old[i] <= 35) m++;
else if (old[i] >= 36 && old[i] <= 60) b++;
else if (old[i] >= 61) j++;
}
// %输出
System.out.printf("%.2f%%\n",(float)s*100/n);
System.out.printf("%.2f%%\n",(float)m*100/n);
System.out.printf("%.2f%%\n",(float)b*100/n);
System.out.printf("%.2f%%\n",(float)j*100/n);
}06:校门外的树
OpenJudge - 06:校门外的树http://noi.openjudge.cn/ch0106/06/
描述
某校大门外长度为L的马路上有一排树，每两棵相邻的树之间的间隔都是1米。我们可以把马路看成一个数轴，马路的一端在数轴0的位置，另一端在L的位置；数轴上的每个整数点，即0，1，2，……，L，都种有一棵树。
由于马路上有一些区域要用来建地铁。这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有重合的部分。现在要把这些区域中的树（包括区域端点处的两棵树）移走。你的任务是计算将这些树都移走后，马路上还有多少棵树。
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 输入两个整数L代表马路的长度，M代表区域的数目
int L = scanner.nextInt();
int M = scanner.nextInt();
// L+1是树的棵树
int s=L+1;
boolean[] b = new boolean[s];
// 开始种树 初始值设置为1
for (int i = 0; i < s; i++) {
b[i] = true;
}
for (int i = 0; i < M; i++) {
int x = scanner.nextInt();
int y = scanner.nextInt();
// 防止题目有坑，保证左x右y
if (x>y) {int t=x;x=y;y=t;}
// 开始砍树 1改为0
for (int j = x; j <= y; j++) {
// 有树的时候
if (b[j] == true){
// 砍树
b[j]=false;
// 计数
s--;
}
}
}
// 输出马路上剩余的树的数目
System.out.println(s);
}07:有趣的跳跃
OpenJudge - 07:有趣的跳跃http://noi.openjudge.cn/ch0106/07/
描述
一个长度为n（n>0）的序列中存在“有趣的跳跃”当前仅当相邻元素的差的绝对值经过排序后正好是从1到(n-1)。例如，1 4 2 3存在“有趣的跳跃”，因为差的绝对值分别为3,2,1。当然，任何只包含单个元素的序列一定存在“有趣的跳跃”。你需要写一个程序判定给定序列是否存在“有趣的跳跃”。
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// n代表序列长度
int n;
n = scanner.nextInt();
// a数组代表序列的元素
int[] a = new int[n];
for (int i = 0; i < n; i++) {
// 存入元素
a[i] = scanner.nextInt();
}
// b数组代表两个数的差值
int[] b = new int[n-1];
for (int i = 0; i < n-1; i++) {
b[i]=Math.abs(a[i+1]-a[i]);
}
// 冒泡排序从小到大
for (int i = 0; i < n-1; i++) {
for (int j = i+1; j < n-1; j++) {
if (b[i] > b[j]){int t=b[i];b[i]=b[j];b[j]=t;}
}
}
for (int i = 0; i < n-1; i++) {
// 如果不等于i+1，就输出Not Jolly
if (b[i] != i+1) {
System.out.println("Not jolly");
// 条件符合直接结束程序
return;
}
}
// 输出Jolly
System.out.println("Jolly");
}08:石头剪刀布
描述
OpenJudge - 08:石头剪刀布http://noi.openjudge.cn/ch0106/08/
石头剪刀布是常见的猜拳游戏。石头胜剪刀，剪刀胜布，布胜石头。如果两个人出拳一样，则不分胜负。
一天，小A和小B正好在玩石头剪刀布。已知他们的出拳都是有周期性规律的，比如：“石头-布-石头-剪刀-石头-布-石头-剪刀……”，就是以“石头-布-石头-剪刀”为周期不断循环的。请问，小A和小B比了N轮之后，谁赢的轮数多？
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// N代表比了N轮
int N = scanner.nextInt();
// NA代表小A的出拳周期
int NA = scanner.nextInt();
// NB代表小B的出拳周期
int NB = scanner.nextInt();
// NA的出拳规律
int[] a = new int[NA];
for (int i = 0; i < NA; i++) {
a[i] = scanner.nextInt();
}
// NB的出拳规律
int[] b = new int[NB];
for (int i = 0; i < NB; i++) {
b[i] = scanner.nextInt();
}
// t代表下标，s代表胜的数量
int ta=0,tb=0,sa=0,sb=0;
for (int i = 0; i < N; i++) {
// 判断胜负
if (a[ta] == 0 && b[tb] == 2) sa++;
else if (a[ta] == 0 && b[tb] == 5) sb++;
else if (a[ta] == 2 && b[tb] == 0) sb++;
else if (a[ta] == 2 && b[tb] == 5) sa++;
else if (a[ta] == 5 && b[tb] == 0) sa++;
else if (a[ta] == 5 && b[tb] == 2) sb++;
// t下标++
ta++;
tb++;
// 下标归0
if (ta == NA) ta=0;
if (tb == NB) tb=0;
}
// 输出胜负
if (sa > sb) System.out.println("A");
else if (sa < sb) System.out.println("B");
else
System.out.println("draw");
}09:向量点积计算
OpenJudge - 09:向量点积计算http://noi.openjudge.cn/ch0106/09/
描述
在线性代数、计算几何中，向量点积是一种十分重要的运算。
给定两个n维向量a=(a1,a2,...,an)和b=(b1,b2,...,bn)，求点积a·b=a1b1+a2b2+...+anbn。
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 输入一个整数n，代表元素的个数
int n = scanner.nextInt();
int[] an = new int[n];
int[] bn = new int[n];
// 输入数组an的元素的值
for (int i = 0; i < n; i++) {
an[i] = scanner.nextInt();
}
// 输入数组bn的元素的值
for (int i = 0; i < n; i++) {
bn[i] = scanner.nextInt();
}
// sum代表累加器
int sum=0;
for (int i = 0; i < n; i++) {
// a1*b1+sum
sum = an[i]*bn[i]+sum;
}
// 输出答案
System.out.println(sum);
}10:大整数加法
OpenJudge - 10:大整数加法http://noi.openjudge.cn/ch0106/10/
描述
求两个不超过200位的非负整数的和。
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 输入两个不超过200位的非负数
String a = scanner.next();
String b = scanner.next();
// 创建两个数组，放入两组多位整数，放入方式0放最高位
int[] na = new int[a.length()];
int[] nb = new int[b.length()];
for (int i = 0; i < a.length(); i++) {
na[i] = a.charAt(i) - '0';
}
for (int i = 0; i < b.length(); i++) {
nb[i] = b.charAt(i) - '0';
}
/*
B代表最大位数
S代表最小位数
N代表计数
*/
int B,S,N;
if (na.length > nb.length) {
B = na.length;
S = nb.length;
N=1;
}
else if (na.length < nb.length){
B = nb.length;
S = na.length;
N=2;
}
else {
B = nb.length;
S = na.length;
N=3;
}
// sj代表创建数组的长度，这个和下面的最高位进位有关
// 此处有冗余
int sj;
if (N == 3){
if (na[B-2] + nb[B-2] >= 10){
if (na[B-1] + nb[B-1] + 1 >= 10){
sj=B+1;
}
else {
sj=B;
}
}
else{
if (na[B-1] + nb[B-1] >= 10){
sj=B+1;
}
else {
sj=B;
}
}
}
else if (N == 1) {
if (na[B - 2] == 9 && na[B - 1] == 9) {
sj = B + 1;
}
else sj = B;
}
else if (N == 2) {
if (nb[B - 2] == 9 && nb[B - 1] == 9) {
sj = B + 1;
}
else sj = B;
}
else sj = B;
// 创建sum
int[] sum = new int[sj];
// 位数na大时
if (N == 1) {
for (int i = 0; i < B; i++) sum[i] = na[i];
for (int i = S - 1; i >= 0; i--) {
sum[i+(B-S)] = sum[i+(B-S)] + nb[i];
if (sum[i+(B-S)] >= 10) {
sum[i+(B-S)] = sum[i+(B-S)] - 10;
sum[i + (B-S-1)] = sum[i + (B-S-1)] + 1;
}
}
}
// 位数nb大时
else if (N == 2){
for (int i = 0; i < B; i++) sum[i] = nb[i];
for (int i = S - 1; i >= 0; i--) {
sum[i+(B-S)] = sum[i+(B-S)] + na[i];
if (sum[i+(B-S)] >= 10) {
sum[i+(B-S)] = sum[i+(B-S)] - 10;
sum[i + (B-S-1)] = sum[i + (B-S-1)] + 1;
}
}
}
// 位数相同时
else {
for (int i = 0; i < B; i++) sum[i+1] = nb[i];
for (int i = S - 1; i >= 0; i--) {
sum[i + 1] = sum[i + 1] + na[i];
if (sum[i+1] >= 10) {
sum[i + 1] = sum[i + 1] - 10;
sum[i] = sum[i] + 1;
}
}
}
// 10的向前进一
for (int i = sum.length-1; i > 0; i--) {
if (sum[i] == 10) {
sum[i]=sum[i] - 10;
sum[i-1]++;
}
}
// 输出
for (int i = 0; i < sj; i++) {
System.out.print(sum[i]);
}
}11:大整数减法
OpenJudge - 11:大整数减法http://noi.openjudge.cn/ch0106/11/
描述
两个大的正整数相减的差。
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 输入两个不超过200位的非负数
String a = scanner.next();
String b = scanner.next();
// 创建两个数组，放入两组多位整数，放入方式0放最高位
int[] na = new int[a.length()];
int[] nb = new int[b.length()];
for (int i = 0; i < a.length(); i++) {
na[i] = a.charAt(i) - '0';
}
for (int i = 0; i < b.length(); i++) {
nb[i] = b.charAt(i) - '0';
}
/*
B代表最大位数
S代表最小位数
*/
int B,S;
B = na.length;
S = nb.length;
// sum代表创建数组的长度，这个和下面的最高位进位有关
// 创建sum
int[] sum = new int[B];
// 核心算法
for (int i = 0; i < B; i++) sum[i] = na[i];
for (int i = S - 1; i >= 0; i--) {
// 相减
sum[i+(B-S)] = sum[i+(B-S)] - nb[i];
if (sum[i+(B-S)] < 0) {
sum[i+(B-S)] = sum[i+(B-S)] + 10;
sum[i + (B-S-1)] = sum[i + (B-S-1)] - 1;
}
}
// 算法补丁1
// 因为出现前置位的退位在前面中没有，所以在这里完善
for (int i = B - S + 1; i <= 0; i--) {
if (sum[i] < 0){
sum[i+(B-S)] = sum[i+(B-S)] + 10;
sum[i + (B-S-1)] = sum[i + (B-S-1)] - 1;
}
}
// 算法补丁2
// 去掉前面多余的0
int N=0;
for (int i = sum.length - 1; i >= 0; i--) {
if (sum[i] == 0) N++;
}
// 算法补丁3
// 因为无法显示0，所以在这里加上
if (sum[0] == 0 && N == B) System.out.println(0);
else
// 输出
for (int i = 0+N; i < B; i++) {
System.out.print(sum[i]);
}
}12:计算2的N次方
OpenJudge - 12:计算2的N次方http://noi.openjudge.cn/ch0106/12/
描述
任意给定一个正整数N(N<=100)，计算2的n次方的值。
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int[] result = new int[1000];
int N = scanner.nextInt();
result[0] = 1;
// 存储当前被乘数有效位数
int Len = 1;
// 处理N次*2
for (int i = 0; i < N; i++)
{
for (int j = 0; j < Len; j++) {
result[j] = result[j] * 2;
}
//对每位超过10的，做-10并进位处理
for (int j = 0; j < Len; j++) {
if (result[j] >= 10) {
result[j] -= 10;
result[j + 1]++;
// 有进位时，考虑更新被乘数有效位数
Len = (j + 1 + 1) > Len ? (j + 1 + 1) : Len;
}
}
}
// 输出结果
for (int i = Len - 1; i >= 0; i--) {
System.out.print(result[i]);
}
}xx:另
代码
public class Demoxx {
// 已知正整数k满足2<=k<=9，现给出长度最大为30位的十进制非负整数c，求所有能整除c的k。
//全部是String类型
//jia(a,b) //a+b
//mi(x,n) //x的n次方 //前置jia
//chen(a,b) //a*b //前置jia
//chenPro(a,b) //a*b //效率大幅度提升!且不用前置
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
String sum = null;
for (a=a ; a > 1 ; a--) sum = chen(a, a);
System.out.print(sum);
}
public static String chenPro(String a,String b) {
String output = "";
//确保a<b
if(a.length()<b.length()) {
String t;
t = a;a = b;b = t;t = "0";
}
//拆a
int[] arr1 = new int[a.length()];
for(int i = 0; i < a.length();i++) {
arr1[i] = a.charAt(i) - 48;
}
//倒序
for (int start = 0, end = arr1.length - 1; start < end; start++, end--) {
int temp = arr1[end];
arr1[end] = arr1[start];
arr1[start] = temp;
}
//计算开始
int ttt = 0;
for(int i = 0; i < arr1.length;i++) {
ttt += arr1[i] * Integer.parseInt(b);
output += String.valueOf(ttt % 10);
ttt /= 10;
}
while(ttt >0) {
output += String.valueOf(ttt % 10);
ttt /= 10;
}
//计算结束,倒序
char[] ch = output.toCharArray();
String str2 = "";
for (int i = ch.length - 1; i >= 0; i --) {
str2 += ch[i];
}
//去0
ttt = str2.length() - 1;
for(int i = 0; i < str2.length(); i++) {
if(str2.charAt(i) != 48) {
ttt = i;
break;
}
}
String str = "";
for(int i = ttt; i < str2.length();i++) {
str+=str2.charAt(i);
}
//输出
return str;
}
//--------------------------分割线--------------------------
public static String chen(String a,String b) {
String p = "1";
String t = "0";
boolean flag = !(a.equals("0")||b.equals("0"));
if(b.length()<a.length()) {
t = a;a = b;b = t;t = "0";
}
while(flag) {
if(p.equals(jia(a,"0"))) {flag = false;}
p = jia("1",p);
t = jia(t,b);
}
return t;
}
//--------------------------分割线--------------------------
public static String mi(String x,String n) {
int y = Integer.parseInt(n);
int t = Integer.parseInt(x);
String output=x;
for(int i = 1; i < y; i++) {
for(int j = 1; j < t;j++) {
output = jia(output,x);
}
x = output;
}
if(y == 0) {x = "0";}
return x;
}
//--------------------------分割线--------------------------
public static String jia(String a,String b) {
int arr1[];
int arr2[];
int len1;
int len2;
if(a.length()<b.length()) {
arr1 = new int[a.length()];
arr2 = new int[b.length()];
for(int i = 0; i < a.length();i++) {
arr1[i] = a.charAt(i) - 48;
}
for(int i = 0; i < b.length();i++) {
arr2[i] = b.charAt(i) - 48;
}
len1 = a.length() - 1;
len2 = b.length() - 1;
}else {
arr2 = new int[a.length()];
arr1 = new int[b.length()];
for(int i = 0; i < b.length();i++) {
arr1[i] = b.charAt(i) - 48;
}
for(int i = 0; i < a.length();i++) {
arr2[i] = a.charAt(i) - 48;
}
len2 = a.length() - 1;
len1 = b.length() - 1;
}
for (int start = 0, end = arr1.length - 1; start < end; start++, end--) {
int temp = arr1[end];
arr1[end] = arr1[start];
arr1[start] = temp;
}
for (int start = 0, end = arr2.length - 1; start < end; start++, end--) {
int temp = arr2[end];
arr2[end] = arr2[start];
arr2[start] = temp;
}
boolean flag = true;
int p = -1;
int t = 0;
String output = "";
while(flag) {
p++;
if(p <= len1) {
t += arr1[p] + arr2[p];
if(t>=10) {
output += String.valueOf(t % 10);
t = t/10%10;
}else {
output += String.valueOf(t);
t = 0;
}
}else if(p <= len2) {
t += arr2[p];
if(t>=10) {
output += String.valueOf(t % 10);
t = t/10%10;
}else {
output += String.valueOf(t);
t = 0;
}
}else if(t > 0){
if(t>=10) {
output += String.valueOf(t % 10);
t = t/10%10;
}else {
output += String.valueOf(t);
t = 0;
}
flag = false;
}else {
flag = false;
}
}
char[] ch = output.toCharArray();
String str2 = "";
for (int i = ch.length - 1; i >= 0; i --) {
str2 += ch[i];
}
t = str2.length() - 1;
for(int i = 0; i < str2.length(); i++) {
if(str2.charAt(i) != 48) {
t = i;
break;
}
}
String str = "";
for(int i = t; i < str2.length();i++) {
str+=str2.charAt(i);
}
return str;
}
}
扫一扫
8184
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
