একটি তালিকা আন-মার্জ করুন

Question

ভূমিকা

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

function merge(A, B):
  C = []
  while A is not empty or B is not empty:
    if A is empty:
      C.append(B.pop())
    else if B is empty or A[0] ≤ B[0]:
      C.append(A.pop())
    else:
      C.append(B.pop())
  return C

ধারণা প্রথম উপাদানের ছোট পপিং রাখা Aএবং Bযতক্ষণ না উভয় তালিকা খালি রয়েছে, এবং মধ্যে ফলাফল সংগ্রহ C। যদি Aএবং Bউভয়ই বাছাই করা হয়, তবে তাই C।

বিপরীতভাবে, যদি Cএকটি সাজানো তালিকা, এবং আমরা কোনো দুই subsequences সেটিকে বিভক্ত Aএবং Bতারপর, Aএবং Bএছাড়াও সাজানো হয় এবং merge(A, B) == C। মজার বিষয় হল, Cবাছাই না করা হলে এটি অগত্যা ধরে রাখে না, যা আমাদের এই চ্যালেঞ্জের কাছে নিয়ে আসে।

ইনপুট

আপনার ইনপুটটি কয়েকটি হিসাবে প্রথম 2*nননজিটিভেটিভ পূর্ণসংখ্যার ক্রমবিন্যাস, তালিকা হিসাবে দেওয়া হয়েছে ।[0, 1, 2, ..., 2*n-1]n > 0C

আউটপুট

আপনার আউটপুট একটি truthy মান যদি দুটি তালিকা অস্তিত্ব থাকবে Aএবং Bদৈর্ঘ্য nযেমন যে C == merge(A, B), এবং একটি falsy মান অন্যথায়। যেহেতু ইনপুটটিতে কোনও ডুপ্লিকেট নেই, আপনাকে কীভাবে mergeফাংশনে বন্ধনগুলি ভাঙা হবে সে সম্পর্কে আপনাকে চিন্তা করতে হবে না ।

বিধি ও বোনাস

আপনি কোনও ফাংশন বা একটি সম্পূর্ণ প্রোগ্রাম লিখতে পারেন। সর্বনিম্ন বাইট গণনা জয়, এবং মান লুফোলগুলি অনুমোদিত নয়।

নোট করুন যে আপনাকে তালিকাটি Aএবং B"হ্যাঁ" উদাহরণগুলিতে গণনা করার দরকার নেই । তবে, যদি আপনি তালিকাগুলি বাস্তবে আউটপুট করেন তবে আপনি -20% এর বোনাস পাবেন । এই বোনাসটি দাবি করতে, আপনাকে অবশ্যই কেবলমাত্র এক জোড়া তালিকা আউটপুট করতে হবে, সমস্ত সম্ভাবনা নয়। দৃ bon়ভাবে টাইপ করা ভাষায় এই বোনাসটিকে দাবি করা সহজ করার জন্য, "না" উদাহরণগুলিতে খালি তালিকার একজোড়া আউটপুট দেওয়ার অনুমতি রয়েছে।

ব্রুট জোর করা নিষিদ্ধ নয়, তবে সর্বশেষ চারটি পরীক্ষার কেসকে 1 সেকেন্ডের কমের মধ্যে গণনা করার জন্য -10% বোনাস রয়েছে ।

পরীক্ষার কেস

"হ্যাঁ" দৃষ্টান্তগুলিতে কেবলমাত্র একটি সম্ভাব্য আউটপুট দেওয়া হয়।

[1,0] -> False
[0,1] -> [0] [1]
[3,2,1,0] -> False
[0,3,2,1] -> False
[0,1,2,3] -> [0,1] [2,3]
[1,4,0,3,2,5] -> False
[4,2,0,5,1,3] -> [4,2,0] [5,1,3]
[3,4,1,2,5,0] -> [4,1,2] [3,5,0]
[6,2,9,3,0,7,5,1,8,4] -> False
[5,7,2,9,6,8,3,4,1,0] -> False
[5,6,0,7,8,1,3,9,2,4] -> [6,0,8,1,3] [5,7,9,2,4]
[5,3,7,0,2,9,1,6,4,8] -> [5,3,7,0,2] [9,1,6,4,8]
[0,6,4,8,7,5,2,3,9,1] -> [8,7,5,2,3] [0,6,4,9,1]
[9,6,10,15,12,13,1,3,8,19,0,16,5,7,17,2,4,11,18,14] -> False
[14,8,12,0,5,4,16,9,17,7,11,1,2,10,18,19,13,15,6,3] -> False
[4,11,5,6,9,14,17,1,3,15,10,12,7,8,0,18,19,2,13,16] -> [4,17,1,3,15,10,12,7,8,0] [11,5,6,9,14,18,19,2,13,16]
[9,4,2,14,7,13,1,16,12,11,3,8,6,15,17,19,0,10,18,5] -> [9,4,2,16,12,11,3,8,6,15] [14,7,13,1,17,19,0,10,18,5]

Answer 1

পাইথ, 39 * 0.9 * 0.8 = 28.08

#aY->QxQeS-QsY&YsY)KfqylTlQmsdty_Y%tlKK

এই প্রোগ্রামটি সমস্ত দুটি বোনাস ক্ল্যাম করে। এটি একজোড়া তালিকাগুলি মুদ্রণ করে, যদি আন-মার্জ করা সম্ভব হয়, অন্যথায় একটি খালি তালিকা, যা পাইথ (এবং পাইথন) এর মিথ্যা মান।

Input:  [5,3,7,0,2,9,1,6,4,8]
Output: ([9, 1, 6, 4, 8], [5, 3, 7, 0, 2])
Input:  [5,7,2,9,6,8,3,4,1,0]
Output: [] (falsy value)

আপনি এটি পরীক্ষা করতে পারেন অনলাইনে তবে এটি অফলাইন সংস্করণ থেকে কিছুটা ধীর হতে পারে। অফলাইন সংস্করণ আমার ল্যাপটপে <0.15 সেকেন্ডের মধ্যে প্রতিটি পরীক্ষার কেস সমাধান করে।

সম্ভবত (এর মধ্যে একটি) প্রথমবারে, একটি পাইথ সলিউশন সক্রিয়ভাবে ব্যতিক্রমগুলি ব্যবহার করে (এটি কমপক্ষে 1 টি সংরক্ষণ করেছে)। এটি পিটার টেলরের সমাধান হিসাবে একই ধারণা ব্যবহার করে।

                         preinitialisations: Q = input(), Y = []
#                 )     while 1: (infinite loop)
        eS-QsY             finds the biggest, not previous used, number
      xQ                   finds the index
    >Q                     all elements from ... to end
   -          &YsY         but remove all used elements
 aY                        append the resulting list to Y

When all numbers are used, finding the biggest number fails, 
throws an exception and the while loop ends.  
This converts [5,3,7,0,2,9,1,6,4,8] to [[9, 1, 6, 4, 8], [7, 0, 2], [5, 3]]

        msdty_Y  combine the lists each for every possible subset of Y (except the empty subset)
 fqylTlQ         and filter them for lists T with 2*len(T) == len(Q)
K                and store them in K

%tlKK        print K[::len(K)-1] (prints first and last if K, else empty list)

পাইথ, 30 * 0.9 = 27.0

ফলস্বরূপ তালিকাগুলি মুদ্রণ না করেই আমি সত্যিই এটি সমাধান করার চেষ্টা করি নি। তবে উপরের কোডের উপর ভিত্তি করে এখানে একটি দ্রুত সমাধান দেওয়া হয়েছে।

#aY->QxQeS-QsY&YsY)fqylsTlQtyY

আমি মূলত মুদ্রণ বিবৃতি সরিয়েছি। আউটপুট যদিও বেশ কুরুচিপূর্ণ।

Input:  [0,1,2,3]
Output: [[[3], [2]], [[3], [1]], [[2], [1]], [[3], [0]], [[2], [0]], [[1], [0]]] (truthy value)
Input:  [5,7,2,9,6,8,3,4,1,0]
Output: [] (falsy value)

এটি অনলাইনে চেষ্টা করুন ।

Comments

আপনি মুদ্রণ (K[0], Q-K[0])করতে চেয়ে মুদ্রণের চেয়ে এটি পেতে পারেন (K[0], K[-1])। যদিও এটি কোনও সঞ্চয় দেয় কিনা তা আমি জানি না।

— পিটার টেলর

@ পিটারটেলর ধন্যবাদ, 2 টি অক্ষর সংরক্ষণ করেছেন।

— জাকুবে

@ পিটারটেলর এবং আরও 2 টি চর, যদি আমি মুদ্রণ করি K[::len(K)-1]।

— জাকুবে

Answer 2

গল্ফস্ক্রিপ্ট (35 * 0.9 = 31.5)

{.$-1>/~,)\.}do;]1,\{{1$+}+%}/)2/&,

অনলাইন ডেমো বেশ ধীর হল: আমার কম্পিউটারে, এটা 0.04 অধীনে সেকেন্ডের মধ্যে পরীক্ষার সব রান, তাই আমি 10% হ্রাস দাবি করুন।

ব্যাখ্যা

সি বৃহত্তম সংখ্যার সাথে শুরু সি এর প্রত্যয় একই তালিকা থেকে আসতে হবে। তারপরে এই যুক্তিটি (সি - প্রত্যয়) এ প্রয়োগ করা যেতে পারে, যাতে সমস্যাটি সাবসেটের পরিমাণ কমে যায়।

Answer 3

এপিএল, 62 50 44 * 90% = 39.6

{(l÷2)⌷↑(⊢∨⌽)/(2-/(1,⍨⍵≥⌈\⍵)/⍳l+1),⊂l=⍳l←⍴⍵}

এখানে চেষ্টা করুন।