确定字符串是否包含唯一字符-值得研究

题目描述

实现一个算法来识别一个字符串的字符是否是唯一的（忽略字母大小写）。

若唯一，则输出YES，否则输出NO。

输入描述

输入一行字符串，长度不超过 100。

输出描述

输出一行，若字符串的字符是唯一的，则输出YES，否则输出NO。

输入输出样例

示例

输入

abd25+

输出

YES

运行限制

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

来自: 1.确定字符串是否包含唯一字符 – 蓝桥云课

我的题解

def onlyone(str_2):
    for i in range(len(str_2)):
        for j in range(i+1, len(str_2)):
            if str_2[i] == str_2[j]:
                return "NO"
    return "YES"


str_1 = input()
print(onlyone(str_1))

忽略大小写？

发现了一个问题，我没有考虑题干要求的“忽略大小写”

修改：

def onlyone(str_2):
    for i in range(len(str_2)):
        for j in range(i+1, len(str_2)):
            if str_2[i] == str_2[j]:
                return "NO"
    return "YES"


str_1 = input()
print(onlyone(str_1.lower()))

即将输入的字符串转换成小写之后再传入函数进行计算。

AI 题解

qwen-max-longcontext

def is_unique_string_ignore_case(s):
    s = s.lower()
    char_set = set()
    
    for char in s:
        if char in char_set:
            return "NO"
        char_set.add(char)
    
    return "YES"

# 测试函数
test_string = "HelloWorld"
print(is_unique_string_ignore_case(test_string))

上述Python代码定义了一个名为is_unique_string_ignore_case的函数，它接受一个字符串s作为输入。首先，我们将输入字符串转换为小写以忽略大小写差异。然后创建一个空集合char_set用于存储已经遇到的字符。

接下来，遍历字符串中的每个字符，如果字符已经在集合中（即已遇到过），则返回”NO”表示该字符串不具有唯一字符。否则，将字符添加到集合中。

如果循环结束都没有遇到重复字符，则返回”YES”表示所有字符都是唯一的。

qwen-max

下面是一个简单的Python函数实现：

def is_unique_string(s):
    s = s.lower()  # 将字符串转为小写以便忽略大小写
    unique_chars = set(s)  # 使用集合来去除重复字符
    if len(s) == len(unique_chars):  # 如果字符串长度等于不重复字符的个数，则所有字符都是唯一的
        return "YES"
    else:
        return "NO"

# 测试函数
print(is_unique_string("Hello"))  # 输出：NO
print(is_unique_string("Python"))  # 输出：YES

这个函数首先将输入的字符串转换为小写，然后使用Python的set数据结构来移除所有重复的字符。由于集合中的元素是唯一的，所以如果原始字符串的长度和转换后的集合的长度相等，那么原始字符串中的所有字符都是唯一的。否则，至少有一个字符是重复的。

ChatGLM-Turbo

def  is_unique(s):
     s  =  s.lower()
     char_set  =  set()
     for  char  in  s:
         if  char  in  char_set:
             return  False
         char_set.add(char)
     return  True

#  Test  cases
print(is_unique("abcde"))   #  YES
print(is_unique("abcdeA"))   #  NO
print(is_unique("abcdeabcde"))   #  NO
print(is_unique("abcdeABCDE"))   #  YES

这个算法将字符串的所有字符转换为小写，然后使用一个集合来存储已经遇到的字符。遍历字符串，如果字符已经在集合中，则返回False，表示不是唯一的。如果遍历结束后，集合中只有字符串中的字符，返回True，表示字符是唯一的。

ERNIE-Bot-4.0

这个问题可以使用Python中的set数据结构来解决。set是一个无序且不包含重复元素的集合，所以我们可以将字符串转换为set，然后比较set的长度和原字符串的长度是否相等。如果相等，说明字符串中的字符都是唯一的。另外，由于题目要求忽略字母大小写，所以在转换之前我们需要将字符串转换为全小写或全大写。

以下是一个实现该算法的Python函数：

def is_unique_chars(s):
    s = s.lower()  # 转换为小写
    if len(s) == len(set(s)):
        return 'YES'
    else:
        return 'NO'

# 测试
print(is_unique_chars('Hello World!'))  # 输出: NO
print(is_unique_chars('abcdefghijklmnopqrstuvwxyz'))  # 输出: YES

这个函数首先将输入字符串转换为小写，然后检查转换后的字符串长度是否等于其转换为set后的长度。如果相等，则返回’YES’，否则返回’NO’。

需要注意的是，这个函数假设输入的是ASCII字符。如果输入包含非ASCII字符（如Unicode字符），那么可能需要更复杂的处理方式来正确地比较字符。同时，这个函数也无法处理空格，因为空格在字符串中也是一个字符。如果需要忽略空格，可以在转换为set之前使用replace()函数将空格替换掉。

另外，这个函数的时间复杂度是O(n)，其中n是字符串的长度。这是因为我们需要遍历整个字符串来创建set，而创建set的时间复杂度是O(n)。然后，我们比较set的长度和原字符串的长度，这个操作的时间复杂度是O(1)。所以，总的时间复杂度是O(n)。

讯飞星火 V3.0

好的，以下是解决这个问题的Python代码：

def 是否字符唯一(s):
    s = s.lower()  # 转换为小写
    seen = set()   # 用于存储已经看到的字符

    for char in s:
        if char in seen:
            return "NO"
        seen.add(char)

    return "YES"

# 测试
test_str = "AaBbCc"
print(是否字符唯一(test_str))

当你运行上述代码并使用AaBbCc作为输入时，它会输出YES。如果你使用一个包含重复字符的字符串，例如AaBbCa，它会输出NO。

qwen-plus

这是一个简单的Python程序，它使用集合（set）来检查字符串中的字符是否都是唯一的。集合是一个无序的不重复元素序列，所以如果字符串转换为集合后的长度等于原字符串长度，那么字符串中的字符就是唯一的。

def is_unique_chars(s):
    s = s.lower()  # 将所有字符转为小写
    return 'YES' if len(set(s)) == len(s) else 'NO'

# 测试
print(is_unique_chars("apple"))  # 输出: NO
print(is_unique_chars("banana"))  # 输出: NO
print(is_unique_chars("cherry"))  # 输出: YES

这个函数首先将输入的字符串转换为小写，然后将其转换为一个集合。如果集合的长度小于字符串的长度，那么说明原字符串中有重复的字符，函数返回’NO’。否则，返回’YES’。

qwen-turbo

你可以使用Python的内置数据结构set来实现这个功能。set是一个无序不重复元素序列，非常适合用来检查元素的唯一性。以下是一个简单的实现：

def is_unique_string(s):
    # 将字符串转换为小写并分割成字符列表
    char_list = list(s.lower())
    
    # 使用set去除重复字符
    unique_chars = set(char_list)
    
    # 如果字符数量等于set的长度，说明所有字符都是唯一的
    if len(unique_chars) == len(char_list):
        return "YES"
    else:
        return "NO"

# 测试函数
print(is_unique_string("Hello"))  # 输出：YES
print(is_unique_string("Hello World"))  # 输出：NO

这个函数首先将输入的字符串转换为小写，并将其拆分成字符列表。然后，它创建一个set，其中包含所有独特的字符。如果set的长度等于原始字符列表的长度，那么所有的字符都是唯一的，函数返回”YES”。否则，返回”NO”。

ERNIE-Bot-turbo

可以使用Python的set数据结构来识别一个字符串的字符是否是唯一的。以下是一个简单的实现：

def is_unique(s):
    return len(set(s)) == len(s)

# 测试代码
print(is_unique("Hello"))  # 输出: YES
print(is_unique("hello"))  # 输出: NO

这段代码首先将输入字符串转换为一个集合（set），然后使用len()函数获取集合中元素的数量。如果原始字符串和集合中元素的数量相同，说明没有重复的字符，返回”YES”。如果有重复的字符，说明存在唯一字符，返回”NO”。这个方法只适用于大小写敏感的情况。如果你希望忽略字母大小写，可以将字符串转换为全小写或全大写后再进行处理。

如果你想要在忽略大小写的同时找出所有的唯一字符，可以稍作修改如下：

def find_unique_chars(s):
    s = s.lower()  # 将字符串转换为小写
    unique_chars = set()
    for char in s:
        if char not in unique_chars:
            unique_chars.add(char)
    return unique_chars

# 测试代码
print(find_unique_chars("Hello"))  # 输出: {'e', 'l', 'l', 'o'}

这段代码会找出所有唯一的字符，并将它们存储在一个集合中。这个方法不仅可以识别唯一字符，还可以找出所有唯一字符。

ERNIE-Bot

这是一个简单的Python算法，使用Python的内置数据类型和函数来实现。首先，我们将字符串转换为小写，然后使用Python的set数据类型来检查是否有重复的字符。set数据类型在Python中是一个无序且不包含重复元素的集合。

以下是Python代码：

def is_unique(s):
    s = s.lower()  # 将字符串转换为小写
    if len(s) != len(set(s)):  # 如果字符串长度不等于集合长度，说明有重复字符
        return "NO"
    else:
        return "YES"

# 测试代码
print(is_unique("Hello World"))  # 输出: "NO"
print(is_unique("abcdef"))  # 输出: "YES"

这个算法的时间复杂度是O(n)，其中n是字符串的长度。这是因为我们需要遍历整个字符串来创建一个集合，然后再次遍历整个集合来检查是否有重复元素。在空间复杂度方面，我们需要额外的空间来存储集合，因此空间复杂度也是O(n)。

360 智脑

可以使用Python的集合数据结构来实现这个算法。集合是一个无序的、不重复的元素集合，可以用来判断一个字符串的字符是否是唯一的。具体实现方法如下：

def is_unique(s):
    s = s.lower()  # 将字符串转换为小写
    unique_chars = set(s)  # 将字符串转换为集合，自动去除重复字符
    if len(unique_chars) == len(s):  # 判断集合长度是否等于字符串长度
        return 'YES'
    else:
        return 'NO'

# 测试
print(is_unique('abcdefg'))  # 输出YES，因为'abcdefg'的字符是唯一的
print(is_unique('hello world'))  # 输出NO，因为'hello world'的字符中存在重复的

这个算法会将字符串转换为小写，并判断字符串的字符是否是唯一的。如果字符是唯一的，就会输出’YES’，否则会输出’NO’。请注意，这个算法只能判断字符串的字符是否是唯一的，不考虑字符串中字母的大小写。

豆包

以下是一个使用 Python 实现的算法，用于检查一个字符串中的字符是否唯一（忽略字母大小写）：

def check_unique_chars(s):
    s = s.lower()
    char_count = {}

    for char in s:
        if char in char_count:
            return "NO"
        char_count[char] = 1

    return "YES"

# 测试示例
string = "Hello World"
print(check_unique_chars(string))  
string = "hello world"
print(check_unique_chars(string))

在这个算法中，我们首先将字符串转换为小写，以忽略字母大小写。然后，我们创建一个空字典 char_count 来记录每个字符出现的次数。

接下来，我们遍历字符串中的每个字符。如果字符已经在字典中存在，说明它不是唯一的，我们直接返回 “NO”。否则，我们将字符添加到字典中，并将其计数设置为 1。

最后，如果我们遍历完整个字符串都没有返回 “NO”，则说明字符串中的字符都是唯一的，我们返回 “YES”。

你可以根据需要修改和使用这个算法。希望这对你有帮助！如果还有其他问题，请随时提问。

百川大模型

以下是一个使用 Python 实现的算法，用于检查一个字符串中的字符是否唯一（忽略字母大小写）：

def check_unique_chars(s):
    s = s.lower()
    char_count = {}

    for char in s:
        if char in char_count:
            return "NO"
        char_count[char] = 1

    return "YES"

# 测试示例
string = "Hello World"
print(check_unique_chars(string))  
string = "hello world"
print(check_unique_chars(string))

在这个算法中，我们首先将字符串转换为小写，以忽略字母大小写。然后，我们创建一个空字典 char_count 来记录每个字符出现的次数。

最后，如果我们遍历完整个字符串都没有返回 “NO”，则说明字符串中的字符都是唯一的，我们返回 “YES”。

你可以根据需要修改和使用这个算法。希望这对你有帮助！如果还有其他问题，请随时提问。

商汤商量大模型

当然可以，下面是一个使用Python实现的算法：

def is_unique(string):
    unique_chars = set()
    
    for char in string:
        if char.lower() in unique_chars:
            return "NO"
        else:
            unique_chars.add(char.lower())
            
    return "YES"

print(is_unique("hello"))  # Output: NO
print(is_unique("abcdefg"))  # Output: YES

这个函数首先创建一个空的集合unique_chars来存储已经出现过的字符。然后，它遍历输入的字符串，对于每个字符，都将其转换为小写并检查是否在unique_chars集合中已经存在。如果存在，则返回”NO”；否则，将该字符添加到unique_chars集合中。最后，如果所有字符都没有重复，则返回”YES”。

MiniMax-abab6-chat

可以使用Python的字典来统计每个字符（忽略大小写）出现的次数，然后判断是否每个字符只出现了一次。下面是实现这个算法的代码：

def is_unique(s):
    # 将字符串转换为小写，并统计每个字符出现的次数
    char_count = {}
    for char in s.lower():
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1

    # 检查每个字符是否只出现了一次
    for count in char_count.values():
        if count > 1:
            return "NO"
    return "YES"

# 测试代码
test_string = "Python"
print(is_unique(test_string))  # 应该输出 "YES"

test_string = "Python3"
print(is_unique(test_string))  # 应该输出 "NO"

这段代码定义了一个函数is_unique，它接受一个字符串s作为参数。函数首先将字符串转换为小写，然后遍历字符串中的每个字符，使用一个字典char_count来统计每个字符出现的次数。最后，函数遍历字典中的值，如果发现任何字符出现的次数超过一次，则返回”NO”，否则返回”YES”。

腾讯混元助手

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

def is_unique_chars(string):
    # 将字符串转换为小写并转换为集合以删除重复项
    unique_chars = set(string.lower())

    # 如果集合的长度等于原始字符串的长度，则说明所有字符都是唯一的
    if len(unique_chars) == len(string):
        return "YES"
    else:
        return "NO"

# 测试示例
string1 = "abcde"
string2 = "aabbcc"
string3 = "AbCde"

print(is_unique_chars(string1))  # 输出：YES
print(is_unique_chars(string2))  # 输出：NO
print(is_unique_chars(string3))  # 输出：YES

这个算法首先将输入字符串转换为小写，然后将其转换为集合，从而自动删除重复的字符。接下来，我们比较集合的长度和原始字符串的长度。如果它们相等，则说明所有字符都是唯一的，输出”YES”；否则，输出”NO”。

天工 AI 创作

def isUniqueChars(s):
    # Create a set to store seen characters
    seen = set()
    
    # Iterate over the string and check if any character is seen before
    for char in s:
        if char.lower() in seen:
            return "NO"
        seen.add(char.lower())
    
    return "YES"

# Example usage
input_string = input("Enter a string: ")
print(isUniqueChars(input_string))

天工 AI 搜索

def is_unique_case_insensitive(s):
    # Convert the string to lower case to ignore letter case
    s = s.lower()
    
    # Create a set to store encountered characters
    char_set = set()
    
    # Iterate over each character in the string
    for char in s:
        # If the current character is already in the set, it's not unique
        if char in char_set:
            return "NO"
        # Otherwise, add it to the set
        char_set.add(char)
    
    # If no duplicates were found, all characters are unique
    return "YES"

# Example usage:
input_string = "Hello World!"
print(is_unique_case_insensitive(input_string))

This Python script defines a function called is_unique_case_insensitive that takes a string as input and returns ‘YES’ if all characters in the string are unique (ignoring letter case), and ‘NO’ otherwise. The function first converts the input string to lower case using the lower() method. Then, it iterates over each character in the string and checks if it is already present in a set called char_set. If a duplicate is found, the function immediately returns ‘NO’. If no duplicates are found after processing all characters, it means all characters are unique, and the function returns ‘YES’. Finally, an example usage of the function is provided with the input string “Hello World!”.

搜索 AI 伙伴

这是一个相对简单的任务，可以通过Python的集合（set）数据结构来实现。集合是一种不包含重复元素的数据结构，因此，如果我们将字符串中的所有字符（忽略大小写）转换为一个集合，然后比较集合的大小和原始字符串的长度，如果两者相等，那么字符串中的字符就是唯一的。

以下是一个简单的Python函数，用于实现这个功能：

python
def is_unique_chars(s):
# 将字符串转换为小写并转换为集合
s_set = set(s.lower())

# 如果集合的大小等于字符串的长度，那么字符就是唯一的
if len(s_set) == len(s):
    return "YES"
else:
    return "NO"

测试函数

print(is_unique_chars(“Hello”)) # 输出: NO
print(is_unique_chars(“World”)) # 输出: YES

这个函数首先将输入的字符串转换为小写，然后将其转换为一个集合。然后，它比较集合的大小和原始字符串的长度。如果它们相等，那么函数返回”YES”，否则返回”NO”。

紫东太初

要实现这个功能，你可以使用Python的collections模块中的Counter类，它可以帮助你计数字符串中各个字符出现的次数。以下是一个实现该功能的函数：

from collections import Counter

def is_unique_character(string):
    # 转换字符串为大写以忽略大小写差异
    string = string.upper()
    # 使用Counter计算每个字符出现的次数
    counter = Counter(string)
    # 检查是否所有字符的计数均为1
    return all(counter[char] == 1 for char in string)

# 测试函数
str1 = "hello"
str2 = "HELL0"
print(is_unique_character(str1))
print(is_unique_character(str2))

在这个函数中，我们首先将输入的字符串转换为大写，这样就可以忽略大小写差异了。然后，我们使用Counter来统计每个字符出现的次数。通过遍历字符串并检查Counter中每个字符的计数是否都为1，我们可以确定字符串中是否有重复的字符。如果所有的计数都为1，说明字符串中所有字符都是唯一的，函数返回YES；如果有任何字符的计数不为1，函数返回NO。

智谱清言

您可以使用以下Python代码来实现这个算法。这个算法首先将字符串转换为小写，然后使用集合来跟踪出现过的字符。如果集合的大小等于原始字符串的长度，那么所有字符都是唯一的（忽略大小写）。

def check_unique_chars(s):
    # 将字符串转换为小写
    s = s.lower()
    # 创建一个空集合来存储字符
    char_set = set()
    
    # 遍历字符串中的每个字符
    for char in s:
        # 如果字符已经在集合中，则它不是唯一的
        if char in char_set:
            return 'NO'
        # 将字符添加到集合中
        char_set.add(char)
    
    # 如果所有字符都是唯一的，则返回'YES'
    return 'YES'
# 测试函数
print(check_unique_chars("Python"))  # 应输出'NO'，因为'y'和'o'重复了
print(check_unique_chars("Alphabet"))  # 应输出'YES'，因为所有字符都是唯一的

这个算法的时间复杂度是O(n)，其中n是字符串的长度，因为我们只需要遍历字符串一次。空间复杂度也是O(n)，在最坏的情况下（即字符串中的所有字符都不同），我们需要存储所有的字符在集合中。

kimi.ai

当然，下面是一个简单的Python函数，用于检查字符串中的字符是否唯一（忽略大小写）：

def are_characters_unique(s):
    # 将字符串转换为小写，以便忽略大小写
    s = s.lower()
    # 创建一个集合来存储已经遇到的字符
    seen_chars = set()
    # 遍历字符串中的每个字符
    for char in s:
        # 如果字符已经在集合中，说明不是唯一的
        if char in seen_chars:
            return "NO"
        # 将字符添加到集合中
        seen_chars.add(char)
    # 如果遍历完字符串没有发现重复的字符，说明字符是唯一的
    return "YES"

# 示例使用
test_string = "Hello, World!"
result = are_characters_unique(test_string)
print(result)  # 输出结果应该是 "NO"，因为 "l" 出现了两次

这个函数首先将输入的字符串转换为小写，然后创建一个空集合用于存储已经遇到的字符。接着，它遍历字符串中的每个字符，如果字符已经在集合中，说明该字符不是唯一的，函数返回”NO”。如果遍历结束后没有发现重复的字符，函数返回”YES”。

存档地址：https://www.yuque.com/worthstudy/study/ehn26sqg0v8bt652?singleDoc#

文章版权归作者所有，如需转载请联系作者。若文章内容侵犯了您的权益，请通过网站底部联系方式联系我们处理（本站具有最终解释权）。如有不便之处，敬请谅解。

THE END

确定字符串是否包含唯一字符