मर्ज़ सॉर्ट

इस चुनौती में, आप मर्ज सॉर्ट के मर्ज सबरूटिन को लागू करेंगे। विशेष रूप से, आपको एक फ़ंक्शन या प्रोग्राम या क्रिया या समान बनाना होगा जो दो सूचियों को लेता है, प्रत्येक बढ़ते क्रम में क्रमबद्ध करता है, और उन्हें बढ़ते क्रम में क्रमबद्ध एक सूची में जोड़ता है। आवश्यकताएँ:

- आपके एल्गोरिथ्म को इनपुट के आकार में एक समान रूप से रैखिक राशि लेनी चाहिए। कृपया O (n ^ 2) समाधान देना बंद करें।

आप किसी अंतर्निहित कार्यों का उपयोग नहीं कर सकते हैं जो किसी सूची को छाँटने में सक्षम हैं, या किसी सूची को विलय करने में सक्षम हैं, या ऐसा कुछ भी। लेखक का विवेक
कोड को दोहराया तत्वों को संभालने में सक्षम होना चाहिए।
खाली सूची की चिंता न करें।

उदाहरण:

merge([1],[0,2,3,4])
[0,1,2,3,4]

merge([1,5,10,17,19],[2,5,9,11,13,20])
[1, 2, 5, 5, 9, 10, 11, 13, 17, 19, 20]

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीत सकता है!

code-golf sorting

— isaacg
स्रोत

क्या हमें किसी सूची के भीतर या केवल दो सूचियों के बीच दोहराए गए तत्वों को संभालना है?

— कीथ रान्डेल

चलो दोनों बोलें। विचार यह है कि आपको मर्ज सॉर्ट करने के लिए इसका उपयोग करने में सक्षम होना चाहिए।

— isaacg

क्या यह इनपुट सरणियों को हटाने के लिए कोषेर है?

— skibrianski

3

मुझे यकीन नहीं है कि एल्गोरिथ्म की व्याख्या करने के लिए समय की एक विषम लीनियर राशि कैसे लेनी चाहिए । एल्गोरिदम किसी भी समय नहीं लेते हैं, कार्यान्वयन करते हैं। रूबी दुभाषिया के साथ मेरे गोल्फस्क्रिप्ट उत्तर का निष्पादन समय ओ (डरावना) है, लेकिन ऑनलाइन गोल्फस्क्रिप्ट परीक्षक बहुत बेहतर व्यवहार करता है और वास्तव में रैखिक हो सकता है (हालांकि स्रोत कोड के बिना बताने का कोई वास्तविक तरीका नहीं है)। मेरी बात यह है b=a;b=b.lengthकि a(यदि प्रत्येक तत्व के लिए निष्पादित किया जाता है) पूरे सरणी (और परिणाम O (n ^ 2) समय में डुप्लिकेट हो सकता है) या सरणी (O (n) समय) के संदर्भ में केवल डुप्लिकेट। कौन सी गिनती?

— डेनिस

1

मैं इस तरह के मामलों में अनुमान लगाता हूं, बस यह पता लगाने की पूरी कोशिश करता हूं, लेकिन अगर आप ईमानदारी से नहीं बता सकते हैं, तो आप अच्छी तरह से काम कर सकते हैं, जैसे कि दूसरा विकल्प। यदि आपकी भाषा में मानक दुभाषिया नहीं है, तो आप मान सकते हैं कि दुभाषिया अच्छी तरह से काम करता है।

— isaacg

8

रेम्बु ( 35 32 वर्ण)

u[iG^aNXa[rvA]apGtkFaM?fA]apGscA

परीक्षा

>> rebmu/args [u[iG^aNXa[rvA]apGtkFaM?fA]apGscA] [[1 5 10 17 19] [2 5 9 11 13 20]] 
== [1 2 5 5 9 10 11 13 17 19 20]

>> rebmu/args [u[iG^aNXa[rvA]apGtkFaM?fA]apGscA] [[2 5 9 11 13 20] [1 5 10 17 19]] 
== [1 2 5 5 9 10 11 13 17 19 20]

के बारे में

रेम्बु , रेबोल की एक बोली है जो उन परिस्थितियों के लिए नियमित कोड के 'मशिंग' की अनुमति देता है जिनके लिए संक्षिप्तता की आवश्यकता होती है। अनमूल्ड, कोड कुछ हद तक काम करता है:

u [                     ; until
    i g^ a nx a [       ; if greater? args next args
       rv a             ; reverse args
    ]                   ; (we want the block containing the next value first)

    ap g tk f a         ; append output take first args
    m? f a              ; empty? first args
]                       ; (first block is now empty)

ap g sc a               ; append output second args
                        ; (add the remainder of the second)

मेरा मानना है कि यह ओ (n) आवश्यकता को पूरा करता है, जब तक कि ब्लॉक इनपुट की लंबाई के रूप में कई बार लूप हो जाता है (और reverseकेवल इनपुट ब्लॉक के कंटेनर के ऑर्डर को स्विच करता है, न कि खुद को ब्लॉक करता है)। उपयोग करना takeशायद एक स्वतंत्रता है, लेकिन अभी भी एक मामूली दक्षता हिट है।

रेबोल ( 83 75 वर्ण)

बस एक अलग मूत: रेबोल में, पथ firstया की तुलना में एक छोटी अभिव्यक्ति है second। aदो ब्लॉक वाले इनपुट ब्लॉक है:

until[if a/2/1 < a/1/1[reverse a]append o:[]take a/1 tail? a/1]append o a/2

— rgchris
स्रोत

5

ओपी के समाधान:

हास्केल 49 44 40

k@(p:r)%l@(q:s)|p>=q=q:k%s|0<1=l%k
a%_=a

पायथन 131 105 101 99 93

@Evpok को धन्यवाद के साथ:

f=lambda u,v:v and(v[-1]<u[-1]and f(v,u)or[b.append(a)for a,b in[(v.pop(),f(u,v))]]and b)or u

— isaacg
स्रोत

1

आप a%b=a++bखाली सूचियों को संभालने के लिए मुख्य पैटर्न के मिलान के बाद लिख सकते हैं , जो कुछ पात्रों को काट देगा।

— बेंत की मार

क्या हस्केल समाधान विफल नहीं होता है यदि पहली सूची सामग्री से पहले चलती है?

— जॉन ड्वोरक

यदि आप पहले फ़ंक्शन को देखते हैं, तो यह संक्षिप्त रूप से फ़ंक्शन को दूसरे तर्क के रूप में संक्षिप्त सूची के साथ कॉल करता है, और पहले तर्क के रूप में लंबी सूची, या फिर तर्क को स्वैप करता है। इसलिए, पहला तर्क कभी छोटा नहीं होता। ओपी के बाद से यह खाली नहीं शुरू होता है, यह कभी खाली नहीं होगा।

— ईसैक

4

पायथन (79)

from itertools import*
def m(*a):
 while any(a):yield min(compress(a,a)).pop(0)

अजगर (95, यदि हमें जनरेटर वापस करने की अनुमति नहीं है)

from itertools import*
def m(*a):
 r=[]
 while any(a):r+=[min(compress(a,a)).pop(0)]
 return r

Itertools सभी सांसारिक समस्याओं के लिए समाधान है।

बोनस: इन में से दो सूचियों की एक मनमानी संख्या पर काम करते हैं, और खाली सूचियों के बारे में चिंता करते हैं (जैसा कि, वे खुशी से 2 खाली सूची लेंगे, और एक खाली सूची वापस करेंगे, या 1 खाली और 1 गैर-खाली सूची लेंगे। और वे गैर-खाली एक लौटा देंगे। 2 गैर-उपज वाले लोगों की एक और अतिरिक्त सुविधा: वे बिना किसी तर्क के भी चलेंगे, और बस एक खाली सूची वापस करेंगे।)

Ungolfed:

from itertools import *  # Import all items from itertools
def m(*a):               # Define the function m, that takes any number of arguments, 
                         #  and stores those arguments in list a
    r=[]                 # Create an empty list r                         
    while any(a):        # While any element in a returns True as value:
        b=compress(a,a)  # Remove any element from a that isn't True (empty lists)
                         #  The example in the official documentation is this one:
                         #  compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
        c=min(b)         # Sort the lists by first value, and take the first one of these.
        d=c.pop(0)       # Take the first element from c
        r.append(d)      # Append this first element to r
    return r             # Gives back r

— ɐɔıʇǝɥʇuʎs
स्रोत

जनरेटर के बिना अपने समाधान में, के r+=[...]बजाय का उपयोग करें r.append(...)(हर बार 4

— चार्ट

मुझे इससे कोई मतलब नहीं है, लेकिन अगर आपके जवाब में एक भाषा में कोड है जो विशेष रूप से गोल्फ के लिए किए गए संशोधनों के साथ एक और भाषा है, तो मैं इसे नीचा दिखाने जा रहा हूं। यह शर्म की बात है, असली अजगर जवाब अच्छे हैं।

— अंडरग्राउंडोरेल

यदि आप उन्हें अलग-अलग पोस्ट में विभाजित करते हैं तो मैं अजगर को बढ़ा दूंगा।

— अंडरग्राउंडोरेल

4

@undergroundmonorail क्या आप सभी गोल्फस्क्रिप्ट उत्तरों को डाउनवोट करते हैं?

— Evpok

1

@ ईवपोक अब जब आप इसका उल्लेख करते हैं, तो इसे मेटा पर फेंक सकते हैं, और देख सकते हैं कि उन्हें वहां क्या कहना है।

— atı 17uʎs

3

सी - 75

यह NULLसमाप्त सरणियों पर int *काम करता है, हालांकि यह अन्य प्रकारों के लिए समान रूप से अच्छी तरह से काम करने के लिए उपयुक्त तुलनात्मक फ़ंक्शन **b < **a(जैसे, strcmp(*b, *a) < 0) की तुलना करके इंगित करता है ।

void m(int**a,int**b,int**c){while(*a||*b)*c++=!*a||*b&&**b<**a?*b++:*a++;}

Ungolfed:

void merge(int **a, int **b, int **c)
{
    while(*a || *b)
        *c++ = !*a || *b && **b < **a
            ? *b++
            : *a++;
}

— laindir
स्रोत

3

गोल्फस्क्रिप्ट, 29 27 30 29 26 बाइट्स

~{.0=@.0=@<{}{\}if(@@.}do;~]p

या

~{.0=@.0=@>{\}*(@@.}do;~]p

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

आदेश

golfscript merge.gs <<< '[2 3] [1 4]'

निम्नानुसार संसाधित किया जाएगा:

~            # Interpret the input string.
             #
             # STACK: [2 3] [1 4]
{            #
    .@=0.@=0 # Duplicate the two topmost arrays of the stack and extract their first 
             # elements. This reverses the original order of the first copy.
             #
             # STACK: [1 4] [2 3] 2 1
             #
    >        # Check if the respective first elements of the arrays are ordered.
             #
             # STACK: [1 4] [2 3] 1
             #
    {\}*     # If they are not, swap the arrays. This brings the array with the smallest
             # element to the top of the stack.
             #
             # STACK: [2 3] [1 4]
             #
    (@@      # Shift the first element of the array on top of the stack and rotate it
             # behind the arrays.
             #
             # STACK: 1 [2 3] [4]
             #
    .        # Duplicate the topmost array.
             #
             # STACK: 1 [2 3] [4] [4]
             #
}do          # Repeat this process if the array is non-empty.
             #
             # STACK: 1 [2 3] [4] -> 1 2 [4] [3] -> 1 2 3 [4] []
             #
;~           # Delete the empty array from the stack and dump the non-empty array.
             #
             # STACK: 1 2 3 4
             #
]p           # Combine all elements on the stack into a single array, the to a string and
             # print.

आउटपुट है:

[1 2 3 4]

— डेनिस
स्रोत

क्या स्टैक में सरणियों का दोहराव इसे O (n ^ 2) बनाता है?

— बेंत की मार

@swish: मैं कोई कंप्यूटर वैज्ञानिक नहीं हूं, लेकिन मैं कहूंगा कि यह कार्यान्वयन पर निर्भर करता है। अगर दुभाषिया वास्तव में पूरे सरणियों की नकल करता है, तो मुझे लगता है कि यह करता है।

— डेनिस

पिछले संस्करण O (n ^ 2) बहुत समान सरणियों (जैसे, [1 1 1 ... 2]और [1 1 1 ... 3]) के लिए था, क्योंकि सरणियों की तुलना (उनके पहले तत्वों के बजाय) इस मामले में बहुत धीमी होगी।

— डेनिस

नए संस्करण में होने वाले एकमात्र सरणी संचालन डुप्लिकेट, स्वैपिंग और स्टैक पर रोटेशन हैं। चूंकि डुप्लिकेट किए गए सरणियों का उपयोग केवल एकल तत्वों को निकालने और गैर-शून्यता के लिए सरणियों का परीक्षण करने के लिए किया जाता है (गोल्फस्क्रिप्ट में दोनों विनाशकारी संचालन), उपरोक्त कोड को ओ (एन) समय में (डुप्लिकेट करके, स्वैप करके और संदर्भों को घुमाकर) चलाया जा सकता है। सरणियों)। वास्तविक प्रदर्शन दुभाषिया पर निर्भर करता है।

— डेनिस

2

जे - 42 33

यहाँ से संशोधित संस्करण + @algorithmshark की टिप्पणी

k=:(m}.),~0{]
m=:k~`k@.(>&{.) ::,

kदोनों सरणियों के मर्ज किए गए पूंछ के लिए सही सरणी के सिर को प्रस्तुत करता है। k~एक ही है, लेकिन सरणियों के साथ फ़्लिप किया गया। (>&{.)सिर की तुलना कर रहा है। यदि कोड में से कोई एक खाली है, तो कोड एक त्रुटि फेंक देगा, उस स्थिति में हम सिर्फ उनका संघटन वापस करते हैं ,।

— बेंत की मार
स्रोत

मैं मान रहा हूं कि चूंकि /:~ a,bनिषिद्ध उत्तर (साथ में [:/:~,) है, इसलिए आप सबसे छोटे उत्तर की शूटिंग कर रहे हैं जिसमें शामिल नहीं है /:, है ना?

— डेन

मैं इंगित करूंगा कि प्रश्न में कहा गया है, "खाली सूचियों के बारे में चिंता न करें।"

— डेन

@ डेन पुनरावृत्ति को रोकने के लिए आवश्यक शून्यता के लिए परीक्षण।

— swish

m=:k~`k@.(>&{.)`,@.(0=*&#)2 चार बचाता है।

— एल्गोरिद्मशर्क

वास्तव में, आप पूरी चीज़ को 33 char में नीचे ला सकते हैं: k=:(m}.),~0{]और m=:k~`k@.(>&{.) ::,। 0{सूची के खाली होने पर हम एक त्रुटि फेंकने के लिए उपयोग करते हैं , और फिर उस त्रुटि को पकड़ते हैं और उसके साथ बाहर निकल जाते हैं ,।

— एल्गोरिथमशार्क

2

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

f=(a,b,c=[])=>(x=a[0]<b[0]?a:b).length?f(a,b,c.concat(x.shift())):c.concat(a,b)

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

f = (a, b, c = []) =>          // `f' is a function that takes arguments `a', `b' and `c' -
                               // `c' defaults to `[]' - which returns the following
                               // expression:
                               //
 (x = a[0] < b[0] ? a : b)     // Store the array among `a' and `b' with the smaller first 
                               // element in `x'.
                               //
 .length ?                     // If it's non-empty,
                               //
  f(a, b, c.concat(x.shift())) // append the first element of array `x' to array `c' and run
                               // `f' again;
                               //
  : c.concat(a,b)              // otherwise, append the arrays `a' and `b' to `c'.
                               //
)

— डेनिस
स्रोत

<ऑपरेटर के साथ सरणियों की तुलना करना मान्य नहीं है क्योंकि यह एक स्ट्रिंग तुलना करता है:f([123, 456, 789], [1, 2, 3, 4, 5]) => [1, 123, 2, 3, 4, 456, 5, 789]

— nscorecore

@nderscore: राइट। यह वैसे भी काम नहीं करेगा, क्योंकि पूरे सरणियों की तुलना ओ (एन) नहीं हो सकती है। यह गैर-शून्यता परीक्षा के लिए सही प्रतीत होता है, जिसमें संपूर्ण सरणी को एक स्ट्रिंग में बदलना होता है।

— डेनिस

हाँ, मुझे यकीन नहीं है कि सरणी-> स्ट्रिंग प्रकार रूपांतरण के लिए बिग-ओ क्या है।

— अंडरस्कोर

1

किसी सरणी को सम्‍मिलित करना []और फिर उसे एक स्ट्रिंग में बदलना O (n) समय की आवश्यकता है। सरणी के सभी n तत्वों के लिए एक बार ऐसा करने से O (n ^ 2) समय लगता है।

— डेनिस

समझ में आता है। समझ गया।

— 20

2

पायथन (63) (69) (71)

def m(a,b):
 if a[0]>b[0]:a,b=b,a
 return[a.pop(0)]+(m(a,b)if a else b)

मैंने अन्य उत्तरों के रनटाइम पर ओपी की टिप्पणियों को देखने से पहले यह लिखा था, इसलिए यह एल्गोरिथ्म में ओ (एन) का एक और समाधान है लेकिन कार्यान्वयन नहीं है।

— XNOR
स्रोत

ओ (1) के रूप में सरणियों के सामने से क्या एल्गोरिदम के अर्क हैं? सूची की तुलना ओ (1) से क्या है? इसके अलावा, आप इसे बदल कर आगे बढ़ सकते हैं ... यदि ... और ... से ... और ... या ...

— isaacg

@isaacg शूट, मैं पुनरावृत्ति के बारे में भूल गया था संभवतः सूची की तुलना ओ (एन) कर रही थी। इसलिए, मैंने उस अनुकूलन को 6 और पात्रों के लिए निकाल लिया है। आप एक लिंक की गई सूची में O (1) में सामने से आकर जोड़ सकते हैं। मैं नहीं देखता कि आप कैसे बना सकते हैं ... और ... या ... मूल्य वापस करने के साथ अच्छा खेलते हैं।

— xnor

ठीक है, अब मैं देखता हूं कि कैसे करना है ... और ... या ..., लेकिन यह जरूरी नहीं कि परगनों के कारण आकर्षण को बचाए। return[a.pop(0)]+(a and m(a,b)or b)

— xnor

@ आईआईएसएसीजी: ओ (1) में एक सरणी के सामने को निकालने के लिए, बस सरणी पॉइंटर को ऐसे बढ़ाएं कि यह दूसरे तत्व को इंगित करता है और पहले तत्व द्वारा खपत की गई मेमोरी को रिलीज़ करता है।

— Wrzlprmft

@Wrzlprmft मुझे काम करने के लिए एरे ट्रिक नहीं मिल सकी क्योंकि एरे के दोनों तत्वों का मूल्यांकन बूलियन मान की परवाह किए बिना किया जाता है, जो एक खाली सूची होने पर एक त्रुटि फेंकता है। क्या एक "आलसी सरणी" बनाने का एक छोटा तरीका है?

— xnor

2

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

a#b@(c:d)|a<[c]=b#a|0<1=c:a#d
a#_=a

हास्केल, 30 बाइट्स (गैर-प्रतिस्पर्धात्मक)

यह गैर-प्रतिस्पर्धात्मक संस्करण केवल रैखिक रनटाइम की गारंटी देता है यदि aऔर bइसमें असमान तत्व हैं; अन्यथा यह अभी भी सही ढंग से चलता है लेकिन द्विघात समय का उपयोग कर सकता है।

a#b|a<b=b#a|c:d<-b=c:a#d
a#_=a

— एंडर्स कसीर्ग
स्रोत

2

PHP 91 98 91 बाइट्स

# 1 संपादित करें: खाली $bकर्ली ब्रेसिज़ (+7) में एक अतिरिक्त स्थिति की आवश्यकता होती है।
# 2 संपादित करें: मामूली गोल्फिंग
# 3 संपादित करें: दूसरा संस्करण जोड़ा गया

बहुत सीधा। सबसे अच्छा हिस्सा अंदर का टर्नरी होता है array_shift
(जो कि अगर आप इसे बिना रस्सियों के आज़माते हैं तो यह विफल हो जाता है)

function m($a,$b){for($c=[];$a|$b;)$c[]=array_shift(${$a&(!$b|$a[0]<$b[0])?a:b});return$c;}

या

function m($a,$b){for($c=[];$a|$b;)$c[]=array_shift(${$a?!$b|$a[0]<$b[0]?a:b:b});return$c;}

ungolfed

function m($a,$b)
{
    $c=[];
    while($a||$b)
    {
        $c[] = array_shift(${
            $a&&(!$b||$a[0]<$b[0])
                ?a
                :b
        });
#       echo '<br>', outA($a), ' / ', outA($b) , ' -> ', outA($c);
    }
    return $c;
}

परीक्षा

$cases = array (
    [1],[0,2,3,4], [0,1,2,3,4],
    [1,5,10,17,19],[2,5,9,11,13,20], [1, 2, 5, 5, 9, 10, 11, 13, 17, 19, 20],
    [1,2,3],[], [1,2,3],
    [],[4,5,6], [4,5,6],
);
function outA($a) { return '['. implode(',',$a). ']'; }
echo '<table border=1><tr><th>A</th><th>B</th><th>expected</th><th>actual result</th></tr>';
while ($cases)
{
    $a = array_shift($cases);
    $b = array_shift($cases);
#   echo '<hr>', outA($a), ' / ', outA($b) , ' -> ', outA($c);
    $expect = array_shift($cases);
    $result=m($a,$b);
    echo '<tr><td>',outA($a),'</td><td>',outA($b),'</td><td>', outA($expect), '</td><td>', outA($result),'</td></tr>';
}
echo '</table>';

— टाइटस
स्रोत

मैं समझ नहीं पाया कि आप इसे आसान क्यों नहीं बनाते $a&(!$b|$a[0]<$b[0])?$a:$bहैं${$a&(!$b|$a[0]<$b[0])?a:b}

— Jörg Hülsermann

1

@ JörgHülsermann array_shiftपैरामीटर का उपयोग संदर्भ द्वारा किया जाता है। यह एक परिवर्तनशील होना है; एक अभिव्यक्ति का काम नहीं किया।

— टाइटस

1

जाओ, १२४ चरस

func m(a,b[]int)(r[]int){for len(a)>0{if len(b)==0||a[0]>b[0]{a,b=b,a}else{r=append(r,a[0]);a=a[1:]}};return append(r,b...)}

— कीथ रान्डेल
स्रोत

1

जावास्क्रिप्ट - 133

function m(a,b){c=[];for(i=j=0;i<a.length&j<b.length;)c.push(a[i]<b[j]?a[i++]:b[j++]);return c.concat(a.slice(i)).concat(b.slice(j))}

ओपी के रूप में एक ही तरह का दृष्टिकोण।

— मैट
स्रोत

1

पर्ल, 87 चार्ट / पर्ल 5.14, 78 + 1 = 79 चार्ट

यह कार्यान्वयन इनपुट सरणी संदर्भों को देखता है। इसके अलावा, यह बहुत सीधा-आगे है: जबकि दोनों सरणियों में कुछ है, दोनों के निचले हिस्से को बंद कर दें। फिर किसी भी शेष बिट्स (केवल @ $ x या @ $ y में से एक रहेगा) के साथ मिला हुआ विलय वापस लौटाएं। सीधे-अप perl5, 87 वर्ण:

sub M{($x,$y,@o)=@_;push@o,$$x[0]>$$y[0]?shift@$y:shift@$x while@$x&&@$y;@o,@$x,@$y}

पर्ल 5.14.0 और इसके न्यूफंगल सरणी सरणी बदलाव का उपयोग करना: 78 वर्ण + 1 वर्ण दंड = 79 वर्ण:

sub M{($x,$y,@o)=@_;push@o,shift($$x[0]>$$y[0]?$y:$x)while@$x&&@$y;@o,@$x,@$y}

— skibrianski
स्रोत

*इसके बजाय &&एक बाइट बचाएगा। और इससे भी अधिक अगरsub M{map{shift(!@$x+@$y*($$y[0]<$$x[0])?$y:$x)}map@$_,($x,$y)=@_}

— 16:28 पर user2846289

@VadimR, वाह। अच्छा काम। आगे बढ़ें और पोस्ट करें कि अगर आपको पसंद है - मैंने कभी नहीं सोचा था कि किसी सरणी पर पुश करने के बजाय डबल मैप ट्रिक करें।

— skibrianski

1

जावा: 144

यह बहुत सीधा है। एक फ़ंक्शन जो दो सरणियों लेता है और एक रिटर्न देता है, मर्ज किए गए संस्करण, गोल्फ और संकलन आवरण के बिना:

int[]m(int[]a,int[]b){int A=a.length,B=b.length,i,j;int[]c=new int[A+B];for(i=j=0;i+j<A+B;c[i+j]=j==B||i<A&&a[i]<b[j]?a[i++]:b[j++]);return c;}

Ungolfed (संकलन-योग्य और रन करने योग्य आवरण के साथ):

class M{
    public static void main(String[]args){
        int[]a=new int[args[0].split(",").length];
        int i=0;
        for(String arg:args[0].split(","))
            a[i++]=Integer.valueOf(arg);
        int[]b=new int[args[1].split(",").length];
        int j=0;
        for(String arg:args[1].split(","))
            b[j++]=Integer.valueOf(arg);
        int[]c=(new M()).m(a,b);
        for(int d:c)
            System.out.printf(" %d",d);
        System.out.println();
    }
    int[]m(int[]a,int[]b){
        int A=a.length,B=b.length,i,j;
        int[]c=new int[A+B];
        for(i=j=0;i+j<A+B;c[i+j]=j==B||i<A&&a[i]<b[j]?a[i++]:b[j++]);
        return c;
    }
}

उदाहरण निष्पादन:

$ javac M.java
$ java M 10,11,12 0,1,2,20,30
 0 1 2 10 11 12 20 30
$ java M 10,11,12,25,26 0,1,2,20,30
 0 1 2 10 11 12 20 25 26 30

किसी भी सुझाव को छोटा किया जाएगा।

— ProgrammerDan
स्रोत

1

स्काला, 97 बाइट्स

O (n) के साथ पुनरावर्ती समाधान। कोड को छोटा करने के लिए, कभी-कभी 2 विनिमेय मापदंडों को स्विच करके एक ऑपरेशन किया जाता है, यानी f (a, b) कॉल f (b, a)।

type L=List[Int];def f(a:L,b:L):L=if(a==Nil)b else if(a(0)<=b(0))a(0)::f(a.drop(1),b) else f(b,a)

Ungolfed:

type L=List[Int]

def f(a:L, b:L) : L =
  if (a == Nil)
    b 
  else 
    if (a(0) <= b(0))
      a(0) :: f(a.drop(1), b) 
    else
      f(b,a)

— lambruscoAcido
स्रोत

अपवाद यदि कोई खाली नहीं है, लेकिन ख खाली है

— डैन ओसिपोव

1

एपीएल (32)

{⍺⍵∊⍨⊂⍬:⍺,⍵⋄g[⍋g←⊃¨⍺⍵],⊃∇/1↓¨⍺⍵}

स्पष्टीकरण:

{⍺⍵∊⍨⊂⍬                               if one or both of the arrays are empty
        :⍺,⍵                           then return the concatenation of the arrays
             ⋄g[⍋g←⊃¨⍺⍵]              otherwise return the sorted first elements of both arrays
                          ,⊃∇/        followed by the result of running the function with
                               1↓¨⍺⍵}  both arrays minus their first element

— मारीनस
स्रोत

1

एलआईएसपी, 117 बाइट्स

एल्गोरिथ्म n + 1पुनरावृत्तियों में समाप्त होता है , जहां nइनपुट में सबसे छोटी सूची की लंबाई है।

(defun o(a b)(let((c(car a))(d(car b)))(if(null a)b(if(null b)a(if(< c d)(cons c(o(cdr a)b))(cons d(o a(cdr b))))))))

— PieCot
स्रोत

0

PYG (50)

def m(*a):
 while An(a):yield Mn(ItCo(a,a)).pop(0)

PYG (64, फिर से, यदि कोई जनरेटर की अनुमति नहीं है।):

def m(*a):
 r=[]
 while An(a):r+=[(Mn(ItCo(a,a)).pop(0)]
 return r

मेरे पायथन उत्तर का एक अनुकूलन ।

— ɐɔıʇǝɥʇuʎs
स्रोत

0

अजगर - 69 बाइट्स

def m(A,B):
    C=[]
    while A and B:C+=[[A,B][A>B].pop(0)]
    return C+A+B

यदि इनपुट और आउटपुट का क्रम घट रहा था, तो इसे 61 बाइट्स तक छोटा किया जा सकता है :

def m(A,B):
    C=[]
    while A+B:C+=[[A,B][A<B].pop(0)]
    return C

और अगर जनरेटर की अनुमति हो तो 45 बाइट्स के लिए नीचे :

def m(A,B):
    while A+B:yield[A,B][A<B].pop(0)

— Wrzlprmft
स्रोत

यह निश्चित रूप से ओ (एन) नहीं है। .pop (0) और + = दोनों O (n) ऑपरेशन हैं जो आप O (n) बार करते हैं।

— isaacg

मुझे अब तक यह पता नहीं था कि पायथन में सूचियों के रूप में कार्यान्वित नहीं किया जाता है और तब भी pop(0)ओ (1) में लागू किया जा सकता है और +=कम से कम ओ (एन) (लिंक देखें) से बेहतर लागू किया जा सकता है। वैसे, आपके समाधान का उपयोग +=(यानी, appendऔर extend) जितनी बार मेरा होता है। वैसे भी, यह सब एक कार्यान्वयन प्रश्न है (जहाँ तक मुझे पता है), इसलिए (काल्पनिक) पायथन कार्यान्वयन, जहाँ सूचियों को सूचियों के रूप में कार्यान्वित किया जाता है, मेरा कार्य O (n) है। अंत में आपके प्रश्न के लिए एल्गोरिथ्म O (n) होना आवश्यक है , और मेरा है।

— 22

दरअसल, + = के मुकाबले अजगर में एपेंड और एक्सटेंशन को अलग-अलग तरीके से लागू किया जाता है। + = एक नई सूची बनाता है, जबकि .append और .endend किसी मौजूदा को संशोधित करते हैं।

— इसहाक

0

पर्ल 6: 53 वर्ण

sub M(\a,\b){{shift a[0]>b[0]??b!!a}...{a^b},a[],b[]}

जब तक XOR ( ) सही है , तब तक aया bजिसमें से भी छोटा मूल्य है, से शिफ्ट करें । फिर जो कुछ बचा है, उसे समतल ( ) सूची में ( ) में लौटा दें ।aba^b[]a[],b[]

किसी सरणी के प्रारंभ से शिफ्टिंग मान लेना O (n) है, सबसे खराब स्थिति दो तुलना है और प्रति तत्व एक शिफ्ट है, इसलिए एल्गोरिथ्म O (n) है।

— Mouq
स्रोत

0

जावास्क्रिप्ट (ईएस 5) 90 86 90 बाइट्स

function f(a,b){for(o=[];(x=a[0]<b[0]?a:b).length;)o.push(x.shift());return o.concat(a,b)}

संपादित करें: (90 -> 86) लूप की स्थिति के लिए टर्नरी को स्थानांतरित किया। डेनिस से आइडिया चोरी।

संपादित करें: (86 -> 90) स्ट्रिंग को कास्ट को हटा दिया, क्योंकि यह ओ (एन) आवश्यकता को तोड़ता है ।

— nderscore
स्रोत

0

गणितज्ञ, १३hem १३५

m[a_,b_]:=(l=a;Do[Do[If[b[[f]]<=l[[s]],(l=Insert[l,b[[f]],s];Break[]),If[s==Length@l,l=l~Append~b[[f]]]],{s,Length@l}],{f,Length@b}];l)

इनपुट:

m[{2,2,4,6,7,11},{1,2,3,3,3,3,7}]

आउटपुट:

{1, 2, 2, 2, 3, 3, 3, 3, 4, 6, 7, 7, 11}

Ungolfed:

mergeList[a_, b_] := (
    list = a;
    Do[
        Do[(
            If[
                b[[f]] <= list[[s]],
                (list = Insert[list, b[[f]], s]; Break[]),
                If[
                    s == Length@list,
                    list = list~Append~b[[f]]
                ]
        ]),
        {s, Length@list}
    ],
    {f, Length@b}
    ];
    list
)

शायद बेहतर कर सकता था।

— kukac67
स्रोत

m[a:{x___,y_},b:{___,z_}]:=If[y<z,b~m~a,{x}~m~b~Join~{y}];{}~m~b_=b;

— एलेफल्फा

0

आर, 80

स्काला और अन्य भाषाओं में समान समाधान। मैं x [-1] O (1) के बारे में इतना निश्चित नहीं हूं।

f=function(a,b)if(length(a)){if(a[1]<=b[1])c(a[1],f(a[-1],b))else f(b,a)}else b

— lambruscoAcido
स्रोत

0

गणितज्ञ, 104 बाइट्स

Reap[{m,n}=Length/@{##};i=k=1;Do[If[k>n||TrueQ[#[[i]]<#2[[k]]],Sow@#[[i++]],Sow@#2[[k++]]],n+m]][[2,1]]&

बेनामी फ़ंक्शन, चर में दो इनपुट सूचियों की लंबाई को संग्रहीत करता है, mऔर nफिर Doलूप के प्रत्येक पुनरावृत्ति Sowमें एक सूची का एक तत्व होता है जो उस सूची के लिए काउंटर को बढ़ाता है ( iपहले के kलिए, दूसरे के लिए)। यदि काउंटरों में से एक सूची की लंबाई से अधिक है, तो Ifकथन हमेशा Sowअन्य सूची से तत्व होगा । n+mसंचालन के बाद , सभी तत्वों का ध्यान रखा गया है। Reapया [[2,1]]इसके उत्पादन का एक हिस्सा उन तत्वों की एक सूची है, जिस क्रम में वे Sown हैं।

मैं इंटर्ल्स के बारे में निश्चित नहीं हूं (एक सूची के एक भाग को एक O(1)ऑपरेशन या नहीं) तक पहुंच रहा है , लेकिन इनपुट सूची की लंबाई के संबंध में टाइमिंग मेरी मशीन पर काफी रैखिक दिख रही थी।

— LLlAMnYP
स्रोत

दो क्रमबद्ध सूचियों को मर्ज करें

मर्ज़ सॉर्ट

- आपके एल्गोरिथ्म को इनपुट के आकार में एक समान रूप से रैखिक राशि लेनी चाहिए। कृपया O (n ^ 2) समाधान देना बंद करें।

उदाहरण:

रेम्बु ( 35 32 वर्ण)

रेबोल ( 83 75 वर्ण)

ओपी के समाधान:

हास्केल 49 44 40

पायथन 131 105 101 99 93

पायथन (79)

अजगर (95, यदि हमें जनरेटर वापस करने की अनुमति नहीं है)

सी - 75

गोल्फस्क्रिप्ट, 29 27 30 29 26 बाइट्स

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

जे - 42 33

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

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

पायथन (63) (69) (71)

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

हास्केल, 30 बाइट्स (गैर-प्रतिस्पर्धात्मक)

PHP 91 98 91 बाइट्स

जाओ, १२४ चरस

जावास्क्रिप्ट - 133

पर्ल, 87 चार्ट / पर्ल 5.14, 78 + 1 = 79 चार्ट

जावा: 144

स्काला, 97 बाइट्स

एपीएल (32)

एलआईएसपी, 117 बाइट्स

PYG (50)

PYG (64, फिर से, यदि कोई जनरेटर की अनुमति नहीं है।):

अजगर - 69 बाइट्स

पर्ल 6: 53 वर्ण

जावास्क्रिप्ट (ईएस 5) 90 86 90 बाइट्स

गणितज्ञ, १३hem १३५

आर, 80

गणितज्ञ, 104 बाइट्स