首页 > 试题广场 >

查找兄弟单词

[编程题]查找兄弟单词
  • 热度指数：445486 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M
  • 算法知识视频讲解
\hspace{15pt}定义一个字符串 s 的“兄弟单词”为：将 s 重新排序后得到的与原字符串不同的新字符串。
\hspace{15pt}现在，对于给定的 n 个字符串 s_1, s_2, \dots, s_n 和另一个单独的字符串 x，你需要解决两个问题：
\hspace{23pt}\bullet\,统计这 n 个字符串中，有多少个是 x 的“兄弟单词”（注意，这 n 个字符串可能有重复，重复字符串分别计数）；
\hspace{23pt}\bullet\,将这 n 个字符串中 x 的“兄弟单词”按字典序从小到大排序，输出排序后的第 k 个兄弟单词（从 1 开始计数）。特别地，如果不存在，则不输出任何内容。

【名词解释】
\hspace{15pt}从字符串的第一个字符开始逐个比较，直至发现第一个不同的位置，比较这个位置字符的字母表顺序，字母序较小的字符串字典序也较小；如果比较到其中一个字符串的结尾时依旧全部相同，则较短的字符串字典序更小。

输入描述:
\hspace{15pt}在一行上依次输入：
\hspace{23pt}\bullet\,一个整数 n \left(1 \leqq n \leqq 10^3\right) 代表字符串的个数；
\hspace{23pt}\bullet\,n 个长度为 1 \leqq {\rm length}(s_i) \leqq 10，仅由小写字母构成的字符串 s_1, s_2, \dots, s_n ；
\hspace{23pt}\bullet\,一个长度为 1 \leqq {\rm length}(x) \leqq 10，仅由小写字母构成的字符串 x ；
\hspace{23pt}\bullet\,一个整数 k \left(1 \leqq k \leqq n\right) 代表要查找的第 k 小的兄弟单词的序号。


输出描述:
\hspace{15pt}第一行输出一个整数，代表给定的 n 个字符串中，x 的“兄弟单词”的数量；
\hspace{15pt}第二行输出一个字符串，代表将给定的 n 个字符串中 x 的“兄弟单词”按字典序排序后的第 k 小兄弟单词。特别地，如果不存在，则不输出任何内容（完全省略第二行）。
示例1

输入

3 abc bca cab abc 1

输出

2
bca

说明

\hspace{15pt}在这个样例中，x 的兄弟单词为 \texttt{ 、\texttt{ 、\texttt{ 、\texttt{ 、\texttt{ 。其中，标橙色的两个字符串存在于所给定的 n 个字符串中。第 1 小的兄弟单词为 \texttt{。
示例2

输入

3 a aa aaa a 1

输出

0

说明

\hspace{15pt}在这个样例中，按照定义，字符串 \texttt{ 没有兄弟单词。

备注:
本题已于下方时间节点更新，请注意题解时效性：
1. 2025-05-30 更新题面。
2. 2024-12-29 更新题面。
算法知识视频讲解
添加回答
Python3
heiqizero头像 heiqizero 
words = input().split(" ")
n = int(words[0])
words_list = words[1:n+1]
x = words[-2]
k = int(words[-1])

result = []
for word in words_list:
    if len(word) != len(x)&nbs***bsp;word == x:
        pass 
    else:
        for s in x:
            if x.count(s)!=word.count(s):
                break   
        else:
            result.append(word)
print(len(result))
if len(result) >= k:
    print(sorted(result)[k-1])

发表于 2025-11-29 00:53:22 回复(0)
Python3
愉快的大熊猫才华横溢头像 愉快的大熊猫才华横溢 
input_ = input().split()
n = int(input_[0])
data = input_[1:n+1]
x = input_[-2]
k = int(input_[-1])

brothers = []
for each in data:
    if each != x and sorted(list(each)) == sorted(list(x)):
        brothers.append(each)

print(len(brothers))

if k <= len(brothers):
    print(sorted(list(brothers))[k-1])

发表于 2025-10-22 14:00:25 回复(0)
Python3
牛客183489514号头像 牛客183489514号 
s = input().split()
num = int(s[0])


def IsBro(s1, s2):
    if s1 != s2 and sorted(s1) == sorted(s2):
        return True
    else:
        return False


numbro = 0
bro = []

for i in range(1, num + 1):
    if IsBro(s[i], s[num + 1]):
        numbro += 1
        bro.append(s[i])
print(numbro)

bro_sorted = sorted(bro)

index = int(s[-1]) - 1
if index < len(bro_sorted):
    print(bro_sorted[index])

发表于 2025-09-11 11:15:23 回复(0)
Python3
DDRicardo头像 DDRicardo
bro=[]
s = input().split()
num = int(s[0])
k = int(s[-1])
x = s[-2]
for i in range(1,len(s)-2):
    if s[i]!=x:
        if sorted(s[i])== sorted(x):
            bro.append(s[i])
out = sorted(bro)
print(len(out))
if len(out)>=k:
    print(out[k-1])
发表于 2025-09-01 20:53:02 回复(0)
Python3
喜欢吃火锅的艾伦只想搞钱头像 喜欢吃火锅的艾伦只想搞钱
#抄了一下怎么判断兄弟单词
li = list(input().split(" ")[1:])
s = li[-2]
n = int(li[-1])
li = li[:-2]
li1 = []
for i in range(len(li)):
    if len(li[i]) == len(s) and s != li[i] and sorted(s) == sorted(li[i]):        
            li1.append(li[i])
for i in range(len(li1) - 1):
    for j in range(len(li1) - i - 1):
        for k in range(len(s)):
            if li1[j][k] == li1[j + 1][k]:
                continue
            elif li1[j][k] > li1[j + 1][k]:
                li1[j], li1[j + 1] = li1[j + 1], li1[j]
                break
            break
print(len(li1))
if n <= len(li1):
    print(li1[n - 1])
发表于 2025-09-01 12:27:21 回复(0)
Python3
不会哈气学哈气头像 不会哈气学哈气
#输入处理
ls = input().split()
n = int(ls[0])
group = ls[1:-2]
x = ls[-2]
k = int(ls[-1])

import itertools

bro = []
for i in range(n):
    if group[i] != x and group[i] in set([''.join(p) for p in itertools.permutations(x, len(x))]):
        bro.append(group[i])

bro.sort()

print(len(bro))
try:
    print(bro[k-1])
except:
    pass

#偷懒用库写了兄弟们，虽然占了点内存但是无所谓啦，不超时就行
发表于 2025-05-17 16:53:01 回复(0)
Python3
卖萌的小章鱼在许愿头像 卖萌的小章鱼在许愿
以为只能交换一次两个字母，做了一晚上怎么调都通过不了，遇到好几道题目描述有问题的浪费时间了。。。。。。
发表于 2025-03-08 00:20:20 回复(0)
Python3
小琴傷头像 小琴傷
任意交换 s 中两个字母的位置
不等于
任意交换 s 中字母的位置
你告诉我abc怎么通过一次“任意交换 s 中两个字母的位置”变换成bca？
出题至少要学好语文吧？
发表于 2025-01-17 00:22:04 回复(5)
Python3
牛客723671816号头像 牛客723671816号
这道题关于兄弟单词的定义描述有严重的本质问题，根据定义，s的“兄弟单词”为：任意交换 s 中两个字母的位置，得到的新字符串，且其与 s 不同。那么对于示例中的字符串 abc，橙色的bca 和cab均不是其兄弟单词。abc的兄弟单词通过交换字母顺序，可以发现只有交换ac，交换bc，交换ab三种情况依次得到的：cba，acb和bac三种，并没有bca和cab。所以本题目为错题
发表于 2025-01-06 13:37:24 回复(1)
Python3
牛客419894724号头像 牛客419894724号
source=input().split(' ')
count=0
res=[]
for i in range(1,len(source)-2):
    if source[i]!=source[-2] and sorted((source[i]))==sorted(source[-2]):
        count+=1
        res.append(source[i])
print(count)
if len(res)>int(source[-1]):
    print(sorted(res)[int(source[-1])-1])

发表于 2024-11-25 18:06:08 回复(0)
Python3
想和你写一辈子的bug头像 想和你写一辈子的bug
# 读取单行输入并且split成单个word
words = input().split()

# 提取total(单词总数x); x(目标单词x); k(字典排序后k个单词)
total = int(words[0])
x = words[-2]
k = int(words[-1])

# list需要查找的全部单词(第二个单词至倒数第二个单词)
words_list = words[1:-2]

# initialize一个list储存查找出来的兄弟单词
output_list = []

# 分别兄弟单词
for word in words_list:
    # 兄弟单词和x不应该完全一样，但是顺序要发生变化
    if (word != x) and (sorted(word) == sorted(x)):
        output_list.append(word)

# 重新sort兄弟单词list
output_list.sort()

# 输出兄弟单词list count
print(len(output_list))

# 打印第k个单词（如果存在的话）
if k <= len(output_list):
    print(output_list[k - 1])

发表于 2024-11-07 12:13:02 回复(0)
Python3
顶呱呱的回宇同桌很想润头像 顶呱呱的回宇同桌很想润 
import sys

s = input().split()
n=int(s[0])
k=int(s[-1])
target = s[-2]
lst =s[1:-2]
lst1=[]
num =0
for i in lst:
    if len(i) == len(target):
        if (sorted(list(target))==sorted(list(i))) and (i!=target):
            lst1.append(i)
            num+=1
print(num)
lst = sorted(lst1)
if k<=len(lst):
    print(lst[k-1])

发表于 2024-07-12 14:14:04 回复(0)
Python3
J丶x头像 J丶x 
def is_bro(word1, word2):
    if word1 == word2:
        return False
    j = False
    w_l1 = []
    w_l2 = []
    for i in word1:
        w_l1.append(i)
    for i in word2:
        w_l2.append(i)
    w_l1 = sorted(w_l1)
    w_l2 = sorted(w_l2)
    if w_l1 == w_l2:
        j = True
    return j


shu_ru = input().split()
m = int(shu_ru[0])  #
d = shu_ru[1 : m + 1]  # 单词待查找列表
x = shu_ru[m + 1]  # 单词本身
k = int(shu_ru[m + 2])  # 找第k个字典序排序后的兄弟单词

bro = []
for word in d:
    if is_bro(x, word):
        bro.append(word)

print(len(bro))

bro = sorted(bro)
if k <= len(bro):
    print(bro[k - 1])

发表于 2024-06-19 00:16:03 回复(0)
Python3
谓风yousa头像 谓风yousa 
list_input = input().split()

n = int(list_input[0])
x = list_input[-2]
k = int(list_input[-1])
list_dict_in = list_input[1: -2]

list_brother = []

for word in list_dict_in:
    if (word != x) and (sorted(word) == sorted(x)):
        list_brother.append(word)

print(len(list_brother))
if k <= len(list_brother):
    list_brother.sort()
    print(list_brother[k-1])

编辑于 2024-04-24 13:33:44 回复(0)
Python3
虾仁炖蛋666头像 虾仁炖蛋666 
a = list(input().split(' '))

n = int(a[0])
k = int(a[-1])
mode = a[-2]

a1 = a[1:-2]

n_b = 0

b = []

for i in a1:
    if len(i) == len(mode) and i != mode:
        if sorted(i) == sorted(mode):
            n_b += 1
            b.append(i)

print(n_b)

if k <= len(b):
    print(sorted(b)[k-1])

编辑于 2024-03-26 18:45:17 回复(0)
Python3
RionaZhang头像 RionaZhang 
inp = list(map(str, input().split()))

n = int(inp[0])
k = int(inp[-1])

target_word = inp[-2]
dic = inp[1:-2]


def is_brother(word1, word2):
    return sorted(word1) == sorted(word2) and word1 != word2


def find_brother_words(word_list, target_word, k):
    brother_words = [word for word in word_list if is_brother(target_word, word)]
    brother_words.sort()

    if k <= len(brother_words):
        return len(brother_words), brother_words[k - 1]
    else:
        return len(brother_words), None


count, result_word = find_brother_words(dic, target_word, k)

print(count)
if result_word != None:
    print(result_word)

发表于 2023-11-27 22:20:31 回复(0)
Python3
mhec头像 mhec 
s = input().split(" ")
rnk = []
for value in s[1:-2]:
    if value != s[-2] and sorted(value) == sorted(s[-2]):
        rnk.append(value)
print(len(rnk))
if len(rnk) > int(s[-1]):
    print(sorted(rnk)[int(s[-1]) - 1])


发表于 2023-11-23 18:00:41 回复(1)
提交观点

问题信息

字符串 排序
来自：华为机试编程模拟题2
难度：
66条回答 65000浏览

热门推荐

通过挑战的用户

查看代码

相关试题

查找兄弟单词

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号