সাজানো দুটি তালিকা মার্জ করুন

Question

বাছাই বাছাই করুন

এই চ্যালেঞ্জে আপনি মার্জ সাজানোর মার্জ সাবরোটাইন প্রয়োগ করবেন। বিশেষত, আপনাকে অবশ্যই একটি ক্রিয়াকলাপ বা প্রোগ্রাম বা ক্রিয়া বা অনুরূপ তৈরি করতে হবে যা প্রতিটি ক্রম ক্রম অনুসারে বাছাই করা দুটি তালিকাগুলি গ্রহণ করে এবং ক্রমবর্ধমান ক্রম অনুসারে বাছাই করা তালিকায় তাদের একত্রিত করে। প্রয়োজনীয়তা:

- আপনার অ্যালগরিদম অবশ্যই ইনপুট আকারে একটি asyptotically রৈখিক পরিমাণ সময় নিতে হবে। দয়া করে ও (এন ^ 2) সমাধান দেওয়া বন্ধ করুন।

• আপনি কোনও তালিকা বাছাই করতে সক্ষম, বা একটি তালিকা মার্জ করতে সক্ষম এমন কোনও বিল্ট-ইন ফাংশন ব্যবহার করতে পারবেন না that লেখকের বিচক্ষণতা।
• কোডটি পুনরাবৃত্তি উপাদানগুলি পরিচালনা করতে সক্ষম হওয়া উচিত।
• খালি তালিকা সম্পর্কে চিন্তা করবেন না।

উদাহরণ:

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]

এটি কোড-গল্ফ , তাই সংক্ষিপ্ততম কোডটি জিততে পারে!

Comments

আমাদের কি তালিকার মধ্যে পুনরাবৃত্ত উপাদানগুলি পরিচালনা করতে হবে, বা কেবল দুটি তালিকার মধ্যে?

— কিথ র্যান্ডাল

দুজনেই বলি। ধারণাটি হ'ল আপনার মার্জ সাজানোর জন্য এটি ব্যবহার করতে সক্ষম হওয়া উচিত।

— ইসাকাক

ইনপুট অ্যারে ক্লোবার করা কি কোশার?

— skibrianski

আমি নিশ্চিত না কীভাবে অ্যালগরিদমকে ব্যাখ্যা করতে হবে অবশ্যই একটি asympototical রৈখিক সময় নিতে হবে । অ্যালগরিদম কোনও সময় নেয় না, বাস্তবায়ন করে। আমার গল্ফস্ক্রিপ্ট উত্তরের কার্যকর হওয়ার সময়টি রুবি ইন্টারপ্রেটারের সাথে ও (ভীতিজনক), তবে অনলাইন গল্ফস্ক্রিপ্ট পরীক্ষক আরও ভাল আচরণ করে এবং বাস্তবে লিনিয়ার হতে পারে (যদিও উত্স কোড ব্যতীত বলার কোনও আসল উপায় নেই)। আমার বক্তব্যটি হ'ল: b=a;b=b.lengthসম্পূর্ণ অ্যারেটিকে নকল করতে পারে a(এবং ফলাফলটি প্রতিটি উপাদানগুলির জন্য কার্যকর হলে O (n ^ 2) এর ফলাফল হতে পারে ) বা অ্যারের (O (n) সময়) কেবলমাত্র রেফারেন্সটি সদৃশ করে। কোন একটি গণনা?

— ডেনিস

আমি এই জাতীয় ক্ষেত্রে অনুমান করি, কেবল এটি নির্ধারণের জন্য যথাসাধ্য চেষ্টা করুন, তবে আপনি যদি সত্যই বলতে না পারেন, তবে আপনি উল্লিখিত দ্বিতীয় বিকল্পের মতো জিনিসগুলি খুব ভালভাবে কাজ করতে পারবেন। আপনি ধরে নিতে পারেন যে আপনার ভাষায় কোনও মানক দোভাষী না থাকলে দোভাষী ভালভাবে কাজ করে works

— isaacg

Answer 1

রেব্মু ( ৩৩ টি চর)

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)

আমি বিশ্বাস করি যে এটি ও (এন) এর প্রয়োজনীয়তাকে সন্তুষ্ট করে যতক্ষণ না ব্লক সর্বাধিক ইনপুটটির দৈর্ঘ্যের (এবংreverse একমাত্র ইনপুট ব্লকগুলির ধারকটির ক্রম স্যুইচ করে, ব্লকগুলি নিজেরাই নয়)। ব্যবহার takeকরা সম্ভবত একটি স্বাধীনতা, তবে এটি এখনও একটি সামান্য দক্ষতার হিট।

রিবোল ( 83 75 টি চর)

শুধু একটি পুঁচকে একটু অন্যরকম দেখাচ্ছে: Rebol এ, পাথ তুলনায় খাটো অভিব্যক্তি 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

Answer 2

ওপির সমাধান:

হাস্কেল 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

@ এভপোককে ধন্যবাদ সহ:

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

Comments

a%b=a++bখালি তালিকাগুলি হ্যান্ডেল করার জন্য আপনি মূল প্যাটার্নের মিলের পরে লিখতে পারেন , যা বেশ কয়েকটি চরিত্রের শেভ করবে।

— ফিটফাট

যদি প্রথম তালিকাটি প্রথমে সামগ্রীর বাইরে চলে যায় তবে হাসেল সমাধানটি ব্যর্থ হয় না?

— জন ডিভোরাক

আপনি যদি প্রথম ফাংশনটি লক্ষ্য করেন তবে এটি সংক্ষেপে দ্বিতীয় আর্গুমেন্ট হিসাবে সংক্ষিপ্ত তালিকার সাথে ফাংশনটি এবং প্রথম আর্গুমেন্ট হিসাবে লম্বা তালিকাটি অন্যথায় যুক্তিগুলি অদলবদল করে calls অতএব, প্রথম যুক্তিটি কখনই সংক্ষিপ্ত হয় না। যেহেতু ওপি দ্বারা এটি খালি শুরু হয় না, এটি কখনই খালি হবে না।

— isaacg

Answer 3

পাইথন (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 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

Comments

জেনারেটর ছাড়াই আপনার সমাধানগুলিতে, r+=[...]পরিবর্তে ব্যবহার করুন r.append(...)(প্রতিবার 4 টি চর বাঁচায়)

— এইচটিএল

আমি এর দ্বারা কোনও অপরাধ বোঝাতে চাইছি না, তবে যদি আপনার উত্তরটিতে এমন কোনও ভাষার কোড থাকে যা কেবলমাত্র অন্য ভাষা যা গল্ফিংয়ের জন্য বিশেষভাবে করা পরিবর্তনগুলির সাথে থাকে তবে আমি এটিকে হ্রাস করব। এটি লজ্জাজনক, আসল অজগর উত্তরগুলি ভাল।

— আন্ডারগ্রাউন্ডোমোনাইল

আপনি যদি এগুলিকে বিভিন্ন পোস্টে বিভক্ত করেন তবে আমি অজগরটিকে উত্সাহিত করব।

— আন্ডারগ্রাউন্ডোমোনাইল

আপনি কি গল্ফস্ক্রিপ্টের সমস্ত উত্তরকে নীচে রেখেছেন?

— ইভপোক

@ এভপোক এখন আপনি এটি উল্লেখ করেছেন, পাশাপাশি এটি মেটাতে ফেলে দিতে পারেন এবং সেখানে তাদের কী বলতে হবে তা দেখুন।

— 5uʎs

Answer 4

সি - 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++;
}

Answer 5

গল্ফস্ক্রিপ্ট, 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]

Comments

স্ট্যাকের অ্যারেগুলির সদৃশকরণ কী এটি ও (এন ^ 2) করে?

— ফিটফাট

@ সুইশ: আমি কোনও কম্পিউটার বিজ্ঞানী নই, তবে আমি বলব এটি বাস্তবায়নের উপর নির্ভর করে। দোভাষী যদি পুরো অ্যারেটির সদৃশ হয় তবে আমার ধারণা এটি হয়েছে।

— ডেনিস

পূর্ববর্তী সংস্করণটি খুব অনুরূপ অ্যারেগুলির জন্য ও (এন ^ 2) ছিল (উদাহরণস্বরূপ, [1 1 1 ... 2]এবং [1 1 1 ... 3]), যেহেতু অ্যারের তুলনা করা (তাদের প্রথম উপাদানগুলির চেয়ে বরং) এই ক্ষেত্রে খুব ধীর হবে।

— ডেনিস

নতুন সংস্করণে কেবলমাত্র অ্যারে অপারেশনগুলি হ'ল হ'ল সদৃশ, অদলবদল এবং স্ট্যাকের আবর্তন। যেহেতু সদৃশ অ্যারেগুলি কেবলমাত্র একক উপাদানগুলি বের করতে এবং বিনা শূন্যতার জন্য অ্যারেগুলি পরীক্ষা করতে ব্যবহৃত হয় (গল্ফস্ক্রিপ্টে উভয় ধ্বংসাত্মক ক্রিয়াকলাপ), উপরের কোডটি ও (এন) সময়ে চালানো যেতে পারে (নকল করে, অদলবদল করে এবং রেফারেন্সগুলিকে ঘোরানোর মাধ্যমে) অ্যারে)। আসল কর্মক্ষমতা দোভাষীর উপর নির্ভর করে।

— ডেনিস

Answer 6

জে - 42 33

এখান থেকে পরিবর্তিত সংস্করণ + @ অ্যালগরিদমশর্ক এর মন্তব্য

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

kউভয় অ্যারের মার্জড লেজগুলিতে ডান অ্যারের মাথাটি প্রস্তুত করে। k~একই, কিন্তু অ্যারে উল্টানো সঙ্গে। (>&{.)মাথা তুলনা করা হয়। কোডগুলির মধ্যে একটি ত্রুটি ছুঁড়ে ফেলবে যদি অ্যারেগুলির মধ্যে একটি শূন্য থাকে, সেক্ষেত্রে আমরা কেবল তাদের যুক্তিটি ফিরিয়ে দেব ,।

Comments

আমি অনুমান করছি যেহেতু /:~ a,bনিষিদ্ধ উত্তর (বরাবর [:/:~,) যেহেতু আপনি সংক্ষিপ্ত উত্তরটির জন্য শুটিং করছেন যা /:ঠিক নেই?

— ডেন

আমি উল্লেখ করব যে প্রশ্নটি বলে, "খালি তালিকা নিয়ে চিন্তা করবেন না।"

— ডেন

@ ডেন পুনরাবৃত্তি থামার জন্য শূন্যতার জন্য পরীক্ষা প্রয়োজন।

— ফিটফাট

m=:k~`k@.(>&{.)`,@.(0=*&#)2 চর সঞ্চয় করে

— অ্যালগরিদমশর্ক 21

আসলে, আপনি পুরো জিনিসটি 33 চরে নামাতে পারবেন: k=:(m}.),~0{]এবং m=:k~`k@.(>&{.) ::,। 0{তালিকাটি খালি থাকাকালীন আমরা একটি ত্রুটি ছুঁড়ে ফেলার জন্য ব্যবহার করি এবং তারপরে সেই ত্রুটিটি ধরা এবং প্রস্থান করে ,।

— অ্যালগরিদমশর্ক

Answer 7

জাভাস্ক্রিপ্ট (ES6), 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'.
                               //
)

Comments

<অপারেটরের সাথে অ্যারের তুলনা বৈধ নয় কারণ এটি একটি স্ট্রিং তুলনা করে:f([123, 456, 789], [1, 2, 3, 4, 5]) => [1, 123, 2, 3, 4, 456, 5, 789]

— nderscore

@ আন্ডারস্কোর: ঠিক আছে। এটি কোনওভাবেই কাজ করবে না, যেহেতু পুরো অ্যারেগুলি তুলনা করা O (n) নাও হতে পারে। শূন্যতা পরীক্ষার জন্য একইটি সত্য বলে মনে হয়, যা পুরো অ্যারেটিকে স্ট্রিংয়ে রূপান্তর করতে হয়।

— ডেনিস

হ্যাঁ, আমি নিশ্চিত নই যে অ্যারে-> স্ট্রিং টাইপের রূপান্তরটির জন্য বড়-ও কী।

— nderscore

একটি অ্যারের সাথে সংঘবদ্ধ করা []এবং তারপরে স্ট্রিংয়ে রূপান্তর করতে ও (এন) সময় প্রয়োজন। অ্যারের সমস্ত এন উপাদানগুলির জন্য একবার এটি করতে O (n ^ 2) সময় লাগে।

— ডেনিস

বোধ হয়। বুঝেছি.

— nderscore

Answer 8

পাইথন (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)

অন্যান্য উত্তরের রানটাইমের বিষয়ে ওপির মন্তব্যগুলি দেখার আগে আমি এটি লিখেছিলাম, সুতরাং এটি অন্য একটি সমাধান যা অ্যালগরিদমের ও (এন) কিন্তু বাস্তবায়ন নয়।

Comments

ও (1) হিসাবে অ্যারের সামনের অংশ থেকে কোন অ্যালগরিদমগুলি নিষ্কাশিত হয়েছে? ও (1) এর সাথে তালিকার তুলনাগুলি কোন অ্যালগরিদমগুলিতে রয়েছে? এছাড়াও, আপনি এটি পরিবর্তন করে আরও গল্ফ করতে পারেন ... যদি ... অন্যথায় ... থেকে ... এবং ... বা ...

— ইসাএ্যাকগ

@ আইস্যাক শ্যুট, আমি পুনরাবৃত্তির সম্পর্কে ভুলে গিয়েছি সম্ভবত তালিকা তুলনা করে ও (এন) তৈরি করব। সুতরাং, আমি আরও 6 টি চরিত্রের জন্য সেই অপটিমাইজেশনটি বের করেছি। আপনি লিঙ্কিত তালিকায় ও (1) এর সম্মুখভাগ থেকে এক্সট্রাক্ট করতে এবং যুক্ত করতে পারেন। আপনি কীভাবে তৈরি করতে পারবেন তা আমি দেখতে পাই না ... এবং ... বা ... মানটি ফিরিয়ে দেওয়ার সাথে দুর্দান্ত খেলি।

— xnor

ঠিক আছে, আমি এখন কীভাবে করব ... এবং ... বা ... দেখছি, তবে প্যারেন্সের প্রয়োজনীয়তার কারণে এটি অক্ষর সংরক্ষণ করে না। return[a.pop(0)]+(a and m(a,b)or b)

— xnor

@ আইস্যাকগ: ও (1) এ অ্যারের সামনের অংশটি বের করতে, কেবল অ্যারের পয়েন্টারটি বাড়িয়ে দিন যাতে এটি দ্বিতীয় উপাদানটির দিকে নির্দেশ করে এবং প্রথম উপাদানটির দ্বারা গ্রাস করা স্মৃতি ছেড়ে দেয়।

— Wrzlprmft

@Wrzlprmft আমি অ্যারে কৌশলটি কাজ করতে পারি না কারণ অ্যারের উভয় উপাদানই বুলিয়ান মান নির্বিশেষে মূল্যায়ন করা হয়, যা খালি তালিকা থাকা অবস্থায় একটি ত্রুটি নিক্ষেপ করে। "অলস অ্যারে" তৈরি করার কোনও সংক্ষিপ্ত পথ রয়েছে?

— xnor

Answer 9

হাস্কেল, 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

Answer 10

পিএইচপি 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>';

Comments

আমি বুঝতে পারছিলাম না কেন আপনি তা না সহজ করতে $a&(!$b|$a[0]<$b[0])?$a:$bপরিবর্তে${$a&(!$b|$a[0]<$b[0])?a:b}

— Jörg Hülsermann

@ JörgHülsermann array_shiftপরামিতি রেফারেন্স দ্বারা ব্যবহৃত হয়। এটি একটি পরিবর্তনশীল হতে হবে; একটি অভিব্যক্তি কাজ না।

— তিতাস

Answer 11

যান, 124 অক্ষর

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...)}

Answer 12

জাভাস্ক্রিপ্ট - 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))}

ওপির হিসাবে একই ধরণের পদ্ধতির।

Answer 13

পার্ল, 87 অক্ষর / পার্ল 5.14, 78 + 1 = 79 অক্ষর

এই প্রয়োগটি ইনপুট অ্যারে রেফারেন্সগুলি ক্লোবার করে। এগুলি বাদে, এটি বেশ সোজা-এগিয়ে: উভয় অ্যারেতে কিছু থাকাকালীন, দু'টির নীচে সরিয়ে। তারপরে অবশিষ্ট বিটগুলির সাথে যোগ হওয়া মার্জ বিটটি ফিরিয়ে দিন (কেবলমাত্র @ $ x বা @ $ y এর মধ্যে একটিই থাকবে)। স্ট্রেট-আপ পার্ল 5, 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}

Comments

*পরিবর্তে &&একটি বাইট সংরক্ষণ করা হবে। এবং আরও বেশি যদিsub M{map{shift(!@$x+@$y*($$y[0]<$$x[0])?$y:$x)}map@$_,($x,$y)=@_}

— ব্যবহারকারী 2846289

@ ভাদিমআর, বাহ চমৎকার কাজ. এগিয়ে যান এবং পোস্ট করুন যে আপনি যদি চান - আমি কখনও অ্যারের উপর চাপ দেওয়ার পরিবর্তে ডাবল মানচিত্রের কৌশলটি করার কথা ভাবিনি।

— skibrianski

Answer 14

জাভা: 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;}

অসম্পূর্ণ (সংকলন-সক্ষম এবং চলমানযোগ্য মোড়ক সহ):

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

সংক্ষিপ্ত করার জন্য কোনও টিপস প্রশংসা করা হবে।

Answer 15

স্কালা, 97 বাইট

ও (এন) এর সাথে পুনরাবৃত্তির সমাধান। কোডটি সংক্ষিপ্ত করতে, কখনও কখনও 2 এক্সচেঞ্জযোগ্য পরামিতিগুলি, যেমন f (a, b) কল এফ (বি, এ) স্যুইচ করে একটি অপারেশন করা হয়।

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)

Comments

ব্যতিক্রম যদি কোনও খালি না হয় তবে খ খালি হয়

— ড্যান ওসিপভ

Answer 16

এপিএল (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

Answer 17

এলআইএসপি, 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))))))))

Answer 18

পিওয়াইজি (50)

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

পিওয়াইজি (আবারও, যদি কোনও জেনারেটরের অনুমতি না দেওয়া হয়,):

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

আমার পাইথন উত্তরের একটি অভিযোজন ।

Answer 19

পাইথন - 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)

Comments

এটি অবশ্যই ও (এন) নয়। .pop (0) এবং + = উভয়ই হে (এন) অপারেশন যা আপনি ও (এন) বার করেন।

— isaacg

আমি এখনও অবধি জানি না যে পাইথনে তালিকাগুলি তালিকা হিসাবে প্রয়োগ করা হয় না এবং তারপরেও pop(0)ও (1) +=এ প্রয়োগ করা যেতে পারে এবং কমপক্ষে ও (এন) (লিঙ্কটি দেখুন) এর চেয়ে আরও ভাল প্রয়োগ করা যেতে পারে। যাইহোক, আপনার সমাধানটি আমার হিসাবে প্রায়শই +=(যেমন, appendএবং extend) ব্যবহার করে । যাইহোক, এটি সমস্ত একটি বাস্তবায়ন প্রশ্ন (যতদূর আমি জানি), সুতরাং পাইথন বাস্তবায়নের ক্ষেত্রে, যেখানে তালিকাগুলি তালিকা হিসাবে প্রয়োগ করা হয়, আমার ফাংশন ও (এন)। অবশেষে আপনার প্রশ্নের জন্য অ্যালগরিদম O (n) হওয়া দরকার, এবং আমার হয়।

— Wrzlprmft

আসলে, অ্যাডেন্ড এবং প্রসারিত ++ এর চেয়ে অজগরটিতে আলাদাভাবে প্রয়োগ করা হয়। + = একটি নতুন তালিকা তৈরি করে, যখন অ্যাপ্লিকেশন এবং। Expend একটি বিদ্যমান তালিকা পরিবর্তন করুন।

— isaacg

Answer 20

পার্ল 6: 53 টি অক্ষর

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

এক্সওআর ( ) সত্য হওয়ার আগ পর্যন্ত যেকোনটি থেকে aবা bএর থেকে কম মান সরিয়ে নেওয়া হবে । তারপরে যা যা বাকী থাকে তা ফিরিয়ে দিন ( ) ফ্ল্যাশ করে অ্যারেটিকে তালিকায় ( )।aba^b[]a[],b[]

অ্যারের শুরু থেকে স্থানান্তরিত হওয়াকে ও (এন) বলা হয়, সবচেয়ে খারাপ ক্ষেত্রে দুটি উপাদানের তুলনা এবং একটি উপাদান প্রতি শিফট হয়, সুতরাং অ্যালগরিদম হল ও (এন)।

Answer 21

জাভাস্ক্রিপ্ট (ES5) 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) স্ট্রিং কাস্টে অ্যারে সরানো হয়েছে, কারণ এটি ও (এন) প্রয়োজনীয়তা ভঙ্গ করে ।

Answer 22

গণিত, 137 135

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
)

সম্ভবত আরও ভাল করতে পারে।

Comments

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

— আলেফাল্ফা

Answer 23

আর, 80

স্কেলা এবং অন্যান্য ভাষার মতো একই সমাধান। আমি x [-1] এর সম্পর্কে ও (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

Answer 24

গণিত, 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]] তার আউটপুট হ'ল Sowএন হয়েছে এমন উপাদানগুলির একটি তালিকা ।

আমি অভ্যন্তরীণ সম্পর্কে নিশ্চিত নই (কোনও তালিকার কোনও অংশে কোনও O(1)ক্রিয়াকলাপ অ্যাক্সেস করছে কিনা ) তবে সময়গুলি আমার মেশিনে ইনপুট তালিকার দৈর্ঘ্যের ক্ষেত্রে বেশ লিনিয়ার লাগছিল।