मूल प्रकार, कष्टप्रद बग के साथ

28

आपका इनपुट 5-255 पॉजिटिव पूर्णांक की एक सूची / अनुक्रम / वेक्टर / सरणी है, जरूरी नहीं कि अद्वितीय हो। आप मान सकते हैं कि जो भी इनपुट प्रारूप सबसे उपयुक्त है, और यह कि प्रत्येक पूर्णांक (साथ ही पूर्णांकों की मात्रा) को 5-255 की सीमा से समान रूप से यादृच्छिक पर चुना जाता है।

लक्ष्य समान सूची (समान (या समतुल्य) प्रारूप में आउटपुट करना है, लेकिन क्रम में वृद्धि करना (क्रमबद्ध करना) है। भाषा सीखने का एक सामान्य प्रारंभिक अभ्यास। शामिल करने के लिए प्रस्तुतियाँ:

  1. एक उत्तर जो सही ढंग से काम करता है और लक्ष्य को प्राप्त करता है; तथा

  2. एक दूसरा उत्तर जिसमें एक कष्टप्रद बग होता है। 1% से 10% समय के बीच, आउटपुट को सही प्रारूप में और सही तत्वों से युक्त होने की सूची होनी चाहिए, लेकिन गलत क्रम में (किसी भी क्रम को छोड़कर सही क्रमबद्ध)। बाकी समय, कार्यक्रम को सही ढंग से काम करना चाहिए और लक्ष्य को प्राप्त करना चाहिए।

दो जवाबों में लेवेंसहाइट दूरी एक होनी चाहिए ; अर्थात्, हम एक बाइट हटाकर, या एक बाइट जोड़कर, या एक बाइट बदलकर एक से दूसरे को प्राप्त कर सकते हैं।

कोड-गोल्फ में सामान्य रूप से स्कोरिंग करना (आपके दो उत्तरों में से कम पर आधारित), सामान्य कमियां के साथ निषिद्ध।

10% बोनस (स्कोर में कमी) यदि कष्टप्रद बग इनपुट-स्वतंत्र है, तो उसी इनपुट का उपयोग करके फिर से बग को पुन: उत्पन्न नहीं किया जाता है (केवल 1% और 10% के बीच)।

code-golf  array-manipulation  random  integer 
— वादिम पोनोमारेंको
स्रोत
9
PPCG में आपका स्वागत है! मेरा सुझाव है कि बोनस निकालना, यह वास्तव में अच्छा अभ्यास नहीं है।
— श्री एक्सकोडर
2
यह स्पष्ट नहीं है कि प्रत्येक संभावित इनपुट लंबाई की संभावना क्या है।
— user202729
12
क्या प्रत्येक इनपुट के लिए 1% से 10% के बीच की कल्पना को पूरा किया जाना चाहिए या संभव इनपुट के सेट के लिए कुल मिलाकर ? कुछ इनपुटों के लिए जैसे कि गलत क्रम का उत्पादन असंभव है[5,5,5]
— लुइस मेंडू
4
हमारे डिफ़ॉल्ट IO स्वरूपों के बारे में एक सूक्ष्मता है । यदि हमारा कोड किसी फ़ंक्शन को परिभाषित करता है, तो क्या यह ठीक है अगर इसमें फ़ंक्शन को लगातार छोटी गाड़ी को परिभाषित करने का मौका है, जैसा कि एक फ़ंक्शन को परिभाषित करने का विरोध करता है जिसमें छोटी गाड़ी होने की संभावना है?
— Xnor
1
@VadimPonomarenko इस साइट पर लोगों को फ़ंक्शंस के साथ-साथ पूर्ण कार्यक्रम प्रदान करने की अनुमति है। xnor पूछ रहा है कि क्या इसे एक फ़ंक्शन की अनुमति है जो, निर्मित होने पर 1% से 10% समय है, एक छोटी गाड़ी फ़ंक्शन है जिसमें हमेशा एक बग होगा। अपने प्रश्न के पत्र को उत्तर के उत्तर में रखना शायद नहीं , लेकिन यदि यह हाँ था तो अधिक मजेदार होगा ।
— 15 अक्टूबर को wizzwizz4

जवाबों:

9

पायथन 3 , 36 बाइट्स

बग-मुक्त संस्करण, 37 बाइट्स

lambda l:sorted(l,reverse=l[-9:]==[])

इसे ऑनलाइन आज़माएं!

कष्टप्रद संस्करण, 36 बाइट्स

lambda l:sorted(l,reverse=l[9:]==[])

इसे ऑनलाइन आज़माएं!

यह इनपुट पर निर्भर करता है और इसलिए बोनस के लिए योग्य नहीं है।
इसके विफल होने की संभावना लगभग 2% है। यह विफल रहता है जब इनपुट लंबाई कम होती है तो 10।

LyricLy के जवाब के साथ संयुक्त इस 34 बाइट्स हो जाता है:

lambda l:sorted(l)[::l[9:]>[]or 1]
lambda l:sorted(l)[::l[9:]>[]or-1]
— OVS
स्रोत
मुझे नहीं लगता कि आपको बग-मुक्त संस्करण में स्थान की आवश्यकता है।
— 15 अक्टूबर को wizzwizz4
@ wizzwizz4 अंतरिक्ष के बिना or1एक चर नाम के रूप में व्याख्या की जाएगी और एक वाक्यविन्यास त्रुटि उठाएगा ।
— अंडा
9

05AB1E , 5 * 0.9 = 4.5 बाइट्स

काम करने का उपाय

{TLΩi

इसे ऑनलाइन आज़माएं!

व्याख्या

{      # sort input
 TL    # push the range [1 ... 10]
   Ω   # pick a random number in the range
    i  # if true (equal to 1), do nothing

बग युक्त समाधान

10% समय का गलत समाधान देता है (इनपुट पर स्वतंत्र)।

{TLΩiR

इसे ऑनलाइन आज़माएं!

व्याख्या

काम कर रहे समाधान के रूप में भी, यह सूची को उलट देता है यदि चुना गया नंबर सही है।

— Emigna
स्रोत
गंभीरता से क्या हे। आउटपुट सही कार्डिनैलिटी का भी नहीं है।
— जोशुआ
@ जोशुआ आपका क्या मतलब है?
— आउटगोल्फर
इसे आज़माएं ऑनलाइन यह सूचियों की सूची का आउटपुट देता है।
— जोशुआ
4
@ जोशुआ टीआईओ लिंक में एक हेडर 100Fऔर एक पाद शामिल होता है },जो कई बार इनपुट पर कहे गए फंक्शन के परिणाम की कल्पना करने में हमारी मदद करता है। इससे हमें पता चलता है कि काम करने वाला समाधान हमेशा सही परिणाम देता है, जबकि बगेड में त्रुटिपूर्ण आउटपुट होता है।
— श्री Xcoder
कृपया, किसी को, एल्गोरिथ्म की व्याख्या करें। जल्द ही मैं शीर्ष रैंक वाले सबमिशन (या शीर्ष रैंक वाले सबमिशन में से एक) को स्वीकार करूंगा। मैं किसी भी समाधान को स्वीकार नहीं कर सकता, जिसे मैं नहीं समझ सकता।
— वादिम पानोनारेंको
7

जेली , 7 * (100% - 10%) = 6.3 बाइट्स

Ṣ¹⁵X:¤¡

इसे ऑनलाइन आज़माएं!

छोटी गाड़ी संस्करण:

ṢẊ⁵X:¤¡

इसे ऑनलाइन आज़माएं!

दोनों लिंक में, एक टेस्ट हार्नेस है जो कोड को 100 बार चलाएगा, हर बार उस सूची के साथ जिसे आप तर्क के रूप में देते हैं, और फिर परिणाम लौटाते हैं।

प्रत्येक इनपुट लंबाई की संभावना है:

0.1 - 0.1/(length!)

इसलिए लंबाई 1 के लिए 0% संभावना है, लंबाई 2 5% के लिए, लंबाई 3 8.83 1%, लंबाई 4 9.583 length% आदि के लिए, लंबाई तक ∞ जिसमें 10% संभावना है।

— आउटग्रॉफर को एरिक करें
स्रोत
होना चाहिए 0.1 - 0.1/(length!)।
— user202729
@ user202729 सुनिश्चित
— एरिक आउटगोल्फ
Ṣ⁵X’¤¡और Ṣ⁵X¤¡यह भी काम करना चाहिए: छोटी गाड़ी संस्करण सूची को अनसर्टेड <10% समय पर लौटाता है, और यह देखते हुए कि इनपुट समान रूप से यादृच्छिक चुना जाता है, इसे काम करना चाहिए, 2 बाइट्स बचाएं।
— user202729
यदि आप उस समाधान को पसंद नहीं करते हैं, तो आप स्पष्ट रूप से केवल ¹1 बाइट (बाइट की नियम संख्या = छोटी संख्या) को बचाने के लिए हटा सकते हैं ; वहाँ भी दूसरी के बाद एक व्यापक संयोजन ओवरलाइन 6है 6.6̅%।
— user202729
@ user202729 दुर्भाग्य से यह अब इनपुट-स्वतंत्र नहीं होगा, और नहीं, मैं इसे सिर्फ "हटा नहीं सकता ¹" क्योंकि तब यह सभी 10% समय पर नहीं होता।
— एर्ग आउटफोलर
6

पायथन 3, स्कोर 58 57 - 10% = 51.3

ओट्स के लिए एक बाइट धन्यवाद सहेजा गया।

बग-मुक्त संस्करण, 57 बाइट्स

lambda m:sorted(m)[::random()>.1or 1]
from random import*

इसे ऑनलाइन आज़माएं!

बग्ड संस्करण, 57 बाइट्स

lambda m:sorted(m)[::random()>.1or-1]
from random import*

इसे ऑनलाइन आज़माएं!

मैंने एक समाधान का प्रयास करने का फैसला किया जो बोनस का उपयोग करता है। यह अन्य पायथन जवाब को हरा नहीं करता है, लेकिन मुझे यह सोचने में मज़ा आया।

— LyricLy
स्रोत
5

सी, 71 * 0.9 = 63.9 बाइट्स

बग मुक्त:

c(int*a,int*b){return*a-*b;}f(a,n)int*a;{if(rand()%1<9)qsort(a,n,4,c);}

इसे ऑनलाइन आज़माएं!

छोटी गाड़ी:

c(int*a,int*b){return*a-*b;}f(a,n)int*a;{if(rand()%10<9)qsort(a,n,4,c);}

इसे ऑनलाइन आज़माएं!

— Steadybox
स्रोत
+1 के लिए 1 (ओह, 6 से अधिक आने के लिए आप मुझे मजाक कर रहे हैं)
— जोशुआ
4

ग्रूवी , 31 बाइट्स

हल किया हुआ हल:

{a->a.sort()[a[9]?0..-1:-1..0]}

काम कर समाधान:

{a->a.sort()[a[0]?0..-1:-1..0]}

getAtयदि इंडेक्स आकार से बड़ा है, तो ग्रूवी सबस्क्रिप्ट ऑपरेटर ( विधि) सूचियों के लिए शून्य है। इसलिए यदि कोई नौवां तत्व है तो वह छांटे गए सूची के समान ही रहेगा, लेकिन यदि (1.99203187% मौका) यह उलटा नहीं होगा। हालाँकि हमेशा एक पहला तत्व होगा क्योंकि सूची का आकार हमेशा 5 से बड़ा या बराबर होता है। इसलिए 0 a[0]को 1, 2, 3 या 4 के साथ स्वैप किया जा सकता है।

— Hlaaftana
स्रोत
1
साइट पर आपका स्वागत है और अच्छी पहली पोस्ट!
— 15
3

वोल्फ्राम भाषा (गणितज्ञ) , 29 बाइट्स

यह बोनस के साथ 26.1 बाइट्स है, लेकिन मुझे पूरी तरह से यकीन नहीं है कि मैं बोनस कमाऊंगा; पहले से ही सॉर्ट किए गए इनपुट पर, दोनों संस्करण हमेशा सॉर्ट किए गए आउटपुट का उत्पादन करते हैं।

बग-मुक्त संस्करण (29 बाइट्स)

If[RandomReal[]<0.,#,Sort@#]&

इसे ऑनलाइन आज़माएं!

कष्टप्रद संस्करण (30 बाइट्स)

If[RandomReal[]<0.1,#,Sort@#]&

इसे ऑनलाइन आज़माएं!

— मिशा लावरोव
स्रोत
3

PHP, 70 बाइट्स

बग-मुक्त संस्करण, 70 बाइट्स

<?unset($argv[0]);((rand(1,9)?"":r).sort)($argv);echo join(" ",$argv);

इसे ऑनलाइन आज़माएं!

बग संस्करण, 70 बाइट्स

<?unset($argv[0]);((rand(0,9)?"":r).sort)($argv);echo join(" ",$argv);

इसे ऑनलाइन आज़माएं!

समय के 10% (क्रमबद्ध संख्या जनरेटर के आधार पर) उल्टे क्रम में बिगड़े हुए संस्करण छाँटे जाते हैं।

— Jo।
स्रोत
टैग के लिए कोई ज़रूरत नहीं है -r(-2 बाइट्स)। अंडरस्कोर से जुड़ें; यह समतुल्य होना चाहिए (-2 बाइट्स)। (-1 बाइट) के asortबजाय उपयोग करें sort।
— टाइटस
... या उपसर्ग (या नहीं) के बजाय पूरे शब्द का उपयोग करें: unset($argv[0]);(rand(1,9)?sort:rsort)($argv);echo join(_,$argv);(भी 65 बाइट्स)
— टाइटस
3

पायथन 2 , 26 बाइट्स

छोटी गाड़ी:

lambda l:l[9:]and l.sort()

इसे ऑनलाइन आज़माएं!

इनपुट सूची को संशोधित करके आउटपुट । सूची में केवल तभी इसकी लंबाई कम से कम 10 गैर गाड़ी संस्करण की जगह है क्रमित 9एक साथ 0हमेशा प्रकार के।

काम कर रहे:

lambda l:l[0:]and l.sort()

इसे ऑनलाइन आज़माएं!

हम 30 बाइट्स के लिए 4 बाइट्स की कीमत पर सूची वापस करने के लिए फ़ंक्शन को संशोधित कर सकते हैं:

lambda l:l[9:]and l.sort()or l

इसे ऑनलाइन आज़माएं!

नियमों के कुछ हिस्सों के साथ 25 बाइट्स:

[list,sorted][id(0)%17>0]

इसे ऑनलाइन आज़माएं!

एक फ़ंक्शन शाब्दिक आउटपुट जो या तो सॉर्ट करता है या id(0)एक यादृच्छिक स्रोत के रूप में उपयोग करके पहचान है । बदलें >को >=ठीक करने के लिए, या 0करने के लिए ~0।

— XNOR
स्रोत
3

भूसी , 6 बाइट्स

छोटी गाड़ी संस्करण:

?OIV¦9

इसे ऑनलाइन आज़माएं!

सही संस्करण:

?OIVK9

इसे ऑनलाइन आज़माएं!

व्याख्या

ये कार्यक्रम पूरी तरह से निर्धारक हैं। वास्तव में, हस्क के पास वर्तमान में यादृच्छिक संख्याओं के लिए कोई समर्थन नहीं है।

?  V    If any element
    ¦9  is divisible by 9 (in buggy version),
    K9  is truthy when replaced by 9 (in correct version),
 O      sort the list,
  I     otherwise return it unchanged.

मेरा दावा है कि छोटी गाड़ी कार्यक्रम का उत्पादन 1% और 2% के बीच संभावना के साथ हल नहीं किया गया है। तत्वों के संभावित मानों की संख्या N = 251 द्वारा निरूपित करें । संभावना है कि लंबाई L की एक यादृच्छिक सूची में 9 का कोई गुणक नहीं है ((NK) / N) ^ L , जहां K 9 से विभाज्य मानों की संख्या है (हमारे मामले में K = 28 )। कुल संभावना 5 ≤ L which 255 के लिए औसत है , जो लगभग 1.98% है। इनमें से कुछ सूचियाँ झूठी सकारात्मक हैं, क्योंकि वे पहले से ही क्रमबद्ध हैं। छांटे जाने वाली लंबाई L की यादृच्छिक सूची की संभावना सबसे अधिक है ((N + N * (N-1) / 2) / N ^ 2) ^ /L / 2⌋ : यदि हम सूची को लंबाई में तोड़ते हैं 2, प्रत्येक⌊L / 2⌊ चूजों को छांटना चाहिए। किसी सूची को छांटने की कुल संभावना 5 ≤ L , 255 के लिए उपरोक्त के औसत से बंधी है , जो लगभग 0.30% है। इस प्रकार गैर-सॉर्ट की गई सूची में फ़ंक्शन की संभावना 1.67% और 1.98% के बीच है।

— Zgarb
स्रोत
9 से विभाज्य विफलता का लगभग 11% मौका देता है। और सूची को अनसर्ट नहीं करने की गारंटी नहीं देता है।
— टाइटस
1
@Titus मैं विश्लेषण में यह पता। सॉर्ट करने में विफलता केवल तब होती है जब सूची में कोई तत्व नहीं होते हैं जो 9. से विभाज्य होते हैं। इस की संभावना लगभग 1.98% है। और यह सच है कि यदि सूची पहले से ही क्रमबद्ध है, तो कुछ भी नहीं करने से क्रमबद्ध सूची भी मिल जाएगी। हालांकि, सूची के पहले से ही सॉर्ट किए जाने की संभावना सबसे अधिक 0.30% है, जो कि कम है कि एक अनसुलझी सूची के आउटपुट की कुल संभावना 1% से ऊपर है।
— जरगब
सच ... और इनपुट सॉर्ट नहीं किया जा रहा है बग बदलें।
— टाइटस
क्या आप ↓9इसके बजाय इस्तेमाल कर सकते हैं V¦9, और इसे केवल 9सही संस्करण के लिए छोटा कर सकते हैं ? यह शॉर्ट इनपुट पर हमेशा विफल होता है और हमेशा लंबे समय तक काम करता है, लेकिन चूंकि इनपुट लंबाई एक यादृच्छिक वितरण का अनुसरण करती है, इसलिए यह अभी भी एक मान्य उत्तर होना चाहिए।
— लियो
3

बैश , 26 बाइट्स

सही संस्करण

s=n
sort -${s:RANDOM%20<0}

इसे ऑनलाइन आज़माएं! या संभावनाओं की जाँच करें ।

बदला हुआ संस्करण

s=n
sort -${s:RANDOM%20<1}

इसे ऑनलाइन आज़माएं! या संभावनाओं की जाँच करें ।

इनपुट को न्यूलाइन-सेपरेटेड नंबर्स के रूप में लेता है। अंतर्निहित चर का उपयोग करता है RANDOM, जो हमेशा 0 (32767) श्रेणी में एक (छद्म) यादृच्छिक संख्या देता है । %20लगभग 5% की विफलता दर के साथ परिणामों का उपयोग करना (धन्यवाद @ समस्याओं के साथ स्पष्टीकरण के लिए %10)।

इस यादृच्छिकता का मतलब है कि विफलता दर इनपुट से स्वतंत्र है, लेकिन इसके लिए यह आवश्यक है कि इनपुट सरणी में कम से कम एक संख्या एक से अधिक अंकों के साथ हो, क्योंकि विफलता आउटपुट को लेक्सोग्राफिक रूप से क्रमबद्ध किया गया है।

वैकल्पिक संस्करण, 27 बाइट्स

((RANDOM+20))||cat&&sort -n

+एक के साथ बदला हुआ संस्करण बदल जाता है %। इसे ऑनलाइन आज़माएँ या इसे कमज़ोर करने का प्रयास करें ।

— जस्टिन मेरिनर
स्रोत
पैसा पिकिंग: %10लौटने की संभावना अधिक होती है 0करने के लिए 7की तुलना में 8या 9;), तो असफलता के लिए मौका 10% से ऊपर है
— टाइटस
@Titus धन्यवाद, मैं उस तथ्य के बारे में भूल गया। %20आपके उत्तर की तरह उपयोग करने के लिए अद्यतन किया जाता है।
— जस्टिन मैरिनर
3

पायथ , स्कोर 8 * 0.9 = 7.2

पहला स्निपेट (सही एक):

h.uSNT.S

यहाँ यह कोशिश करो!

दूसरा स्निपेट (एक खराब)

O.uSNT.S

यहाँ यह कोशिश करो!

इसहाक के लिए दो बाइट्स (और 1.8 अंक) की बचत हुई !

— श्री Xcoder
स्रोत
मुझे लगता है कि 10 नई प्रतियों के बजाय 9 ठीक होगी। .Sइनपुट के अपरिवर्तित लौटने की संभावना का मतलब है कि उन (दुर्लभ) मामलों में, गलत उत्तर छोड़ने की हमारी संभावना 10% से 0% तक कम है - इसलिए औसतन, यह अभी भी सही सीमा में है। बेशक, 10 प्रतियां भी ठीक हैं।
— मिशा लावरोव
@ मिशालारोव मैंने अपने स्पष्टीकरण में एक गलती की है, जिसे अब संबोधित किया गया है। मैंने कहा .Sकि इनपुट को भी वापस कर सकते हैं (जो एक समस्या नहीं होगी), लेकिन मेरा मतलब .Sयह है कि क्रमबद्ध सूची भी लौटा सकता है ।
— श्री एक्सकोडर
सही है, मेरा भी यही मतलब है।
— मिशा लावरोव
समान विचार, लेकिन कम:O.uSNT.S
— isaacg
2

जावास्क्रिप्ट (ईएस 6), 24 बाइट्स

बग-मुक्त संस्करण (कम से कम 0-2147483647 सीमा में पूर्णांक के लिए, इसलिए दी गई श्रेणी में कुछ भी):

a=>a.sort((a,b)=>a-b>>0)

छोटी गाड़ी संस्करण:

a=>a.sort((a,b)=>a-b>>1)

पर निर्भर करता है) इंजन की छँटाई एल्गोरिथ्म और बी) गलत क्रम में दो मानों वाली इनपुट सूची 1 से भिन्न होती है। (यदि उस की संभावना बहुत कम 1हो जाती है तो बढ़ाया जा सकता है, लेकिन तब तक जब आप प्राप्त करते हैं करने के लिए 8यह बस रेंज में कुछ भी सॉर्ट नहीं होगा 5-255।)

— नील
स्रोत
2

PHP, 62 बाइट्स

जोस समाधान से प्रेरित (और मैंने अभी देखा: जस्टिन मार्नर के इट्स पोर्ट ):

काम करना (आरोही प्रकार):

unset($argv[0]);(r[rand()+20].sort)($argv);echo join(_,$argv);

छोटी गाड़ी (लगभग 5% अवरोही क्रम की संभावना):

unset($argv[0]);(r[rand()%20].sort)($argv);echo join(_,$argv);

साथ दौड़ो -nr

— टाइटस
स्रोत
2

पुष्य , 9 बाइट्स - 10% = 8.1

हल किया हुआ हल:

g0TUn?};_

इसे ऑनलाइन आज़माएं!

काम कर समाधान:

g1TUn?};_

इसे ऑनलाइन आज़माएं!

बग कोड निम्न करता है:

g0TUn?};_

g          \ Sort the stack correctly
 0TU       \ Generate random(0, 10)
    n? ;   \ If this is zero:
      }    \    Cyclically shift the stack right once
        _  \ Print the result

निश्चित कोड बस में बदलता 0है 1। जैसा कि random(1, 10)कभी नहीं होगा 0, यदि कथन को कभी निष्पादित नहीं किया जाएगा।

— FlipTack
स्रोत
2

MATL , 7 * 0.9 = 6.3 6 * 0.9 = 5.4 बाइट्स

छोटी गाड़ी संस्करण:

Gr.9<?S

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

G        % Grab input
 r       % Push a random number between 0 and 1
  .9     % Push 0.9
    <    % Check if the random number is smaller than 0.9
     ?   % If true
      S  % Sort input
         % Implicit output

बग-मुक्त संस्करण:

Gr9<?S

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

G       % Grab input
 r      % Push a random number between 0 and 1
  9     % Push 9
   <    % Check if the random number is smaller than 9 (always true)
    ?   % If true
     S  % Sort the input
        % Implicit output
— स्टीवी ग्रिफिन
स्रोत
1

Jq 1.5 , 42 बाइट्स

छोटी गाड़ी

sort|if length%13<=0then reverse else. end

कार्य करना (हटाना =)

sort|if length%13<0then reverse else. end

मान लें कि रेखा की लंबाई समान है [5,255] जो लगभग 7% बग को ट्रिगर करेगी

इसे ऑनलाइन आज़माएं!

— jq170727
स्रोत
1

आर , 30 * .9 = 27 बाइट्स

(गाड़ी)

function(l)sort(l,runif(1)<.1)

इसे ऑनलाइन आज़माएं!

(छोटी गाड़ी नहीं)

function(l)sort(l,runif(1)<.0)

decreasing=Tएक समान (0,1) वितरण से नमूना समय के 10% में छोटी गाड़ी का प्रकार है । संयुक्त राष्ट्र के छोटी गाड़ी संस्करण हमेशा होता हैdecreasing=F

— ग्यूसेप
स्रोत
1

रोड़ा , 42 बाइट्स - 10% = 37.8

बग मुक्त:

{sort key={|i|currentTime|[_%20//19*0+i]}}

छोटी गाड़ी:

{sort key={|i|currentTime|[_%20//19*i+i]}}

इसे ऑनलाइन आज़माएं!

इस का उपयोग करता है currentTime यादृच्छिक संख्या बनाने के फ़ंक्शन । ऐसा लगता है कि उनका वितरण मशीनों के बीच थोड़ा भिन्न होता है। अनुपात 20//19को बिना बाइट के दंड के लिए अलग-अलग परिणाम प्राप्त करने के लिए समायोजित किया जा सकता है (जब तक कि यह छोटा नहीं है 99//98)।

— fergusq
स्रोत
1

ऑक्टेव , 36 * 0.9 = 32.4 बाइट्स

छोटी गाड़ी संस्करण:

@(x)sort(x)(shift(1:end,+(rand<.1)))

इसे ऑनलाइन आज़माएं!

बग-मुक्त संस्करण:

@(x)sort(x)(shift(1:end,+(rand<.0)))

इसे ऑनलाइन आज़माएं!

यह वेक्टर को क्रमबद्ध करता है, फिर सभी संख्याओं को एक से दाईं ओर शिफ्ट करता है यदि कोई यादृच्छिक संख्या 0.1 से कम है।

— स्टीवी ग्रिफिन
स्रोत
हां, आप बिल्कुल सही कह रहे हैं :) धन्यवाद :)
— स्टीवी ग्रिफ़िन
1

जावा 8, 45 34.2 ( 50) 38 - 10%) बाइट्स

सामान्य संस्करण:

a->{if(Math.random()>0.)a.sort(null);}

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

a->{                    // Method with ArrayList<Integer> parameter and no return-type
  if(Math.random()>0.)  //  If the random 0-1 double is larger than 0:
    a.sort(null);       //   Sort the input-List
}                       // End of method

बिगड़े हुए संस्करण ( 51 39 बाइट्स):

a->{if(Math.random()>0.1)a.sort(null);}

1 का एलडी: 1 जोड़ा गया।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

a->{                     // Method with ArrayList<Integer> parameter and no return-type
  if(Math.random()>0.1)  //  If the random 0-1 double is larger than 0.1:
    a.sort(null);        //   Sort the input-List
}                        // End of method
— केविन क्रूज़सेन
स्रोत
0

जावास्क्रिप्ट, 25 * 0.9 = 22.5

new Date%25?x:x.sort()

इनपुट x

— l4m2
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.