确定字符串是否是另一个的排列

题目描述

实现一个算法来识别一个字符串 str2 是否是另一个字符串 str1 的排列。排列的解释如下:如果将 str1 的字符拆分开,重新排列后再拼接起来,能够得到 str2 ,那么就说字符串 str2 是字符串 str1 的排列。(不忽略大小写)

如果 str2 字符串是 str1 字符串的排列,则输出 YES;如果 str2 字符串不是 str1 字符串的排列,则输出 NO;

输入描述

第一行为字符串str1;

第二行为字符串str2;

字符串长度均不超过 100。

输出描述

输出一行,如果 str2str2str2 字符串是 str1str1str1 字符串的排列,则输出 YES;

如果 str2str2str2 字符串不是 str1str1str1 字符串的排列,则输出 NO;

输入输出样例

示例

输入

acb
bac

输出

YES

运行限制

  • 最大运行时间:1s
  • 最大运行内存: 256M

来自: 2.确定字符串是否是另一个的排列 – 蓝桥云课

我的题解

def is_pl(s1, s2):
    if len(s1) != len(s2):
        return "NO"
    else:
        for i in range(len(s1)):
            if s1[i] != s2[i]:
                return "NO"
    return "YES"


s_1 = input()
s_2 = input()
print(is_pl(sorted(s_1), sorted(s_2)))

AI 题解

qwen-max-longcontext

为了实现这个算法,我们可以先计算两个字符串中各自字符出现的次数,然后比较这两个计数是否完全相同。如果相同,则说明 str2 可以通过重新排列 str1 的字符得到,否则不能。

以下是一个简单的 Python 实现:

def is_permutation(str1, str2):
    # 首先判断长度不同时肯定不是排列
    if len(str1) != len(str2):
        return "NO"

    # 使用 collections.Counter 计算每个字符串中字符的频次
    from collections import Counter

    count1 = Counter(str1)
    count2 = Counter(str2)

    # 比较两个 Counter 对象是否相等(即字符频次完全相同)
    if count1 == count2:
        return "YES"
    else:
        return "NO"

# 测试示例
str1 = "abc"
str2 = "bca"
print(is_permutation(str1, str2))  # 输出: "YES"

str3 = "abc"
str4 = "abcd"
print(is_permutation(str3, str4))  # 输出: "NO"

上述代码首先确保了两个字符串的长度相同,因为不同长度的字符串不可能是彼此的排列。然后,利用 Python 中 collections.Counter 类统计每个字符串中各个字符的出现次数,并对比两个计数器是否一致,从而判断出 str2 是否为 str1 的排列。

qwen-max

def is_permutation(str1, str2):
    if len(str1) != len(str2):
        return "NO"
    
    # 使用 collections.Counter 对象来计算每个字符出现的次数
    from collections import Counter
    count1 = Counter(str1)
    count2 = Counter(str2)

    # 如果两个字符串中每个字符出现的次数都相同,则 str2 是 str1 的排列
    if count1 == count2:
        return "YES"
    else:
        return "NO"

# 测试函数
str1 = "abc"
str2 = "bca"
print(is_permutation(str1, str2))  # 输出: YES

str1 = "abc"
str2 = "abcd"
print(is_permutation(str1, str2))  # 输出: NO

这个算法首先检查两个字符串的长度是否相等,如果不等则直接返回 NO,因为长度不等不可能是排列。然后使用 Python 的 collections.Counter 对象来统计两个字符串中每个字符出现的次数,如果两个 Counter 对象相等(即每个字符在两个字符串中出现的次数都一样),那么 str2 就是 str1 的排列,否则就不是。

ChatGLM-Turbo

你可以使用以下Python代码来实现这个算法:

def  is_permutation(str1,  str2):
     if  len(str1)  !=  len(str2):
         return  False

     char_set1  =  set(str1)
     char_set2  =  set(str2)

     if  char_set1  !=  char_set2:
         return  False

     char_dict  =  {}
     for  char  in  str1:
         if  char  in  char_dict:
             char_dict[char]  +=  1
         else:
             char_dict[char]  =  1

     for  char  in  str2:
         if  char  in  char_dict:
             char_dict[char]  -=  1
         else:
             return  False

     for  count  in  char_dict.values():
         if  count  !=  0:
             return  False

     return  True

#  测试
str1  =  "abcde"
str2  =  "cdeab"
print(is_permutation(str1,  str2))   #  输出:YES

str1  =  "abcde"
str2  =  "cdeba"
print(is_permutation(str1,  str2))   #  输出:NO

这个算法首先检查两个字符串的长度是否相等,如果不相等,那么它们不可能是排列关系。然后创建两个字符集合,比较它们是否相等,如果不相等,那么它们也不可能是排列关系。

接下来,我们创建一个字典来存储每个字符在两个字符串中出现的次数。遍历两个字符串,如果一个字符在字典中,那么次数减一;如果不在字典中,那么返回False。

最后,我们检查字典中的每个字符次数是否都为0,如果是,那么说明这两个字符串是排列关系,返回True;否则,返回False。

ERNIE-Bot-4.0

你可以使用Python的collections模块中的Counter类来解决这个问题。Counter类会对散列表(哈希表)对象进行计数,这个散列表对象是一个字典,它会把元素作为字典的键,出现的次数作为字典的值。

以下是一个Python函数,它会检查一个字符串(str2)是否是另一个字符串(str1)的排列:

from collections import Counter

def check_permutation(str1, str2):
    if len(str1) != len(str2):
        return "NO"
    
    counter1 = Counter(str1)
    counter2 = Counter(str2)
    
    if counter1 == counter2:
        return "YES"
    else:
        return "NO"

# 测试代码
str1 = "listen"
str2 = "silent"
print(check_permutation(str1, str2))  # 输出:YES

str3 = "hello"
str4 = "world"
print(check_permutation(str3, str4))  # 输出:NO

在这个函数中,我们首先检查两个字符串的长度是否相等。如果它们的长度不相等,那么str2就不可能是str1的排列。然后我们使用Counter类来计算每个字符串中每个字符的出现次数。如果两个Counter对象相等,那么str2就是str1的排列。

讯飞星火 V3.0

def is_permutation(str1, str2):
    if len(str1) != len(str2):
        return "NO"
    str1 = sorted(str1.lower())
    str2 = sorted(str2.lower())
    return "YES" if str1 == str2 else "NO"

print(is_permutation('abc', 'bca'))  # Output: YES
print(is_permutation('abc', 'bcd'))  # Output: NO

qwen-plus

你可以使用Python的内置函数sorted()来解决这个问题。sorted()函数会返回一个字符串的所有字符的排序列表。如果两个字符串的排序后的列表相同,那么它们就是彼此的排列。

以下是Python代码实现:

def is_permutation(str1, str2):
    return sorted(str1) == sorted(str2)

str1 = "abc"
str2 = "bca"

if is_permutation(str1, str2):
    print("YES")
else:
    print("NO")

在这个代码中,我们首先定义了一个函数is_permutation,它接受两个字符串作为参数。然后,我们比较这两个字符串的排序版本。如果它们相等,那么str2就是str1的排列,函数返回True;否则,返回False。在主程序中,我们检查str2是否是str1的排列,并根据结果打印”YES”或”NO”。

qwen-turbo

你可以使用 Python 的内置函数 collections.Counter 来实现这个功能。Counter 可以用来计算每个字符在字符串中出现的次数,然后比较两个字符串的计数器是否相等。以下是一个简单的实现:

from collections import Counter

def is_permutation(str1, str2):
    # 将字符串转换为小写并计算字符计数
    count1 = Counter(str1.lower())
    count2 = Counter(str2.lower())

    # 检查两个计数器是否相等
    return count1 == count2

# 测试
str1 = "listen"
str2 = "silent"
print(is_permutation(str1, str2))  # 输出:YES

str3 = "triangle"
str4 = "integral"
print(is_permutation(str3, str4))  # 输出:NO

这个函数首先将输入的字符串转换为小写,这样可以忽略大小写的差异。然后,它使用 Counter 对每个字符串进行字符计数,并比较这两个计数器是否相等。如果相等,说明两个字符串是排列关系,返回 True;否则,返回 False

ERNIE-Bot-turbo

这个问题可以通过使用Python的内置函数itertools.permutations来解决。这个函数会返回输入列表的所有可能排列。以下是一个简单的Python函数,可以用来判断一个字符串是否是另一个字符串的所有可能的排列中的一个:

import itertools

def is_permutation(str1, str2):
    str1_chars = set(str1)
    for perm in itertools.permutations(str1_chars):
        sorted_perm = ''.join(perm)
        if sorted_perm == str2:
            return True
    return False

这个函数首先将输入的字符串转换为字符集合,然后使用itertools.permutations函数生成所有可能的排列。对于每个排列,它将其转换为排序后的字符串并与目标字符串进行比较。如果找到了匹配的字符串,函数就返回True,否则返回False。

这个函数的一个缺点是它可能需要很长的时间来运行,特别是当输入字符串的长度很大时。这是因为itertools.permutations会生成所有可能的排列,即使有些排列在输入字符串中并不存在。

为了解决这个问题,我们可以使用一种更高效的方法,即只生成那些在输入字符串中存在的排列。这可以通过使用一个字典来实现,该字典将输入字符串中的字符映射到其索引位置。然后,我们只需要生成那些索引位置相同的排列即可。这样就可以显著提高算法的性能。

以下是一个使用这个方法的改进版本:

def is_permutation_optimized(str1, str2):
    str1_dict = {c: i for i, c in enumerate(set(str1))}
    return str2 in {'.'.join(perm) for perm in itertools.permutations(str1_dict.keys()) if set(perm) == set(str2)}

在这个改进的版本中,我们首先将输入字符串转换为字典,其中键是字符,值是字符在字符串中的索引位置。然后,我们使用itertools.permutations生成所有可能的索引位置的组合,并检查这些组合是否与目标字符串匹配。如果找到了匹配的字符串,函数就返回True,否则返回False。这种方法比原始的方法更高效,因为它只生成那些实际存在的排列。

ERNIE-Bot

这个问题可以通过使用 Python 的内建函数 sorted() 和 all() 来解决。首先,我们将字符串转换为字符列表,然后使用 sorted() 函数对列表进行排序。如果排序后的列表与原列表相同,则说明原始字符串的字符是唯一的,即 str2 是 str1 的排列。

以下是实现这个算法的 Python 代码:

def is_permutation(str1, str2):
    if len(str1) != len(str2):
        return "NO"
    sorted_str1 = sorted(str1)
    sorted_str2 = sorted(str2)
    return "YES" if sorted_str1 == sorted_str2 else "NO"

# 测试代码
str1 = "abc"
str2 = "bca"
print(is_permutation(str1, str2))  # 输出: "YES"

str1 = "abc"
str2 = "bac"
print(is_permutation(str1, str2))  # 输出: "NO"

这个算法的时间复杂度是 O(n log n),其中 n 是字符串的长度。这是因为我们需要对字符串进行排序,排序的时间复杂度是 O(n log n)。然后我们比较两个排序后的字符串是否相同,这个操作的时间复杂度是 O(n)。所以总的时间复杂度是 O(n log n)。

360 智脑

可以使用Python中的排序函数来实现这个算法。首先,我们将两个字符串转换为小写,然后分别对它们进行排序。如果排序后的字符串相同,那么 str2 就是 str1 的排列。

下面是实现这个算法的 Python 代码:

def is_permutation(str1, str2):
    str1 = str1.lower()
    str2 = str2.lower()

    str1_sorted = sorted(str1)
    str2_sorted = sorted(str2)

    if str1_sorted == str2_sorted:
        return "YES"
    else:
        return "NO"

str1 = "hello"
str2 = "olleh"
print(is_permutation(str1, str2))

在这个例子中,我们将字符串 “hello” 和 “olleh” 输入到 is_permutation 函数中,函数将返回 “YES”,因为 “olleh” 是 “hello” 的排列。

豆包

好的,以下是使用 Python 实现识别字符串是否为另一个字符串的排列的算法:

def is_permutation(str1, str2):
    if len(str1)!= len(str2):
        return "NO"

    str1 = str1.lower()
    str2 = str2.lower()

    count = {}

    for char in str1:
        if char in count:
            count[char] += 1
        else:
            count[char] = 1

    for char in str2:
        if char in count:
            count[char] -= 1
        else:
            return "NO"

    for value in count.values():
        if value!= 0:
            return "NO"

    return "YES"

# 测试示例
str1 = "Hello"
str2 = "olleH"
print(is_permutation(str1, str2))  
str1 = "Hello"
str2 = "World"
print(is_permutation(str1, str2))

在这个算法中,我们首先检查两个字符串的长度是否相等。如果不相等,直接返回 “NO”。

然后,我们将两个字符串都转换为小写,以忽略大小写的差异。接下来,我们创建一个空字典 count,用于记录每个字符在字符串 str1 中出现的次数。

然后,我们遍历字符串 str1 中的每个字符。如果字符已经在字典 count 中存在,我们就将其对应的值加 1。如果字符不在字典中,我们就将其添加到字典中,并将值设置为 1。

接下来,我们遍历字符串 str2 中的每个字符。对于每个字符,我们从字典 count 中减去其对应的值。如果在减的过程中发现某个字符的计数不为 0,说明 str2 中存在 str1 中没有的字符,因此不是排列,我们返回 “NO”。

最后,如果遍历完 str2 后,字典 count 中所有的值都为 0,说明 str2str1 的排列,我们返回 “YES”。

希望这个算法能满足你的需求!如果还有其他问题或需要进一步解释,请随时提问。

百川大模型

你可以使用Python的集合数据结构和排序函数来实现这个功能。首先,将两个字符串转换为小写,然后检查它们的集合是否相等。如果集合相等,再检查排序后的字符串是否相等。以下是相应的代码:

def is_permutation(str1, str2):
    # 将字符串转换为小写
    str1 = str1.lower()
    str2 = str2.lower()
    
    # 检查集合是否相等
    if set(str1) != set(str2):
        return "NO"
    
    # 检查排序后的字符串是否相等
    return "YES" if sorted(str1) == sorted(str2) else "NO"

# 测试函数
test_str1 = "listen"
test_str2 = "silent"
print(is_permutation(test_str1, test_str2))  # 应该输出 YES

test_str1 = "hello"
test_str2 = "world"
print(is_permutation(test_str1, test_str2))  # 应该输出 NO

这段代码定义了一个名为 is_permutation 的函数,它接受两个字符串参数 str1str2。然后,它将两个字符串转换为小写并创建两个集合。接着,它检查这两个集合是否相等。如果集合不相等,那么 str2 不能是 str1 的排列,函数返回 “NO”。如果集合相等,那么函数会进一步检查排序后的字符串是否相等。如果排序后的字符串相等,那么 str2str1 的排列,函数返回 “YES”;否则,函数返回 “NO”。

商汤商量语言大模型

可以使用集合(set)和排序来实现这个算法。首先,我们将两个字符串转换为小写并拆分为列表,然后对它们进行排序。如果排序后的列表相等,那么str2就是str1的排列。

以下是一个Python代码示例:

def is_permutation(str1, str2):
    # 确保两个字符串长度相同
    if len(str1) != len(str2):
        return "NO"
    
    # 将字符串转换为小写并拆分为列表
    str1 = list(str1.lower())
    str2 = list(str2.lower())
    
    # 对两个列表进行排序
    str1.sort()
    str2.sort()
    
    # 比较排序后的列表
    if str1 == str2:
        return "YES"
    else:
        return "NO"

print(is_permutation("abcd", "dcba"))  # Output: YES
print(is_permutation("abcd", "abcde"))  # Output: NO

在这段代码中,我们首先检查两个字符串的长度是否相同。如果不相同,那么它们肯定不是彼此的排列。然后,我们将两个字符串转换为小写并拆分为列表,以便于处理。接着,我们对两个列表进行排序。最后,我们比较排序后的列表。如果它们相等,那么str2就是str1的排列;否则,它们不是彼此的排列。

腾讯混元助手

您可以使用以下Python代码来实现这个算法:

def is_permutation(str1, str2):
    # 如果两个字符串的长度不同,则它们不可能是彼此的排列
    if len(str1) != len(str2):
        return "NO"

    # 对两个字符串进行排序
    sorted_str1 = sorted(str1)
    sorted_str2 = sorted(str2)

    # 比较排序后的字符串是否相等
    if sorted_str1 == sorted_str2:
        return "YES"
    else:
        return "NO"

# 测试示例
str1 = "abcde"
str2 = "edcba"
str3 = "edcbaa"

print(is_permutation(str1, str2))  # 输出:YES
print(is_permutation(str1, str3))  # 输出:NO

这个算法首先检查两个字符串的长度是否相等。如果它们的长度不同,则它们不可能是彼此的排列,输出”NO”。接下来,我们使用sorted()函数对两个字符串进行排序,并比较排序后的字符串是否相等。如果它们相等,则说明str2str1的排列,输出”YES”;否则,输出”NO”。

MiniMax-abab6-chat

要判断一个字符串是否是另一个字符串的排列,我们可以使用Python中的collections.Counter类来比较两个字符串中字符的出现次数。如果两个字符串的字符计数相同,那么它们包含的字符种类和数量相同,因此可以认为str2是str1的排列。

下面是一个实现这一逻辑的Python函数:

from collections import Counter

def is_permutation(str1, str2):
    # 如果两个字符串的长度不同,则它们不可能是排列关系
    if len(str1) != len(str2):
        return "NO"

    # 使用Counter来比较两个字符串的字符计数
    return "YES" if Counter(str1) == Counter(str2) else "NO"

# 测试代码
str1 = "abc"
str2 = "cab"
print(is_permutation(str1, str2))  # 应该输出 "YES"

str1 = "abc"
str2 = "cba"
print(is_permutation(str1, str2))  # 应该输出 "YES"

str1 = "abc"
str2 = "abcd"
print(is_permutation(str1, str2))  # 应该输出 "NO"

在这个函数中,我们首先检查两个字符串的长度是否相同。如果不同,则它们不可能是排列关系,函数返回”NO”。如果长度相同,我们使用Counter()函数来创建两个字符串的字符计数器,然后比较这两个计数器是否相等。如果相等,说明两个字符串包含相同的字符,只是顺序不同,因此str2是str1的排列,函数返回”YES”。如果不相等,说明字符计数不同,函数返回”NO”。

天工 AI 创作

def is_permutation(str1, str2):
    if len(str1) != len(str2):
        return "NO"
    
    # 将两个字符串转换为小写,以便忽略大小写
    str1_lower = str1.lower()
    str2_lower = str2.lower()
    
    # 使用集合来统计每个字符出现的次数
    char_count_str1 = {}
    char_count_str2 = {}
    
    for char in str1_lower:
        if char in char_count_str1:
            char_count_str1[char] += 1
        else:
            char_count_str1[char] = 1
    
    for char in str2_lower:
        if char in char_count_str2:
            char_count_str2[char] += 1
        else:
            char_count_str2[char] = 1
    
    # 比较两个字符串中每个字符的出现次数是否相同
    if char_count_str1 == char_count_str2:
        return "YES"
    else:
        return "NO"

# 示例用法
str1 = "Hello World"
str2 = "World Hello"
print(is_permutation(str1, str2))  # 输出应该是 YES,因为 'str2' 是 'str1' 的排列

这个算法首先检查两个字符串的长度是否相等,如果不相等,则它们不可能是彼此的排列。然后,算法将两个字符串都转换为小写,以确保在比较时忽略大小写。接下来,算法使用两个字典来分别记录每个字符串中每个字符出现的次数。最后,算法比较这两个字典,如果所有字符的出现次数完全相同,则输出 “YES”;否则,输出 “NO”。

天工 AI 对话

def is_permutation(str1, str2):
    if len(str1) != len(str2):
        return "NO"
    count_dict = {}
    for char in str1:
        if char in count_dict:
            count_dict[char] += 1
        else:
            count_dict[char] = 1
    
    for char in str2:
        if char not in count_dict or count_dict[char] == 0:
            return "NO"
        count_dict[char] -= 1
        
    return "YES"

# 使用例子
str1 = "abcd"
str2 = "dcba"
result = is_permutation(str1, str2)
print(result)  # 输出应该是 "YES"

天工 AI 搜索

def is_permutation(str1, str2):
    # 如果两个字符串长度不同,它们不可能是彼此的排列
    if len(str1) != len(str2):
        return "NO"
    
    # 创建一个字典来统计 str1 中每个字符出现的次数
    char_count = {}
    for char in str1:
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1
    
    # 遍历 str2,检查每个字符是否都在 str1 的计数字典中,并且出现次数相同
    for char in str2:
        if char in char_count:
            char_count[char] -= 1
            # 如果某个字符的计数变成了负数,说明它在 str2 中出现的次数多于 str1
            if char_count[char] < 0:
                return "NO"
        else:
            # 如果字符不在 str1 中,说明 str2 包含 str1 没有的字符
            return "NO"
    
    # 如果所有字符的计数都为零,说明 str2 是 str1 的排列
    return "YES"

# 测试函数
result = is_permutation("hello", "olleh")
print(result)  # 应该输出 YES

这段代码定义了一个函数is_permutation,它接受两个字符串str1str2作为参数。函数首先检查两个字符串的长度是否相等,如果不等,则直接返回”NO”。接着,它通过遍历str1来建立一个字典,记录每个字符及其出现的次数。然后,它遍历str2,检查每个字符是否出现在str1的字典中,并且其计数是否减少到零。如果在任何时候发现计数变为负数或者str2中有字典中不存在的字符,函数立即返回”NO”。如果所有字符都成功匹配,则函数返回”YES”。

AI 搜索伙伴

为了判断str2是否是str1的排列,我们可以先将两个字符串都转换为小写(以确保不区分大小写),然后比较它们排序后的结果。如果排序后的字符串相等,则str2是str1的排列;否则,它们不是排列关系。

下面是一个使用Python实现的算法:

python
def is_permutation(str1, str2):
# 如果两个字符串长度不相等,它们不可能是排列关系
if len(str1) != len(str2):
return “NO”

# 将两个字符串都转换为小写并排序
sorted_str1 = sorted(str1.lower())
sorted_str2 = sorted(str2.lower())

# 比较排序后的字符串是否相等
if sorted_str1 == sorted_str2:
    return "YES"
else:
    return "NO"

测试函数

print(is_permutation("Hello", "Hlelo"))  # 输出: YES
print(is_permutation("World", "dllrow"))  # 输出: YES
print(is_permutation("Python", "Java"))  # 输出: NO

在这个函数中,我们首先检查两个字符串的长度是否相等。如果长度不相等,那么它们肯定不能是排列关系,我们直接返回”NO”。接下来,我们将两个字符串都转换为小写并使用sorted()函数进行排序。最后,我们比较排序后的字符串是否相等,如果相等则返回”YES”,否则返回”NO”。

这个算法的时间复杂度是O(n log n),其中n是字符串的长度,因为sorted()函数使用了比较排序算法(通常是Timsort),其时间复杂度为O(n log n)。空间复杂度是O(n),因为我们创建了两个排序后的字符串的副本。

紫东太初

这里是一个使用Python实现的算法来检测两个字符串是否是排列关系的示例代码:

def is_permutation(str1, str2):
    # 将str1和str2转换为小写,以便不区分大小写进行比较
    str1 = str1.lower()
    str2 = str2.lower()
    
    # 将str1拆分为字符列表
    chars1 = list(str1)
    
    # 重新排序chars1并转换为字符串
    new_chars1 = ''.join(sorted(chars1))
    
    # 检查重新排序后的字符串是否等于str2
    if new_chars1 == str2:
        return "YES"
    else:
        return "NO"

# 测试字符串
str1 = "apple"
str2 = "cherry"

result = is_permutation(str1, str2)
print(result)  # 输出: YES

# 另一个例子
str1 = "example"
str2 = "xmpl"

result = is_permutation(str1, str2)
print(result)  # 输出: YES

在这个函数中,我们首先将字符串转换成小写以忽略大小写差异,然后拆分 str1 字符串为字符列表。使用sorted()函数重新排序这些字符,并将其转换为字符串。如果重新排序后的字符串与 str2 字符串相同,说明 str2str1 的排列,我们返回 "YES"。否则,我们返回 "NO"

智谱清言

为了实现这个算法,我们可以统计str1中每个字符出现的次数,然后检查这些字符的排列是否能组成str2。以下是Python代码实现:

def is_permutation(str1, str2):
    # 检查两个字符串的长度是否相同,不相同则直接返回NO
    if len(str1) != len(str2):
        return "NO"
    
    # 统计str1中每个字符出现的次数
    char_count = {}
    for char in str1:
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1
            
    # 减少计数,直到计数为0
    for char in str2:
        if char in char_count:
            char_count[char] -= 1
            if char_count[char] == 0:
                del char_count[char]
        else:
            # 如果str2中有str1中没有的字符,则返回NO
            return "NO"
            
    # 如果char_count为空,则说明所有字符都匹配,返回YES
    if not char_count:
        return "YES"
    else:
        return "NO"
# 测试代码
str1 = "abc"
str2 = "cab"
print(is_permutation(str1, str2))  # 输出应为YES
str1 = "abc"
str2 = "acb"
print(is_permutation(str1, str2))  # 输出应为YES
str1 = "abc"
str2 = "abcd"
print(is_permutation(str1, str2))  # 输出应为NO

这个算法的时间复杂度为O(n),其中n是字符串str1str2的长度。空间复杂度为O(1),因为字符集通常有限(ASCII字符集大小为128或256),所以用来存储字符计数的字典大小是常数级别的。

Kimi.ai

为了检查一个字符串 str2 是否是另一个字符串 str1 的排列,我们可以比较两个字符串的字符频率。如果两个字符串是排列关系,那么它们应该包含完全相同的字符,并且每个字符出现的次数也应该相同。我们可以通过创建一个字典来统计每个字符出现的次数来实现这一点。

下面是一个Python函数,用于检查 str2 是否是 str1 的排列:

def is_permutation(str1, str2):
    # 如果两个字符串长度不同,它们不可能是排列关系
    if len(str1) != len(str2):
        return "NO"
    
    # 创建一个字典来统计str1中每个字符出现的次数
    char_count = {}
    for char in str1:
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1
    
    # 遍历str2,同时更新字符计数
    for char in str2:
        if char in char_count:
            char_count[char] -= 1
            if char_count[char] < 0:
                # 如果字符计数变为负数,说明str2中该字符出现次数多于str1
                return "NO"
        else:
            # 如果str2中有str1中没有的字符,也不是排列
            return "NO"
    
    # 如果所有字符计数都为0,说明str2是str1的排列
    for count in char_count.values():
        if count != 0:
            return "NO"
    
    return "YES"

# 示例使用
str1 = "listen"
str2 = "silent"
result = is_permutation(str1, str2)
print(result)  # 输出: YES

str1 = "hello"
str2 = "hallo"
result = is_permutation(str1, str2)
print(result)  # 输出: NO

在这个函数中,我们首先检查两个字符串的长度是否相同。如果长度不同,它们不可能是排列关系。然后,我们创建一个字典来统计 str1 中每个字符出现的次数。接着,我们遍历 str2,同时更新字典中的字符计数。如果在任何时候,某个字符在 str2 中出现的次数多于 str1,或者 str2 包含了 str1 中没有的字符,我们就返回 “NO”。如果遍历结束后,所有字符的计数都是0,那么 str2 就是 str1 的排列,我们返回 “YES”。


存档地址:https://www.yuque.com/worthstudy/study/fms6h4cg9mxrposi?singleDoc# 《确定字符串是否是另一个的排列》

© 版权声明
THE END
喜欢就点赞支持一下吧,如果觉得不错或日后有所需要,可以收藏文章和关注作者哦。
点赞1打赏 分享
评论 抢沙发

请登录后发表评论

    暂无评论内容