java筑基小成之LeetCode

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

来源：力扣（LeetCode）

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for(int i=0;i<nums.length;i++){
            for(int j=i+1;j<nums.length;j++){
                if(nums[j]==target-nums[i]){
                    return new int[]{i,j};
                }
            }
        }
        return nums;
    }
}

暴力破解法：遍历每个元素 xx，并查找是否存在一个值与 target - xtarget−x 相等的目标元素。

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2], 

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 

你不需要考虑数组中超出新长度后面的元素。

来源：力扣（LeetCode）

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums == null || nums.length == 1){
            return nums.length;
        }
        int i = 0;
        for(int j = 0; j < nums.length;j++){
            if(nums[i] != nums[j]){
                i++;
                nums[i] = nums[j];
            }
        }
        return i + 1;
    }
}

使用双指针 i和 j，只要 nums[i] = nums[j]，我们就增加 j以跳过重复项。当我们遇到 nums[j] ！= nums[i]时，跳过重复项的运行已经结束，因此我们必须把它nums[j]的值复制到 nums[i +1]。然后递增 i，接着我们将再次重复相同的过程，直到 jj到达数组的末尾为止。

给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1:

给定 nums = [3,2,2,3], val = 3,

函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。

你不需要考虑数组中超出新长度后面的元素。

来源：力扣（LeetCode）

class Solution {
    public int removeElement(int[] nums, int val) {
        if (nums == null || nums.length == 0)
			return 0;
        int count=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]!=val){
                    nums[count]=nums[i];
                    count++;
                }
        }
        return count;

    }
}

双指针同上：当 nums[j]与给定的值相等时，递增 j以跳过该元素。只要 nums[j]！=val，我们就复制 nums[j] 到nums[i] 并同时递增两个索引。重复这一过程，直到 j 到达数组的末尾，该数组的新长度为 i。

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回  -1。

示例 1:

输入: haystack = "hello", needle = "ll"
输出: 2

来源：力扣（LeetCode）
 

class Solution {
    public int strStr(String haystack, String needle) {
        int needleLen = needle.length();
        if (needleLen == 0) {
            return 0;
        }
        for (int i = 0; i < haystack.length(); i++) {
            if ((i + needleLen) <= haystack.length() && haystack.substring(i, i + needleLen).equals(needle)){
                return i;
            }
        }
         
        return -1;
    }
}

使用substring( , )来比较。

给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。

函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。

说明:

返回的下标值（index1 和 index2）不是从零开始的。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
示例:

输入: numbers = [2, 7, 11, 15], target = 9
输出: [1,2]
解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

 

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int[] res = new int[2];
        int low = 0;
        int high = numbers.length - 1;
        while (low < high) {
            if (numbers[low] + numbers[high] > target) {
                high--;
            }
            else if (numbers[low] + numbers[high] < target) {
                low++;
            }
            else {
                res[0] = low + 1;
                res[1] = high + 1;
                break;
            }
        }
        return res;
    }
}

给定一个正整数，返回它在 Excel 表中相对应的列名称。

例如，

    1 -> A
    2 -> B
    3 -> C
    ...
    26 -> Z
    27 -> AA
    28 -> AB 
    ...
示例 1:

输入: 1
输出: "A"
示例 2:

输入: 28
输出: "AB"

来源：力扣（LeetCode）

class Solution {
    public String convertToTitle(int n) {
        String s = "";
        int k  = n;
        while(n > 26){
            k = n  % 26;
            n = n / 26;
            if(k==0){//没有表示0的字母，故若余数为0，需置为26， 商退一位
                k = 26;
                n = n - 1;
            } 
            char c = (char)('A' + k-1 );
            s = c+s;
        }
        char c = (char)('A' +  n -1);
        s = c+s;
        return s;
    }
}

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1:

输入: [3,2,3]
输出: 3
示例 2:

输入: [2,2,1,1,1,2,2]
输出: 2

来源：力扣（LeetCode）

class Solution {
    public int majorityElement(int[] nums) {
        int count = 1;
		int arr = nums[0];
		for (int i = 1; i < nums.length; i++) {
			if (arr == nums[i])
				count++;
			else {
				count--;
				if (count == 0) {
					arr = nums[i + 1];
				}
			}
        }
        return arr;
    }
}

给定一个Excel表格中的列名称，返回其相应的列序号。

例如，

    A -> 1
    B -> 2
    C -> 3
    ...
    Z -> 26
    AA -> 27
    AB -> 28 
    ...
示例 1:

输入: "A"
输出: 1
示例 2:

输入: "AB"
输出: 28

来源：力扣（LeetCode）

class Solution {
    public int titleToNumber(String s) {
        int ans = 0, len = s.length();
    	for(int i = 0; i < len; i++){
    	    ans = ans * 26 + (s.charAt(i)-'A'+1);
    	}
	return ans;
    }
}

给定一个整数 n，返回 n! 结果尾数中零的数量。

示例 1:

输入: 3
输出: 0
解释: 3! = 6, 尾数中没有零。
示例 2:

输入: 5
输出: 1
解释: 5! = 120, 尾数中有 1 个零.

来源：力扣（LeetCode）
 

class Solution {
    public int trailingZeroes(int n) {
        int count = 0;
        while(n >= 5) {
            count += n / 5;
            n /= 5;
        }
        return count;
    }
}