[已解决]Python：【新】每日一题 3

liuzhengyuan

专辑说明（积分规则）

今天的题目：

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循 pattern 所表示的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

请封装成一个函数，pattern，str 为参数

函数模板：

def wordPattern(pattern, s):
    """
    :type pattern: str
    :type s: str
    :rtype: bool
    """

示例1:

输入: pattern = "abba", str = "dog cat cat dog"
输出: true

示例 2:

输入:pattern = "abba", str = "dog cat cat fish"
输出: false

示例 3:

输入: pattern = "aaaa", str = "dog cat cat dog"
输出: false

示例 4:

输入: pattern = "abba", str = "dog dog dog dog"
输出: false

限制：

你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。   

欢迎大家来答题

来源：力扣（LeetCode）

最佳答案

月排行榜 / 总排行榜

crisfo

2021-3-22 12:29:26

def wordPattern(keys, s):

    values = s.split(' ')
    
    if len(keys) != len(values):
        return False

    dic1 = {}

    for i in range(len(keys)):
        if(keys[i] not in dic1.keys()):
            if(values[i] in dic1.values()):
                return False
            dic1[keys[i]] = values[i]
            
        else:
            if(dic1.get(keys[i]) != values[i]):
                return False

    return True
    
    pass


pattern = 'abbba'
str1 = 'dog cat cat cat dog'
print(wordPattern(pattern, str1))

跳转到最佳答案楼层

洋洋痒

def wordPattern(pattern, s):
    if len(set(pattern))!=len(set(s.split())) or len(pattern)!=len(s.split()):
        return False
    L=s.split()
    count=0
    s=len(L)-len(set(L))
    for i in range(len(L)):
        count+=1
        if count>s:
            return True
        for j in range(i+1,len(L)):
            if L[j]==L[i] and pattern[j]!=pattern[i]:
                return False
    return True
print(wordPattern("abba","dog cat cat dog"))
print(wordPattern("abba","dog cat cat fish"))
print(wordPattern("aaaa","dog cat cat dog"))
print(wordPattern("aaaa","dog dog dog dog"))

我猜又会超时

小仙

def wordPattern(pattern, string):
  str_map = dict()
  string = string.split()
  for i, p in enumerate(pattern):
    if p in str_map.keys():
      if string[i] not in str_map[p]:
        return False
    else:
      str_map[p] = [string[i]]
  if len(set(pattern)) != len(set(string)): 
    return False
  return True

Daniel_Zhang

def wordPattern(pattern, s):
    pattern_list = list(pattern)
    s_list = s.split(' ')
    length_s = len(s_list)
    length_p = len(pattern_list)
    if length_s != length_p:
        return False
    check_list = []
    for each in range(length_p):
        check_list.append([pattern_list[each], each])
    check_list.sort()

    for each in range(len(check_list) - 1):
        if check_list[each][0] == check_list[each + 1][0]:
            if s_list[check_list[each][1]] == s_list[check_list[each + 1][1]]:
                pass
            else:
                return False
    return True


print(wordPattern("abba", "dog cat cat dog"))
print(wordPattern("abba", "dog cat cat fish"))
print(wordPattern("aaaa", "dog cat cat dog"))
print(wordPattern("aaaa", "dog dog dog dog"))

单层 for 循环应该会快一点？

柿子饼同学

我一直搞不懂这种题，是不能用函数么，还是匹配的功能要自己写

qq1151985918

def wordPattern(pattern, s):
    pList,sList = list(pattern),s.split()
    if len(pList) != len(sList) or len(set(pList)) != len(set(sList)):
        return False
    Dict = {}
    for i in range(len(pList)):
        if pList[i] not in Dict.keys():
            Dict[pList[i]] = sList[i]
        else:
            if Dict[pList[i]] != sList[i]:
                return False
    return True

crisfo

def wordPattern(keys, s):

    values = s.split(' ')
    
    if len(keys) != len(values):
        return False

    dic1 = {}

    for i in range(len(keys)):
        if(keys[i] not in dic1.keys()):
            if(values[i] in dic1.values()):
                return False
            dic1[keys[i]] = values[i]
            
        else:
            if(dic1.get(keys[i]) != values[i]):
                return False

    return True
    
    pass


pattern = 'abbba'
str1 = 'dog cat cat cat dog'
print(wordPattern(pattern, str1))

Stubborn

def wordPattern(pattern: str, s:str):
    """
    :type pattern: str
    :type s: str
    :rtype: bool
    """
    strs = s.split(" ")
    if len(pattern) != len(strs): return False
    D = dict()
    for p, ss in zip(pattern, strs):
        # 根据规则p，去映射字典取字符串
        r = D.get(p, None)
        # 如果是None,说明当前规则没有录入
        if r is None:
            D[p] = ss
        # 如果有值，且和当前字符对不上，返回False
        elif r != ss:
            return False
    return True

liuzhengyuan

柿子饼同学 发表于 2021-3-22 07:43
我一直搞不懂这种题，是不能用函数么，还是匹配的功能要自己写

封装成函数更方便测试代码

liuzhengyuan

-------------------------------------分割线-------------------------------
之后答题不会有奖励

liuzhengyuan

洋洋痒 发表于 2021-3-21 22:14
我猜又会超时

输入：
"aba"
"dog cat cat"
结果错误

liuzhengyuan

小仙 发表于 2021-3-21 22:41

输入：
"aba"
"cat cat cat dog"
解答错误

liuzhengyuan

Daniel_Zhang 发表于 2021-3-21 23:25
单层 for 循环应该会快一点？

输入：
"abba"
"dog dog dog dog"
输出：
true
预期结果：
false

liuzhengyuan

Stubborn 发表于 2021-3-22 17:04

输入：
"abba"
"dog dog dog dog"
输出：
true
预期结果：
false

Daniel_Zhang

liuzhengyuan 发表于 2021-3-24 17:06
输入：
"abba"
"dog dog dog dog"

def wordPattern(pattern, s):
    pattern_list = list(pattern)
    s_list = s.split(' ')
    length_s = len(s_list)
    length_p = len(pattern_list)
    if length_s != length_p:
        return False
    check_list = []
    for each in range(length_p):
        check_list.append([pattern_list[each], each])
    check_list.sort()
    print(check_list)

    for each in range(len(check_list) - 1):
        if check_list[each][0] == check_list[each + 1][0]:
            if s_list[check_list[each][1]] == s_list[check_list[each + 1][1]]:
                pass
            else:
                return False
        else:
            if s_list[check_list[each][1]] == s_list[check_list[each+1][1]]:
                return False
    return True

这样应该就可以了吧，漏了一种情况