华为算法题 go 语言或者 python 原创

1

给定一个整数内存数和一个整数目标值目标，请你在该内存中查找并为那两个整数的目标值目标，并返回它们的内存下标。

但是你可以假设全部输入只能回答一个答案。，阵列中同一个元素在答案里不能重复出现。

你可以按任何顺序返回答案。< /p>

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]< /p>

包 main导入 “fmt”func twoSum( nums []int， tar获取 int) []int {numMap := 制作(地图 [int]int) // 前一个是键，后一个int是值，map是映射< span class="00a1-626c-8b55-6c0f token comment">// 完成导入 nums，i 是当前元素的索引，num 是当前元素的值for i， num := 范围 nums  {完整ment := target - num// j：这是从 numMap 中获取的与补码对应的值if j, ok  := numMap[补集]; ok {// []int{j, i} 是一个整数切片的初始化。返回一个包含两个整数的切片，第一个整数是j，第二个整数是ireturn []int{j, i}}numMap[num] = i}返回 nil}func main() {2< span class="20be-e354-e110-7216 token punctuation">， 7，  11， 15}目标1 :=9结果1 := twoSum(nums1, target1)fmt。< /span>Println(result1)nums2 := []int {3,< /span> 2, 4}目标2 := 6结果2 := twoSum(nums2, target2< span class="7216-00a1-626c-8b55 token punctuation">)fmt.Println(结果2)}

2

给你两个非空的链表，表示两个非负的整数。它们里面的数字都是按照逆序的方式存储的，并且每个节点只能存储一个数字。
请你将两个数相加，并以相同的形式返回一个表示和的链表。
你可以假设除了数字0之外，这两个数都不会以0开头。

包 main导入 "fmt"//表示链表节点的数据结构type ListNode struct {Val intNext *ListNode}//接受两个非空链表，表示两个非负整数，返回它们的和的链表func addTwoNumbers(l1 *ListNode, l2 * ListNode) *ListNode {} // 创建一个指针当前:= dummyHead//进位标志携带:= 0//遍历两个链表，直到两个链表都完成并且没有进位状态for l1 != nil || l2 != nil | | 携带 > 0 {sum += l1.Vall1 =  l1。下一步}if l2 != nil {sum += l2.Vall2 = l2.下一个}< /span>//更新进位，注意这里如果小于10进位就是0，否则为1进位= sum / 10//创建新节点存储当前位置的数字current .下一个 = &ListNode{Val: sum % 10}//将指针移动到下一个节点当前= current.下一个}//返回结果链表的头节点的下一个节点（跳过虚拟头节点）return dummyHead.下一个}//用于打印链表的值，方便查看结果func printLinkedList(节点*ListNode)< /span> {for 节点 !=  nil {fmt。 打印(节点.Val)< /span>if 节点.下一个 != nil {fmt。打印("->")}节点=节点。下一步}fmt。Println()}func main() {//实例1l1 := &ListNode{Val: < span class="20be-e354-e110-7216 token number">2, 下一个： &ListNode{Val: 4, 下一个： & ListNode{Val: 3}}}l2 := &ListNode{Val: 5, 下一个： & ListNode{Val:  6，下一个： &ListNode< span class="65c6-aa12-20be-e354 token punctuation">{Val: 4< span class="e354-e110-7216-00a1 token punctuation">}}}结果 := addTwoNumbers(l1, l2)printLinkedList(结果) }

3

给定一个字符串 s ，请你查找其中不含有重复字符的字符终止子串的长度。
示例 1:

输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的终止子串是“ abc”，所以其长度为 3。
示例 2:

输入: s = “bbbbb”
输出: 1
解释: 因为无重复字符的终止子字符串是“b”，所以其长度为1。
示例3:

输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的终止子串是“wke”，所以其长度为3。
请注意，你的答案必须是子串的长度，“pwke”是一个子序列，不是子串。

假设我们有一个字符串：s = "abcabcbb"。

我们开始遍历这个字符串，使用一个“盒子”来存储不重复的字符。

我们开始遍历这个字符串，使用一个“盒子”来存储不重复的字符。 > 我们从字符串的开头开始，第一个字符是 'a'，我们放入盒子中，盒子内有：[a]，目前盒子的长度为1。接着是 'b'，我们放入盒子中，盒子内有：[a, b]，目前盒子的长度为2。是'c'，然后我们放入盒子中，盒子内有：< code>[a, b, c]，目前盒子的长度为3。然后又是'a'，这里我们发现盒子内已经多了'a'，所以我们需要重新开始计算盒子。我们将 'a' 上一次出现的位置后面的字符全部去掉，得到新的盒子内容为 [b, c, a]，目前盒子的长度为3。然后是 'b'，我们放入盒子中，盒子内有：[b, c, a]，目前盒子的长度为3。接着是 'c'，我们发现 'c' 已经在盒子中了，所以我们需要重新开始计算盒子。我们将 'c' 上一次出现的位置后面的字符都去掉，得到新的盒子内容为 [a, b, c]，目前盒子的长度为3。最后是'b'，我们放入盒子中，盒子内有：[a, b, c]，目前盒子的长度为3。

我们遍历完整个字符串后，最长的发音重复字符的子串就是“abc”，它的长度为3。

package
 
package mainimport "fmt"// start 和 i 分别表示当前清晰重复的字符子串的起始位置和结束位置。lastI 表示字符上一次出现的位置。func 长度OfLongestSubstring(s 字符串) int {// 使用地图 存储字符最后出现的位置lastOccurred := make( 映射[字节]int)开始， maxLength := 0, 0//遍历字符串for i,  ch:= 范围 []字节(s) {// 如果字符已经出现过，并且出现位置在当前子串中 if lastI, ok := lastOccurred[ch]; ok &&  lastI >= start {start = lastI + 1 // 更新子串起始位置}//更新字符最后出现的位置lastOccurred[ ch] = i//更新最大子串长度 if i-开始+1 > maxLength {maxLength = i - 开始 + 1< /span>}}返回 maxLength}func main(<水疗中心n class="65c6-aa12-20be-e354 token punctuation">) {s1 := "abcabcbb"fmt.Println(lengthOfLongestSubstring(s1))}
 
4
 
给分别定两个大小为 m 和 n 的正序（差不多到大）数组 nums1 和 nums2。请你算一下并返回这两个正序数组的中位数。
 
算法的时间复杂度度应该为 O(log (m+n)) 。
 示例 1：
 
输入：nums1 = [1,3], nums2 = [2]
 输出：2.00000< br /> 解释：合并阵列 = [1,2,3] ，中添加 2
 示例 2：
 
输入：nums1 = [1,2], nums2 = [3,4 ]
 产出：2.50000
 解释：修复磁盘 = [1,2,3,4] ，中增量 (2 + 3) / 2 = 2.5
 
# 双斜杠 // 表示整数除法，它合并结果一代取整为最接近的整数class 解决方案(对象)： def findMedianSortedArrays(self, nums1 , nums2): "" " :type nums1: List[int] # 接受的第一个小区数据库 :type nums2: List[int] # 接受的第一个小区数据库 :rtype: float # 返回值为中位数的浮点数 " "" m = len(nums1) # 第一个吞吐量的长度 n < span class="aa12-20be-e354-e110 token 运算符">= len(nums2) #第二个备份的容量 for num 在 nums2： nums1。追加( num) # 将 nums2 中的所有元素添加到 nums1 中 nums1。 sort() #将合并后的 nums1 磁盘进行排序 i = len(nums1) # 合并后备份的容量 if i % 2 == 0: # 如果备份容量为偶数 a = nums1[i // 2] # 取中间两个数中的后一个数 b = nums1[i //  2 - 1] #取中间两个数中的前一个数 k = (float (a) + b) / 2 #计算中增量 else: #如果备份容量为奇数 k = nums1[(i ) // 2] #取中间的那个数字作为中位 return k #返回中耳机
 
5
 
给你一个字符串s，找到s中的回文子串。
如果字符字符串的反序与原始字符串，相同则该字符串称为回文字符串。
 示例 1：
 
输入：s = “babad”
 输出：“bab ”
 解释：“aba”同样是符合题意的答案。
 示例 2：
 
输入：s = “cbbd”
 输出：“bb” 
class 解决方案 def 最长回文(self, s: str） -> str: n = len(s) # 字符串长度 if n < 2: #如果字符串长度小于2，直接返回字符串本身 返回 s #创建一个包含 n 行的列表，每行包含 n 个元素，每个元素都是 False dp = [[False] * n for _ in 范围(n)] #创建一个二维仓库，用于存储子串是否为回文串的状态 start , max_len = 0, 1 #记录终止回文子串的起始位置和长度，默认为第一个字符和长度为1 < span class="20be-e354-e110-7216 token comment"># 初始化长度为1和2的回文子串 for i in 范围(n)： dp[i][< /span>i] = True 如果我< n - 1 和 s[i] == s[i + 1]： dp[i][i + 1] = True 开始 = span> i max_len = 2 # 从长度为3开始遍历，更新状态备份dp for length in 范围(3, n + 1)： 对于 i 在 范围(n -长度+ 1): j = i + 长度 - 1 # 子串的结束位置 if s[i] == s[j] 和 dp[i + 1][< /span>j - 1]: # 如果子串终端字符恰好且去掉终端字符后仍为回文串 dp[i][j] = True start = i # 更新最长回文子串的起始位置 max_len = length # 更新终止回文子串的长度 # start 是子串的起始索引。# start + max_len 是子串的结束索引（不包括该索引对应的字符） ）。#因此，s[start:start + max_len] 表示从字符串 s 中提取子串，起始索引为 start，结束索引为 start + max_len - 1 ，#即提取了从start开始到start + max_len - 1（包括起始索引，不包括结束索引）的子串。 返回 s[开始：开始 + max_len] # 返回最后回文子串
 
6