java基础算法31-50题

将一个数组逆序输出。

public class Suan31 {
 ​
     public static void main(String[] args) {
         int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
         int len = arr.length;
         int[] b = new int[arr.length];
         for (int i = 0; i < arr.length; i++) {
             b[len - 1] = arr[i];
             len--;
         }
 ​
         System.out.println(Arrays.toString(b));
     }
 ​
 }

取一个整数a从右端开始的4～7位。

public class Suan32 {
 ​
     public static void main(String[] args) {
         Scanner sc = new Scanner(System.in);
         System.out.println("请输入一个大于7位的整数：");
         String s = sc.nextLine();
         char[] c = s.toCharArray();
         System.out.println(Arrays.toString(c));
         char[] arr = new char[c.length - 1];
         int len = c.length;
         Random rd = new Random();
         int n = rd.nextInt(4) + 4;
         System.out.println(n);
         for (int i = 0; i < n; i++) {
             arr[i] = c[len - 1];
             len--;
         }
 ​
         System.out.println(Arrays.toString(arr));
         for (int i = 0; i < n; i++) {
             System.out.print(arr[i]);
         }
     }
 ​
 }
 ​

打印出杨辉三角形（要求打印出7行如下图）

public class Suan33 {
 ​
     public static void main(String[] args) {
 ​
         int len = 7;
         int arr[][] = new int[7][7];
 ​
         for (int i = 0; i < arr.length; i++) {
             for (int j = 0; j <= i; j++) {
                 if (i == j || j == 0) {
                     arr[i][j] = 1;
                 } else {
                     arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
                 }
                 System.out.print(arr[i][j] + "\t");
             }
             System.out.println();
 ​
         }
     }
 }
 ​

输入3个数a,b,c，按大小顺序输出。

 public class Suan34 {
 ​
     public static void main(String[] args) {
         // 输入3个数a,b,c，按大小顺序输出。
         Scanner sc = new Scanner(System.in);
         System.out.println("请输入a的值：");
         int a = sc.nextInt();
         System.out.println("请输入a的值：");
         int b = sc.nextInt();
         System.out.println("请输入a的值：");
         int c = sc.nextInt();
         int[] arr = { a, b, c };
         for (int i = 0; i < arr.length - 1; i++) {
             for (int j = 0; j < arr.length - 1; j++) {
                 if (arr[j] > arr[j + 1]) {
                     int temp = arr[j + 1];
                     arr[j + 1] = arr[j];
                     arr[j] = temp;
                 }
             }
 ​
         }
         for (int i = 0; i < arr.length; i++) {
             System.out.print(arr[i] + "\t");
         }
 ​
     }
 ​
 }
 ​

输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

import java.util.Arrays;
 import java.util.Scanner;
 ​
 public class Suan35 {
 ​
     public static void main(String[] args) {
         Scanner sc = new Scanner(System.in);
         // 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
         int[] arr = new int[10];
         System.out.println("请输入十个数：");
         for (int i = 0; i < arr.length; i++) {
         int n =sc.nextInt();
         System.out.print(",");
         arr[i] = n;
         }
         
         int max = arr[0];
         int min = arr[0];
         for (int j = 0; j < arr.length - 1; j++) {
             if (arr[j] > max) {
                 max = arr[j];
             }
             if (arr[j] < min) {
                 min = arr[j];
             }
         }
         int a = fun3(arr,max,0,arr.length);
         int b = fun3(arr,min,0,arr.length);
         
         int temp =arr[0];
         arr[0] = arr[a];
         arr[a] = temp;
         
         int sum = arr[arr.length];
         arr[arr.length] = arr[b];
         arr[b] = sum;
      
         System.out.println(Arrays.toString(arr));
         
     }
 ​
     
 ​
     public static int fun3(int[] arr,int key,int start,int end) {
         if(start<=end) {
             int middle = (start+end)/2;
             if(key == arr[middle]) {
                 return middle;
             }else if(key>arr[middle]) {
                 return fun3(arr,key,middle+1,end);
             }else if(key<arr[middle]) {
                 return fun3(arr,key,start,middle-1);
             }
         }
         return -1;
     }
     
 ​
 }

有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数

 import java.util.Arrays;
 import java.util.Random;
 ​
 //题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
 public class Suan36 {
 ​
     public static void main(String[] args) {
 ​
         Random rd = new Random();
         int[] arr = new int[10];
         int[] brr = new int[10];
         int m = 4;
         for (int i = 0; i < arr.length - 1; i++) {
             arr[i] = rd.nextInt(100);
         }
 ​
         int len = (arr.length - 1) / 2;
         for (int i = 0; i < arr.length - 1; i++) {
 ​
             if (i < len) {
                 brr[i] = arr[len];
                 len--;
             } else {
                 brr[i] = arr[i];
             }
 ​
         }
 ​
         System.out.println(Arrays.toString(arr));
         System.out.println(Arrays.toString(brr));
 ​
     }
 }
 ​

有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。 import

java.util.Arrays;
 ​
 //题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。 
 public class Suan37 {
 ​
     public static void main(String[] args) {
         // 初始化游戏人数
         boolean[] person = new boolean[7];
         // 保证都是活着的人
         Arrays.fill(person, true);
         // 死了的人要在总人数中减去
         int len = person.length;
         // 报数
         int num = 1;
         // 开始游戏
         while (len > 1) {
             for (int i = 0; i < person.length; i++) {
                 if (person[i]) {
                     System.out.printf("位置为%d的人报数:%d%n", i, num);
                     if (num % 3 == 0) {
                         System.out.println("我死了!");
                         person[i] = false;
                         len--;
                     }
                     num++;
                 }
             }
         }
         System.out.println(Arrays.toString(person));
         for (int i = 0; i < person.length; i++) {
             if (person[i]) {
                 System.out.println(i);
                 break;
             }
         }
     }
 }
 ​

写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。

import java.util.Scanner;
 ​
 public class Suan38 {
     public static void main(String[] args) {
         //题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。  
         
             Scanner sc = new Scanner(System.in);
             System.out.println("请输入一行字符串");
             String s = sc.nextLine();
             int len = s.length();
             System.out.println(len);
     }
 ​
 }
 ​冒泡排序 import java.util.Arrays;
 ​
 public class Suan39 {
 ​
     public static void main(String[] args) {
 ​
         int[] arr = { 13, 67, 43, 98, 23, 56, 78, 11 };
 ​
         for (int i = 0; i < arr.length - 1; i++) {
             for (int j = 0; j < arr.length - 1; j++) {
                 if (arr[j] > arr[j + 1]) {
                     int temp = arr[j + 1];
                     arr[j + 1] = arr[j];
                     arr[j] = temp;
                 }
             }
         }
 ​
         System.out.println(Arrays.toString(arr));
     }
 ​
 }

​海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？

 public class Suan40 {
     
     public static void main(String[] args) {
         
         int x = 5;
         int sum = 0;
         for (int i = 1; i < 5; i++) {
             //i = 1时，x+1为第一只猴子拥有的最少的桃子数，六个桃子分五份，每份一个，扔海里一个
             sum=(x+1)*5;
             x=sum;
             
         }
         System.out.println(sum);
     }
 ​
 }求0—7所能组成的奇数个数。 import java.util.Random;
 ​
 public class Suan41 {
     //题目：求0—7所能组成的奇数个数。
     public static void main(String[] args) {
         
         int count = 0;
         //声明由数字组成的数
         int n = 8;
         //一位数
         count = n/2;
         //两位数
         count += n/2*(n-1);
         //三位数
         count += n*n/2*(n-1);
         //四位数
         count += n*n*n/2*(n-1);
         //五位数
         count += n*n*n*n/2*(n-1);
         //六位数
         count += n*n*n*n*n/2*(n-1);
         //七位数
         count += n*n*n*n*n*n/2*(n-1);
         System.out.println("0-7所能组成的奇数个数："+count);
     }
 }一个偶数总能表示为两个素数之和。 public class Suan42 {
 

​一个偶数总能表示为两个素数之和。

public class Suan42 {
     public static void main(String[] args) {
 ​
         Scanner sc = new Scanner(System.in);
         System.out.println("请输入一个整数：");
         int n = sc.nextInt();
         int sum = n / 2;
         if (n % 2 == 0) {
             for (int i = 0; i < n; i++) {
                 for (int j = 0; j < n; j++) {
                     if (i % 2 != 0 && j % 2 != 0 && i + j == n) {
 ​
                         System.out.printf("%d+%d=%d", i, j, n);
                     }
                 }
                 System.out.println();
             }
         } else {
             System.out.println("这不是偶数");
         }
     }
 ​
 }
 

​判断一个整数能被几个9整除

public class Suan43 {
 ​
     public static void main(String[] args) {
 ​
         Scanner sc = new Scanner(System.in);
         System.out.println("请输入一个整数：");
         int n = sc.nextInt();
         int count = 0;
         for (int i = n; i >= 9;) {
             if (i % 9 == 0) {
                 i /= 9;
                 count++;
 ​
             } else {
                 break;
             }
 ​
         }
         System.out.println(count);
     }
 }
 

​两个字符串连接程序

public class Suan44 {
     
     public static String fun(String s1,String s2) {
         //第一种：
         String s3 = s1.concat(s2);
         System.out.println(s3);
         
         System.out.println();
         return s1+s2;
         
     }
     
     public static void main(String[] args) {
         
         String s1 = "Mame name is Jeck!";
         String s2 = "I love you!";
         System.out.println(fun(s1,s2));
     }
 ​
 }读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的＊。 public class Suan45 {
     
     public static void main(String[] args) {
         Random rd = new Random();
         for (int i = 0; i < 7; i++) {
             int n = rd.nextInt(50)+1;
             for (int j = 0; j < n; j++) {
                 System.out.print("*");
                 
             }
             System.out.println();
         }
     }
 ​
 }
 ​

某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。

import java.util.Arrays;
 import java.util.Scanner;
 ​
 //题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，
 //再将第一位和第四位交换，第二位和第三位交换。 
 public class Suan46 {
     
     public static void main(String[] args) {
     
         Scanner sc = new Scanner(System.in);
         System.out.println("请输入一个四位整数：");
         int n = sc.nextInt();
         
         int a = (n%10+5)%10;
         int b = (n/10%10+5)%10;
         int c = (n/100%10+5)%10;
         int d = (n/1000+5)%10;
         
         System.out.println("每位数字都加上5,然后用和除以10的余数代替该数字后得到的每位数为："+d+","+c+","+b+","+a);
     
         String s = ""+d+c+b+a;
         char[] arr = s.toCharArray();
         System.out.println("没有换位前："+Arrays.toString(arr));
         String s2 = ""+a+b+c+d;
         char[] arr2 = s2.toCharArray();
         System.out.println("换位后的数字为"+Arrays.toString(arr2));
         
         for (char e : arr2) {
             System.out.print(e);
         }
         
     }
 ​
 }
 ​

计算字符串中子串出现的次数

public class Suan47 {
     
     public static void main(String[] args) {
         
         String s = "fguiwkqjefgopfgrtuifg";
         //contatins方法判断s是否包含字符串fg
         int count = 0;
         while(s.contains("fg")) {
             int index= s.indexOf("fg");
             //substring截取fg以后的字符串
             s = s.substring(index+2,s.length());
             count++;
             System.out.println(s);
         }
         System.out.println(count);
         
         
     }
 ​
 }

有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），计算出平均成绩，把原有的数据和计算出的平均分数

public class Suan48 {
 ​
     public static void main(String[] args) {
 ​
         int student = 5;
 ​
         Scanner sc = new Scanner(System.in);
         while (student > 0) {
             System.out.println("请输入学生号：");
             String no = sc.next();
             System.out.println("请输入姓名：");
             String name = sc.next();
             System.out.println("请输入语文成绩：");
             double a = sc.nextDouble();
             System.out.println("请输入数学成绩：");
             double b = sc.nextDouble();
             System.out.println("请输入英语成绩：");
             double c = sc.nextDouble();
 ​
             double sum = (a + b + c) / 3;
 ​
             System.out.println("姓名：" + name + "学号：" + no + "平均成绩：" + sum);
 ​
             student--;
         }
     }
 ​
 }

插入排序

import java.util.Arrays;
 ​
 public class Suan49 {
 ​
     public static void main(String[] args) {
 //      首先，我们将数组中的数据分为两个区间，已排序区间[9]和未排序区间[7, 8, 2, 5, 1, 3, 6, 4]。
 //      初始已排序区间只有一个元 素，就是数组的第一个元素。
 //      插入算法的核心思想是取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，
 //      并 保证已排序区间数据一直有序。重复这个过程，直到未排序区间中元素为空，算法结束
        // 
         int[] a = { 9, 7, 8, 2, 5, 1, 3, 6, 4 };
         //待插入的元素?
         for(int i=1;i<a.length;i++) {
             int insertNum=a[i];
             System.out.printf("待插入的值%d\t",insertNum);
             //插入的值的前面所有已经排好的值比较， 前面所有已经排好值的范围0-(i-1)
             int j = i - 1;
             for ( ;j >= 0; j--) {
                 //谁和谁比较？
                 System.out.printf("和%d比较\t",a[j]);
                 if(a[j]>insertNum) {
                     a[j+1] = a[j];
                 }else {
                     //一旦发现小于insertNum的数
                     break;
                 }
             }
             a[j+1]=insertNum;
             System.out.print("\n");
             System.out.println(Arrays.toString(a));
         }
     }
 ​
 }
 
 

​二分查找递归法 

 public class Suan50{
     public static int fun(int[] arr,int key,int start,int end) {
         
         if(start<=end) {
             int middle = (start+end)/2;
             if(arr[middle]==key) {
                 return arr[middle];
             }else if(arr[middle]>key) {
                 return fun(arr,key,start,middle-1);
             }else if(arr[middle]<key) {
                 return fun(arr,key,middle-1,end);
             }
         }
         return -1;
     }
     
     public static void main(String[] args) {
         
         int[] arr= {13,45,67,89,112,456};
         
         int i = fun(arr,89,0,arr.length-1);
         System.out.println(i);
     }
 ​
 }
 ​