文章目录
1.求和求平均值
题目描述
问题描述
从键盘输入10个浮点数，求出它们的和以及平均值，要求用函数实现
输入格式
测试数据的输入一定会满足的格式。
1 10 （1行10列的向量）
输出格式
要求用户的输出满足的格式。
2 1 （2行1列的矩阵）
样例输入
一个满足题目要求的输入范例。
例：
1.2 2.2 3.2 4.2 5.2 6.2 7.2 8.2 9.2 10.2
样例输出
与上面的样例输入对应的输出。
例：
57
5.7
数据规模和约定
输入数据中每一个数的范围。
例：0<n,m<100, 0<=矩阵中的每个数<=1000。
代码实现
import java.util.Scanner;
public class ALGO238 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double[]arr=new double[10];
for (int i = 0; i < arr.length; i++) {
arr[i]=sc.nextDouble();
}
result(arr);
}
private static void result(double[] arr) {
double sum=0,average=0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
average=sum/10;
System.out.printf("%.0f",sum);
System.out.println();
System.out.println(average);
}
}
2.奇变的字符串
题目描述
问题描述
将一个字符串的奇数位（首位为第0位）取出，将其顺序弄反，再放回原字符串的原位置上。
如字符串"abcdefg"，奇数位为"bdf"，顺序弄反后为"fdb"，最后得到字符串"afcdebg"。
输入格式
输入共一行，为一个字符串，字符串中无空格。
输出格式
输出共一行，为一个字符串，即最后得到的字符串。
样例输入
abcdefg
样例输出
afcdebg
代码实现
package LanQiao_algorithm;
import java.util.Scanner;
public class ALGO218 {
/*
* 解题思路：现将偶数位的字符放入结果数组中，奇数位的字符放入
* 另一个临时的数组中 然后在把结果集补充完整
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.next();
char[] c = str.toCharArray();
char[] res = new char[str.length()];
char[] tmp = new char[str.length() / 2];
int k = 0;
for (int i = 0; i < c.length; i++) {
if (i % 2 == 0) {
res[i] = c[i];
} else {
tmp[k++] = c[i];
}
}
for (int i = 0; i < c.length; i++) {
if (i % 2 == 1) {
res[i] = tmp[--k];
}
}
for (char d : res) {
System.out.print(d);
}
}
}
3.找零钱
题目描述
问题描述
有n个人正在饭堂排队买海北鸡饭。每份海北鸡饭要25元。奇怪的是，每个人手里只有一张钞票（每张钞票的面值为25、50、100元），而且饭堂阿姨一开始没有任何零钱。请问饭堂阿姨能否给所有人找零（假设饭堂阿姨足够聪明）
输入格式
第一行一个整数n，表示排队的人数。
接下来n个整数a[1],a[2],…,a[n]。a[i]表示第i位学生手里钞票的价值（i越小，在队伍里越靠前）
输出格式
输出YES或者NO
样例输入
4
25 25 50 50
样例输出
YES
样例输入
2
25 100
样例输出
NO
样例输入
4
25 25 50 100
样例输出
YES
代码实现
package LanQiao_algorithm;
import java.util.Scanner;
public class Algo232 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a[] = new int[n];
int m_25 = 0;
int m_50 = 0;
boolean flag = true;
for (int i = 0; i < n; i++) {
//没输入一个数字都进行判断，如果flag为真，就继续进行判断，
//如果flag为加，说明之后的顾客都不能买，也就不需要进行判断了
a[i] = sc.nextInt();
if (flag) {
if (a[i] == 25) {
m_25++;
} else if (a[i] == 50) {
if (m_25 > 0) {
m_25--;
m_50++;
} else flag = false;
} else if (a[i] == 100) {
if (m_25 > 0 && m_50 > 0) {
m_25--;
m_50--;
} else if (m_25 >= 3) {
m_25 = m_25 - 3;
} else {
flag = false;
}
}
}
}
if (flag) {
System.out.println("YES");
} else {
System.out.println("NO");
}
}
}
4.元素统计
题目描述
编写一个程序，读入一组整数，这组整数是按照从小到大的顺序排列的，它们的个数N也是由用户输入的，最多不会超过20。然后程序将对这个数组进行统计，把出现次数最多的那个数组元素值打印出来。如果有两个元素值出现的次数相同，即并列第一，那么只打印较小的那个值。例如，假设用户输入的是“100 150 150 200 250”，则输出为150。
输入:
6
100 150 150 200 200 250
输出:
150
代码实现
package LanQiaoVip_algorithm;
import java.util.Scanner;
public class P0502 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int[] arr = new int[N];
for (int i = 0; i < arr.length; i++) {
arr[i] = sc.nextInt();
}
int count = 1;
int max = Integer.MIN_VALUE;
int res = 0;
if (N == 1) {
res = arr[0];
} else {
for (int i = 1; i < arr.length; i++) {
if (arr[i] == arr[i - 1]) {
count++;
} else {
count = 1;
}
if (count > max) {
res = arr[i-1];
max = count;
}
}
}
System.out.println(res);
}
}
5.P1102（学生成绩排序）
题目描述
定义一个学生结构体类型student，包括4个字段，姓名、性别、年龄和成绩。然后在主函数中定义一个结构体数组（长度不超过1000），并输入每个元素的值，程序使用冒泡排序法将学生按照成绩从小到大的顺序排序，然后输出排序的结果。
输入格式：第一行是一个整数N（N<1000），表示元素个数；接下来N行每行描述一个元素，姓名、性别都是长度不超过20的字符串，年龄和成绩都是整型。
输出格式：按成绩从小到大输出所有元素，若多个学生成绩相同则成绩相同的同学之间保留原来的输入顺序。
输入：
3
Alice female 18 98
Bob male 19 90
Miller male 17 92
输出：
Bob male 19 90
Miller male 17 92
Alice female 18 98
代码实现
package LanqiaoVip;
import java.util.Scanner;
public class P1102 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
Student[] students = new Student[N];
for (int i = 0; i < N; i++) {
students[i] = new Student();
students[i].name = sc.next();
students[i].sex = sc.next();
students[i].age = sc.nextInt();
students[i].grade = sc.nextInt();
}
optimizeBubbleSort(students);
}
public static void optimizeBubbleSort(Student[] students) {
Student temp;
boolean flag = false;
for (int i = 0; i < students.length - 1; i++) {
for (int j = 0; j < students.length - 1 - i; j++) {
if (students[j].grade > students[j + 1].grade) {
flag = true;
temp = students[j];
students[j] = students[j + 1];
students[j + 1] = temp;
}
}
if (!flag) {
// flag为false，说明在一趟排序中没有进入交换环节 --->已经有序
break;
} else {
flag = false;
}
}
for (Student student : students) {
System.out.println(student.name + " " + student.sex + " " + student.age + " " + student.grade);
}
}
}
class Student {
String name;
String sex;
int age;
int grade;
}
6.摆动序列
题目描述
如果一个序列满足下面的性质，我们就将它称为摆动序列：
1. 序列中的所有数都是不大于k的正整数；
2. 序列中至少有两个数。
3. 序列中的数两两不相等；
4. 如果第i – 1个数比第i – 2个数大，则第i个数比第i – 2个数小；如果第i – 1个数比第i – 2个数小，则第i个数比第i – 2个数大。
比如，当k = 3时，有下面几个这样的序列：
1 2
1 3
2 1
2 1 3
2 3
2 3 1
3 1
3 2
一共有8种，给定k，请求出满足上面要求的序列的个数。
输入格式
输入包含了一个整数k。（k<=20）
输出格式
输出一个整数，表示满足要求的序列个数。
样例输入
3
样例输出
8
代码实现
用公式实现： 摆动序列的个数=(2ⁿ-n-1)*2。
package LanQiaoVip_algorithm;
import java.util.Scanner;
public class ALGO9 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int k = sc.nextInt();
System.out.println((int) (Math.pow(2, k) - k - 1) * 2);
}
}
7.P0504(Anagrams)
题目描述
Anagrams指的是具有如下特性的两个单词：在这两个单词当中，每一个英文字母（不区分大小写）所出现的次数都是相同的。例如，Unclear和Nuclear、Rimon和MinOR都是Anagrams。编写一个程序，输入两个单词（只包含英文字母），然后判断一下，这两个单词是否是Anagrams。每一个单词的长度不会超过80个字符，而且是大小写无关的。
Input:长度不超过80个字符的两个单词，用空格隔开，不考虑字母大小写 （大小写无关）
Output: yes或者no
输入:
Rimon MinOR
输出:
yes
代码实现
package LanQiaoVip_algorithm;
import java.util.Scanner;
public class Anagrams {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str1 = sc.next().toLowerCase();
String str2 = sc.next().toLowerCase();
int num = str1.length();
char[] arr1 = str1.toCharArray();
char[] arr2 = str2.toCharArray();
int count = 0;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
count++;
arr2[j] = 0;
break;
}
}
}
if (num == count&&str1.length()==str2.length()) {
System.out.println("yes");
} else {
System.out.println("no");
}
}
}
8. 王、后传说
题目描述
地球人都知道，在国际象棋中，后如同太阳，光芒四射，威风八面，它能控制横、坚、斜线位置。
看过清宫戏的中国人都知道，后宫乃步步惊心的险恶之地。各皇后都有自己的势力范围，但也总能找到相安无事的办法。
所有中国人都知道，皇权神圣，伴君如伴虎，触龙颜者死…
现在有一个n*n的皇宫，国王占据他所在位置及周围的共9个格子，这些格子皇后不能使用（如果国王在王宫的边上，占用的格子可能不到9个）。当然，皇后也不会攻击国王。
现在知道了国王的位置（x,y）（国王位于第x行第y列，x,y的起始行和列为1），请问，有多少种方案放置n个皇后，使她们不能互相攻击。
输入格式
一行，三个整数，皇宫的规模及表示国王的位置
输出格式
一个整数，表示放置n个皇后的方案数
样例输入
8 2 2
样例输出
10
数据规模和约定
n<=12
思路分析
第一眼看看到题目就想起nn皇后问题，不过这题有个坑。题目多了个皇帝，且皇帝的周围的位置皇后也无法站。我一开始认为皇帝的地盘是道墙，不过认真的分析题目可知题目并没说，也就说皇后是可以跨过皇帝的位置攻击其他皇后的。
这道题在nn皇后的基础输加上条件判断皇后无法站皇帝的位置即可。
代码实现
package LanQiaoVip_algorithm;
import java.util.Scanner;
// 8皇后问题，多了一个国王的位置 (国王的上下左右和上左上右下左下右)
//不能站皇后，其他都一样
public class ALGO125 {
private static int cnt = 0;
private static int[] a;
private static int x;
private static int y;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
x = sc.nextInt() - 1;
y = sc.nextInt() - 1;
a = new int[n];// 用来表示第i行放在第几个位置，如a[5]=10 表示 第5行皇后放在第10个位置
dfs(0, n);
System.out.println(cnt);
}
public static boolean isSafe(int row) {
// 在国王的九个格子内，不是安全区
if (Math.abs(row - x) <= 1 && Math.abs(a[row] - y) <= 1) {
//表示在不在王的周围以及王的位置
return false;
}
for (int i = 0; i < row; i++) {
// 当为斜对角线，或者
if (a[row] == a[i] || row - i == Math.abs(a[row] - a[i])) {
return false;
}
}
return true;
}
public static void dfs(int row, int n) {
if (row >= n) {
//表示第row行 如果row>=n,说明前n行已经都放上了皇后
cnt++;
return;
}
for (a[row] = 0; a[row] < n; a[row]++) {
// System.out.println("a["+row+"]="+a[row]);
if (isSafe(row)) {
dfs(row + 1, n);
}
}
}
}
9.相邻数对
题目描述
问题描述
给定n个不同的整数，问这些数中有多少对整数，它们的值正好相差1。
输入格式
输入的第一行包含一个整数n，表示给定整数的个数。
第二行包含所给定的n个整数。
输出格式
输出一个整数，表示值正好相差1的数对的个数。
样例输入
6
10 2 6 3 7 8
样例输出
3
样例说明
值正好相差1的数对包括(2, 3), (6, 7), (7, 8)。
评测用例规模与约定
1<=n<=1000，给定的整数为不超过10000的非负整数。
代码实现
package LanQiaoVip_algorithm;
import java.util.Arrays;
import java.util.Scanner;
public class ALGO279 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int arr[]=new int[n];
int cnt=0;
for (int i = 0; i < arr.length; i++) {
arr[i]=sc.nextInt();
}
Arrays.sort(arr);
for (int i = 0; i < arr.length-1; i++) {
for (int j = 1; j < arr.length; j++) {
if (arr[j]-arr[i]==1) {
cnt++;
}
if (arr[j]-arr[i]>1) {
break;
}
}
}
System.out.println(cnt);
}
}
10.画图（求有重叠矩形的面积）
题目描述
问题描述
在一个定义了直角坐标系的纸上，画一个(x1,y1)到(x2,y2)的矩形指将横坐标范围从x1到x2，纵坐标范围从y1到y2之间的区域涂上颜色。
下图给出了一个画了两个矩形的例子。第一个矩形是(1,1) 到(4, 4)，用绿色和紫色表示。第二个矩形是(2, 3)到(6, 5)，用蓝色和紫色表示。图中，一共有15个单位的面积被涂上颜色，其中紫色部分被涂了两次，但在计算面积时只计算一次。在实际的涂色过程中，所有的矩形都涂成统一的颜色，图中显示不同颜色仅为说明方便。
给出所有要画的矩形，请问总共有多少个单位的面积被涂上颜色。
输入格式
输入的第一行包含一个整数n，表示要画的矩形的个数。
接下来n行，每行4个非负整数，分别表示要画的矩形的左下角的横坐标与纵坐标，以及右上角的横坐标与纵坐标。
输出格式
输出一个整数，表示有多少个单位的面积被涂上颜色。
样例输入
2
1 1 4 4
2 3 6 5
样例输出
15
评测用例规模与约定
1<=n<=100，0<=横坐标、纵坐标<=100。
思路分析
思路：这道题我看了很久，刚开始以为是普通的求矩形并的问题，但是后来才发现本题要简单许多。之所以能够简化，是因为这道题的矩形是有方格的。我们将方格的左下角坐标表示该方格，初始化所有方格的标记为0，然后将矩形表示范围内所有方格的标记置为1，注意标记不重复计数，即记为1的方格下次还是1。最后只要统计标记不为1的格子数 就是所有矩形表示的面积。
代码实现
package LanQiaoVip_algorithm;
import java.util.Scanner;
public class ALGO278 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[][] arr = new int[n][4];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 4; j++) {
arr[i][j] = sc.nextInt();
}
}
int[][] cube = new int[100][100];//创建一张二维表
int count = 0;//保存结果
// 将矩形内的数字遍历为1
for (int i = 0; i < n; i++) {
for (int j = arr[i][0]; j < arr[i][2]; j++) {// x轴方向
for (int k = arr[i][1]; k < arr[i][3]; k++) {// y轴方向
cube[j][k] = 1;
}
}
}
for (int i = 0; i < cube.length; i++) {
for (int j = 0; j < cube.length; j++) {
if (cube[i][j] == 1) {
count++;
}
}
}
System.out.println(count);
}
}
11.学做菜
题目描述
问题描述
涛涛立志要做新好青年，他最近在学做菜。由于技术还很生疏，他只会用鸡蛋，西红柿，鸡丁，辣酱这四种原料来做菜，我们给这四种原料标上字母A,B,C,D。
涛涛现在会做的菜有五种：
1、 西红柿炒鸡蛋 原料：AABDD
2、 酸辣鸡丁 原料：ABCD
3、 宫保鸡丁 原料：CCD
4、 水煮西红柿 原料：BBB
5、 怪味蛋 原料：AD
这天早上，开开去早市给涛涛买了一些原料回来。由于事先没有什么计划，涛涛决定，对于现存的原料，每次尽量做菜单上靠前（即编号小）的菜。
现在请你写一个程序，判断一下开开和涛涛中午能吃到哪些菜。
输入格式
共4个整数a,b,c,d。分别表示开开买的A,B,C,D这4种原料的数量。每种原料不会超过30份。
输出格式
输出5行。其中第i行表示涛涛做的第i种菜的数目。
样例输入
3
1
2
4
样例输出
1
0
1
0
1
代码实现
package LanQiaoVip_algorithm;
import java.util.Scanner;
public class ALGO120 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a,b,c,d;
a=sc.nextInt();
b=sc.nextInt();
c=sc.nextInt();
d=sc.nextInt();
int[]res=new int[5];
//计算做几份西红柿
res[0]=Math.min(Math.min(a/2, b), d/2);
a-=res[0]*2;
b-=res[0];
d-=res[0]*2;
//计算做几份酸辣鸡丁
res[1]=Math.min(Math.min(a, b), Math.min(c, d));
a-=res[1];
b-=res[1];
c-=res[1];
d-=res[1];
//计算几份宫保鸡丁
res[2]=Math.min(c/2, d);
c-=res[2]*2;
d-=res[2];
//计算几份水煮西红柿
res[3]=b/3;
b-=res[3]*3;
//计算做几份怪味蛋
res[4]=Math.min(a, d);
a-=res[4];
d-=res[4];
for (int i : res) {
System.out.println(i);
}
}
}
扫一扫
464
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
