เขียนโปรแกรมที่เรียงเวกเตอร์ของตัวเลข (หรือองค์ประกอบชนิดใดก็ได้) ที่ดูเหมือนว่ามีข้อบกพร่องอย่างน้อยหนึ่งข้อ แต่จริง ๆ แล้วก็โอเค

• รหัสจะต้องชัดเจน ใครบางคนมองไปที่รหัสจะต้องระบุได้อย่างง่ายดายว่ามันเป็นขั้นตอนวิธีการจัดเรียงและจะต้องสับสนได้อย่างง่ายดายชิ้นส่วนของรหัสที่ถูกต้องกับข้อผิดพลาด
• ข้อผิดพลาด (ชัดเจน) สามารถทำอะไรก็ได้ที่ทำให้รหัส syntactically หรือ semantically ill-formed (เช่นทำให้โปรแกรมไม่คอมไพล์ / รัน, แสดง UB เมื่อ runned), ทำให้โปรแกรมสร้างผลลัพธ์ที่ไม่ถูกต้อง, ไม่ยุติ, หรือไม่เป็นระเบียบ
• รหัสจะต้องมีรูปแบบที่ดีและโปรแกรมจะต้องสร้างผลลัพธ์ที่ถูกต้องในเวลาที่ จำกัด
• อินพุตอาจเป็นรหัสฮาร์ดในโปรแกรมหรือสามารถอ่านได้ (จากผู้ใช้จากไฟล์ ฯลฯ )
• อินพุตถือว่าถูกต้องและไม่จำเป็นต้องใช้โปรแกรมเพื่อตรวจสอบความถูกต้องอินพุต
• อัลกอริทึมการเรียงลำดับใด ๆ ที่เป็นที่ยอมรับ โครงสร้างข้อมูลเพื่อเก็บตัวเลขไม่จำเป็นต้องเป็นเวกเตอร์จริง โปรแกรมสามารถออกแบบให้เรียงลำดับหมายเลขตัวแปรหรือจำนวนคงที่ของตัวเลข (เช่นโปรแกรมเรียงลำดับ 3 หมายเลขก็โอเค ) การเรียงลำดับอาจมีความเสถียรหรือไม่ (หมายเหตุ: โปรแกรมที่ออกแบบมาเพื่อจัดเรียงแบบเสถียรที่มีจุดบกพร่องที่ชัดเจนซึ่งทำให้การเรียงลำดับดูไม่เสถียร แต่ในความเป็นจริงมันไม่ใช่ข้อผิดพลาด: โปรแกรมจริง ๆ เรียงแบบเสถียร - เป็นคำตอบที่ถูกต้อง )
• คุณสามารถเรียกฟังก์ชั่นใด ๆ (รวมทั้งฟังก์ชั่นการจัดเรียง) ยกเว้นเครื่องมือของบุคคลที่ 3 (ยกเว้นกรณีที่พวกเขามีอยู่อย่างแพร่หลายและใช้การแพร่กระจายเช่นboosสำหรับC++, JQueryสำหรับJavascript- ผู้ที่มีตกลงที่จะใช้งาน)
• ระบุภาษา
• แสดงความคิดเห็นในรหัสส่วนที่ดูเหมือนข้อผิดพลาด
• อธิบายว่าข้อผิดพลาดดูเหมือนว่าทำผิด
• อธิบาย (ในกล่องสปอยเลอร์) ว่าทำไมมันถึงไม่ใช่ข้อผิดพลาด

นี่คือการประกวดความนิยม คำตอบที่ได้คะแนนมากที่สุดจะเป็นฝ่ายชนะ

ความท้าทายนี้สิ้นสุดลงแล้ว ผู้ชนะคือ @Clueless /codegolf//a/30190/11400ด้วย 8 คะแนน ขอขอบคุณผู้ส่งทั้งหมด!

หากคุณต้องการเข้าร่วมหลังจากผู้ชนะได้รับรางวัลโปรดเพิ่มคำตอบใหม่ คุณออกจากการแข่งขัน แต่เราทุกคนสนใจที่จะดูคำตอบที่น่าสนใจ

C ++

แรงบันดาลใจจากApple 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ซึ่งเรียงลำดับไว้การรวมส่วนที่จัดเรียงไว้ด้วยการแบ่งส่วนจะไม่ทำงานแม้ว่าจะมีการดำเนินการก็ตาม

ค

การใช้การเรียงลำดับไม่ถูกต้อง - บนระบบ 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) Endian-ness 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มีการกำหนดคอมไพเลอร์จะถือว่าครึ่งแรกของคู่คีย์ - ค่า (เนื่องจากคอมมา) แต่ไม่มีคู่คีย์ - ค่าดังนั้นคอมไพเลอร์ไม่บ่นเมื่อไม่สามารถกำหนดครึ่งหลังได้ ของมันเป็นตัวแปรที่ไม่มีอยู่จริง สิ่งนี้ส่งผลnให้ได้รับค่าคีย์ .. ซึ่งในกรณีนี้คือหมายเลขดัชนี เครื่องหมายคอมม่าที่ไม่อยู่ในตำแหน่งอื่น ๆ ทั้งหมดในบรรทัดสุดท้ายนั้นเป็นส่วนหนึ่งของไวยากรณ์คอบร้ามาตรฐาน

ชวา

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 

ทำงานได้เนื่องจากค่าสุ่มเฉพาะนี้ส่งคืน '1' สำหรับผลลัพธ์ 10 รายการแรก

Perl

ผู้รับเหมาวันนี้! พวกเขาไม่ทราบหรือไม่ว่าตัวดำเนินการ<=>(ยานอวกาศ "aka") ใช้สำหรับการเรียงลำดับตัวเลขเท่านั้น

และทำไมพวกเขาถึงเปรียบเทียบผู้ประกอบการ

รหัสนี้ยังผ่านการทดสอบที่เข้มงวดของเราได้อย่างไร? !! มันใช้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ขึ้นอยู่กับว่าอาร์กิวเมนต์ซ้าย stringwise น้อยกว่าเท่ากับหรือมากกว่าอาร์กิวเมนต์ที่เหมาะสม