真的感觉有点难。。。
这还是简单级别。。。
我也是醉了
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));
}
}