力扣-每日一道算法题(java)_每天一道算法题java

---

力扣官方网站：https://leetcode-cn.com/

持续更新中…

---

两数之和

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int nums[] = {4,2,2,1,9,1,2};
        int[] result = twoSum(nums,6);
        System.out.println(Arrays.toString(result));
    }

    public static int[] twoSum(int[] nums, int target) {
        int i,j;
        for(i=0;i<nums.length;i++){
            for(j=0;j<nums.length;j++){
                if(i == j ){
                    continue;
                }
                if(nums[i]+nums[j]==target){
                    return new int[] {i,j};
                }
            }
        }
        return nums;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

猜数字

public class test {
    public static void main(String[] args) {
       int  answer[] = {2,2,3};
       int guess[] = {3,2,1};
        System.out.println(game(answer,guess));
    }
    public static int game(int[] guess, int[] answer) {
        int number=0;
        int i;
        for(i = 0;i<guess.length;i++){
            if(guess[i] == answer[i]){
                number++;
            }
        }
        return number;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

加一

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class test {
    public static void main(String[] args) {
        int digits[] = {8,9,9} ;
        //System.out.println(12%10);
        int [] result = plusOne(digits);
        System.out.println(Arrays.toString(result));
    }
    public static int[] plusOne(int[] digits) {

        for(int i=digits.length-1;i>=0;i--){
            digits[i]++;
            if(digits[i]%10!=0){
                return  digits;
            }else {
                digits[i]=0;
            }
        }
        digits=new int[digits.length+1];
        digits[0]=1;
        return digits;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

拿硬币

public class test {
    public static void main(String[] args) {
        int[] arr = {10,3,2,1};
        System.out.println(minCount(arr));
    }
    public static int minCount(int[] coins) {
        int number =0;
        for(int i =0;i<coins.length;i++) {
            while (true) {
                if(coins[i]<=0){
                    break;
                }
                if (coins[i] > 0) {
                    if (coins[i] == 1) {
                        coins[i]--;
                        number++;
                    } else {
                        coins[i] -= 2;
                        number++;
                    }
                }

            }
        }
        return number;
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

统计位数为偶数的数字

public class test {
    public static void main(String[] args) {
        int[] arr = {11, 23, 23};
        System.out.println(findNumbers(arr));
    }

    public static int findNumbers(int[] nums) {
        int len = 0;
        for(int i =0;i<nums.length;i++){
            if((""+nums[i]).length()%2 == 0 )len++;
        }
        return len;
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

有多少小于当前数字的数字

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int[] arr = {11, 23, 23};
        System.out.println(Arrays.toString(smallerNumbersThanCurrent(arr)));
    }

    public static int[] smallerNumbersThanCurrent(int[] nums) {
        int arr1[] =  new int[nums.length];

        for(int i =0;i< nums.length;i++){
            for(int j =0;j< nums.length;j++){
                if (nums[i] >nums[j] && nums[i] != nums[j]){
                    arr1[i]++;
                }
            }

        }
        return arr1;
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

斐波那契数列

public class test {
    public static void main(String[] args) {
        System.out.println(fib(46));
    }

    public static int fib(int n) {

        int arr[] = new int[n];

        switch (n){
            case 0:
                return 0;
            case 1:
                return 1;
            case 2:
                return 1;
        }
        arr[0]=1;
        arr[1]=1;

        for(int i = 2 ; i<n ;i++){

            arr[i] = arr[i-1]+arr[i-2];
            if(arr[i]>=1000000007) {
                arr[i]%=1000000007;
            }

        }

        return arr[arr.length-1];
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

打印从1到最大的n位数

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        System.out.println(Arrays.toString(printNumbers(1)));
    }

    public static int[] printNumbers(int n) {
        int end = (int)Math.pow(10, n);
        int arr[] = new int[end-1];
        for(int i=1; i<end;i++){
            arr[i-1] = i;
        }

        return arr;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

转换成小写字母

public String toLowerCase(String str) {
        return str.toLowerCase();
    }
1
2
3

替换空格

public String replaceSpace(String s) {
            return s.replace(" ","%20");
    }
1
2
3

唯一摩尔斯密码词

import java.util.*;

public class test {
    public static void main(String[] args) {

        String words[] ={"noilq","kzlq","ydreq","ybxk","kzlq"};


        System.out.println( uniqueMorseRepresentations(words));

    }

        public static int uniqueMorseRepresentations(String[] words) {
        
            String encode[] ={".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."};

            char docode[] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};

            String arr[] = new String[words.length];
            for(int i = 0;i<words.length;i++){
                char[] caifen = words[i].toCharArray();
                for (int j= 0;j<caifen.length;j++){


                    for (int k = 0;k<docode.length;k++){
                        if (docode[k] == caifen[j]){
                            if(arr[i] == null){
                                arr[i] = encode[k];
                                break;
                            }else{
                                arr[i] += encode[k];
                                break;
                            }

                        }
                    }


                }

                }


            //去重
            List<String> result = new ArrayList<>();
            boolean flag;
            for(int i=0;i<arr.length;i++){
                flag = false;
                for(int j=0;j<result.size();j++){
                    if(arr[i].equals(result.get(j))){
                        flag = true;
                        break;
                    }
                }
                if(!flag){
                    result.add(arr[i]);
                }
            }
            String[] arrayResult = (String[]) result.toArray(new String[result.size()]);

            int number = arrayResult.length;
            return number;
        }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

数组中两元素的最大乘积

public class test {
    public static void main(String[] args) {
        int nums[] = {3,4,5,2};
        System.out.println(maxProduct(nums));

    }

    public static int maxProduct(int[] nums) {
        
        int a =0;
        int max_num = 0;

        for (int i = 0;i<nums.length;i++){
            if (max_num<nums[i]){
                a=i;
                max_num = nums[i];
            }
        }

        //删除最大的元素
        int new_nums[] = new int[nums.length-1];
        for(int i=0;i<new_nums.length; i++) {
            // 判断元素是否越界
            if (a < 0 || a >= nums.length) {
                throw new RuntimeException("元素越界... ");
            }
            //
            if(i<a) {
                new_nums[i] = nums[i];
            }
            else {
                new_nums[i] = nums[i+1];
            }
        }

        int b = 0;
        max_num = 0;
        for (int i = 0;i<new_nums.length;i++){
            if (max_num<new_nums[i]){
                b=i;
                max_num = new_nums[i];
            }
        }
        return (nums[a]-1)*(new_nums[b]-1);
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

剑指 Offer 58 - II. 左旋转字符串

public class test {
    public static void main(String[] args) {
        String s = "lrloseumgh";int k = 6;

        System.out.println(reverseLeftWords(s,k));
    }

    public static String reverseLeftWords(String s, int n) {
    String a = "";

    for (int i = n ; i<=s.length()-1;i++){
        a += s.charAt(i);
    }

    for (int i = 0 ; i<n;i++){
        a += s.charAt(i);
    }
    return a;
    }


}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

整数反转

这题还是直接看官方的思路吧…我写得太菜了 。。。。

class Solution {
    public int reverse(int x) {
        	
		//判断是否大于0
		if(x >0) {
			StringBuilder s = new StringBuilder(""+x);
			//判断是否越界
			long y = Long.valueOf(s.reverse().toString());
			
			if(y >= 2147483648L) {
				return 0;
			}else {
				return (int)(y);
			}
			
		}else {
			x=x-x-x;
			
			if(x <= -2147483648L) {
				return 0;
			}
			
			StringBuilder s = new StringBuilder(""+x);
			
			
			
			//判断是否越界
			long y =  Long.valueOf(s.append("-").reverse().toString());
			if(y <= -2147483648L) {
				return 0;
			}else {
				return (int)(y);
			}
		}
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

剑指 Offer 58 - I. 翻转单词顺序

class Solution {
    public String reverseWords(String s) {
        //分割字符串
	    	String[] strArr = s.split(" ");
	    	String xin = "";
	    	//反转
	    	for (int i = strArr.length-1; i >= 0; i--) {
	    		//判断是否是空格
	    		if(strArr[i].trim().isEmpty()) {
	    			continue;
	    		}
	    		
	    		
	    		
	    			xin +=strArr[i]+" ";

				
			}
	    	
	    	return xin.trim();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

557. 反转字符串中的单词 III

class Solution {
    public String reverseWords(String s) {
        String ss[] = s.split(" ");
        String ssss = "";

        for (int i = 0 ;i<ss.length;i++){
            ssss +=new StringBuilder(ss[i]).reverse().append(" ").toString();
        }

        return ssss.trim();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

剑指 Offer 11. 旋转数组的最小数字

int a = 2147483647;

            for (int i = 0;i<numbers.length;i++){
                if(numbers[i] <a){
                    a=numbers[i];
                }
            }

            return a;
1
2
3
4
5
6
7
8
9