标签: lexicographic-ordering

"按字典顺序比较两个字符串"是什么意思？

我有一个列表,其中包含代表动物名称的字符串.我需要对列表进行排序.如果我使用sorted(list),它将首先使用大写字符串给出列表输出,然后是小写.

但我需要以下输出.

输入:

var = ['ant','bat','cat','Bat','Lion','Goat','Cat','Ant']

输出:

['ant', 'Ant', 'bat', 'Bat', 'cat', 'Cat', 'Goat', 'Lion']

面试关于代码战斗的哈希图问题，需要帮助优化我的暴力解决方案。问题是这样的：

给定一个字符串 str 和一对数组（指示字符串中的哪些索引可以交换），返回执行允许的交换后按字典顺序排列的最大字符串。您可以任意多次交换索引。

例子

For str = "abdc" and pairs = [[1, 4], [3, 4]], the output should be
swapLexOrder(str, pairs) = "dbca".

通过交换给定的索引，您将得到字符串：“cbda”、“cbad”、“dbac”、“dbca”。此列表中按字典顺序最大的字符串是“dbca”。

我目前的解决方案

通过不断添加所有可能性，直到没有新的解决方案为止进行暴力破解。这对于 来说太慢了swapLexOrder('dznsxamwoj',[[1,2],[3,4],[6,5],[8,10]])，无法在我的机器上完成。有什么优化提示吗？通过的一个更简单的测试用例是swapLexOrder('abdc,[[1,4],[3,4]])= dbca

def swapLexOrder(str, pairs):
    d = {}
    d[str]=True
    while True:
        oldlen=len(d)
        for x,y in pairs:
            for s in d.keys():
                d[swp(s,x,y)]=True
        if len(d) == oldlen:
            #no more new combinations.
            return sorted(d)[-1]

def swp(str,x,y):
    x=x-1
    y=y-1
    a=str[x]
    b=str[y]
    return str[0:x]+b+str[x+1:y]+a+str[y+1:]

我正在尝试解决 Java 中字符串操作的编码问题。问题是

给定两个由数字和小写字母组成的字符串 S 和 T，您只能从任一字符串中删除一位数字，计算有多少种删除方式可以使 S 按字典顺序小于 T。

我自己想出了这个测试用例。如果 s = '3ab' 且 t = 'cd'，则返回 1。如果 s = '123ab' 且 t = '423cd'，则返回 6。

我的想法是使用 2 个 for 循环并通过检查字符是否为数字来遍历每个字符串，将其删除并与其他字符串进行比较。

private static int numSmaller(String s, String t){
    int ways = 0;

    for(int i = 0; i < s.length(); i++){
        StringBuilder sbs = new StringBuilder(s);
        if(Character.isDigit(s.charAt(i))){
            sbs.deleteCharAt(i);
            String sub = sbs.toString();
            if(sub.compareTo(t) < 0) {
                ways++;
            }
        }
    }

    for(int i = 0; i < t.length(); i++){
        StringBuilder sbt …

我目前正在阅读std::next_permutation函数并遇到术语“词典顺序”。在特定的时间，我对这个术语没有任何经验，所以在谷歌搜索这个词，发现这种类型的订单只有一些神秘的定义，包括维基文章（至少对我来说是这样）。

那么有人可以尝试帮助我理解这一点吗？对您来说，这个术语的“好”定义是什么？

关于维基文章- 他们声称词典顺序也称为字母顺序，但随着我继续阅读，我了解到它们不一样。因此，正在进行的比较让我有点困惑。

有没有办法用Java 8 Comparator实现Ordering.lexicographical()？

Comparator.thenCompare似乎在这方面受到限制

我有一个 Java ArrayList，列表中的每个元素都是一个具有 3 个字段（a、b 和 c）的对象。我应该按升序排列；如果 2 个元素的 a 值相同，则应按 b 降序排列它们；最后，如果 2 个元素即使对于 b 也具有相同的值，则它们应该按 c 升序排列。

我尝试了 stackoverflow 上发布的基于 Comparator 的其他解决方案，但我没有按降序排列。

有人可以帮助我吗？非常感谢！

如果我想按字典顺序比较两个向量，我可以这样做：

int main() {
    std::vector<int> a{0, 7, 8, 9};
    std::vector<int> b{1, 2, 3, 4};

    std::cout << std::boolalpha;
    std::cout << "a < b returns " << (a < b) << '\n';
}

但是以相反的顺序执行相同的操作无法编译：

int main() {
    std::vector<int> a{3, 2, 1};
    std::vector<int> b{9, 8, 7, 6};

    std::cout << std::boolalpha;
    std::cout << "revrese a < reverse b returns " << ((a | std::views::reverse) < (b | std::views::reverse)) << '\n';
}

后一个代码失败并显示：

<source>:23:81: error: no match for 'operator<' (operand types are 'std::ranges::reverse_view<std::ranges::ref_view<std::vector<int> > >' …

我想获取元组列表的最小元素

a = [[(1, 0), (2, 0), (1, 1)], [(2, 0), (1, 1), (1, 0)], [(1, 1), (1, 0), (2, 0)]]

按字典顺序排列，因此[(1,1),(1,0),(2,0)]] < [(1,0),(2,0),(1,1)]，因为元组的第 0 个条目具有更高的优先级，即1,1,2 < 1,2,1，而第 1 个条目的优先级较低。

min(a)

返回[(1, 0), (2, 0), (1, 1)]，这当然是不正确的。

我只需要最小元素的索引，因此错误的版本是

print(min(range(len(a)), key=lambda i: a[i]))

（最小元素和仅索引方法将受到赞赏）。

当然，可以使用 zip 或其他东西编写自定义循环，但我想要一种开销很小的解决方案。

我有一些POD struct foo; 假设是的struct foo { int x; unsigned y; }.我希望能够struct foo使用词典顺序进行比较- 当然是按照他们的字段顺序进行比较.也就是说,我希望所有的运营商<,==>等为工作struct foo的

我可以用一些通用的方式做到这一点,而没有用任何反射巫术装饰我的结构定义- 而且没有拼写出所有那些操作符定义？或者是否有能力做到这一点太依赖"语言反思"的期望？