【LEETCODE】53、数组分类，简单级别，题目：989、674、1018、724、840、747
真的感觉有点难。。。
这还是简单级别。。。
我也是醉了
package y2019.Algorithm.array; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; /** * @ProjectName: cutter-point * @Package: y2019.Algorithm.array * @ClassName: AddToArrayForm * @Author: xiaof * @Description: TODO 989. Add to Array-Form of Integer * For a non-negative integer X, the array-form of X is an array of its digits in left to right order. * For example, if X = 1231, then the array form is [1,2,3,1]. * Given the array-form A of a non-negative integer X, return the array-form of the integer X+K. * * Input: A = [1,2,0,0], K = 34 * Output: [1,2,3,4] * Explanation: 1200 + 34 = 1234 * * 对于非负整数 X 而言，X 的数组形式是每位数字按从左到右的顺序形成的数组。例如，如果 X = 1231，那么其数组形式为 [1,2,3,1]。 * 给定非负整数 X 的数组形式 A，返回整数 X+K 的数组形式。 * 来源：力扣（LeetCode） * 链接：https://leetcode-cn.com/problems/add-to-array-form-of-integer * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 * @Date: 2019/7/11 17:50 * @Version: 1.0 */ public class AddToArrayForm { //但是数组很长的时候就凉了 public List<Integer> solution(int[] A, int K) { //说白了就是获取相加的结果 StringBuffer value = new StringBuffer(); for(int i = 0; i < A.length; ++i) { value.append("" + A[i]); } int num = Integer.valueOf(value.toString()) + K; //转换为int数组 String numStr = String.valueOf(num); List<Integer> res = new ArrayList<>(); for(int i = 0; i < numStr.length(); ++i) { res.add(Integer.valueOf(numStr.charAt(i))); } return res; } public List<Integer> solution1(int[] A, int K) { //说白了就是获取相加的结果,那么现在只能通过对数据进行相加了，进位了 //我们从最后面一个数开始加起，然后不断进位，吧值放到list中 List<Integer> res = new ArrayList<>(); for(int i = A.length - 1; i >= 0; --i) { //这里要头插，因为我们从低位开始 res.add(0, (A[i] + K) % 10); //吧进位值重新给K K = (A[i] + K) / 10; } //如果到最后K还是大于0，那么继续进位 while(K > 0) { res.add(0, K % 10); K /= 10; } return res; } }
package y2019.Algorithm.array; /** * @ProjectName: cutter-point * @Package: y2019.Algorithm.array * @ClassName: FindLengthOfLCIS * @Author: xiaof * @Description: TODO 674. Longest Continuous Increasing Subsequence * Given an unsorted array of integers, find the length of longest continuous increasing subsequence (subarray). * Example 1: * Input: [1,3,5,4,7] * Output: 3 * Explanation: The longest continuous increasing subsequence is [1,3,5], its length is 3. * Even though [1,3,5,7] is also an increasing subsequence, it's not a continuous one where 5 and 7 are separated by 4. * * 给定一个未经排序的整数数组，找到最长且连续的的递增序列。 * * @Date: 2019/7/11 9:53 * @Version: 1.0 */ public class FindLengthOfLCIS { public int solution(int[] nums) { if(nums == null || nums.length <= 0) { return 0; } //1.需要统计当前递增的长度，2.保存最长递增个数 每次和上一个比较，当不是递增的时候，吧当前递增格式和最大比较，并且清空当前长度 int curIncreLen = 1, maxIncreLen = 0, preValue = nums[0]; for(int i = 1; i < nums.length; ++i) { if(nums[i] > preValue) { ++curIncreLen; } else { //如果变成不是递增的了 maxIncreLen = Math.max(curIncreLen, maxIncreLen); curIncreLen = 1; } preValue = nums[i]; } return Math.max(curIncreLen, maxIncreLen); } public static void main(String args[]) { int[] A = {1,3,5,7}; int[] B = {1,3,5,4,2,3,4,5}; int k = 1; System.out.println(new FindLengthOfLCIS().solution(B)); } }
package y2019.Algorithm.array; import java.util.*; /** * @ProjectName: cutter-point * @Package: y2019.Algorithm.array * @ClassName: PrefixesDivBy5 * @Author: xiaof * @Description: TODO 1018. Binary Prefix Divisible By 5 * Given an array A of 0s and 1s, consider N_i: the i-th subarray from A[0] to A[i] interpreted as a binary number * (from most-significant-bit to least-significant-bit.) * Return a list of booleans answer, where answer[i] is true if and only if N_i is divisible by 5. * * Input: [0,1,1] * Output: [true,false,false] * Explanation: * The input numbers in binary are 0, 01, 011; which are 0, 1, and 3 in base-10. Only the first number is divisible by 5, * so answer[0] is true. * * 给定由若干 0 和 1 组成的数组 A。我们定义 N_i：从 A[0] 到 A[i] 的第 i 个子数组被解释为一个二进制数（从最高有效位到最低有效位）。 * 返回布尔值列表 answer，只有当 N_i 可以被 5 整除时，答案 answer[i] 为 true，否则为 false。 * * 来源：力扣（LeetCode） * 链接：https://leetcode-cn.com/problems/binary-prefix-divisible-by-5 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 * @Date: 2019/7/11 8:58 * @Version: 1.0 */ public class PrefixesDivBy5 { public List<Boolean> solution(int[] A) { //直接运算求解，然后对5取余 int k = 0;List<Boolean> res = new ArrayList<>(); for(int i = 0; i < A.length; ++i) { //计算加入当前二进制的值，这里要先进行对5取余，不然会溢出 k = ((k << 1) | A[i]) % 5; res.add(k == 0); } return res; } public static void main(String args[]) { int[] A = {1,0,0,1,0,1,0,0,1,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,0,1,0,0,0,0,1,1,0,1,0,0,0,1}; int[] B = {5}; int k = 1; System.out.println(new PrefixesDivBy5().solution(A)); } }
package y2019.Algorithm.array; import java.util.Arrays; /** * @ProjectName: cutter-point * @Package: y2019.Algorithm.array * @ClassName: PivotIndex * @Author: xiaof * @Description: TODO 724. Find Pivot Index * Given an array of integers nums, write a method that returns the "pivot" index of this array. * We define the pivot index as the index where the sum of the numbers to the left of the index is equal to the sum of the numbers to * the right of the index. * If no such index exists, we should return -1. If there are multiple pivot indexes, you should return the left-most pivot index. * * Example 1: * Input: * nums = [1, 7, 3, 6, 5, 6] * Output: 3 * Explanation: * The sum of the numbers to the left of index 3 (nums[3] = 6) is equal to the sum of numbers to the right of index 3. * Also, 3 is the first index where this occurs. * * 我们是这样定义数组中心索引的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。 * 如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。 * 来源：力扣（LeetCode） * 链接：https://leetcode-cn.com/problems/find-pivot-index * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 * * @Date: 2019/7/11 18:08 * @Version: 1.0 */ public class PivotIndex { public int solution(int[] nums) { //1.获取中位数 int sum = (int) Arrays.stream(nums).sum(); int cur = 0; //2.顺序遍历，获取到和为总和一半的位置结束 int index = -1; for(int i = 0; i < nums.length; cur += nums[i++]) { if(cur * 2 == sum - nums[i]) { //这个就是中间 index = i; break; } } return index; } public static void main(String args[]) { int[] A = {1,7,3,6,5,6}; int k = 1; System.out.println(new PivotIndex().solution(A)); } }
package y2019.Algorithm.array; /** * @ClassName NumMagicSquaresInside * @Description TODO 840. Magic Squares In Grid * * A 3 x 3 magic square is a 3 x 3 grid filled with distinct numbers from 1 to 9 such that each row, column, * and both diagonals all have the same sum. * Given an grid of integers, how many 3 x 3 "magic square" subgrids are there? (Each subgrid is contiguous). *Input: [[4,3,8,4], * [9,5,1,9], * [2,7,6,2]] * Output: 1 * Explanation: * The following subgrid is a 3 x 3 magic square: * 438 * 951 * 276 * while this one is not: * 384 * 519 * 762 * In total, there is only one magic square inside the given grid. * *3 x 3 的幻方是一个填充有从 1 到 9 的不同数字的 3 x 3 矩阵，其中每行，每列以及两条对角线上的各数之和都相等。 * 给定一个由整数组成的 grid，其中有多少个 3 × 3 的 “幻方” 子矩阵？（每个子矩阵都是连续的）。 * 来源：力扣（LeetCode） * 链接：https://leetcode-cn.com/problems/magic-squares-in-grid * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 * * * @Author xiaof * @Date 2019/7/11 22:42 * @Version 1.0 **/ public class NumMagicSquaresInside { public int solution(int[][] grid) { //因为每个数字都要有一个，那么就是中间的位置为5和为15 //找到5的位置 if(grid == null || grid.length < 3 || grid[0].length < 3) { return 0; } int count = 0; for(int i = 1; i < grid.length - 1; ++i) { for(int j = 1; j < grid[i].length - 1; ++j) { //判断这个位置是否是5，如果是，那么再判断是否是幻方 if(grid[i][j] == 5 && isMagic(grid, i, j)) { ++count; } } } return count; } //判断是否是幻方 private boolean isMagic(int[][] grid, int r, int c) { int[] times = new int[9]; //避免出现重复数字 for(int i = -1; i < 2; ++i) { int rSum = 0, cSum = 0; for(int j = -1; j < 2; ++j) { //计算行和 rSum += grid[r + i][c + j]; cSum += grid[r + j][c + i]; //一列 int num = grid[r + i][c + j]; if(num > 9 || num < 1 || times[num]++ > 0) { return false; } } //计算结果 if(rSum != 15 || cSum != 15) { return false; } } return true; } }
package y2019.Algorithm.array; /** * @ClassName DominantIndex * @Description TODO 747. Largest Number At Least Twice of Others * * In a given integer array nums, there is always exactly one largest element. * Find whether the largest element in the array is at least twice as much as every other number in the array. * If it is, return the index of the largest element, otherwise return -1. * * Input: nums = [3, 6, 1, 0] * Output: 1 * Explanation: 6 is the largest integer, and for every other number in the array x, * 6 is more than twice as big as x. The index of value 6 is 1, so we return 1. * * @Author xiaof * @Date 2019/7/11 22:49 * @Version 1.0 **/ public class DominantIndex { public int solution(int[] nums) { Integer[] maxNums = {null, null}; int maxIndex = 0; for(int i = 0; i < nums.length; ++i) { //跟max数组进行比较 int curIndex = -1; for(int j = 0; j < maxNums.length; ++j) { if(maxNums[j] == null || nums[i] > maxNums[j]) { //如果比较大，或者初始化的时候 ++curIndex; } else { break; } } if(curIndex > -1) { //移动相应的数据,然后放入新的数据 if(curIndex == 1) maxIndex = i; for(int k = 0; k < maxNums.length - 1; ++k) { maxNums[k] = maxNums[k + 1]; } maxNums[curIndex] = nums[i]; } } //最后统计结果 if(maxNums[0] != null && maxNums[1] != null && maxNums[0] != 0 && maxNums[1] != 0) { return maxNums[1] / maxNums[0] >= 0 ? maxIndex : -1; } else if(maxNums[1] != null && maxNums[1] != 0) { return maxIndex; } else { return -1; } } public static void main(String args[]) { int[] A = {0,0,3,2}; int k = 1; System.out.println(new DominantIndex().solution(A)); } }
