चुनौती

यह वास्तव में काफी सरल है, संख्याओं की सूची को क्रमबद्ध करें।

विवरण

आपको आरोही क्रम में संख्याओं की एक सूची को क्रमबद्ध करना होगा, बिना किसी अंतर्निहित छँटाई कार्यों / पुस्तकालयों / आदि (अर्थात list.sort()पायथन में) का उपयोग किए बिना ।

इनपुट / आउटपुट आपके द्वारा चुने गए किसी भी तरीके से किया जा सकता है, जब तक कि यह मानव पठनीय है।

मानक खामियों को हमेशा की तरह खारिज कर दिया जाता है।

बाइट्स में सबसे छोटा कोड जीतता है।

आपको यह स्पष्ट करना होगा कि आपने किस प्रकार की विधि का उपयोग किया है (सूची बबल, प्रविष्टि, चयन, आदि)

इनपुट में डुप्लिकेट नहीं होंगे।

नमूना इनपुट / आउटपुट

इनपुट: 99,-2,53,4,67,55,23,43,88,-22,36,45

आउटपुट: -22,-2,4,23,36,43,45,53,55,67,88,99

नोट: क्रमबद्ध संख्याओं के विपरीत एक निकट

code-golf sorting integer

— माइकलफ्रांसिस बस्टिलोस
स्रोत

8

मुझे बहुत आश्चर्य हुआ अगर यह डुप्लिकेट नहीं है, लेकिन मेरे पास जांचने का समय नहीं है। वैसे भी, "अंतर्निहित छँटाई कार्य" बेहतर परिभाषित किया जाना चाहिए। क्या आप ऐसे फ़ंक्शन का उपयोग कर सकते हैं जो सभी मूल्यों को अनुक्रमित करता है? [7 2 4 1] -> [4 2 3 1]। इसके अलावा, क्या CSV सूची कोष्ठक के अंदर हो सकती है? इसके अलावा, विशिष्ट इनपुट प्रारूप कुछ भाषाओं के लिए बहुत उपयुक्त है, और दूसरों के लिए खराब है। यह इनपुट को कुछ सबमिशन के लिए एक बड़ा हिस्सा बनाता है, और दूसरों के लिए अनावश्यक बनाता है।

— स्टीवी ग्रिफ़िन

1

@StewieGriffin मैंने कई तरह की चुनौतियों को देखा है, लेकिन कोई भी केवल एक मूल पूर्णांक सूची को छांटने का काम नहीं कर रहा है। कई चुनौतियां हैं जो कुछ भाषाओं के लिए आसान हैं, और कुछ में बहुत कठिन हैं।

— मिशेलफ्रांसिस बस्टिलोस

यह है बहुत समान है, लेकिन एक हे (Nlog (एन)) पर प्रतिबंध है।

— नाथन मेरिल

2

इस प्रश्न से बहुत निकटता से संबंधित है , लेकिन चूंकि कुछ उत्तर यहां (जैसे डेनिस रेंज फ़िल्टरिंग) इनपुट की आवश्यकता है, इसलिए मुझे पूर्णांक के रूप में बंद करने के लिए वोट नहीं होगा।

— पीटर टेलर

प्रासंगिक: youtube.com/user/AlgoRythmics/videos - एक Youtube चैनल जो हंगेरियाई नृत्यों के माध्यम से छँटाई एल्गोरिदम सिखाता है!

— सर्गियोल

23

05AB1E , 2 बाइट्स

कोड:

œß

जेली जवाब के रूप में एक ही एल्गोरिदम । इनपुट के सभी क्रमपरिवर्तन की गणना करता है और सबसे छोटे को बाहर निकालता है।

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

एक अधिक कुशल विधि है:

E[ß,Ž

चयन प्रकार करता है । CP-1252 एन्कोडिंग का उपयोग करता है ।

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

— अदनान
स्रोत

6

इसे अस्थायी रूप से स्वीकार करना, क्योंकि मुझे किसी को कम से कम 2 दिखाई नहीं दे रहे हैं

— मिशेलफ्रांसिस बस्टिलोस

6

@ MichelfrancisBustillos अच्छी तरह से, अगर उन्होंने किया, तो यह एक बिल्टिन होगा, है ना?

— विनाशकारी नींबू

मैंने सिर्फ एक मिनट पहले 05AB1E / Base को देखा और फिर मैंने इसे देखा। संयोग?

— फेसपालम

17

जेली, 3 बाइट्स

Œ!Ṃ

यह इनपुट सूची के सभी क्रमपरिवर्तन को उत्पन्न करता है, फिर लेक्सोग्राफिक रूप से सबसे छोटे क्रमपरिवर्तन का चयन करता है। बहुत कुशल है।

@ अदनान को क्रेडिट जो स्वतंत्र रूप से एक ही विचार था।

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

जेली, 4 बाइट्स

ṂrṀf

यह सूची के न्यूनतम से लेकर सूची की अधिकतम सीमा तक बनाता है, फिर श्रेणी के तत्वों को मूल सूची में मौजूद नहीं होने की छूट देता है। यह तकनीकी रूप से एक बाल्टी सॉर्ट है , जिसमें बहुत छोटी बाल्टी हैं। मुझे इस विशिष्ट संस्करण के लिए एक नाम की जानकारी नहीं है।

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

यह काम किस प्रकार करता है

ṂrṀf  Main link. Argument: A (list/comma-separated string)

Ṃ     Compute the minimum of A.
  Ṁ   Compute the maximum of A.
 r    Yield the inclusive range from the minimum to the maximum.
   f  Filter the range by presence in A.

— डेनिस
स्रोत

ओ ( बहुत )। बहुत तरह का उपयोग करता है।

— mbomb007

22

तो O. बहुत उपयोग करता है। बहुत तरह का। विस्मित! (क्षमा करें, क्या?)

— डेनिस

मैं एल्गोरिदम की जटिलता में महान नहीं हूं, क्या यह O (n) होगा?

— 21

2

@FlipTack न तो मैं। शायद थोड़ा अधिक है, क्योंकि वहाँ n हैं! लंबाई के सरणियों एन ।

— डेनिस

1

भौगोलिक रूप से प्रत्येक के बाद से सबसे छोटा lexographically O (n * n!) है। सरणियों की तुलना क्रमिक रूप से की जानी चाहिए, और लेक्सोग्राफिक तुलना O (n) है। जनरेशन O (n * n!) में किया जा सकता है और साथ ही अगर कुशलता से किया जाए तो मैं

— सोचूंगा

12

पायथन, 46 45 बाइट्स

lambda l:[l.pop(l.index(min(l)))for _ in 1*l]

सरल चयन प्रकार।

— orlp
स्रोत

4

l[:]हो सकता है1*l

— feersum

9

ब्रेकीलॉग , 12 7 बाइट्स

p.'(s>)

यह क्रमचय क्रमबद्धता का उपयोग करता है, जो स्पष्ट रूप से भयानक है, लेकिन हे यह पायथ से छोटा है!

व्याख्या

p.       Unifies the output with a permutation of the input
  '(  )  True if what's inside the parentheses cannot be proven, else backtrack and
         try with another permutation of the input.
    s    Take an ordered subset from the output
     >   True if the first element is bigger than the second (hence not sorted)
         We don't need to check that the subset is 2 elements long because > will be false
         for inputs that are not 2 elements long anyway

— Fatalize
स्रोत

9

हास्केल, 38 बाइट्स

h%t|(a,b)<-span(<h)t=a++h:b
foldr(%)[]

बाइनरी फ़ंक्शन तत्वों के एक उपसर्ग और तत्वों के एक प्रत्यय में विभाजित करके %एक नए तत्व hको एक सॉर्ट की tगई सूची में सम्मिलित करता है , और उनके बीच में चिपक जाता है ।ta<hb>hh

ऑपरेशन foldr(%)[]फिर इनपुट सूची से तत्वों को बार-बार सम्मिलित करके खाली से सॉर्ट की गई सूची बनाता है।

यह प्रत्यक्ष पुनरावर्ती कार्यान्वयन की तुलना में एक बाइट कम है

f(h:t)|(a,b)<-span(<h)$f t=a++h:b
f x=x

41 बाइट्स के लिए एक और रणनीति:

f[]=[]
f l|x<-minimum l=x:f(filter(/=x)l)

— XNOR
स्रोत

तो यह en.wikipedia.org/wiki/Insertion_sort है , %इनरियन इनर लूप के रूप में और foldrइसे बाहरी लूप के रूप में लागू करने के लिए।

— पीटर कॉर्डेस

8

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

a=>a.map(_=>m=Math.min(...a.filter(e=>e>m)),m=-1/0)

प्रत्येक लूप सबसे छोटी संख्या पाता है जो अब तक नहीं मिला है।

— नील
स्रोत

इस पर कॉलिंग [1,2,3,4,5,4,3,2,1]का उत्पादन[1, 2, 3, 4, 5, Infinity, Infinity, Infinity, Infinity]

— बेंजामिन Gruenbaum

@BenjaminGruenbaum "इनपुट में डुप्लिकेट नहीं होंगे।"

— नील

मैं एक अलग दृष्टिकोण के साथ ठीक उसी bytecount है

— Bálint

असल में, 1 बाइट कम

— बैलिंट

यह एल्गोरिथ्म एक en.wikipedia.org/wiki/Selection_sort

— पीटर कॉर्ड्स

8

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

def f(s):m=min(s);print m;f(s-{m})

एक सेट के रूप में इनपुट लेता है, बढ़ते हुए तत्वों को छपाई करता है, त्रुटि के साथ समाप्त करता है।

एक साफ समाप्ति 41 बाइट्स में की जा सकती है:

def f(s):
 if s:m=min(s);print m;f(s-{m})

या

l=input()
while l:m=min(l);print m;l-={m}

इनपुट को 39 बाइट्स या 38 बाइट्स के लिए पायथन 3.5 में सूची के रूप में लिया जा सकता है:

def f(l):m=min(l);print m;f(set(l)-{m})
def f(l):m=min(l);print(m);f({*l}-{m})

— XNOR
स्रोत

यह एक है en.wikipedia.org/wiki/Selection_sort , का उपयोग करते हुए m=min(s)/ s - (m)भीतरी लूप के रूप में खोजने के लिए और बाहरी के रूप में अवर्गीकृत तत्वों से मिनट, और प्रत्यावर्तन दूर करने के लिए।

— पीटर कॉर्ड्स

8

हास्केल, 42 41 38 बाइट्स

f u=filter(`elem`u)[(minBound::Int)..]

सभी पूर्णांक (मेरी मशीन पर 64 बिट पर हस्ताक्षर किए गए) के माध्यम से लूप्स, और उन लोगों को रखता है जो अंदर हैं u। बेशक यह उचित समय में खत्म नहीं होता है।

पिछले संस्करण को लूप [minimum u..maximum u]किया गया जिसके माध्यम से चलने का समय सबसे खराब है।

संपादित करें: @xnor ने एक बाइट को बचाया। धन्यवाद!

— nimi
स्रोत

filterएक छोटा है:f u=filter(`elem`u)[minimum u..maximum u]

— xnor

कितना बल है! [minimum u..]प्रकार कारणों से काम नहीं करता है?

— xnor

@xnor: मुझे ऐसा लगता है। जब कॉल करते हैं, तो कहते हैं f [1,3,0], तत्व डिफ़ॉल्ट रूप से टाइप करते हैं Integerजो अनबाउंड है, इसलिए ..कभी समाप्त नहीं होता है। अगर आपको इसे कॉल करना है f ([1, 3, 0]::[Int])तो मुझे लगता है कि, टाइप एनोटेशन को बाइट की गिनती में शामिल करना होगा।

— nimi

यह उन तत्वों का पता कैसे लगाता है जो एक से अधिक बार होते हैं?

— feersum

1

@ Faersum: यह नहीं है, लेकिन चुनौती कहती है: "इनपुट में डुप्लिकेट नहीं होंगे"।

— nimi

8

Oracle SQL 11.2, 205 बाइट्स

WITH s AS(SELECT COLUMN_VALUE||''e FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))),v(p,f)AS(SELECT e,e FROM s UNION ALL SELECT p||','||e,e FROM v,s WHERE e+0>f)SELECT p FROM v WHERE LENGTH(p)=LENGTH(:1);

संयुक्त राष्ट्र के golfed

WITH 
s AS  -- Split the string using ',' as separator
(     -- ||'' cast the xml type to varchar
  SELECT COLUMN_VALUE||''e FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))
),  
v(p,f) AS  -- Recursive view : p = sorted string, f last number added
(
  SELECT e,e FROM s -- use each number as seed
  UNION ALL         -- only add a number if it is > the last added
  SELECT p||','||e,e FROM v,s WHERE e+0>f  -- +0 is needed to compare int and not strings
)  
-- The valid string has the same length as the input
SELECT p FROM v WHERE LENGTH(p)=LENGTH(:1)

यह किस प्रकार की विधि है, मुझे पता नहीं है, ORDER BYसुनिश्चित करें कि मैं उन्हें भूल गया।

— Jeto
स्रोत

मैं बमुश्किल एसक्यूएल को जानता हूं, लेकिन आपकी टिप्पणियों से मुझे लगता है कि आप बचे हुए तत्वों से न्यूनतम या अधिकतम का चयन कर रहे हैं, और इसे क्रमबद्ध सूची के अंत में जोड़ रहे हैं। जो इसे एक en.wikipedia.org/wiki/Selection_sort बनाता है ।

— पीटर कॉर्डेस

8

x86-16 मशीन कोड (BubbleSort int8_t), 20 19 बाइट्स

x86-64 / 32 मशीन कोड (जंपडाउनसॉर्ट) 21 19 बाइट्स

बदलाव का:

@ Ped7g के लिए धन्यवाद lodsb/ cmp [si],alविचार के लिए, और एक सूचक वृद्धि / रीसेट के साथ एक साथ रखा है कि मैं देख रहा था। आवश्यकता नहीं है al/ ahहमें बड़े पूर्णांक के लिए लगभग समान कोड का उपयोग करने देता है।
नया (लेकिन संबंधित) एल्गोरिथ्म, कई कार्यान्वयन परिवर्तन: बबली सेलेक्शनोर्ट बाइट्स या डिडर्स के लिए एक छोटे x86-64 कार्यान्वयन की अनुमति देता है; ब्रेक- यहां तक कि x86-16 पर (बाइट्स या शब्द)। इसके अलावा आकार पर बग से बचा जाता है = 1 जो मेरे बबलसॉर्ट के पास है। निचे देखो।
यह पता चला है कि हर बार जब आप एक नया मिनट पाते हैं तो स्वैप के साथ मेरा चुलबुली चयन सॉर्ट पहले से ही एक ज्ञात एल्गोरिथ्म, जंपडाउन सॉर्ट है। इसका उल्लेख बबल सॉर्ट में किया गया है : एक पुरातात्विक एल्गोरिथम विश्लेषण (यानी बबल सॉर्ट चूसने के बावजूद लोकप्रिय कैसे हुआ)।

8-बिट हस्ताक्षरित पूर्णांक को अंदर रखता है । (अहस्ताक्षरित एक ही कोड का आकार है, बस बदलने के jgeएक करने के लिए jae)। डुप्लिकेट कोई समस्या नहीं है। हम 16 बिट का उपयोग करके स्वैप करते हैं 8 (एक मेमोरी गंतव्य के साथ)।

बबल सॉर्ट प्रदर्शन के लिए बेकार है , लेकिन मैंने पढ़ा है कि यह मशीन कोड में लागू करने के लिए सबसे छोटा है। यह विशेष रूप से सच लगता है जब आसन्न तत्वों को स्वैप करने के लिए विशेष चालें होती हैं। यह बहुत ही इसका एकमात्र लाभ है, लेकिन कभी-कभी (वास्तविक जीवन में एम्बेडेड सिस्टम) यह बहुत ही कम सूचियों के लिए उपयोग करने के लिए पर्याप्त लाभ है।

मैंने बिना किसी स्वैप के शुरुआती समाप्ति को छोड़ दिया । मैंने विकिपीडिया के "अनुकूलित" बबलसॉर्ट लूप का इस्तेमाल किया n − 1, जो n-तो समय के लिए चलने पर अंतिम वस्तुओं को देखने से बचता है , इसलिए बाहरी लूप काउंटर आंतरिक लूप के लिए ऊपरी सीमा है।

एनएएसएम लिस्टिंग ( nasm -l /dev/stdout), या सादे स्रोत

 2 address  16-bit       bubblesort16_v2:
 3          machine      ;; inputs: pointer in ds:si,  size in in cx
 4          code         ;; requires: DF=0  (cld)
 5          bytes        ;; clobbers: al, cx=0
 6                       
 7 00000000 49               dec     cx          ; cx = max valid index.  (Inner loop stops 1 before cx, because it loads i and i+1).
 8                       .outer:                 ; do{
 9 00000001 51               push    cx          ;   cx = inner loop counter = i=max_unsorted_idx
10                       .inner:                 ;   do{
11 00000002 AC               lodsb               ;     al = *p++
12 00000003 3804             cmp     [si],al     ;     compare with *p (new one)
13 00000005 7D04             jge     .noswap
14 00000007 C144FF08         rol     word [si-1], 8    ; swap
15                       .noswap:
16 0000000B E2F5             loop    .inner      ;   } while(i < size);
17 0000000D 59               pop     cx          ;  cx = outer loop counter
18 0000000E 29CE             sub     si,cx       ;  reset pointer to start of array
19 00000010 E2EF             loop    .outer      ; } while(--size);
20 00000012 C3               ret

22 00000013  size = 0x13 = 19 bytes.

cxआंतरिक लूप के चारों ओर पुश / पॉप का मतलब है कि यह cx= बाहरी_cx से 0 के साथ चलता है ।

ध्यान दें कि rol r/m16, imm8एक 8086 निर्देश नहीं है, इसे बाद में (186 या 286) जोड़ा गया था, लेकिन यह 8086 कोड होने की कोशिश नहीं कर रहा है, सिर्फ 16-बिट x86। अगर SSE4.1 phminposuwमदद करेगा, तो मैं इसका इस्तेमाल करूंगा।

इसका 32-बिट संस्करण (अभी भी 8-बिट पूर्णांक पर लेकिन 32-बिट पॉइंटर्स / काउंटरों के साथ काम कर रहा है) 20 बाइट्स (ऑपरेंड-आकार उपसर्ग पर rol word [esi-1], 8) है

बग: आकार = 1 को आकार = 65536 माना जाता है, क्योंकि कुछ भी हमें बाहरी कार्य में प्रवेश करने से रोकता है / जबकि cx = 0 के साथ। (आप सामान्य रूप से इसके लिए उपयोग jcxzकरेंगे।) लेकिन सौभाग्य से 19-बाइट जंपडाउन सॉर्ट 19 बाइट्स है और इसमें कोई समस्या नहीं है।

मूल x86-16 20 बाइट संस्करण (बिना पेड 7 जी के विचार)। अंतरिक्ष को बचाने के लिए, विवरण के साथ इसके लिए संपादित इतिहास देखें ।

प्रदर्शन

आंशिक रूप से ओवरलैपिंग स्टोर / रीलोड (मेमोरी-डेस्टिनेशन रोटेट में) आधुनिक x86 CPUs (इन-ऑर्डर एटम को छोड़कर) पर स्टोर-फ़ॉरवर्डिंग स्टाल का कारण बनता है। जब एक उच्च मूल्य ऊपर की ओर बुदबुदाती है, तो यह अतिरिक्त विलंबता लूप-चालित निर्भरता श्रृंखला का हिस्सा होता है। पहली जगह में स्टोर / रीलोड चूसता है (जैसे हसवेल पर 5 साइकिल स्टोर-फ़ॉरवर्डिंग लेटेंसी), लेकिन एक फ़ॉर्वर्डिंग स्टाल इसे 13 चक्रों की तरह लाता है। आउट-ऑफ-ऑर्डर निष्पादन को इसे छिपाने में परेशानी होगी।

इसे भी देखें: स्टैक ओवरफ्लो: एक समान कार्यान्वयन के साथ इसके एक संस्करण के लिए स्ट्रिंग को छांटने के लिए बबल सॉर्ट , लेकिन जब कोई स्वैप की आवश्यकता नहीं होती है तो जल्दी आउट के साथ। यह स्वैपिंग के लिए xchg al, ah/ का उपयोग करता है mov [si], ax, जो 1 बाइट लंबा है और कुछ सीपीयू पर आंशिक-रजिस्टर स्टाल का कारण बनता है। (लेकिन यह अभी भी मेमोरी-डीएसटी घुमाव से बेहतर हो सकता है, जिसे फिर से मूल्य लोड करने की आवश्यकता होती है)। मेरी टिप्पणी में कुछ सुझाव हैं ...

x86-64 / x86-32 जंपडाउन सॉर्ट करें, 19 बाइट्स (सॉर्ट करें इंट 32_टी)

C86 से x86-64 सिस्टम V कॉलिंग कन्वेंशन
int bubblyselectionsort_int32(int dummy, int *array, int dummy, unsigned long size); (रिटर्न मान = अधिकतम (सरणी [])) का उपयोग करके कॉल करने योग्य ।

यह https://en.wikipedia.org/wiki/Selection_sort है , लेकिन मिनट तत्व की स्थिति को याद रखने के बजाय, वर्तमान उम्मीदवार को सरणी में स्वैप करें । एक बार जब आप मिन (अनसोर्स्ड_ग्रीन) पा लेते हैं, तो इसे सॉर्ट किए गए क्षेत्र के अंत में स्टोर करें, जैसे सामान्य चयन सॉर्ट। यह एक के आधार पर छांटे गए क्षेत्र को बढ़ता है। (कोड में, rsiसॉर्ट किए गए क्षेत्र के अंत में एक को इंगित करता है; lodsdइसे आगे बढ़ाता है और mov [rsi-4], eaxमिनट को वापस इसमें संग्रहीत करता है।)

नाम जंप डाउन सॉर्ट का उपयोग बबल सॉर्ट में किया जाता है : एक पुरातात्विक एल्गोरिथम विश्लेषण । मुझे लगता है कि मेरी तरह वास्तव में एक जम्प अप प्रकार है, क्योंकि उच्च तत्व ऊपर की ओर कूदते हैं, नीचे छंटनी छोड़ते हैं, अंत नहीं।

यह एक्सचेंज डिज़ाइन सरणी के अनसर्टेड हिस्से को ज्यादातर रिवर्स-सॉर्ट किए गए क्रम में ले जाता है, जिससे बाद में बहुत सारे स्वैप हो जाते हैं। (क्योंकि आप एक बड़े उम्मीदवार के साथ शुरू करते हैं, और निचले और निचले उम्मीदवारों को देखते रहते हैं, इसलिए आप स्वैप करते रहते हैं।) मैंने इसे "चुलबुली" कहा, भले ही यह तत्वों को दूसरी दिशा में ले जाए। जिस तरह से यह तत्वों को स्थानांतरित करता है वह भी पीछे की ओर सम्मिलन-प्रकार की तरह थोड़ा सा होता है। इसे क्रिया में देखने के लिए, GDB का उपयोग करें, display (int[12])bufआंतरिक loopनिर्देश पर एक ब्रेकपॉइंट सेट करें, और उपयोग करें c(जारी रखें)। दोहराने के लिए वापसी दबाएँ। ("डिस्प्ले" कमांड जीडीबी को हर बार जब हम ब्रेकपॉइंट मारते हैं, तो पूरे एरे स्टेट को प्रिंट करने के लिए मिलता है)।

xchgमेम के साथ एक अंतर्निहित lockउपसर्ग है जो इस अतिरिक्त को धीमा करता है। संभवतः एक कुशल लोड / स्टोर स्वैप की तुलना में परिमाण के क्रम के बारे में; xchg m,rSkylake पर प्रति 23c थ्रूपुट में से एक है, लेकिन एक कुशल स्वैप (reg, मेम) के लिए tmp reg के साथ लोड / स्टोर / मूव प्रति घड़ी एक तत्व को स्थानांतरित कर सकता है। यह एक एएमडी सीपीयू पर एक बदतर अनुपात हो सकता है जहां loopनिर्देश तेज है और आंतरिक लूप को उतना अधिक नहीं टोंक सकता है, लेकिन शाखा में अभी भी एक बड़ी अड़चन होगी क्योंकि स्वैप सामान्य होते हैं (और अनियोजित क्षेत्र जितना छोटा होता है उतना छोटा हो जाता है) )।

 2 Address               ;; hybrib Bubble Selection sort
 3        machine         bubblyselectionsort_int32:   ;; working, 19 bytes.  Same size for int32 or int8
 4        code               ;; input: pointer in rsi, count in rcx
 5        bytes              ;; returns: eax = max
 6                       
 7                           ;dec  ecx           ; we avoid this by doing edi=esi *before* lodsb, so we do redundant compares
 8                                               ; This lets us (re)enter the inner loop even for 1 element remaining.
 9                       .outer:
10                           ; rsi pointing at the element that will receive min([rsi]..[rsi+rcx])
11 00000000 56               push   rsi
12 00000001 5F               pop    rdi
13                           ;mov    edi, esi     ; rdi = min-search pointer
14 00000002 AD               lodsd
16 00000003 51               push   rcx          ; rcx = inner counter
17                       .inner:                   ; do {
18                           ; rdi points at next element to check
19                           ; eax = candidate min
20 00000004 AF               scasd                 ; cmp eax, [rdi++]
21 00000005 7E03             jle  .notmin
22 00000007 8747FC           xchg   [rdi-4], eax   ; exchange with new min.
23                         .notmin:
24 0000000A E2F8             loop  .inner          ; } while(--inner);
26                           ; swap min-position with sorted position
27                           ; eax = min.  If it's not [rsi-4], then [rsi-4] was exchanged into the array somewhere
28 0000000C 8946FC           mov    [rsi-4], eax
29 0000000F 59               pop   rcx           ; rcx = outer loop counter = unsorted elements left
30 00000010 E2EE             loop  .outer        ; } while(--unsorted);
32 00000012 C3               ret

34 00000013 13           .size: db $ - bubblyselectionsort_int32
           0x13 = 19 bytes long

के लिए एक ही कोड आकार int8_tउपयोग: lodsb/ scasb, AL, और परिवर्तन [rsi/rdi-4]करने के लिए -1। समान मशीन-कोड 32-बिट मोड में 8/32-बिट तत्वों के लिए काम करता है। 8/16-बिट तत्वों के लिए 16-बिट मोड को फिर से निर्मित ऑफसेट (और 16-बिट एड्रेसिंग मोड एक अलग एन्कोडिंग का उपयोग करें) के साथ बनाने की आवश्यकता है। लेकिन अभी भी सभी के लिए 19 बाइट्स।

यह dec ecxउस तत्व के साथ तुलना करके प्रारंभिक से बचा जाता है जिस पर जाने से पहले इसे लोड किया जाता है। बाहरी लूप के अंतिम पुनरावृत्ति पर, यह अंतिम तत्व को लोड करता है, जांचता है कि क्या यह स्वयं से कम है, तो किया जाता है। यह इसे आकार = 1 के साथ काम करने की अनुमति देता है, जहां मेरा बबलसॉर्ट विफल रहता है (इसे आकार = 65536 के रूप में मानता है)।

मैंने इस कॉलर का उपयोग करके इस संस्करण (GDB में) का परीक्षण किया: इसे ऑनलाइन आज़माएं! । आप इसे TIO पर चला सकते हैं, लेकिन निश्चित रूप से कोई डिबगर या प्रिंटिंग नहीं। फिर भी, _startयह कॉल इसे बाहर निकलने की स्थिति के साथ बाहर निकलता है = सबसे बड़ा तत्व = 99, ताकि आप यह देख सकें कि यह काम करता है।

— पीटर कॉर्डेस
स्रोत

इनर-लूप लूप की स्थिति में सुधार करने के लिए जगह हो सकती है, ऐसा लगता है कि यह बहुत सारे बाइट्स का उपयोग कर रहा है। शायद धक्का / पॉप cxऔर loopदोनों के लिए उपयोग करें ? हो सकता है कि दूसरे तरीके से लूप करें, पीछे से सामने वाले सरणी तक तो हम एक इंडेक्स को शून्य तक गिनते हैं? (और वेतन वृद्धि bxक्योंकि छांटे गए भाग अंत में आप की ओर लूप है)।

— पीटर कॉर्डेस

1

19B तक मिल गया, लेकिन बहुत सारे बदलावों के साथ, इनपुट रेज भी (कुछ बदलावों की शायद जरूरत नहीं थी, लेकिन जैसा कि मैं आसपास रहा था, वे वहां पहले प्रयोगों से बने रहे) ... यह अभी भी आपके काम पर आधारित है, इसलिए पोस्ट करने के लिए अनिच्छुक हैं यह उत्तर के रूप में, आप इसे pastebin पर देख सकते हैं: pastebin.com/0VMzdUjj

— Ped7g

@ Ped7g: अच्छा! मैं sub si, cxइंडेक्सिंग के बजाय एक पॉइंटर का उपयोग करके बाहरी लूप के हिस्से के रूप में माना जाता था, लेकिन मैंने lodsb/ के बारे में नहीं सोचा था cmp [si], al। मैं विचार कर रहा हूँ lodsw/ dec si, या lodsb/ के xchg al,ahलिए अभी भी स्थापित करने के लिएcmp ah,al

— पीटर कॉर्डेस

@ Ped7g: ओह, आपके संस्करण की आवश्यकता है cld, या मुझे लगता है कि हम कॉलिंग सम्मेलन का हिस्सा बना सकते हैं। AFAIK, DF16-बिट कॉलिंग कन्वेंशन का एक मानक हिस्सा नहीं है, केवल 32/64 है। या यह सिर्फ इतना है कि आप इसे बूटलोडर में नहीं मान सकते हैं? लेकिन एक कस्टम रजिस्टर कॉलिंग कन्वेंशन के साथ, यह एक फ़ंक्शन के रूप में एक कोड के टुकड़े के रूप में है, इसलिए निश्चित रूप से, DF = 0 की आवश्यकता क्यों नहीं है। (और अगर हम चाहते हैं, ES = DS तो हम scasbइसके बजाय lodsbअगर यह अधिक सुविधाजनक हो।)

— पीटर कॉर्डेस

1

@ पेड 7 जी: मुझे 16-बिट सम्मेलनों के बारे में कोई पता नहीं है, मुझे पता है कि आप हमेशा यह मान नहीं सकते हैं कि डीएफ को मंजूरी दे दी गई थी। लेकिन मुझे लगता है कि यह ज्यादातर एक बूटलोडर संदर्भ में है। मैंने वास्तविक डीओएस पर जो कुछ भी लिखा है उसे मैंने कभी नहीं चलाया। मैं अटारी मेगा 4 एसटीई (68000/68020), फिर लिनक्स (एक पेंटियम एमएमएक्स पर) पर था, इसलिए मैं 16-बिट x86 से पूरी तरह से बचने में कामयाब रहा जब तक कि एसओ प्रश्नों ने इसे मेरे गले तक नहीं डाला।

— पीटर कॉर्डेस

6

सी, 72 बाइट्स

i,j;a(int*l,int n){for(i=0;i=i?:--n;j>l[n]?l[i]=l[n],l[n]=j:0)j=l[--i];}

बबल शॅाट। पहला तर्क सरणी का एक संकेतक है, दूसरा तर्क सरणी की लंबाई है। जीसीसी के साथ काम करता है।

— mIllIbyte
स्रोत

यह वास्तव में पठनीय होने के लिए एक ungolfed संस्करण की जरूरत है; यह ध्यान रखना मुश्किल है कि टर्नरी ऑपरेटर शुरू / समाप्ति कहाँ करते हैं।

— पीटर कॉर्ड्स

5

MATL , 11 10 बाइट्स

Y@t!d0>AY)

इनपुट के सभी क्रमपरिवर्तन की अत्यधिक अक्षम परीक्षा।

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

व्याख्या

        % Implicitly grab input array
Y@      % Compute all permutations (each permutation as a row)
t       % Duplicate this matrix
!d      % Transpose and take the differences between the values
0>A     % Find the rows where all differences are > 0
Y)      % Return only the row where this is true
        % Implicitly display the result

— Suever
स्रोत

5

रूबी, 40 बाइट्स

चयन छांटना। अनाम फ़ंक्शन; सूची को तर्क के रूप में लेता है।

->a{r=[];r<<a.delete(a.min)while[]!=a;r}

— मूल्य स्याही
स्रोत

4

पायथन, 120 बाइट्स

def f(a):import time,threading;[threading.Thread(None,lambda b=b,c=min(a):print(time.sleep(b-c)or b)).start()for b in a]

यह शायद सबसे छोटा जवाब नहीं होगा, लेकिन मुझे लगता है कि यह एल्गोरिथ्म यहां है। पूर्णांक की एक सूची के साथ कॉल करें, उन्हें स्टडआउट करने के लिए एक हलके तरीके से मुद्रित किया जाएगा। मैं हालांकि बहुत बड़ी संख्या के साथ यह कोशिश नहीं करेंगे।

— CensoredUsername
स्रोत

अच्छी पहली पोस्ट! और अच्छा उपयोगकर्ता नाम। : P

— R

4

एमआइपी, 68 बाइट्स

मैंने कुछ समय पहले एक सरल अडॉप्टर्ड बबल सॉर्ट कार्यान्वयन लिखा था। बाइट गिनती शुरू होती है loopऔर समाप्त होती है li $v0, 10, यह मानते हुए कि सूची का पता और सूची की लंबाई पहले से ही स्मृति में है।

 Address    Code        Basic                     Source

0x00400000  0x3c011001  lui $1,4097           5    main:   la      $s0, list       # List address
0x00400004  0x34300000  ori $16,$1,0               
0x00400008  0x2411000a  addiu $17,$0,10       6            li      $s1, 10         # List length
0x0040000c  0x24080000  addiu $8,$0,0         8    loop:   li      $t0, 0          # swapped
0x00400010  0x24090001  addiu $9,$0,1         9            li      $t1, 1          # for loop "i"
0x00400014  0x1131000b  beq $9,$17,11         11   for:    beq     $t1, $s1, fend  # break if i==length
0x00400018  0x00095080  sll $10,$9,2          13           sll     $t2, $t1, 2     # Temp index, multiply by 4
0x0040001c  0x01505020  add $10,$10,$16       14           add     $t2, $t2, $s0   # Combined address
0x00400020  0x8d4b0000  lw $11,0($10)         15           lw      $t3, 0($t2)     # list[i]
0x00400024  0x8d4cfffc  lw $12,-4($10)        16           lw      $t4, -4($t2)    # list[i-1]
0x00400028  0x21290001  addi $9,$9,1          18           addi    $t1, $t1, 1     # i++
0x0040002c  0x016c082a  slt $1,$11,$12        20           ble     $t4, $t3, for   # if list[i-1] > list[i]
0x00400030  0x1020fff8  beq $1,$0,-8               
0x00400034  0xad4bfffc  sw $11,-4($10)        21           sw      $t3, -4($t2)    # swap and store
0x00400038  0xad4c0000  sw $12,0($10)         22           sw      $t4, 0($t2)     
0x0040003c  0x24080001  addiu $8,$0,1         23           li      $t0, 1          # swapped=true
0x00400040  0x08100005  j 0x00400014          24           j       for
0x00400044  0x20010001  addi $1,$0,1          26   fend:   subi    $s1, $s1, 1     # length--
0x00400048  0x02218822  sub $17,$17,$1             
0x0040004c  0x1500ffef  bne $8,$0,-17         27           bnez    $t0, loop       # Repeat if swapped==true
0x00400050  0x2402000a  addiu $2,$0,10        29           li      $v0, 10        
0x00400054  0x0000000c  syscall               30           syscall

अब मैं x86 के साथ पानी से बाहर निकाले जाने की प्रतीक्षा करता हूं ...

— qwr
स्रोत

1

आप swapped=trueअर्ली-आउट चेक को छोड़ सकते हैं और सरणी आकार के आधार पर गणना कर सकते हैं। मेरा 20 बाइट x86-16 संस्करण देखें जो 8-बिट पूर्णांक को सॉर्ट करता है । मैं एक सामान्य 32 या 64-बिट x86 संस्करण बना सकता हूं जो किसी बिंदु पर 32-बिट पूर्णांक को सॉर्ट करता है, लेकिन 16-बिट मोड में 8-बिट पूर्णांक x86 के लिए एक मीठे स्थान की तरह है।

— पीटर कॉर्डेस

4

अवाक, 66 बाइट्स

{b=$0;a[b]}m<b{m=b}n>b{n=b}END{for(i=n;i<=m;i++)if(i in a)print i}

Awk में Arrays शब्दकोशों की तरह हैं, C सरणियों की तरह नहीं। अनुक्रमणिका गैर-सन्निहित हो सकती है, और वे आवश्यकतानुसार विकसित (और निर्मित) होती हैं। इसलिए, हम aइनपुट के लिए एक सरणी बनाते हैं , जिसमें प्रत्येक पंक्ति एक कुंजी होती है। और हम न्यूनतम और अधिकतम मूल्यों को बचाते हैं। फिर हम न्यूनतम से अधिकतम तक लूप करते हैं, और उन सभी कुंजियों को प्रिंट करते हैं जो अंदर मौजूद हैं a। bकेवल बार-बार उपयोग से बचने के लिए है $0।

— muru
स्रोत

4

पायथन 3, 91 62 47 बाइट्स

def f(z):
 while z:m=min(z);z.remove(m);yield m

गोल्फ की मदद के लिए wnnmaw और Seeq का धन्यवाद ।

तर्क zएक सूची होनी चाहिए। यह चयन प्रकार का एक प्रकार है।

मुझे यकीन नहीं है कि कैसे minके खिलाफ ढेर हो जाता है built-in sorting functions, क्योंकि मुझे यकीन नहीं है कि पायथन कैसे लागू करता है min। उम्मीद है, यह समाधान अभी भी ठीक है। टिप्पणियों में या PPCG चैट में किसी भी गोल्फ सुझाव का स्वागत है।

— Sherlock9
स्रोत

यह बताना सुनिश्चित करें कि आप किस प्रकार का उपयोग कर रहे हैं।

— मिशेलफ्रांसिस बस्टिलोस

@MichelfrancisBustillos मैं ईमानदारी से भूल गया हूं कि यह क्या एल्गोरिदम है। चयन प्रकार हो सकता है?

— शर्लक

1

जिज्ञासा से बाहर, बस सीधे एक सूची क्यों नहीं? प्रश्न खुले इनपुट प्रारूप के लिए अनुमति देता है

— wnnmaw

1

@wnnmaw इसे डांग, मैंने एक को लिखा, लेकिन इसे पोस्ट करना भूल गया। अनुस्मारक के लिए धन्यवाद: D

— शर्लक

हम्म, शायदdef f(z):\nwhile z:m=min(z);z.remove(m);yield m

— 22:15

4

MATL , 11 बाइट्स

`t4#X<2#)tn

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

यह निम्न प्रक्रिया के अनुसार है, जो O ( n ^{2) है} ) है:

सरणी के न्यूनतम ले लो।
उस मान को सरणी से निकालें, और बाद के प्रदर्शन के लिए संग्रहीत करें।
शेष सरणी के साथ एक ही प्रक्रिया लागू करें, जब तक कि यह खाली न हो जाए।
जिस क्रम में उन्हें प्राप्त किया गया था, उसमें सभी संख्याओं को प्रदर्शित करें।

MATL स्टैक-आधारित है। शेष मूल्यों के साथ सरणी को स्टैक के शीर्ष पर रखा जाता है। हटाए गए मान नीचे हैं, क्रम में हैं। कार्यक्रम के अंत में उन सभी मूल्यों को प्रदर्शित किया जाता है। शीर्ष पर स्थित सरणी को भी प्रदर्शित किया जाएगा, लेकिन चूंकि यह खाली है इसलिए इसे नहीं दिखाया गया है।

`        % Do...while loop
  t      %   Duplicate. Implicitly take input in the first iteration
  4#X<   %   Compute index of mininum of the array
  2#)    %   Push the minimum, and then the array with remaining entries
  tn     %   Duplicate and push number of elements, to be used as loop condition
         % Implicitly end do...while loop
         % Implicitly display stack contents

— लुइस मेंडो
स्रोत

3

पायथ - 15 13 11 10 बाइट्स

@Jakube की बदौलत दो बाइट बच गईं।

Bogosort।

f!s>VTtT.p

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

मुझे इस बात की आवश्यकता नहीं है कि hहमें कोई डुप्लिकेट की गारंटी नहीं है।

— Maltysen
स्रोत

@ जाकुब मुझे बेवकूफ लग रहा है, धन्यवाद।

— माल्टसेन

@ जैसा कि मैंने अपने जवाब में कहा था, हमें ओपी के अनुसार कोई डुप्लिकेट नहीं मिलने की गारंटी है।

— माल्टसेन

उसके लिए माफ़ करना! उस बिंदु को याद किया।

— स्वेअर

3

गंभीरता से, 6 बाइट्स

,;l@╨m

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

यह कई अन्य उत्तरों के समान है: सभी क्रमपरिवर्तन उत्पन्न करें, न्यूनतम चुनें। मैं यह भूल गया कि जब मैं नीचे दिए गए समाधान पर काम कर रहा था तो यह काम करेगा।

स्पष्टीकरण:

,;l@╨m
,;l@    push len(input), input
    ╨m  minimum permutation

गंभीरता से, 25 बाइट्स (गैर-प्रतिस्पर्धात्मक)

यह प्रतिस्पर्धी होगा अगर यह फेरबदल कमांड में बग के लिए नहीं था जिसे मैंने अभी तय किया था।

,1WX╚;;pX@dXZ`i@-0<`MπYWX

इसे ऑनलाइन आज़माएं! यह अब तक का सबसे अच्छा छंटाई एल्गोरिथ्म लागू करता है: बोगोसॉर्ट !

स्पष्टीकरण:

,1WX╚;;pX@dXZ`i@-0<`MπYWX
,                          get input
 1W                    WX  do-while:
   X                         discard
    ╚                        shuffle
     ;;                      dupe twice
       pX@dX                 remove first element of first dupe and last element of second dupe
            Z                zip
             `i@-0<`MπY      test if all differences are positive (if any are not, the list is not sorted), negate (1 if not sorted else 0)

— मै जाऊं
स्रोत

3

Matl, 17 16 बाइट्स

@LuisMendo के लिए अशक्त सरणी बनाने के लिए एक बाइट सहेजा गया

vTbtX<-QI$(f8M+q

बाल्टी की तरह। इसे 2 ³¹ -1 से अधिक की रेंज के साथ आज़माएँ ।

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

व्याख्या

v                  % push an empty array
 T                 % push 1
  b                % bubble the input array up to the top of the stack
   t               % duplicate it
    X<             % find the minimum
      -            % subtract min from input array
       Q           % and increment to adjust for 1-based indexing
        I$(        % resulting array used as indices of empty array 
                   % (the [] way up at the top) that are assigned 1 (from T)
           f       % find the nonzero indices
            8M     % magically retrieve the 4th previous function input :/
                     (aka, the min input array value)
              +    % add it to the indices
               q   % and decrement

टीआईएल:

आप MATL का उपयोग करके एक खाली सरणी को इनिशियलाइज़ कर सकते हैं [] MATLAB की तरह ही इसे और इसे बढ़ा सकते हैं
कैसे इस्तेमाल करे (असाइनमेंट इंडेक्सिंग के
Mस्वचालित क्लिपबोर्ड का उपयोग कैसे करें

नया दिन, नया TIL:

vertcat जादुई रूप से एक खाली सरणी बनाता है जब समतल करने के लिए स्टैक पर कुछ भी नहीं होता है

— बीकर
स्रोत

अपने TIL में जोड़ें: एक प्रारंभिक [] द्वारा प्रतिस्थापित किया जा सकता है v। इसका कारण यह है कि इनपुट की डिफ़ॉल्ट संख्या vस्टैक में तत्वों की संख्या है

— लुइस मेंडो

@LuisMendo Sooo ... अगर ढेर पर एक सरणी है ...? जांच।

— बीकर

फिर यह कुछ भी नहीं करता है। इसे ऐसे vertcat(STACK{:})

— समझें

3

जूलिया, 28 27 बाइट्स

x->colon(extrema(x)...)∩x

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

— डेनिस
स्रोत

क्या यह न्यूनतम सूची से अधिकतम तक की सीमा बनाता है, और मूल सूची के साथ प्रतिच्छेद करता है? यह कुछ अन्य उत्तरों की तरह en.wikipedia.org/wiki/Counting_sort का स्वाद होगा : codegolf.stackexchange.com/a/117648/30206 । (प्रश्न विशेष रूप से यह कहने के लिए उत्तरों की आवश्यकता है कि यह किस प्रकार का है।)

— पीटर कॉर्डेस

3

आर, 68 बाइट्स

इनपुट iऔर आउटपुट लेता oहै जो क्रमबद्ध सूची है।

o<-i
for(j in 1:length(i)){
x<-(i-min(i))==0
o[j]<-i[x]
i<-i[!x]
}
o

स्पष्टीकरण:

o<-i                      # Defines output as o
 for(j in 1:length(i)){   # Initializes loop for length of input
  x<-(i-min(i))==0        # Generates logical vector by finding the value 0 
                          # of input less the minimum of input. 
   o[j]<-i[x]             # Puts the smallest value at position j
    i<-i[!x]              # Removes the smallest value from input
      }                   # Ends loop
       o                  # Returns sorted list

क्रमपरिवर्तन से बचने का मतलब है कि यह बड़ी सूचियों को अपेक्षाकृत तेज़ी से क्रमबद्ध कर सकता है। "ट्रिक" यह है कि इनपुट से सबसे छोटे मान को घटाकर एक एकल 0 छोड़ दिया जाता है जो सबसे छोटे मान और सबसे छोटे मान की स्थिति दोनों को निर्धारित करता है।

— Forgottenscience
स्रोत

3

जावा 8, 112 92 बाइट्स

यहाँ एक और चयन प्रकार है। इनपुट List tपूर्णांक का है और छांटे गए आउटपुट को मानक के रूप में मुद्रित किया जाता है।

t->{for(;0<t.size();System.out.println(t.remove(t.indexOf(java.util.Collections.min(t)))));}

अद्यतन करें

-20 [16-08-21] एक मेमने का इस्तेमाल किया

— NonlinearFruit
स्रोत

हाय Nonlinear, और PPCG में आपका स्वागत है!

— isaacg

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! ऐसा प्रतीत होता है कि आपका कोड tअस्तित्व के लिए एक चर मानता है, जो इसे स्निपेट बनाता है; हमें पूरे कार्यक्रम या फ़ंक्शंस के लिए सबमिशन की आवश्यकता होती है जो हमारे डिफ़ॉल्ट I / O स्वरूपों का उपयोग करते हैं । हमें बाइट काउंट में फैक्टर के आयात की भी आवश्यकता होती है। अगर आपका कोई प्रश्न हैं, तो मुझे से पूछें!

— एलेक्स ए।

संसाधनों के लिए धन्यवाद! मैंने अपने उत्तर को एक फ़ंक्शन होने और आयात को शामिल करने के लिए संशोधित किया।

— नॉनलाइनयरफ्रूट

2

रेटिना, 95

संशोधित बुलबुला सॉर्ट। मुझे संदेह है कि ऐसा करने के लिए बहुत बेहतर तरीके हैं, यहां तक कि रेटिना प्रकार के बिलिन के बिना भी।

-\d+
$*n
\d+
$*11
+`(1+) (n+)
$2 $1
+`\b(n+) (\1n+)|(1+)(1+) \3\b
$2$3 $1$3$4
1(1*)
$.1
n+
-$.&

चरण 1 - nअंकों के रूप में एक के साथ पूर्णांक कन्वर्ट -ve ; -संकेत छोड़ें ।
चरण 2 - 1अंक के साथ यूरी और शून्य पूर्णांक को एकरूप में बदलें ; 1प्रत्येक को जोड़ें , ताकि शून्य का प्रतिनिधित्व किया जाए 1।
चरण 3 - सभी -ves को सामने की ओर ले जाएं।
चरण 4 - क्रमबद्ध करें: सभी-सबसे बड़े परिमाण (यानी सबसे छोटे संख्यात्मक) के साथ उच्च-तरंगों को आगे बढ़ाएं। बड़े + वेस के आगे छोटी + वेस ले जाएँ।
चरण 5 - 1 से निकालें, और + ve यूनियनों को वापस दशमलव में बदलें।
स्टेज 6 - कन्वर्ट -ve यूनियनों वापस दशमलव सहित, साइन सहित।

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

— डिजिटल आघात
स्रोत

बस एक बाइट छोटी!

— लीक नून

@LeakyNun सूची में अंतिम तत्व को क्रमबद्ध नहीं करता है।

— mbomb007

@ mbomb007 सही है, कभी मन नहीं।

— लीके नन

2

रूबी, 22 बाइट्स

एक त्वरित क्रमबद्धता क्रम। O (n!) स्थान और समय पर चलता है।

->a{a.permutation.min}

— MegaTom
स्रोत

2

क्लोजर, 73 35 बाइट्स

बोगोसॉर्ट :)

#(if(apply < %)%(recur(shuffle %)))

पुराना संस्करण:

#(reduce(fn[r i](let[[a b](split-with(partial > i)r)](concat a[i]b)))[]%)

rइसे "i से छोटे" और "i से बड़े" भागों में विभाजित करके एक सॉर्ट की गई सूची में कम कर देता है । मुझे लगता है कि यह प्रविष्टि प्रकार है ।

— NikoNyrh
स्रोत

अच्छा! मुझे नहीं पता था कि आप recurएक अनाम फ़ंक्शन पर हो सकते हैं । इसके बारे में भी नहीं पता था shuffle।

— मत्तीस बर्जलैंड

2

रूबी, २६ 24 बाइट्स

वैल्यू इंक के उत्तर के समान चयन प्रकार, लेकिन अधिक गोल्फ के लिए एक अलग दृष्टिकोण का उपयोग करना।

विनिर्देश के अनुसार: "इनपुट / आउटपुट आपके द्वारा चुने गए किसी भी विधि में किया जा सकता है, जब तक कि यह मानव पठनीय है"। मुझे लगता है कि यह विवरण फिट बैठता है, आउटपुट एक तत्व के साथ सरणियों का एक सरणी है।

->l{l.map{l-l-=[l.min]}}

उदाहरण:

->l{l.map{l-l-=[l.min]}}[[2,4,3,1]]
=> [[1], [2], [3], [4]]

— जीबी
स्रोत

2

जावा 7, 106 104 बाइट्स

void a(int[]a){for(int b=a.length-1,d=0,c=0,e;d<b*b;c=++d%b)if(a[c]>a[c+1]){e=a[c];a[c++]=a[c];a[c]=e;}}

यहाँ एक अच्छा ओले बबल सॉर्ट है। फ़ंक्शन पैरामीटर को संशोधित किया गया है, इसलिए मुझे कुछ भी वापस करने की आवश्यकता नहीं है। फिर भी इसमें से कुछ बाइट्स को निचोड़ने की कोशिश की जा रही है ताकि मैं जावा लैम्ब्डा को हरा सकूं जिसे किसी ने पोस्ट किया है।

-1 बाइट की बदौलत जियोबिट्स की ओर इशारा करते हुए कि सामान्य स्वैपिंग xor'ing की धड़कन है।
-1 बाइट लेकी नन की बदौलत यह इंगित करने के लिए कि मैं सभी घोषणाओं को फॉर-लूप में स्थानांतरित कर सकता हूं

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

— प्रहार
स्रोत

2

रूबी, 22 बाइट्स

->a{[*a.min..a.max]&a}

इनपुट सरणी के न्यूनतम और अधिकतम तत्वों के बीच सीमा से बाहर एक सरणी बनाता है। दो सरणियों के बीच प्रतिच्छेदन देता है।

— dkudriavtsev
स्रोत

मुझे लगता है कि यह एक तरह का en.wikipedia.org/wiki/Counting_sort है ।

— पीटर कॉर्डेस

@PeterCordes वह बिंदु था

— dkudriavtsev

प्रश्न आपको यह वर्णन करने के लिए कहता है कि यह किस प्रकार का है, इसलिए मैंने सोचा कि यह अच्छी तरह से ज्ञात एल्गोरिथ्म से जुड़ने के लिए उपयोगी था और साथ ही यह वर्णन करता है कि यह वास्तव में क्या करता है।

— पीटर कॉर्डेस

सच। धन्यवाद @PeterCordes

— dkudriavtsev

एक पूर्णांक सूची को क्रमबद्ध करें

चुनौती

विवरण

नमूना इनपुट / आउटपुट

05AB1E , 2 बाइट्स

जेली, 3 बाइट्स

जेली, 4 बाइट्स

यह काम किस प्रकार करता है

पायथन, 46 45 बाइट्स

ब्रेकीलॉग , 12 7 बाइट्स

व्याख्या

हास्केल, 38 बाइट्स

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

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

हास्केल, 42 41 38 बाइट्स

Oracle SQL 11.2, 205 बाइट्स

x86-16 मशीन कोड (BubbleSort int8_t), 20 19 बाइट्स

x86-64 / 32 मशीन कोड (जंपडाउनसॉर्ट) 21 19 बाइट्स

x86-64 / x86-32 जंपडाउन सॉर्ट करें, 19 बाइट्स (सॉर्ट करें इंट 32_टी)

सी, 72 बाइट्स

MATL , 11 10 बाइट्स

रूबी, 40 बाइट्स

पायथन, 120 बाइट्स

एमआइपी, 68 बाइट्स

अवाक, 66 बाइट्स

पायथन 3, 91 62 47 बाइट्स

MATL , 11 बाइट्स

पायथ - 15 13 11 10 बाइट्स

गंभीरता से, 6 बाइट्स

गंभीरता से, 25 बाइट्स (गैर-प्रतिस्पर्धात्मक)

Matl, 17 16 बाइट्स

जूलिया, 28 27 बाइट्स

आर, 68 बाइट्स

जावा 8, 112 92 बाइट्स

रेटिना, 95

रूबी, 22 बाइट्स

क्लोजर, 73 35 बाइट्स

रूबी, २६ 24 बाइट्स

जावा 7, 106 104 बाइट्स

रूबी, 22 बाइट्स