1.打印倒三角
import java.util.Scanner;
public class daosanjiaoxing {
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
int rows = cin.nextInt(); //输入图形行数
//TODO: 打印由“#”构成的倒三角形
for(int i = 1; i <= rows; i ++) {//i用来记录行数
for(int j = rows; j >= i;j --) {//j用来记录#的数量
System.out.print("#");
}
System.out.print("\n");
int k = i;//记录i的值，用于更改每一次循环空格的数量
while(k > 0) {
k --;
System.out.print(" ");
}
}
}
}
2.判断素数
public class panduansushu {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入1-100中的任意数字：");
int j = sc.nextInt();
for (int i = 1; i <= j; i++) {
if (isPrime(i)) {
System.out.print(i+" ");
}
}
}
//素数的判断方法
private static boolean isPrime(int num) {
if(num==1){
return false;
}
//TODO:求出该数值的2次方根，然后判断2到该值之间是否有可以被整除的数，在“- -”处补全代码
long sqrtNum=(long)Math.sqrt(num);
for(int k = 2;k <=sqrtNum;k++){
if(num % k == 0){
return false;
}
}
return true;
}
}求素数
import java.util.Scanner;
public class Example3_7 {
public static void main(String args[]) {
Scanner reader = new Scanner(System.in);
System.out.println("输入n：");
int n = reader.nextInt();
//TODO:调用prime方法传入需要判断的数n
prime(n);
}
/*
TODO:求素数方法
功能描述：编写方法求n以内的所有素数，并打印输出
参数说明：int型变量n
返回值说明：无
提示：打印语句为System.out.println(j+"是素数");
*/
public static void prime(int n){
for(int j = 2; j <= n; j++){
boolean flag = true;
for(int i = 2; i <= Math.sqrt(j);i++){
if(j % i == 0){
flag = false;
break;
}
}
if(flag){
System.out.println(j+"是素数");
}
}
}
}
3.判断四季
import java.util.Scanner;
public class yuefen {
public static void main(String args[]) {
Scanner cin = new Scanner(System.in);
int month = cin.nextInt(); //输入月份
String season = "不合法的月份！";
if(month >=1 && month <3 || month == 12){
season ="冬天";
System.out.println(season);
}else if(month >=3 && month<6){
season = "春天";
System.out.println(season);
}else if(month >=6 && month <9){
season="夏天";
System.out.println(season);
}else if (month >=9 && month < 12){
season = "秋天";
System.out.println(season);
}else{
System.out.println("月份不合法！");
}
}
}public class Main {
public static void main(String args[]) {
Scanner cin = new Scanner(System.in);
int month = cin.nextInt(); //输入月份
String season = "不合法的月份！";
if(month >=1 && month <3 || month == 12){
season ="冬天";
}else if(month >=3 && month<6){
season = "春天";
}else if(month >=6 && month <9){
season="夏天";
}else if (month >=9 && month < 12){
season = "秋天";
}
System.out.println(season);
}
}4.斐波那契数列
import java.io.*;
import java.util.*;
public class Main {
public static void main(String args[]) {
Scanner cin = new Scanner(System.in);
int n = cin.nextInt();
long fn = 1;
if(n != 1){
int[] arr = new int[n];
arr[0] = 1;
arr[1] = 1;
for(int x = 2; x < arr.length; x ++) {
arr[x] = arr[x-2] + arr[x-1];
}
fn = arr[n-1];
}
System.out.println(fn);
}
}5.两只老虎
/*
两只老虎（180kg和200kg）
需求：
动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，
请用程序实现判断两只老虎的体重是否相同；
*/
public class sanyuan2{
public static void main (String[] args){
//1：定义两个变量用于保存老虎的体重，单位为kg，这里仅体现数据即可。
int weight1 = 180;
int weight2 = 200;
//2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则，返回false；
boolean b = weight1 == weight2 ? true : false;
//3：输出结果
System.out.println("b:" + b);
}
}6.三个和尚
/*
三个和尚
需求：
一个寺庙里住着三个和尚，
已知他们的身高分别为150cm、210cm、165cm，
请用程序实现获取这三个和尚的最高身高。
步骤：
1.定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
2.用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
3.用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
4.输出结果
*/
public class sanyuan3{
public static void main (String[] args){
int height1 = 150;
int height2 = 210;
int height3 = 165;
/*
int a = height1 > height2 ? height1:height2;
int b = height2 > height3 ? height2:height3;
int c = a > b ? a: b;
System.out.println("max:" + c);
*/
int tempHeight = height1 > height2 ? height1 : height2;
int maxHeight = tempHeight > height3 ? tempHeight : height3;
System.out.println("maxHeight:" + maxHeight);
}
}/*
三个和尚升级版
需求：
一个寺庙里住着三个和尚，他们的身高必须经过测量得出，请用程序实现这三个和尚的最高身高。
*/
import java.util.Scanner;
public class shujushuru2{
public static void main (String[] args){
//身高未知，采用键盘录入实现，首先导包，然后创建对象。
Scanner sc = new Scanner(System.in);
//键盘录入三个身高分别赋值给三个变量。
System.out.println("请输入第一个和尚的身高：");
int height1 = sc.nextInt();
System.out.println("请输入第二个和尚的身高：");
int height2 = sc.nextInt();
System.out.println("请输入第三个和尚的身高：");
int height3 = sc.nextInt();
//用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
int tempHeight = height1 > height2 ? height1 : height2;
//用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
int maxHeight = tempHeight > height3 ? tempHeight : height3;
//输出结果。
System.out.println("这三个和尚中身高最高的是:" + maxHeight + "cm");
}
}7.水仙花数
/*
水仙花
定义：
1.是三位数
2.水仙花数的个位、十位、百位的立方和等于原数
需求：
在控制台输出所有的“水仙花数”
*/
public class forxunhuan5{
public static void main(String[] args){
//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
/*
for(int i=100;i<=999;i++){
}
*/
for(int i=100;i<1000;i++){
//在计算之前获取三位数中每个位上的值
int ge = i%10;
int shi = i/10%10;
int bai = i/100;
//判定条件是将三位数中的每个数值取出来，计算立方和与原始数字比较是否相等
if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i){
//输出满足条件的数字就是水仙花数
System.out.println(i);
}
}
}
}8.珠穆朗玛峰
/*
珠穆朗玛峰
需求：世界最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度？
*/
public class whilexunhuan2{
public static void main(String[] args){
//定义一个计数器，初始值为0
int count = 0;
//定义纸张厚度
double paper = 0.1;
//定义珠穆朗玛峰的高度
int zf = 8844430;
//因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
//折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
while(paper <= zf){
//循环的过程中每次纸张折叠，纸张的厚度要加倍
paper *= 2;
//在循环中执行累加，对应折叠了多少次
count++;
}
//打印计数器的值
System.out.println("需要折叠："+count+"次");
}
}9.猜数字
/*
猜数字
需求：
程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
当猜错的时候根据不同情况给出相应的提示
如果猜的数字比真实数字大，提示你猜的数据大了
如果猜的数字比真实数字小，提示你猜的数据小了
如果猜的数字与真实数字相符，提示恭喜你猜中了
*/
import java.util.Random;
import java.util.Scanner;
public class caishuzi{
public static void main(String[] args){
//要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
Random r = new Random();
int number = r.nextInt(100) + 1;
while(true){
//使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要猜的数字：");
int guessNumber = sc.nextInt();
//比较输入的数字和系统产生的数据，需要使用分支语句。这里使用if...else...if...格式，根据不同情况进行猜测结果显示
if(guessNumber > number){
System.out.println("你猜的数字"+ guessNumber +"大了");
}else if(guessNumber < number){
System.out.println("你猜的数字"+ guessNumber +"小了");
}else{
System.out.println("恭喜你猜中了");
break;
}
}
}
}10.探索数组中的最大最小值
/*
获取最值
获取数组中的最大值
最小值自己探索完成
*/
public class ArrayTest02{
public static void main(String[] args) {
//定义数组
int[] arr ={12,45,98,73,60};
//定义一个变量，用于保存最大值
//取数组中第一个数据作为变量的初始值
int max = arr[0];
//与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
for(int x=1;x<arr.length;x++){
if(arr[x]> max){
max = arr[x];
}
}
//循环结束后打印变量的值
System.out.println("max:"+max);
//最小值探索
int min = arr[0];
for(int y=1;y< arr.length;y++){
if(arr[y]<min){
min = arr[y];
}
}
System.out.println("min:"+min);
}
}11.用户模拟登录
import java.util.Scanner;
/*
需求：
已知用户名和密码，请用程序实现模拟用户登录，总共给三次机会，登录之后，给出相应的提示
思路：
1：已知用户名和密码，定义两个字符串表示即可
2：键盘录入要登录的用户名和密码，用Scanner实现
3：拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用equals()方法实现
4：用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
*/
public class StringTest01 {
public static void main(String[] args) {
//已知用户名和密码，定义两个字符串表示即可
String username = "^_^";
String password = "T T";
//用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
for(int i = 0; i<3 ; i++) {
//键盘录入要登录的用户名和密码，用Scanner实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String name = sc.nextLine();
System.out.println("请输入密码");
String pwd = sc.nextLine();
//拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用equals()方法实现
if (name.equals(username) && pwd.equals(password)) {
System.out.println("登录成功");
break;
} else {
if(2 - i == 0){
System.out.println("你的账户被锁定，请与管理员联系");
}else {
//2,1,0
//i:0,1,2
System.out.println("登录失败，你还有" + (2 - i) + "次机会");
}
}
}
}
}
12.遍历字符串
package com.xiaoniao_03;
import java.util.Scanner;
/*
需求：
键盘录入一个字符串，使用程序实现在控制台遍历该字符串
思路：
1：键盘录入一个字符串，用Scanner实现
2：遍历字符串，首先要能够获取到字符串中的每一个字符
public char charAt (int index):返回指定索引处的char值，字符串的索引也是从0开始的
3：遍历字符串，其次要能够获取到字符串的长度
public int length ():返回此字符串的长度
数组的长度：数组名.length
字符串的长度：字符串对象.length()
4：遍历字符串的通用格式
*/
public class StringTest02 {
public static void main(String[] args) {
//键盘录入一个字符串，用Scanner实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
//遍历字符串，首先要能够获取到字符串中的每一个字符
// System.out.println(line.charAt(0));
// System.out.println(line.charAt(1));
// System.out.println(line.charAt(2));
// for(int i = 0;i<3;i++){
// System.out.println(line.charAt(i));
// }
//遍历字符串，其次要能够获取到字符串的长度
// System.out.println(line.length());
for(int i = 0;i<line.length();i++){
System.out.println(line.charAt(i));
}
}
}
13.统计大小写出现次数
import java.util.Scanner;
/*
需求：
键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数（不考虑其他字符）
思路：
1：键盘录入一个字符串，用Scanner实现
2：要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
3：遍历字符串，得到每一个字符
4：判断该字符属于哪种类型，然后对应类型的统计变量+1
假如ch是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范围即可
大写字母：ch>='A' && ch<='Z'
小写字母：ch>='a' && ch<='z'
数字：ch>='0' && ch<='9'
5：输出三种类型的字符个数
*/
public class StringTest03 {
public static void main(String[] args) {
//键盘录入一个字符串，用Scanner实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
//要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
//遍历字符串，得到每一个字符
for(int i = 0;i<line.length();i++){
char ch = line.charAt(i);
//判断该字符属于哪种类型，然后对应类型的统计变量+1
if (ch>='A' && ch<='Z'){
bigCount++;
}else if (ch>='a' && ch<='z'){
smallCount++;
}else if (ch>='0' && ch<= '9'){
numberCount++;
}
}
//输出三种类型的字符个数
System.out.println("大写字母："+ bigCount+"个");
System.out.println("小写字母："+ smallCount+"个");
System.out.println("数字："+ numberCount + "个");
}
}
14.将数组拼接成字符串返回
/*
需求：
定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。
例如，数组为 int[] arr = {1,2,3};，执行方法后的输出结果为：[1, 2, 3]
思路：
1：定义一个int类型的数组，用静态初始化完成数组元素的初始化
2：定义一个方法，用于把int数组中的数据按照指定格式拼接成一个字符串返回
返回值类型String，参数列表int[] arr
3：在方法中遍历数组，按照要求进行拼接
4：调用方法，用一个变量接受结果
5：输出结果
*/
public class StringTest04 {
public static void main(String[] args) {
//定义一个int类型的数组，用静态初始化完成数组元素的初始化
int[] arr = {1,2,3};
//调用方法，用一个变量接受结果
String s = arrayToString(arr);
//输出结果
System.out.println("s:"+s);
}
//定义一个方法，用于把int数组中的数据按照指定格式拼接成一个字符串返回
/*
两个明确：
返回值类型；String
参数：int[] arr
*/
public static String arrayToString(int[] arr){
//在方法中遍历数组，按照要求进行拼接
String s ="";
s+="[";
for(int i=0;i<arr.length;i++){
if(i == arr.length -1){
s+= arr[i];
}else{
s+=arr[i];
s+=", ";
}
}
s+="]";
return s;
}
}15.反转字符串输出
import java.util.Scanner;
/*
需求：
定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果。
例如：键盘录入abc,输出结果cba
思路：
1：键盘录入一个字符串，用Scanner实现
2：定义一个方法，实现字符串反转。返回值类型String，参数String s
3：在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
4：调用方法，用一个变量接受结果
5：输出结果
*/
public class StringTest05 {
public static void main(String[] args) {
//键盘录入一个字符串，用Scanner实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
//调用方法，用一个变量接受结果
String s = reverse(line);
//输出结果
System.out.println("s:"+s);
}
//定义一个方法，实现字符串反转
/*
两个明确：
返回值类型：String
参数:String s
*/
public static String reverse(String s){
//在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
String ss = "";
for(int i =s.length()-1;i>=0;i--){
ss += s.charAt(i);
}
return ss;
}
}
16.逢七过
package com.xiaoniao;
/*
需求：
朋友聚会的时候可能会玩一个游戏，逢七过。
规则是：从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。
为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过规则的数据。
这样，大家将来在玩游戏的时候，就知道哪些数据要说，过。
思路：
1：数据在1-100之间，用for循环实现数据的获取
2：根据规则，用if语句实现数据的判断，要么个位是7，要么十位是7，要么能够被7整除
3：在控制台输出满足规则的数据
*/
public class Test03 {
public static void main(String[] args) {
// 数据在1-100之间，用for循环实现数据的获取
for(int x=1;x<=100;x++){
//根据规则，用if语句实现数据的判断，要么个位是7，要么十位是7，要么能够被7整除
if(x%10==7 || x/10%10==7 || x%7==0){
//在控制台输出满足规则的数据
System.out.println(x);
}
}
}
}17.百钱百鸡
package com.xiaoniao;
/*
需求：
我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一
百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
思路：
1：第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20
2：第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0, 判断条件是y<=33
3：这个时候，用于表示鸡雏的变量 z = 100-x-y
4：判断表达式 z%3==0 和表达式 5*x + 3*y + z/3 = 100 是否同时成立，如果成立，输出对应的x，y，z的值，
就是对应的鸡瓮，鸡母，鸡雏的值
*/
public class Test05 {
public static void main(String[] args) {
//第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20
for(int x=0;x<=20;x++){
//第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0, 判断条件是y<=33
for(int y=0;y<=33;y++){
//这个时候，用于表示鸡雏的变量 z = 100-x-y
int z = 100 - x -y;
//判断表达式 z%3==0 和表达式 5*x + 3*y + z/3 = 100 是否同时成立
if(z%3==0 && 5*x+3*y+z/3==100 ) {
System.out.println(x + "，" + y + "，" + z + "，");
}
}
}
}
}
18.有条件求和
package com.xiaoniao;
/*
需求：
有这样的一个数组，元素是{68，27，95，88，171，996，51，210}.求出该数组中满足要求的元素和。
要求是：求和的元素个位和十位数都不能是7，并且只能是偶数。
思路：
1：定义一个数组，用静态初始化完成数组元素的初始化
2：定义一个求和变量，初始值是0
3：遍历数组，获取到数组中的每一个元素
4：判断该元素是否满足条件，如果满足条件就累加
5：输出求和变量的值
*/
public class Test06 {
public static void main(String[] args) {
//定义一个数组，用静态初始化完成数组元素的初始化
int[] arr={68,27,95,88,171,996,51,210};
//定义一个求和变量，初始值是0
int sum = 0;
//遍历数组，获取到数组中的每一个元素
for(int x=0;x<arr.length;x++){
//判断该元素是否满足条件，如果满足条件就累加
if(arr[x]%10!=7 && arr[x]/10%10!=7 && arr[x]%2==0){
sum += arr[x];
}
}
//输出求和变量的值
System.out.println("sum:"+sum);
}
}
19.比较两数组是否相同
/*
需求：
设计一个方法，用于比较两个数组的内容是否相同
思路：
1：定义两个数组，分别使用静态初始化完成数组元素的初始化
2：定义一个方法，用于比较两个数组的内容是否相同
3：比较两个数组的内容是否相同，按照下面的步骤实现就可以了
首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false
其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
最后循环遍历结束后，返回true
4：调用方法，用变量接收
5：输出结果
*/
public class Test07 {
public static void main(String[] args) {
//定义两个数组，分别使用静态初始化完成数组元素的初始化
int[] arr={11,22,33,44,55};
//int[] arr2={11,22,33,44,55};
int[] arr2={11,22,33,55,44};
//调用方法，用变量接收
boolean flag = compare(arr,arr2);
//输出结果
System.out.println(flag);
}
//定义一个方法，用于比较两个数组的内容是否相同
/*
两个明确：
返回值类型：boolean
参数：int[] arr,int[] arr2
*/
public static boolean compare(int[] arr,int[] arr2){
//首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false
if(arr.length != arr2.length){
return false;
}
//其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
for(int x=0;x<arr.length;x++){
if(arr[x] != arr2[x]){
return false;
}
}
//最后循环遍历结束后，返回true
return true;
}
}
20.查找数组中数据的索引值
import java.util.Scanner;
/*
需求：
已知一个数组arr = {19,28,37,46,50};键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到的索引值。
思路：
1：定义一个数组，用静态初始化完成数组元素的初始化
2：键盘录入要查找的数据，用一个变量接收
3：定义一个索引变量，初始值为-1
4：遍历数组，获取到数组中的每一个元素
5：拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引值赋值给索引变量，并结束循环
6：输出索引变量
*/
public class Test08 {
public static void main(String[] args) {
//定义一个数组，用静态初始化完成数组元素的初始化
int[] arr={19,28,37,46,50};
//键盘录入要查找的数据，用一个变量接收
Scanner sc = new Scanner(System.in);
System.out.println("请输入要查找的数据：");
int number = sc.nextInt();
/*
//定义一个索引变量，初始值为-1
int index=-1;
//遍历数组，获取到数组中的每一个元素
for(int x=0;x<arr.length;x++){
//拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引值赋值给索引变量，并结束循环
if(arr[x]==number){
index = x;
break;
}
}
*/
//调用方法
int index = getIndex(arr,number);
//输出索引变量
System.out.println("index:"+index);
}
//用方法查找指定的数据在数组中的索引
/*
两个明确：
返回值类型：int
参数：int[] arr,int number
*/
public static int getIndex(int[] arr,int number) {
//定义一个索引变量，初始值为-1
int index = -1;
//遍历数组，获取到数组中的每一个元素
for (int x = 0; x < arr.length; x++) {
//拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引值赋值给索引变量，并结束循环
if (arr[x] == number) {
index = x;
break;
}
}
//返回索引
return index;
}
}
21.交换数组中的元素并输出
/*
需求：
已知一个数组 arr = {19,28,37,46,50};用程序实现把数组中的元素值交换，
交换后的数组 arr = {50,46,37,28,19};并在控制台输出交换后的数组元素。
思路：
1：定义一个数组，用静态初始化完成数组元素的初始化
2：循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
3：变量交换
4：遍历数组
*/
public class Test09 {
public static void main(String[] args) {
//定义一个数组，用静态初始化完成数组元素的初始化
int[] arr = {19,28,37,46,50};
/*
//循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
for(int start =0,end=arr.length-1;start<=end;start++,end--){
//变量交换
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
*/
//调用反转方法
reverse(arr);
//遍历数组
printArray(arr);
}
//把反转也写成方法
/*
两个明确：
返回值类型：void
参数：int[] arr
*/
public static void reverse(int[] arr){
//循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
for(int start =0,end=arr.length-1;start<=end;start++,end--) {
//变量交换
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}
/*
两个明确：
返回值类型：void
参数：int[] arr
*/
public static void printArray(int[] arr){
System.out.print("[");
for(int x=0;x<arr.length;x++){
if(x == arr.length-1){
System.out.print(arr[x]);
}else{
System.out.print(arr[x]+", ");
}
}
System.out.println("]");
}
}
22.计算比赛得分
import java.util.Scanner;
/*
需求：
在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
选手的最后的得分为，去掉一个最高分和一个最低分后的4个评委平均值（不考虑小数部分）。
思路：
1：定义一个数组，用动态初始化完成数组元素的初始化，长度为6
2：键盘录入评委分数
3：由于是6个评委打分，所以，接收评委分数的操作，用循环改进
4：定义方法实现获取数组中的最高分（数组最大值），调用方法
5：定义方法实现获取数组中的最低分（数组最小值），调用方法
6：定义方法实现获取数组中的所有元素的和（数组元素求和），调用方法
7：按照计算规则进行计算得到平均分
8：输出平均分
*/
public class Test10 {
public static void main(String[] args) {
//定义一个数组，用动态初始化完成数组元素的初始化，长度为6
int[] arr = new int[6];
//键盘录入评委分数
Scanner sc=new Scanner(System.in);
// System.out.println("请输入第1个评委的打分：");
// arr[0]=sc.nextInt();
// System.out.println("请输入第2个评委的打分：");
// arr[1]=sc.nextInt();
//由于是6个评委打分，所以，接收评委分数的操作，用循环改进
for(int x=0;x<arr.length;x++){
System.out.println("请输入第"+(x+1)+"个评委的打分：");
arr[x] = sc.nextInt();
}
//printArray(arr);
//定义方法实现获取数组中的最高分（数组最大值），调用方法
int max = getMax(arr);
//定义方法实现获取数组中的最低分（数组最小值），调用方法
int min = getMin(arr);
//定义方法实现获取数组中的所有元素的和（数组元素求和），调用方法
int sum = getSum(arr);
//按照计算规则进行计算得到平均分
int avg = (sum - max - min)/(arr.length-2);
//输出平均分
System.out.println("选手的最终得分是："+avg);
}
/*
两个明确：
返回值类型：int
参数：int[] arr
*/
public static int getSum(int[] arr){
int sum = 0;
for(int x=0;x<arr.length;x++){
sum += arr[x];
}
return sum;
}
/*
两个明确：
返回值类型：int
参数：int[] arr
*/
public static int getMin(int[] arr){
int min = arr[0];
for(int x=1;x<arr.length;x++){
if(arr[x]<min){
min=arr[x];
}
}
return min;
}
/*
两个明确：
返回值类型：int
参数：int[] arr
*/
public static int getMax(int[] arr){
int max = arr[0];
for(int x=1;x<arr.length;x++){
if(arr[x]>max){
max = arr[x];
}
}
return max;
}
//遍历数组
public static void printArray(int[] arr){
System.out.print("[");
for(int x = 0;x<arr.length;x++){
if(x == arr.length - 1){
System.out.print(arr[x]);
}else{
System.out.print(arr[x]+",");
}
}
System.out.println("]");
}
}
————————————————————————————————
一、求最大公约数和最小公倍数
import java.util.Scanner;
public class zuoye{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int n1 = input.nextInt();
System.out.println("请输入第二个整数：");
int n2 = input.nextInt();
System.out.println("最大公约数：" + get_gcd(n1, n2));
}
// 最大公约数
public static int get_gcd(int n1, int n2) {
int gcd = 0;
if (n1 < n2) {
gcd = n2;
n2 = n1;
n1 = gcd;
//TODO：如果n1小于n2,将n1和n2 互换。方便后面知道哪个值是最大的，避免多次判断。
}
if (n1 % n2 == 0) {
//TODO:如果n1能被n2整除 最大公约数为n2。
gcd = n2;
return gcd;
}
while (n1 % n2 > 0) {
//TODO：设置n1等于n1除以n2的余数。
n1 = n1 % n2;
if (n1 < n2) {
gcd = n2;
n2 = n1;
n1 = gcd;
//TODO：再判断如果n1小于n2,将n1和n2 互换。
}
if (n1 % n2 == 0) {
//TODO:如果n1能被n2整除 最大公约数为n2。
gcd = n2;
}
}
return gcd;
}
/*
TODO:求最小公倍数
功能描述：求出输入的两个数字的最小公倍数。提示：n1和n2的乘积除以最大公约数既为最小公倍数
参数说明：需要运算的两个数
返回值说明：两个参数的最小公倍数
*/
public static int get_lcm(int n1, int n2) {
int lcm = 0;
lcm = n1 * n2 / get_gcd(n1,n2);
return lcm;
}
}二、用户输入密码来加密“今晚十点进攻”
import java.util.Scanner;
public class Example8_8 {
public static void main(String args[]) {
String sourceString = "今晚十点进攻";
EncryptAndDecrypt person = new EncryptAndDecrypt();
System.out.println("输入密码加密:"+sourceString);
Scanner scanner = new Scanner(System.in);
String password = scanner.nextLine();
String secret = person.encrypt(sourceString,password);
System.out.println("密文:"+secret);
System.out.println("输入解密密码");
password = scanner.nextLine();
String source = person.decrypt(secret,password);
System.out.println("明文:"+source);
}
}
class EncryptAndDecrypt {
String encrypt(String sourceString,String password) { //加密算法
char [] p= password.toCharArray();
int n = p.length;
char [] c = sourceString.toCharArray();
int m = c.length;
/*
TODO: 循环密文长度k，将密文c[k]与密码p[k%n]相加
然后将其结果值返回给c[k]，得到加密的密文
*/
for(int k=0; k<m;k++){
int mima = c[k]+p[k%n];
c[k] = (char)mima;
}
return new String(c); //返回密文
}
String decrypt(String sourceString,String password) { //解密算法
char [] p= password.toCharArray();
int n = p.length;
char [] c = sourceString.toCharArray();
int m = c.length;
/*
TODO:循环密文长度k，将密文c[k]与密码p[k%n]相减
然后将其结果值返回给c[k]，得到解密的密文
*/
for(int k=0; k<m;k++){
int mima = c[k]-p[k%n];
c[k] = (char)mima;
}
return new String(c); //返回明文
}
}三、输出矩形和圆的面积
import java.util.Scanner;
class Circle implements Shape2D {
double radius;
public Circle(double r) { //构造方法
radius = r;
}
public double area() {
//TODO:计算面积，并返回结果
return pi*radius*radius;
}
}
class Rectangle implements Shape2D {
int width, height;
public Rectangle(int w, int h) { //构造方法
width = w;
height = h;
}
public double area() {
//TODO:计算面积，并返回结果
return width*height;
}
}
public class Example7_97 {
public static void main(String[] args) {
//TODO：接口声明变量
Shape2D var1,var2;
Scanner reader = new Scanner(System.in);
int a = reader.nextInt();
int b = reader.nextInt();
double c = reader.nextDouble();
var1 = new Rectangle(a, b);
System.out.println("Area of var1 = " + var1.area());
var2 = new Circle(c);
System.out.println("Area of var2 = " + var2.area());
}
}
interface Shape2D { //声明Shape2D接口
final double pi = 3.14; //数据成员一定要初始化
public abstract double area(); //抽象方法，不需要定义处理方式
}
四、计算输入的手机套餐、商品价钱的和
import java.util.InputMismatchException;
import java.util.Scanner;
public class Example8_13 {
public static void main(String args[]) {
String cost = "市话76.8元,长途:167.38元,短信12.68元";
System.out.println("输入手机套餐：");
Scanner scanner =new Scanner(System.in);
cost = scanner.next();
//TODO:调用GetPrice类的givePriceSum方法获取消费总价钱
double priceSum = GetPrice.givePriceSum(cost);
System.out.printf("%s\n总价:%.2f元\n",cost,priceSum);
System.out.println("输入商品价格：");
cost = "牛奶:8.5元,香蕉3.6元，酱油:2.8元";
cost = scanner.next();
//TODO:调用GetPrice类的givePriceSum方法获取消费总价钱
priceSum = GetPrice.givePriceSum(cost);
System.out.printf("%s\n总价:%.2f元\n",cost,priceSum);
}
}
class GetPrice {
public static double givePriceSum(String cost) {
Scanner scanner = new Scanner(cost);
//scanner设置分隔标记
scanner.useDelimiter("[^0123456789.]+");
double sum=0;
while(scanner.hasNext()){
/*
TODO:获取输入的double类型数据，然后将输入数据与sum相加
相加的结果赋值给sum
*/
try{
double price = scanner.nextDouble();
sum = price + sum;
}catch(InputMismatchException e){
String t=scanner.next();
}
}
return sum;
}
}五、录入5个字符串，删除第4个字符串后再按照顺序输出数组
import java.util.Scanner;
/*
输入5个字符串，通过数组按照顺序接收后，删除第四个元素后按照顺序将数组输出。
如：分别输入：1，2，3，4，5.删除第四个元素后输出：1，2，3，5
*/
public class Example15_3 {
public static void main(String[] args) throws Exception {
Scanner input = new Scanner(System.in);
System.out.println("请您输入5个字符串:");
String[] a = new String[5];
a[0] = input.nextLine();
a[1] = input.nextLine();
a[2] = input.nextLine();
a[3] = input.nextLine();
a[4] = input.nextLine();
String it = delete(a,3);
System.out.print("删除后的内容：");
for(int i=0;i<a.length-1;i++){
System.out.println(a[i]);
}
}
public static String delete(String[] list,int i) throws Exception{
int size =list.length;
if(size == 0){
throw new Exception("顺序表已空无法删除！");
}
if (i < 0 || i > size-1){
throw new Exception("参数错误！");
}
String it = list[i];
//TODO：将第i个元素删除，并对后面的i+1元素往前移动。
for(int j = i ;j<size-1;j++)
{
list[j]=list[j+1];
}
size--;
return it;
}
}
六、比较2个数值的大小
import java.util.Scanner;
/*
随机输入2个数值，利用Math类的方法比较大小并输出其中的较大值和较小值。
如：输入 2.0
3.0
输出 较小值：2.0较大值为：3.0
*/
class Example7_57 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("输入2个数值:");
double s1 = input.nextDouble();
double s2 = input.nextDouble();
//TODO：利用Math类的min和max方法获取录入2个数值的较大值和较小值
double max = Math.max(s1,s2);
double min = Math.min(s1,s2);
System.out.print("较小值："+min+"较大值为："+max);
}
}
七、输入数量不定的整数（不大于10个，0结束输入）初始化数组，然后输出其长度。
import java.util.Scanner;
public class Example2_5_4 {
public static void main(String args[ ]) {
int[] a= new int[10];
System.out.print("输入10个以内整数型数据(0结束)：");
Scanner scanner = new Scanner(System.in);
int b = scanner.nextInt();
int i;
for(i = 0;i<10&&(b!=0);i++){
a[i]=b;
b = scanner.nextInt();
}
/*
TODO:判断数组的长度
提示：int型数组初始化时，默认值为0
判断a[i]是0，输出长度i，如果直到i=9没有元素为0，直接输出a.length
打印语句：System.out.println("数组的长度是："+i);
*/
System.out.println("数组的长度是："+i);
}
}
扫一扫
373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
