एक सॉर्टिंग प्रोग्राम लिखें जो गलत लगता है लेकिन यह वास्तव में सही है [बंद]

Question

एक प्रोग्राम लिखें जो संख्याओं (या किसी भी प्रकार के तत्व) के वेक्टर को सॉर्ट करता है जो एक या अधिक बग होने जैसा दिखता है, लेकिन यह वास्तव में ठीक है।

• कोड स्पष्ट होना चाहिए। कोड को देखने वाले किसी व्यक्ति को आसानी से पहचानना चाहिए कि यह एक सॉर्ट एल्गोरिथ्म है और इसे बग के साथ कोड के एक सही टुकड़े को आसानी से भ्रमित करना चाहिए।
• (स्पष्ट) बग कुछ भी कर सकता है जो कोड को वाक्यविन्यास या शब्दार्थ रूप से बीमार बनाता है (जैसे कि प्रोग्राम को संकलन / रन नहीं बनाते हैं, जब चलाए जाते हैं तो यूबी प्रदर्शित करते हैं), प्रोग्राम को गलत परिणाम देते हैं, समाप्त नहीं करते हैं, या शब्दानुवाद नहीं करते हैं।
• कोड वास्तव में अच्छी तरह से गठित होना चाहिए और कार्यक्रम को निश्चित समय में सही आउटपुट का उत्पादन करना चाहिए।
• इनपुट को प्रोग्राम में हार्ड कोडित किया जा सकता है या पढ़ा जा सकता है (उपयोगकर्ता से, फ़ाइल आदि से)।
• इनपुट को वैध माना जाता है और इनपुट शुद्धता को सत्यापित करने के लिए कार्यक्रम की आवश्यकता नहीं होती है।
• किसी भी सॉर्टिंग एल्गोरिथ्म को स्वीकार किया जाता है। संख्याओं को धारण करने के लिए डेटा संरचना को वास्तविक वेक्टर होने की आवश्यकता नहीं है। कार्यक्रम को संख्याओं की एक चर संख्या या निश्चित संख्याओं को क्रमबद्ध करने के लिए डिज़ाइन किया जा सकता है (जैसे 3 संख्याओं को क्रमबद्ध करने के लिए एक कार्यक्रम ठीक है )। सॉर्टिंग स्थिर हो सकती है या नहीं (ध्यान दें: एक स्थिर सॉर्ट करने के लिए डिज़ाइन किया गया प्रोग्राम जिसमें एक स्पष्ट बग है जो सॉर्ट को अस्थिर दिखता है, लेकिन वास्तविकता में यह बग नहीं है: प्रोग्राम वास्तव में एक स्थिर सॉर्ट करता है - एक वैध उत्तर है )।
• आप 3 पार्टी टूल को छोड़कर किसी भी फ़ंक्शन (सॉर्ट फ़ंक्शंस सहित) को कॉल कर सकते हैं (जब तक कि वे व्यापक रूप से फैल न जाएं और उदाहरण के boosलिए उपयोग न हों C++, जैसे JQueryकि Javascript- वे ठीक हैं)
• भाषा निर्दिष्ट करें
• एक बग की तरह दिखने वाले भाग को कमेंट करें।
• समझाइए कि बग गलत करने जैसा क्या लगता है।
• व्याख्या करें (एक बिगाड़ने वाले बॉक्स में) यह वास्तव में बग क्यों नहीं है।

यह एक लोकप्रियता प्रतियोगिता है। अधिकांश मतों के साथ उत्तर जीत जाता है।

---

यह चुनौती अब खत्म हो गई है। विजेता 8 वोटों के साथ @Clueless /codegolf//a/30190/11400 है । सभी प्रस्तुतकर्ताओं को धन्यवाद!

यदि आप विजेता के सम्मानित होने के बाद आना चाहते हैं, तो कृपया एक नया उत्तर जोड़ने के लिए स्वतंत्र महसूस करें। आप दौड़ से बाहर हैं, लेकिन दिलचस्प जवाब देखने के लिए हम सभी इच्छुक हैं।

Comments

क्या मैं संख्या के बजाय नाइलेबल बूलियन का उपयोग कर सकता हूं?

— Οurous

हां, इस प्रश्न को भी संपादित किया: किसी भी तरह के तत्व

— बोल्व

मैं इस प्रश्न को ऑफ़-टॉपिक के रूप में बंद करने के लिए मतदान कर रहा हूँ क्योंकि इस साइट पर अंडरहैंड चुनौतियाँ अब ऑन-टॉपिक नहीं हैं। meta.codegolf.stackexchange.com/a/8326/20469

— बिल्ली

Answer 1

सी ++

Applegoto 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में चाबियाँ द्वारा छांटा गया है। तो हम सिर्फ बाल्टी को उलट रहे हैं, जो हम चाहते हैं।

Comments

आपने उपयोग नहीं किया goto, इसलिए कोई बग नहीं है। (उन सभी लोगों का जिक्र करते हुए, जिन्होंने कहा था कि अगर ऐप्पल ने उपयोग नहीं किया तो बग कभी भी नहीं होगा goto)

— user253751

बधाई, आपने सबसे अधिक वोट (7 दिन बाद 8 वोट) पाकर इस चुनौती को जीत लिया है। इसके अलावा, मैं वास्तव में आपके उत्तर को पसंद करता हूं क्योंकि आपने वास्तविक जीवन बग का उपयोग किया था।

— बोलोव

Answer 2

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किया जाता है जो कि जगह में हल किया गया है जो कि कैटेनेशन द्वारा हल किए गए हिस्सों को मर्ज कर रहा है, भले ही निष्पादन वहां नहीं हुआ हो।

Comments

बधाई, आपने 7 दिनों के बाद 6 वोटों के साथ दूसरा स्थान पाया है। आपके निवेदन के लिए धन्यवाद।

— बोलोव

Answer 3

सी

सॉर्ट का गलत तरीके से उपयोग करना - 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 

Daud:

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

हाँ, ठीक है!

पांच चीजें चल रही हैं: 1) qsortपूर्णांक के लिए पॉइंटर्स पास करता है, जो कि अक्षरों के पॉइंटर्स के समान आकार हैं। 2) तार लंबाई में चार बाइट्स (तीन + एक टर्मिनेटर) = एक पूर्णांक के आकार के नहीं होते हैं, जो क्रमबद्ध रूप से खुशी के साथ पूर्णांक के रूप में व्यवहार करता है। 3) अधिकांश संकलक डेटा संरचनाओं के संरेखण को बाध्य करते हैं, इसलिए छोटे तार एक ही स्थान को लेते हैं। हालांकि कोई भी बड़ा और विफलताओं के लिए तैयार रहना चाहिए। 4) एंडियन-नेस। 5) आंतरिक बाइट्स का शून्य आरंभीकरण।

Comments

आपके निवेदन के लिए धन्यवाद। आपने 3 को रखा है। बधाई हो!

— बोलोव

Answer 4

कोबरा

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केवल मुख्य मूल्य दिया जा रहा है .. जो इस मामले में एक सूचकांक संख्या है। अंतिम पंक्ति में अन्य सभी दिखने वाले अल्पविराम वास्तव में मानक कोबरा सिंटैक्स का हिस्सा हैं।

Comments

आपके निवेदन के लिए धन्यवाद। आपने 3 को रखा है। बधाई हो!

— बोलोव

Answer 5

जावा

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' देता है

Comments

आप किस भाषा का उपयोग करते हैं?

— कर्नड

जावा, खेद है कि (संपादित) का उल्लेख करना भूल गया।

— रॉय वैन रिजन

Answer 6

पर्ल

इन दिनों ठेकेदार! क्या वे नहीं जानते कि <=>(उर्फ "स्पेसशिप") ऑपरेटर केवल संख्यात्मक छँटाई के लिए उपयोग किया जाता है?

और वे ऑपरेटरों की तुलना क्यों कर रहे हैं?

यह कोड हमारे कड़े परीक्षणों को भी कैसे पारित करता है ?? !! यह भी उपयोग करता है 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??!!

---

पर्ल क्यों संकलन करता है

एकमात्र वास्तविक <=>ऑपरेटर बीच में एक है। अन्य दो लेखन का एक और तरीका है glob("=")। इसका मतलब यह है कि <=><=><=>(उपनाम "अंतरिक्ष बेड़े") का मूल्यांकन करता है 0।

---

यह काम क्यों करता है

asciibeticallyसबरूटीन स्ट्रिंग-की तुलना के एक कार्यान्वयन है cmpऑपरेटर: बाइनरी " cmp" रिटर्न -1, 0या 1जो इस पर निर्भर बाईं तर्क stringwise कम, की तुलना में करने के लिए, या सही तर्क से अधिक के बराबर है।

Comments

वैसे पर्ल मेरे लिए वैसे भी एक बग की तरह दिखता है ...

— chill0r