找出与数组相加的整数 Ⅰ。用go语言，你有两个长度相同的数组 nums1 和 nums2。

数组 nums1 中的每个元素会与一个整数 x 相加，如果 x 是负数，则相当于减少元素值。

经过这种处理后，如果 nums1 和 nums2 相等，即它们包含相同的整数且这些整数的出现频率相同，那么就可以认为这两个数组是相等的。

请返回整数 x 的值。

1 <= nums1.length == nums2.length <= 100。

0 <= nums1[i], nums2[i] <= 1000。

测试用例以这样的方式生成：存在一个整数 x，使得 nums1 中的每个元素都与 x 相加后，nums1 与 nums2 相等。

输入：nums1 = [2,6,4], nums2 = [9,7,5]。

输出：3。

解释：

与 3 相加后，nums1 和 nums2 相等。

大体步骤如下：

1.创建一个函数 addedInteger，接受两个类型为 []int 的参数 nums1 和 nums2，返回一个整数作为结果。

2.在 addedInteger 函数中初始化两个变量 maxVal1 和 maxVal2，初始值为 0，用于存储两个数组中的最大值。

3.使用循环遍历 nums1 数组，并找到最大值存储在 maxVal1 中。

4.使用另一个循环遍历 nums2 数组，并找到最大值存储在 maxVal2 中。

5.返回 maxVal2 - maxVal1，即两数组中最大值的差值。

总体时间复杂度：

• 遍历 nums1 数组的时间复杂度为 O(n)，其中 n 为 nums1 的长度。
• 同理，遍历 nums2 数组的时间复杂度为 O(n)。

因此，总体时间复杂度为 O(n) + O(n) = O(n)，其中 n 是数组的长度。

总体额外空间复杂度：

• 程序并没有使用额外的空间存储结果，只使用了几个变量来存储最大值，因此额外空间复杂度为 O(1)。

Go完整代码如下：

package main

import (
	"fmt"
)

func addedInteger(nums1 []int, nums2 []int) int {
	maxVal1, maxVal2 := 0, 0

	for _, num := range nums1 {
		if num > maxVal1 {
			maxVal1 = num
		}
	}
	for _, num := range nums2 {
		if num > maxVal2 {
			maxVal2 = num
		}
	}
	return maxVal2 - maxVal1
}

func main() {
	nums1 := []int{2, 6, 4}
	nums2 := []int{9, 7, 5}
	fmt.Println(addedInteger(nums1, nums2))
}

Rust完整代码如下：

fn added_integer(nums1: &Vec<i32>, nums2: &Vec<i32>) -> i32 {
    let max_val1 = nums1.iter().max().unwrap_or(&0);
    let max_val2 = nums2.iter().max().unwrap_or(&0);
    
    return max_val2 - max_val1;
}

fn main() {
    let nums1 = vec![2, 6, 4];
    let nums2 = vec![9, 7, 5];
    println!("{}", added_integer(&nums1, &nums2));
}