devbox
运维做开发
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

python哈希算法——两个数的和、三个数的和、单词模式匹配、猜词游戏、神奇的词根实现实例_python中两个数相加得第三个数

作者：运维做开发 | 2024-07-12 00:52:57

赞

踩

python中两个数相加得第三个数

哈希算法

    哈希算法，又称为散列函数算法，是一种查找算法。简单来说，就是把一些复杂的数据，通过某种函数映射关系，

映射成更加易于查找的方式。但是这种映射关系有可能会发生多个关键字映射到同一个地址的现象，称之为冲突。

在这种特殊情况下，需要对关键字进行第二次或更多次的处理。

   1）什么是哈希：简单介绍什么是哈希及哈希的原理

   2）两个数的和：快速寻找两个数的和

   3）单词模式匹配：简单的模式匹配问题

常见的数据查找算法：

  1. 顺序查找：最简单的查找方式，需要对数据集中的数据逐个进行匹配，所以效率相对较低，不太适合大数据量的查找问题
  2. 二分查找：查找效率很高，但要求数据必须有序，而对数据排序通常需要更多的时间开销
  3. 深度优先遍历、广度优先遍历：对大数据量的查找问题效率并不高
  4. 哈希查找：由于其查找速度快，查询、插入、删除操作简单等原因而获得了广泛的应用。很多问题本质上都是查找问题。解决查找问题，哈希算法是较好的选择。

哈希算法进行查找的基本原理是根据数据量预先设置一个长度为M的数组，使用一个哈希函数F并以数据的关键字作为自变量，得到唯一的返回值，返回值的范围为0~M-1。

解决哈希冲突的方法有很多，如链地址法、二次再散列法、线性探测再散列、建立一个公共溢出区等方法。

链地址法处理冲突的方法本质上是一种数组加链表的处理方法，当发生多个数据通过哈希映射后得到相同的哈希值时，通常把具有相同哈希地址的关键字放在同一个链表中，称该链表为同义词链表，也称为桶。（链地址法本质上是数组+链表的数据结构）

 

'''

一、两个数的和的解法

   要求在给定的一些数字中找出两个数，使得它们的和为N，前提是这些数据中保证有答案，并且只有一个答案。

   返回值为原始数组中查找的两个元素的编号

'''

# 求解方法1  使用双指针的方法解决

  1. def twoSum(nums,target):
  2.     res = []                       #存放结果编号数据
  3.     newnums = nums[:]              #深拷贝，把原数据复制到newnums里
  4.     newnums.sort()                 #对新数组排序
  5.     left = 0
  6.     right = len(newnums)-1        #定义left和right指针分别指向新数组的开头和结尾
  7.     while left<right:
  8.         if newnums[left]+newnums[right] == target:
  9.             for i in range(0,len(nums)):
  10.                 if nums[i] == newnums[left]:
  11.                     res.append(i)  #将下标加入结果集
  12.                     break
  13.             for i in range(len(nums)-1,-1,-1): #在原始数组中寻找第二个元素的原始下标
  14.                 if nums[i] == newnums[right]:
  15.                     res.append(i) #将下标加入结果集
  16.                     break
  17.             res.sort()
  18.             break
  19.         elif  newnums[left]+newnums[right] < target:
  20.             left +=1
  21.         elif  newnums[left]+newnums[right] > target:
  22.             right -=1
  23.     return (res[0]+1,res[1]+1)  #返回结果集
'
运行

                   

# 求解方法2  使用哈希算法解决

  1. def twoSum(nums,target):
  2.     dict={}                                # 建立一个字典，存储数据和下标的对应关系
  3.     for i in range(len(nums)):
  4.         m = nums[i]                        # 定义m为当前待查询的数字
  5.         if target-m in dict:               #判断target-m是否已经在字典中
  6.             return (dict[target-m]+1,i+1)  # 如果已经存在，则返回两个数的下标
  7.         dict[m] = i                        # 如果不存在，则记录键值对
'
运行

 

'''

二、三个数的和的解法

  给定一个包含n个整数的数组nums，判断nums中是否存在三个元素a，b，c，使得a+b+c=target(目标值)？找出所有满足条件且不重复的三元组。

  注意：答案中不可以包含重复的三元组。

 

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，target=0

满足要求的三元组集合为：

[

  [-1, 0, 1],

  [-1, -1, 2]

]

解题设计：

    求解三数之和，可以用三层循环分别找到符合题意的三个数，是一种解决办法，但是很耗时，算法复杂度为O(n3)。

    另一种解决办法，可以将三数之和考虑为2+1的形式，先求解两个数的和，然后用目标值target减去两数之和即为所要找的数。

    而找这个数在python中非常简单，假设这个数为c，则只需要写c in nums即可判断是否存在这个数，但只做这个判断有可能

    会使同一个数在解答的一个三元组中出现两次，所以此处采用字典的形式，将每个元素与其所对应的下标组成键值对。

    这样即可轻易地避免元素重复地出现。

'''

  1. def threeSum(nums,target):
  2.     
  3.     """
  4.     type nums: List[int]
  5.     returntype: List[List[int]]
  6.     """
  7.     m={}                      #存储将列表元素和其下标 构建的键值对
  8.     for i in range(len(nums)):
  9.         m[nums[i]]=i
  10.     
  11.     l = []
  12.     for a in range(len(nums)): 
  13.         for b in range(len(nums)):
  14.             c = target-(nums[a]+nums[b])
  15.             if (a != b) and c in nums and (a!=m[c]) and (b!=m[c]):
  16.                 l.append(sorted([nums[a],nums[b],c]))
  17. #    return(list(list(t) for t in(set([tuple(t) for t in l]))))
  18.     return([list(t) for t in (set([tuple(t) for t in l]))])
  19.  
  20. nums = [-1, 0, 1, 2, -1, -4]
  21. target = 0
  22. print(threeSum(nums,target))
'
运行

 

'''

三、单词模式匹配

    模式匹配问题是一个经典的问题，即求目标字符串中单词出现的规律是否符合单词模式字符串中的规律

    解题设计：

        建立哈希表存储数据，需要排除三个问题：1）排除一个模式对应多个字符串的情况；

        2）排除多个模式对应一个字符串的情况。因此需要建立两个哈希表：hash和used.

           (hash用来存储模式字符串和目标字符串的对应关系；used记录目前已经使用的字符串）

        3) 排除两个字符串长度不相等的情况

'''

  1. def wordPattern(wordPattern,inputstring):
  2.     word = inputstring.split(' ')     # 目标字符串中的单词以空格隔开
  3.     if len(word) != len(wordPattern): # 如果两个字符串的长度不一样，则肯定不匹配
  4.         return False
  5.     hash = {}                         # 记录模式字符串和目标字符串的对应关系
  6.     used = {}                         # 记录目前已经使用过的字符串都有哪些
  7.     for i in range(len(wordPattern)):
  8.         if wordPattern[i] in hash:    # 检查模式字符串中的字符是否已经被记录过映射关系
  9.             if hash[wordPattern[i]] != word[i]:  # 不是第一次出现，则检查映射关系是否一致
  10.                 return False
  11.         else:
  12.             if word[i] in used:       # 检查这个单词是否已经使用过，使用过返回不成立
  13.                 return False
  14.         hash[wordPattern[i]] = word[i] #第一次出现，则加入哈希表
  15.         used[word[i]] = True           # 在used中保存哪些单词已经使用过
  16.     return True
'
运行

  

'''

四、猜词游戏

   需要写一个程序，它能够根据秘密数字和朋友的猜测数返回提示，其中A表示公牛（几位数字和确切位置都猜对了），

   B表示奶牛（多少位数字猜对了但位置不对）。注意：秘密数字和朋友猜测的数字都可能含有重复数字

  

   解题设计：

       1）先解决第一个问题，查找公牛(A)的数量。首先定义一个变量A表示公牛的数量，之后循环把每个位置上的

          数字都取出来，按位置对比即可，数字一样则让A加1

       2）然后解决奶牛(B)的数量问题。使用哈希表来加快速度，建立两个字典，因为需要记录配对的过程中哪些

          位置的数字配对了，哪些还没有配对。最终B的数量是由该数在秘密数字中和在猜测数字中更小的那方决定。

          为此，只需要记录秘密数字和猜测数字中未匹配的数字和它的个数，之后看相同数字的最小数即可。

         

          那么在分析A的数量的同时，记录其他未匹配数字的数量

'''

  1. def getHint(secret,guess):
  2.     """
  3.     type secret: str
  4.     type guess:  str
  5.     return type: str
  6.     """
  7.     secret_dict = {}
  8.     guess_dict = {}
  9.     
  10.     A = 0
  11.     B = 0
  12.     for i in range(len(secret)):
  13.         if secret[i] == guess[i]: # 查找A的数量
  14.             A += 1
  15.         else:
  16.             if secret[i] in secret_dict:
  17.                 secret_dict[secret[i]] += 1
  18.             else:
  19.                 secret_dict[secret[i]] = 1
  20.             if guess[i] in guess_dict:
  21.                 guess_dict[guess[i]] += 1
  22.             else:
  23.                 guess_dict[guess[i]] =1
  24.     # 记录好了数量，接下来根据两个数组中的数的最小值来判断B的数量
  25.     for digit in secret_dict:
  26.         if digit in guess_dict:
  27.             B += min(secret_dict[digit],guess_dict[digit])
  28.     return str(A)+'A'+str(B)+'B'

   

'''

五、神奇的词根

    问题：给定一个由许多词根组成的字典和一个句子。你需要将句子中的所有继承词用词根替换掉。

         如果继承词中有许多形成它的词根，则用最短的词根替换它。

'''

# 暴力破解法

  1. def  replaceWords(dict,sentence):
  2.     '''
  3.     type dict : list[str]
  4.     type sentence:str
  5.     return type: str
  6.     '''
  7.     s = sentence.split(' ') # 先把句子转换为列表
  8.     
  9.     # 判断单词是否以词根开头，如果是，则替换(dict存储词根)
  10.     for item in dict:
  11.         for i in range(len(s)):
  12.             n = len(item)
  13.             if item == s[i][:n]:
  14.                 s[i] = item
  15.     return " ".join(s)
'
运行

 

# 哈希来优化解决

  1. def replaceWords(dict,sentence):
  2.     '''
  3.     type dict : list[str]
  4.     type sentence:str
  5.     return type: str
  6.     '''
  7.    #建立两个字典，并做好初始化工作（建立字典使用collections.defaultdict()建立默认字典，python会自动为它的键赋一个初始值。
  8.     d = collections.defaultdict(set)
  9.     s = collections.defaultdict(int)
  10.     sentence = sentence.split(" ")
  11.     
  12.     # 以每一个词根的首字母为键，把每一个词根放到该键所对应的值中去，值是一个集合，同时记录下根根的最大长度
  13.     for w in dict:
  14.         d[w[0]].add(w)
  15.         s[w[0]] = max(s[w[0]],len(w))
  16.         
  17.     # 把每个单词拿出来，查找以该单词开头的词根是否能够和这个单词匹配
  18.     # 使用enumerate()函数来遍历句子，它会把索引放到第一个变量，把元素放到第二个变量。
  19.     for i,w in enumerate(sentence):
  20.         for j in range(s[w[0]]):
  21.             if w[:j+1] in d[w[0]]:
  22.                 sentence[i] = w[:j+1]
  23.                 break
  24.     return ' '.join(sentence)
'
运行

  参考书籍：《你也能看得懂的Python算法书》/王硕等编著.—北京：电子工业出版社,2018.11

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/运维做开发/article/detail/812115
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号