入门算法题（java)

HJ12 字符串反转

描述
接受一个只包含小写字母的字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）

输入描述：
输入一行，为一个只包含小写字母的字符串。

输出描述：
输出该字符串反转后的字符串。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String s = sc.nextLine();
            for(int i =s.length()-1;i>=0;i--){
                System.out.print(s.charAt(i));
            }
        }
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
           System.out.print(new StringBuilder(sc.nextLine()).reverse());
        }
    }
}

HJ15 求int型正整数在内存中存储时1的个数

描述
输入一个 int 型的正整数，计算出该 int 型数据在内存中存储时 1 的个数。

数据范围：保证在 32 位整型数字范围内
输入描述：
输入一个整数（int类型）

输出描述：
这个数转换成2进制后，输出1的个数

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
         int count = 0;
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            String str = Integer.toBinaryString(in.nextInt());
            for(int i = 0;i<str.length();i++){
                if(str.charAt(i) == '1'){
                    count ++;
                }
            }
        }
        System.out.print(count);
    }
}

判断是否为闰年

package Suiyi;
public class demo1 {
	public static void main(String[] args) {
		for(int i =1000;i<=2000;i++) {
			if(i%4==0&&i%100!=0||i%400==0) {
				System.out.print(i+" ");
			}
		}
	}
}

判断是否为素数

素数：也叫做质数，大于1的自然数中，除了1和该数本身外，无法被其他自然数整除的数字。

import java.util.Scanner;
public class demo1 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		boolean bool = true;
		if(n==1)
			bool = false;
		for(int i = 2;i<=(n/2);i++) {
			if(n%i==0) {
				bool = false;
				break;
			}
		}
		if(bool == true) {
			System.out.println(n+"是素数");
		}else{
			System.out.println(n+"不是素数");
		}
	}
}

打印1-100之间的素数

import java.util.Scanner;
public class demo1 {
	public static void main(String[] args) {
		for (int i = 2;i <= 100;i++){    //第一个for循环实现1-100的数字
            boolean bool = true;
            for (int j = 2;j <= (i/2);j++){  //第二个for循环实现从2到i/2的数字能否整除i，如果能，就不是素数，反之。
            	if(i%j==0) {
					bool = false;
					break;
				}
			}
			if(bool == true) {
				System.out.println(i+" ");
			}
		}
	}
}

水仙花数

“水仙花数”是指一个三位数，其各位数字的立方和确好等于该数本身，如；153＝1+125+27=153，则153是一个“水仙花数“。

import java.util.Scanner;
public class demo1 {
	public static void main(String[] args) {
        for (int i = 100; i < 1000; i++) { //“水仙花数”是一个三位数，所以i从100开始。
            int a = i % 10;           //取出个位上的数
            int b = (i / 10) % 10;    //取出十位上的数
            int c = i / 100;          //取出百位上的数
            int pd = a * a * a + b * b * b + c * c * c;
            if (pd == i) {
                System.out.println(i);
            }
        }
    }

}

//1!+2!+3!+4!+....n!
	public static long f1(int n) {
		long result = 0;
		int a = 1;
		for(int i =1;i<=n;i++) {
			a = a*i;
			result += a;
		}
		return result;
	}

选择排序

public class demo8 {
	 public static void quickSort(int []arr) {
		 int N = arr.length;
		 //从0～N-1上取最小值放在0位置上，以此类推
		 for(int i =0;i<N;i++) {
			 int minValueIndex = i;
			 for(int j =i+1;j<N;j++) {
				 minValueIndex = arr[j]<arr[minValueIndex]?j:minValueIndex;
			 }
			 swap(arr,i,minValueIndex);
		 }
	 }
	 
	 public static void swap(int arr[],int i ,int j) {
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
	 }
	 
	 public static void print(int []arr) {
		 for(int i=0;i<arr.length;i++) {
			 System.out.print(arr[i]+" ");
		 }
		 System.out.println();
	 }
	 public static void main(String[]args) {
		 int[] arr = {7,1,3,5,1,6,8,1,3,5,7,5,6};
		 print(arr);
		 quickSort(arr);
		 print(arr);
	 }
}

整形数转成二进制数

public static void print(int n) {
		//int整数在计算机底层是32位
		for(int i =31;i>=0;i--) {
			//1在计算机中表示为 00000000000000000000000000000001
			//1向左移动，与n做异或操作
			System.out.print((n & (1<<i))==0 ? '0': '1');
		}
		System.out.println();
	}
	public static void main(String []args) {
		int test = 1123123;
		//打印test的二进制
		print(test);
	}

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int m = sc.nextInt();
            int n = sc.nextInt();
            if(m<1 || n>10){
                System.out.println(-1);
            }else{
                System.out.println(shareCount(m,n));
            }
            
        }
    }
    public static int shareCount(int m, int n){
        //m会逐渐减少,直到所有苹果都分完。终会到达出口m==0．
        if(m<0){
            return 0;
        }
        //m会逐渐减少,当m=1时,一个苹果放在任意一个盘子里面，是同一种分法。都是所以返回１；
        //n会逐渐减少，终会到达出口.当n=1时，所有苹果都必须放在一个盘子里，所以返回１；
        if(m==1 || n==1){
            return 1;
        }
        // 1、有至少一个盘子空着，即相当于f(m,n) = f(m,n-1);  
        // 2、假设所有盘子都装有苹果，则每个盘子上至少有一个苹果，即最多剩下m-n个苹果，问题转化为将m-n个苹果放到n个盘子上 
        // 而总的放苹果的放法数目等于两者的和，即 f(m,n) =f(m,n-1)+f(m-n,n) 
        return shareCount(m, n-1)+shareCount(m-n,n);
    }
}

有效的大括号

爬楼梯

采用哈希表存储数据，降低复杂度