程序题练习---初级篇

方法肯定不是最优的，还希望能和大家交流探讨

一、初级篇

1.输入n，求1到n的和

public static int sumToN(int n){
		
		return (n==1)?1:(n+sumToN(n-1));
		
	}
	public static void main(String[] args) {
		System.out.println("请输入一位正整数：");
		Scanner scan = new Scanner(System.in);
		int i = scan.nextInt();
		System.out.println("1到"+i+"的和为："+sumToN(i));
	}

2.输入n，求n以内3或者5的倍数的和

public static int sum3Or5Mul(int n){
		if(n>2){
		   return (n%3==0||n%5==0)?(n+sum3Or5Mul(n-1)):sum3Or5Mul(n-1);
		}else{
			return 0;
		}		
	}
	
	public static void main(String[] args) {
		System.out.println("请输入一位整数：");
		Scanner scan = new Scanner(System.in);
		int i = scan.nextInt();
		System.out.println("1到"+i+"之间3或者5的倍数的和"+sum3Or5Mul(i));
	}

3.输入整数n，按40%概率输出1到n的和按60%的概率输出1到n的乘积

public static int productToN(int n){
		return n==1?1:n*productToN(n-1);
	}
public static int sumToN(int n){
		
		return (n==1)?1:(n+sumToN(n-1));
		
	}
public static void main(String[] args) {
		System.out.println("请输入一位整数：");
		Scanner scan = new Scanner(System.in);
		int i = scan.nextInt();
		Random rm = new Random();
		int index = rm.nextInt(10);
		if(index<4){
			System.out.println("1到"+i+"之间的和为："+sumToN(i));
		}else{
			System.out.println("1到"+i+"之间的积为："+productToN(i));
		}	
	}

4.输入整数n，打印n*n的乘法口诀表（格式对齐）

//求整数的位数
	public  static int getNOfInt(int n){
		return Integer.toString(n).length();
	}
	
public static void main(String[] args) {
		System.out.println("请输入一位整数：");
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		System.out.println(n+"*"+n+"的乘法表为：");
		for(int i= 1;i <= n;i++){
			for(int j = 1;j <= i;j++){
				int a = getNOfInt(n);
				int b = getNOfInt(n*n);
			 String fomat = "%1$"+a+"d"+"*"+"%2$"+a+"d"+"="+"%3$"+b+"d";
				String res = String.format(fomat, i,j,i*j);
				System.out.print(res+" ");
			}
			System.out.println();
		}
	}

5.游戏:程序随机生成0-99内的一个数字，由用户猜测，并提示用户输入是大是小，如果猜对输出总的猜测次数

//获取输入的数字
	public static int getInputNum(){
		Scanner scan = new Scanner(System.in);
		int i = scan.nextInt();
		if(i<0||i>99){
			throw new IllegalArgumentException ("输入错误，输入数据不是0-99整数！");
		}else{
			return i;
		}
	}
//进行判断输入数字和所猜测数字的大小,Num是所猜测的数字,n是输入的数字,m是已经猜了的次数
	public static void printRes(int Num,int n,int m){
		if(n != Num){
			String res= n>Num?"您输入的数字大了":"您输入的数字小了";
			System.out.println(res);
			printRes(Num,getInputNum(),m+1);
		}else{
			System.out.println("您猜对了，共用了"+(m+1)+"次！");
		}
	}
	
public static void main(String[] args) {
		System.out.println("猜数字游戏：请猜测出0-99的一个整数：");
		Random rm = new Random();
		int num = rm.nextInt(100);
		printRes(num, getInputNum(),0);
	}

6.输出接下来的20个闰年

//判断是闰年
	public static boolean isLeapYear(int year){
		return (year%4==0 && year%100!=0)||(year%400==0);
	}
//打印最近的20个闰年
	public static void printLeapYears(int m){
		int i = 0;
		while(i<20){
			if(isLeapYear(m)){
				System.out.print(m+" ");
				i++;
			}
			m++;
		}
	}
	public static void main(String[] args) {
		System.out.println("最近的20个闰年分别为：");
		printLeapYears(2013);
	}

7.找出正整数n以内的全部素数

//寻找max以内的素数并输出
	public static void findPrime(int max){
		System.out.println(max+"以内的素数为：");
		int i=0; //用于计数
		if(max<1){
			throw new IllegalArgumentException("无");
		}else{
			System.out.print(String.format("%5d", 2));
			i++;
			for(int j=3;j<=max;j=j+2){
				boolean flag = true;
				for(int k=3;k<=(int)Math.sqrt(j);k=k+2){
					if(j%k==0){
						flag=false;
					}
				}
				if(flag){
					System.out.print(String.format("%5d", j));
					i++;
					if(i%10==0){
						System.out.println();
					}
				}
			}	
		}
		System.out.println();
		System.out.println("共有："+i+"个素数");
	}
	
	
public static void main(String[] args) {
		 double start = System.currentTimeMillis();
		 findPrime(10000);
		 double end = System.currentTimeMillis();
		 System.out.println("所用时间："+(end-start)+"毫秒");

	}

8. 写一个函数，返数组中最大的数。

//生成具有n个m以内随机整数的数组
	public static int[] creatArray(int n,int m){
		Random rm  = new Random();
		int[] array = new int[n];
		for(int i=0;i<n;i++){
			array[i]=rm.nextInt(m);
		}
		return array;
	}
	
//获取数组中的最大元素
	public static int getMaxNum(int[] array){
		int max = array[0];
		for(int i=0;i<array.length;i++){
			max = max>array[i]?max:array[i];
		}
		return max;
	}
	
public static void main(String[] args) {
		 int[] array  = creatArray(20,100);
		 System.out.println("原数组为：");
		 for(int i=0;i<array.length;i++){
			 System.out.print(array[i]+" "); 
		 }
		 System.out.println();
		 System.out.println("最大数为："+getMaxNum(array));
	}

原数组为：
25 54 69 54 40 3 39 85 62 91 5 90 86 71 65 63 17 65 35 75 
最大数为：91

9. 交替合并两个数组

// 写个函数交替合并两个数组
	public static char[] join(char a[],char b[]){
		int length = (a.length<b.length)?2*a.length:2*b.length; 
		char [] array = new char[a.length+b.length];
		for(int i = 0;i<length/2;i++){
			array[2*i]= a[i];
			array[2*i+1] = b[i];
		}
		for(int j = length;j<(a.length+b.length);j++){
			array[j] = (a.length<b.length)?b[j-a.length]:a[j-b.length];
		}
		return array;
	}
//输出数组
	public static void printArray(char[] array){
		for(int i=0;i<array.length;i++){
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		char[] a  = {'1','2','3'};
		char[] b  = {'a','b','c','d','e'};
		System.out.println("原数组为：");
		printArray(a);
		printArray(b);
		System.out.println("交替合并两个数组后：");
		printArray(join(a,b));
	}
原数组为：
1 2 3 
a b c d e 
交替合并两个数组后：
1 a 2 b 3 c d e

10. 给定一个字符串数组并按下面表示打印出来，一行一个打印在矩形框中

如["Hello","World", "in", "a", "frame"] 打印的结果是：

*********

* Hello *

* World *

* in        *

* a         *

* frame *

*********

//获取字符串数组最长元素的长度
	public static int getMaxLength(String[] strArray){
		int length = strArray[0].length();
		for(int i = 0;i<strArray.length;i++){
			length= strArray[i].length()>length?strArray[i].length():length;
		}
		return length;
	}
	//输出一行n个星号
	public static void printNstar(int n){
		for(int i=0;i<n;i++){
			System.out.print("*");
		}
		System.out.println();
	}
	//按格式输出字符串数组
	public static void printStrArray(String[] strArray){
		int maxLength = getMaxLength(strArray);
		printNstar(maxLength+2);
		for(int i = 0;i<strArray.length;i++){
		System.out.println("*"+String.format("%-"+maxLength+"s"+"*", strArray[i]));
		}
		printNstar(maxLength+2);
	} 
	
	public static void main(String[] args) {
		String[] strArray = {"Hello","world","in","a","frame"};
		printStrArray(strArray);
	}

11. 写个函数，返回指定数的各位数字的列表。

//给一个整数，返回各位数字的数组
	public static int[] getNumArray(int n){
		int[] array = new int[getNOfInt(n)]; //getNOfInt参见初级篇第4题
		int i = 0;
		int temp = n;
		while(temp!=0){
			array[i++]=temp%10;
			temp = temp/10;
		}
		return array;
	}
	public static void main(String[] args) {
		int[] array = getNumArray(1258976);
		for(int i=array.length-1;i>=0;i--){
			System.out.print(array[i]+" ");
		}
	}

12. 实现下面的排序算法：选择排序，插入排序，归并排序，快速排序，冒泡排序

选择排序

//选择排序
	public static int[] selectSort(int[] array){
		for(int i=0;i<array.length-1;i++){
			for(int j=i+1;j<array.length;j++){
				if(array[i]>array[j]){
					int temp = array[i];
					array[i] = array[j];
					array[j] =temp;
				}
			}
		}
		return array;
	}
	public static void main(String[] args) {
		int[] array = creatArray(100000,10000);//参见第初级8题
		double start = System.currentTimeMillis();
		selectSort(array);
		double end  = System.currentTimeMillis();
		System.out.println("所用时间为："+(end-start)+"毫秒！");
	}
所用时间为：14015.0毫秒！

插入排序

//插入排序
	public static int[] insertSort(int[] array){
		int length = array.length;
		for(int i=1;i<length;i++){ //从第二个元素起依次将元素插入前面已经排好序的部分数组中
			int temp = array[i];
			int j;
			for(j=i;j>0&&temp<array[j-1];j--){//如果比前一个数小
				array[j]=array[j-1]; //前一个数往后移
			}
			array[j]=temp; //将此数放在前一个数的位子上
		}
		return array;
	}
	
	public static void main(String[] args) {
		int[] array = creatArray(100000,10000);//参见第初级8题
		double start = System.currentTimeMillis();
		insertSort(array);
		double end  = System.currentTimeMillis();
		System.out.println("所用时间为："+(end-start)+"毫秒！");
	}
所用时间为：5157.0毫秒！

归并排序

//归并排序：速度仅次于快速排序，为稳定排序算法，一般用于对总体无序，但是各子项相对有序的数列
public static int[] mergeTwoArray(int[] leftArray ,int[] rightArray){
		int[] newArray = new int[leftArray.length+rightArray.length];
		int index=0,i,j;
		for(i=0,j=0;i<leftArray.length&&j<rightArray.length;index++){
			 if(leftArray[i]<rightArray[j]){
				 newArray[index] = leftArray[i++];
			 }else{
				 newArray[index] = rightArray[j++];
			 }
		}
		for(;i<leftArray.length;i++){
			newArray[index++]=leftArray[i];
		}
		for(;j<rightArray.length;j++){
			newArray[index++]=rightArray[j];
		}
		return newArray;
	}
	
	public static int[] mergeSort(int[] array){
		if(array.length==1){
			return array;
		}else{
			int[] leftArray = new int[array.length/2];
			int[] rightArray = new int[array.length-array.length/2];
			int center = array.length/2;
			for(int i=0;i<leftArray.length;i++){
				leftArray[i]=array[i];
			}
			for(int j=0,k=center;j<rightArray.length;j++,k++){
				rightArray[j]= array[k];
			}
			int[] sortedLeftArray = mergeSort(leftArray);
			int[] sortedrightArray = mergeSort(rightArray);
			return mergeTwoArray(sortedLeftArray,sortedrightArray);
		}
	}
	
	public static void main(String[] args) {
		int[] array = creatArray(100000,10000);//参见第初级8题
		double start = System.currentTimeMillis();
		mergeSort(array);
		double end  = System.currentTimeMillis();
		System.out.println("所用时间为："+(end-start)+"毫秒！");
	}
所用时间为：31.0毫秒！

快速排序

//以数组最后一个元素作为主元将数组进行划分，使得数组的左边元素都比主元小，右边的都比主元大
	public static int partition(int[] array,int start,int end){
		int key = array[end];
		int i = start; //主要是用于依次存放比主元小的元素
		int j = start; //用于遍历数组寻找比主元小的元素
		for(;j<end;j++){ //将小于key的往前放
			if(array[j]<key){
				int temp = array[i];
				array[i] = array[j];
				array[j] = temp;
				i++;
			}
		}
		int flag = array[i];//将key放到划分位置
		array[i] = key;
		array[end] = flag;
		return i; //返回划分的位置
	}
	//快速排序
	public static int[] quickSort(int[] array,int start,int end){
		if(start>=end){
			return array;
		}else{
			int index  = partition(array,start,end);
			quickSort(array,start,index-1);
			quickSort(array,index+1,end);
			return array;
		}
	}
	public static void main(String[] args) {
		int[] array = creatArray(100000,10000);//参见第初级8题
		double start = System.currentTimeMillis();
		quickSort(array,0,array.length-1);
		double end  = System.currentTimeMillis();
		System.out.println("所用时间为："+(end-start)+"毫秒！");
	}
所用时间为：15.0毫秒！

冒泡排序

//冒泡排序
	public static int[] bubbleSort(int [] array){
		//每次排序将一个数字可以按序对位，所以要经过array.length-1次排序
		for(int i=0;i<array.length-1;i++){
			for(int j=array.length-1;j>i;j--){ //从后往前查，小于前面的数就交换，保证小的数往前放
				if(array[j]<array[j-1]){
					int temp = array[j-1];
					 array[j-1] = array[j];
					 array[j] =temp;
				}
			}
		}
		return array;
	}
	public static void main(String[] args) {
		int[] array = creatArray(100000,10000);//参见第初级8题
		double start = System.currentTimeMillis();
		bubbleSort(array);
		double end  = System.currentTimeMillis();
		System.out.println("所用时间为："+(end-start)+"毫秒！");
	}
所用时间为：21078.0毫秒！