编写一个程序，对看起来像有一个或多个错误的数字（或任何类型的元素）向量进行排序，但实际上可以。

• 代码必须清楚。查看代码的人必须轻松地识别出它是一种排序算法，并且必须轻松地将正确的代码与错误混淆。
• （明显的）错误可能导致使代码在语法上或语义上不正确（例如，使程序无法编译/运行，在运行时显示UB），使程序产生不正确的结果，无法终止或不确定。
• 该代码实际上必须格式正确，并且程序必须在有限的时间内确定性地产生正确的输出。
• 输入可以在程序中进行硬编码，也可以读取（从用户，文件等）。
• 输入被认为是有效的，不需要程序来验证输入的正确性。
• 接受任何排序算法。保持数字的数据结构不必是实际的向量。可以将程序设计为对可变数目的数字或固定数目的数字进行排序（例如，对3个数字进行排序的程序是可以的）。排序是否稳定（请注意：设计为执行稳定排序的程序具有明显的错误，该错误使排序看起来不稳定，但实际上并非错误：该程序实际上进行了稳定排序-是有效的答案）。
• 您可以调用除第三方工具以外的任何函数（包括排序函数）（除非它们广泛使用，例如boos用于C++，JQuery因为Javascript–可以使用）
• 指定语言
• 在代码中注释看起来像错误的部分。
• 解释该错误看起来像做错了什么。
• 在扰流盒中解释为什么它实际上不是错误。

这是一次人气竞赛。票数最多的答案胜出。

挑战已经结束。获胜者是@Clueless /codegolf//a/30190/11400，票数为8。感谢所有提交者！

如果您想在获奖者获奖后加入，请随时添加新答案。你们不参加比赛，但我们都希望看到有趣的答案。

C ++

受苹果公司的goto fail启发；虫子。

#include <vector>
#include <map>
#include <iostream>

/**
 * Sorts a vector of doubles in reverse order using the bucket sort algorithm.
 */
std::vector<double> reverse_bucket_sort(const std::vector<double>& input) {
    // put each element into a bucket as many times as it appears
    std::map<double, int> bucket_counts;
    for (auto it : input)
        ++bucket_counts[it];

    std::vector<double> sorted_elements; // the return value

    // loop until we are done
    while (bucket_counts.size() > 0) {
        // find the largest element
        double maximum = std::numeric_limits<double>::lowest();
        for (auto it : bucket_counts) {
            if (it.first > maximum)
                maximum = it.first;
                maximum = it.first;
        }

        // add the largest element N times to our sorted vector
        for (int i = 0; i < bucket_counts[maximum]; ++i)
            sorted_elements.push_back(maximum);

        // and now erase the bucket
        bucket_counts.erase(maximum);
    }

    return sorted_elements;
}

int main(int argc, const char * argv[]) {
    std::vector<double> test_case = { 0, 1, 2.5, 10, 2.5, 2 };

    std::cout << "unsorted:";
    for (auto it : test_case) std::cout << " " << it;
    std::cout << std::endl;

    std::cout << "sorted:";
    for (auto it : reverse_bucket_sort(test_case)) std::cout << " " << it;
    std::cout << std::endl;

    return 0;
}

在页面的大约一半处，有一个错误：if检查后我们有重复的一行！我们将始终使用中的最后一个值来更新最大值bucket_count。值得庆幸的是，我们还可以。在C ++ std::map中，按键排序。因此，我们只是想倒车，这就是我们想要的。

Python2.x

import random
L = [random.randrange(20) for x in range(20)]
print "Unsorted:", L

def sort(L):
    # terminal case first. Otherwise sort each half recursively and combine
    return L.sort() if L > 1 else sort(L[:len(L)//2]) + sort(L[len(L)//2:])

sort(L)
print "Sorted:", L

测试运行

list.sort返回None，因此后面的部分else是None + None。幸运的是，这不会造成问题，因为列表和int的(L > 1)比较总是如此True。该函数总是返回，None因此我们忽略了返回值，并且L即使已经执行了归类操作，按排序合并归类后的两半也不起作用。

C

错误使用排序-在64位系统上int为4字节，char *为8字节，因此不起作用。

码：

#include <stdlib.h>
#include <stdio.h>

/* Compare integers to sort in reverse order */
int compare(const void *p, const void *q)
{
    const int *a = p;
    const int *b = q;

    return *b - *a;
}

int main()
{
    char *strings[] = {"B", "Que", "Ro", "Sum", "T"};
    int i;

    /* Let's use the integer compare to sort strings */
    qsort(&strings, sizeof(strings) / sizeof(char *), sizeof(char *), compare);

    /* Output the sorted results */
    for (i = 0; i < sizeof(strings) / sizeof(char *); i++)
        printf("%s\n", strings[i]);

    return 0;
}

建立：

$ gcc -o sort-no-sort sort-no-sort.c 

跑：

$ ./sort-no-sort 
T
Sum
Ro
Que
B

是的，还可以！

正在进行的五件事：1）qsort将指针传递给整数，该整数的大小与指向字符的指针相同。2）字符串的长度不超过四个字节（三个+一个终止符）=整数的大小，排序例程将其愉快地视为一个整数。3）大多数编译器强制对齐数据结构，因此较短的字符串占用相同的空间。任何更大的东西，并为失败做好准备。4）字节序。5）内部字节的零初始化。

眼镜蛇

class Program
    var _target as List<of bool?> = [true, true, false, true, true, nil, nil, false, true, nil, true]
    def main
        .sort(_target)
        print _target
    def sort(target as List<of bool?>)
        for i in target.count, for n, in target.count -1, if target[n] <> target[n + 1] and (target[n] or target[n + 1] == nil), target[n], target[n + 1] = target[n + 1], target[n]
            #should return sorted as [nil][false][true]

哦，亲爱的，我似乎分配错了n……所有这些逗号是怎么到达那里的？！

n分配了when时，编译器假定它正在提供键值对的前一半（由于逗号），但是没有键值对，因此编译器在无法分配后一半时不会抱怨将其设置为不存在的变量。这样n就简单地得到了键值。在这种情况下，键值是索引号。最后一行中的所有其他错位逗号实际上都是标准Cobra语法的一部分。

爪哇

public final class WeirdSort {
    public static void main(final String[] args) {

        //Random
        final Random random = new Random(441287210);

        //Some numbers:
        final List<Integer> list = new ArrayList<Integer>();
        list.add(9);
        list.add(11);
        list.add(3);
        list.add(5);
        list.add(7);

        //Sort randomly:
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(final Integer o1, final Integer o2) {
                return (o1 - o2) + random.nextInt(10);
            }
        });

        //Print
        for(final Integer i:list) {
            System.out.print(i + " ");
        }
    }
}

Prints: 3 5 7 9 11 

之所以有效，是因为该特定随机值的前10个结果返回“ 1”

佩尔

这些天承包商！他们是否不知道<=>（aka“ spaceship”）运算符仅用于数字排序？

他们为什么要比较运算符？

这段代码如何通过我们的严格测试？它甚至使用strict和warnings！

use strict;
use warnings;

sub asciibetically { 0-($a lt $b) || 0+($a gt $b) || <=><=><=> }
                                                   #  ^  ^  ^
                                                   # What?? How did Perl even compile??!!

my @sorted = sort asciibetically qw( bravo charlie alpha );

print "@sorted";   # "alpha bravo charlie"
                   # And how come it works??!!

为什么Perl编译

唯一的实际<=>运算符是中间的运算符。另外两个只是另一种写作方式glob("=")。这意味着<=><=><=>（昵称“太空船队”）的计算结果为0。

为什么有效

该asciibetically子例程是字符串cmp比较运算符的实现：Binary“ cmp”返回-1，0或1取决于left参数在字符串上是否小于，等于或大于right参数。