按字符频率对字符串排序，按字母顺序断开关系

Question

我想解决这个问题：

给出一个输入字符串，以频率降序对字符进行排序。如果多个字符具有相同的频率计数，请按字典顺序升序对其进行排序。示例：

bdca --> abcd,
bdcda -> ddabc,
abba -> aabb,
bacbdc -> bbccad,

我的解决方案包括在哈希图中创建频率，使用sorted（）和lambda函数按频率对哈希图字典项进行排序。然后，对于具有相同频率的项目（为此我需要编写一个子例程），我还要执行另一个使用lambda函数排序的项目。

def string_sort(s):
    hmap = {}
    for char in s:
        if char not in hmap:
            hmap[char] = 1
        else:
            hmap[char] += 1
    freqs = sorted(hmap.items(), key=lambda x: x[1], reverse=True)
    num_occur: list = find_num_occur(freqs)
    sorted_freqs = []
    start_ind = 0
    for f in num_occur:
        tmp_freqs = sorted(freqs[start_ind : start_ind + f], key=lambda x: x[0])
        sorted_freqs.extend(tmp_freqs)
        start_ind = len(sorted_freqs)
    out = []
    for item in sorted_freqs:
        out.extend([item[0]] * item[1])
    return "".join(out)


def find_num_occur(freqs):
    count = 1
    out = []
    for i in range(len(freqs) - 1):
        if freqs[i][1] == freqs[i + 1][1]:
            count += 1
        else:
            out.append(count)
            count = 1
    out.append(count)
    return out

解决方案并不完美。有人告诉我，使用比较器可以更轻松地解决它，但是我不知道如何在python中使用比较器。有什么建议？还是其他更优雅的解决方案？

谢谢。

Answer 1

您不需要使用比较器，可以使用键功能。您的解决方案中有很多不必要的复杂性，您所需要做的只是达到以下效果：

>>> from collections import Counter
>>> def transmogrify(s):
...     counts = Counter(s)
...     return ''.join(sorted(s, key=lambda c: (-counts[c], c)))
...
>>> transmogrify('bdca')
'abcd'
>>> transmogrify('bdcda')
'ddabc'
>>> transmogrify('abba')
'aabb'
>>> transmogrify('bacbdc')
'bbccad'

请注意，collections.Counter只是专门用于计数的dict，因为它已经足够普遍了。

>>> Counter('bacbdc')
Counter({'b': 2, 'c': 2, 'a': 1, 'd': 1})

Answer 2

计数器和__lt__方法

我认为您的任务可以分为2个任务：

1. 计数任务，可以通过Counter类轻松实现，但是Counter无法保证其键的顺序，因此您需要任务2
2. 排序任务（如CPP之类的比较器），您需要一个自定义排序函数，因此您可以创建一个新类并实现__lt__方法doc

from collections import Counter

class Item:
    def __init__(self, ch, times):
        self.ch = ch
        self.times = times
    def __lt__(self, other):
        if self.times > other.times:
            return True
        if self.times == other.times:
            return self.ch < other.ch
        return False
# my restruct 
def restruct(inp):
    c = Counter(inp)
    data = sorted([Item(ch, times) for ch, times in c.items()])
    return ''.join([item.ch*item.times for item in data])

在@juanpa.arrivillaga之后restruct做一个非常优雅的工具（具有相同的功能），谢谢他。

def restruct(inp):
    c = Counter(inp)
    return ''.join(sorted(inp, key=lambda ch: Item(ch, c[ch])))

然后尝试restruct('bacbdc')得到bbccad，宾果游戏！