【整数数组加一】

给定一个由 整数 组成的 非空 数组所表示的非负整数,在该数的基础上加一。

最高位数字存放在数组的首位, 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外,这个整数不会以零开头。

示例 1:

输入:digits = [1,2,3]
输出:[1,2,4]
解释:输入数组表示数字 123。

示例 2:

输入:digits = [4,3,2,1]
输出:[4,3,2,2]
解释:输入数组表示数字 4321。

示例 3:

输入:digits = [0]
输出:[1]

public class Test2 {
	    public int[] plusOne(int[] digits) {
	        for (int i = digits.length - 1; i >= 0; i--) {
	            digits[i]++;
	            //System.out.println(digits[i]);
	            digits[i] = digits[i] % 10;  //每次取个位
	            if (digits[i] != 0) {
                    return digits;
                }
	        }
	        digits = new int[digits.length + 1]; //数组长度扩容加一
	        digits[0] = 1; //如果是99,999等,将第一位元素设置为1
	        return digits;
	    }

	public static void main(String[] args) {
		Test2 t=new Test2();
		int[] arr={9,8,9,9};
		System.out.println(Arrays.toString(t.plusOne(arr)));
		
	}
}

注意:

输入:digits = [9]
输出:[1,0]

输入:digits = [9,9]
输出:[1,0,0] 

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
### 回答1: 思路: 考虑对于任意的区间[l,r],假设这个区间满足条件,则有: $A_l \oplus A_{l+1} \oplus ... \oplus A_r = A_l \times A_{l+1} \times ... \times A_r$ 两边同时取对数得到:$\log_2(A_l) \oplus \log_2(A_{l+1}) \oplus ... \oplus \log_2(A_r) = \log_2(A_l) + \log_2(A_{l+1}) + ... + \log_2(A_r)$ 因为异或运算的性质,所以可以得到:$\log_2(A_l) \oplus \log_2(A_{l+1}) \oplus ... \oplus \log_2(A_r) = \log_2(A_l) \oplus (\log_2(A_l) \oplus \log_2(A_{l+1})) \oplus ... \oplus (\log_2(A_{r-1}) \oplus \log_2(A_r))$ 然后就可以用前缀异或和的思想来计算了。 代码实现: ### 回答2: 假设数组A的长度为n,我们可以通过计算每个位置的前缀异或值和前缀乘积来解决这个问题,时间复杂度为O(n)。 首先,我们创建两个辅助数组prefixXor和prefixMul,长度都为n。 prefixXor[i]表示数组A[0]到A[i]的异或值,prefixMul[i]表示数组A[0]到A[i]的乘积。 接下来,我们遍历数组A,计算prefixXor和prefixMul的值。 如果A[i]为0,那么prefixXor[i]和prefixMul[i]都为0。 否则,prefixXor[i] = prefixXor[i-1] ^ A[i],prefixMul[i] = prefixMul[i-1] * A[i]。 然后,我们再次遍历数组A,计算子数组满足条件的个数。 对于每个位置i,我们需要找到在位置i之前的某个位置j(0 ≤ j < i),使得prefixXor[i] = prefixMul[i]。 我们可以使用一个哈希表来记录每个前缀异或值出现的次数。 对于每个位置i,我们首先判断prefixXor[i]是否等于prefixMul[i],如果是,则满足条件的子数组个数加一。 然后,我们检查哈希表中是否存在prefixXor[i],如果存在,则将哈希表中prefixXor[i]的值到满足条件的子数组个数上。 最后,将prefixXor[i]的出现次数加一。 最终,遍历完成后,满足条件的子数组个数就是答案。 以下是Go语言的实现代码: ```go func numOfSubarrays(A []int) int { n := len(A) prefixXor := make([]int, n) prefixMul := make([]int, n) prefixXor[0] = A[0] prefixMul[0] = A[0] xorCount := make(map[int]int) xorCount[0] = 1 res := 0 if A[0] == 0 { res++ } for i := 1; i < n; i++ { if A[i] == 0 { res++ } else { prefixXor[i] = prefixXor[i-1] ^ A[i] prefixMul[i] = prefixMul[i-1] * A[i] } res += xorCount[prefixXor[i]] xorCount[prefixXor[i]]++ } return res } ``` 上述代码中,我们使用了一个哈希表xorCount来记录前缀异或值的出现次数,以便快速查找满足条件的子数组个数。整个算法的时间复杂度为O(n),空间复杂度为O(n)。 ### 回答3: 题目要求找出正整数数组中有多少个子数组满足乘积等于异或。我们可以通过遍历数组的每个元素来求解。 假设数组A的长度为n,我们可以使用两个变量count和product来记录满足条件的子数组数量和对应的乘积。首先,将count和product初始化为0,遍历数组A中的每个元素num,对于每个元素,更新count和product的值。 对于当前元素num,如果num等于0,则满足条件的子数组数量需要上count*(count+1)/2,然后将count重新设为0并将product设为1。这是因为对于元素为0的子数组,其乘积为0,和为0,所以需要将之前的子数组数量上,并重新开始计数。 否则,如果num不等于0,则将product乘上num,然后判断product是否等于num的异或值。如果相等,则满足条件的子数组数量需要上count的值。这是因为对于满足乘积等于异或的子数组,其中的元素可以随意排列,只要元素的个数(count)相同,就可以构成不同的子数组。 最后返回count的值即为满足条件的子数组数量。 下面是用Go语言实现的代码: ```go package main import "fmt" func main() { A := []int{1, 2, 3} count := 0 product := 1 for _, num := range A { if num == 0 { count += count * (count + 1) / 2 count = 0 product = 1 } else { product *= num if product == num^(count+1) { count++ } } } count += count * (count + 1) / 2 fmt.Println(count) } ``` 这段代码的时间复杂度为O(n),其中n为数组A的长度。通过遍历数组A中的每个元素,我们可以找出满足条件的子数组数量,并输出结果。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

aigo-2021

您的鼓励是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值