থ্যানোস বাছাই অ্যালগরিদম প্রয়োগ করুন

93

বাছাই করা অ্যালগরিদম এরকম হয়:

তালিকাটি বাছাই না করা অবস্থায়, সমস্ত আইটেমের অর্ধেক স্ন্যাপ করুন (সেগুলি তালিকা থেকে সরান)। তালিকাটি বাছাই না করা বা কেবলমাত্র একটি আইটেম অবধি অব্যাহত থাকে (যা ডিফল্টরূপে বাছাই করা হয়)। এই বাছাই করা অ্যালগরিদম বাস্তবায়নের ভিত্তিতে বিভিন্ন ফলাফল দিতে পারে।

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

ইনপুট তালিকায় একটি স্বতন্ত্র পরিমাণে আইটেম থাকতে পারে (কারণগুলির মধ্যে, 1000 টি আইটেম পর্যন্ত বলা যাক), কেবলমাত্র 2 ^ n আইটেমের পুরোপুরি বিভাজ্য তালিকা নয়। রানটাইমের সময় হার্ডকডযুক্ত বা এলোমেলোভাবে সিদ্ধান্ত নেওয়া হলে তালিকাটি বিজোড় হলে আপনাকে (এন + 1) / 2 বা (এন -1) / 2 আইটেমগুলি সরিয়ে ফেলতে হবে। নিজেরাই সিদ্ধান্ত নিন: মহাবিশ্বে যদি এক অদ্ভুত পরিমাণে জীবন্ত জিনিস থাকে তবে থানস কী করবে?

কোনও আইটেম পূর্ববর্তী আইটেমের চেয়ে ছোট না হলে তালিকাটি বাছাই করা হয়। সদৃশগুলি ইনপুটটিতে ঘটতে পারে এবং আউটপুটে ঘটতে পারে।

আপনার প্রোগ্রামটি পূর্ণসংখ্যার অ্যারে নেওয়া উচিত (স্টিডিনের মাধ্যমে বা প্যারামিটার হিসাবে, পৃথক আইটেম বা অ্যারে প্যারামিটার হিসাবে), এবং সাজানো অ্যারেটি ফিরিয়ে (অথবা এটি স্টাডআউট প্রিন্ট করুন)।

উদাহরণ:

// A sorted list remains sorted
[1, 2, 3, 4, 5] -> [1, 2, 3, 4, 5]

// A list with duplicates may keep duplicates in the result
[1, 2, 3, 4, 3] -> [1, 3, 3] // Removing every second item
[1, 2, 3, 4, 3] -> [3, 4, 3] -> [4, 3] -> [3] // Removing the first half
[1, 2, 3, 4, 3] -> [1, 2] // Removing the last half

[1, 2, 4, 3, 5] বিভিন্ন ফলাফল দিতে পারে:

// Removing every second item:
[1, 2, 4, 3, 5] -> [1, 4, 5]

বা:

// Removing the first half of the list
[1, 2, 4, 3, 5] -> [3, 5] // With (n+1)/2 items removed
[1, 2, 4, 3, 5] -> [4, 3, 5] -> [3, 5] // With (n-1)/2 items removed

বা:

// Removing the last half of the list
[1, 2, 4, 3, 5] -> [1, 2] // With (n+1)/2 items removed
[1, 2, 4, 3, 5] -> [1, 2, 4] // With (n-1)/2 items removed

বা:

// Taking random items away until half (in this case (n-1)/2) of the items remain
[1, 2, 4, 3, 5] -> [1, 4, 3] -> [4, 3] -> [4]
code-golf  sorting 
— vrwim
সূত্র
একটি পরীক্ষার কেস যা আসলে একাধিক বিভিন্ন স্ন্যাপিং অ্যালগরিদমের জন্য একাধিক স্ন্যাপগুলির প্রয়োজন তা খুব সহায়ক হবে।
— সম্পর্কহীন স্ট্রিং ২
22
আমাদের উত্তরগুলির অর্ধেক বাছাই এবং মুছে
— ফেলার দরকার নেই
4
প্রস্তাবিত পরীক্ষা মামলা: [9, 1, 1, 1, 1]। আমার নিজস্ব অ্যালগরিদম এই ইনপুটটিতে ব্যর্থ হয়েছিল
— কনার ও'ব্রায়ান ২

উত্তর:

19

আর , 41 বাইট

x=scan();while(any(x-sort(x)))x=x[!0:1];x

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

— কিরিল এল।
সূত্র
3
is.unsortedবরং any(...)41 বাইট হবে।
— জিউসেপ্পে
এই বেস পদ্ধতিটি পুনরাবৃত্তির কাজ হিসাবে 44 বাইট, গল্ফযোগ্য হতে পারে: এটি অনলাইনে চেষ্টা করুন!
— ক্রিমিনালিভালগার
18

পাইথন 3 , 38 42 39 বাইট

q=lambda t:t>sorted(t)and q(t[::2])or t

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

-3 bytes @ জোকিং এবং @ কিউক্সপ্লাসনে ধন্যবাদ

— সারা জে
সূত্র
2
— জো কিং
39 বাইটস টিফেল্ডের পর্যবেক্ষণকে ধন্যবাদ যে কোনও ক্রম ছাড়তে!= sorted(t) হবে > sorted(t)।
— কুক্সপ্লসোন
12

ব্র্যাচল্যাগ (ভি 2), 6 বাইট

≤₁|ḍt↰

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

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

ব্যাখ্যা

≤₁|ḍt↰
≤₁       Assert that {the input} is sorted {and output it}
  |      Handler for exceptions (e.g. assertion failures):
   ḍ     Split the list into two halves (as evenly as possible)
    t    Take the last (i.e. second) half
     ↰   Recurse {and output the result of the recursion}

বোনাস রাউন্ড

≤₁|⊇ᵇlᵍḍhtṛ↰

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

স্ন্যাপের অর্থ এলোমেলো, তাই না? এখানে প্রোগ্রামটির একটি সংস্করণ যা বেঁচে থাকা উপাদানগুলি এলোমেলোভাবে বেছে নিয়েছে (প্রতিটি রাউন্ডে অর্ধেক বেঁচে থাকার বিষয়টি নিশ্চিত করে)।

≤₁|⊇ᵇlᵍḍhtṛ↰
≤₁            Assert that {the input} is sorted {and output it}
  |           Handler for exceptions (e.g. assertion failures):
   ⊇ᵇ         Find all subsets of the input (preserving order)
     lᵍ       Group them by length
       ḍht    Find the group with median length:
         t      last element of
        h       first
       ḍ        half (split so that the first half is larger)
          ṛ   Pick a random subset from that group
           ↰  Recurse

এই বরং খাটো যদি আমরা উপাদান পুনর্বিন্যাস পারে হতে পারে, কিন্তু whyever একটি বাছাই আলগোরিদিম কাজ করতে চান যে ?

— ais523
সূত্র
12
অনন্ত পাথর প্রতি এক বাইট।
— djechlin
@ ডিজজেচলিন ইনফিনিটি বাইট হ'ল আপনার মাথা এবং বিশেষত চোয়ালের জন্য অবশ্যই যেতে হবে।
— গ্রেট হাঁস
10

পার্ল 6 , 30 বাইট

$!={[<=]($_)??$_!!.[^*/2].&$!}

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

রিকার্সিভ ফাংশন যা তালিকাটি বাছাই না করা পর্যন্ত তালিকার দ্বিতীয়ার্ধকে সরিয়ে দেয়।

ব্যাখ্যা:

$!={                         }    # Assign the function to $!
    [<=]($_)??                    # If the input is sorted
              $_                  # Return the input
                !!                # Else
                  .[^*/2]         # Take the first half of the list (rounding up)
                         .&$!     # And apply the function again
— জো কিং
সূত্র
8

জাভা 10, 106 97 বাইট

L->{for(;;L=L.subList(0,L.size()/2)){int p=1<<31,f=1;for(int i:L)f=p>(p=i)?0:f;if(f>0)return L;}}

-9 বাইটস @ অলিভিগ্রগ্রোয়ারকে ধন্যবাদ ।

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

প্রতিটি পুনরাবৃত্তির জন্য তালিকার প্রথম ভাগটি কেবল রেখে দিন, এবং n + 1 মুছে ফেলেn+12তালিকা-আকারটি বিজোড় হলে 2 টি আইটেম।

ব্যাখ্যা:

L->{               // Method with Integer-list as both parameter and return-type
  for(;;           //  Loop indefinitely:
      L=L.subList(0,L.size()/2)){
                   //    After every iteration: only leave halve the numbers in the list
    int p=1<<31,   //   Previous integer, starting at -2147483648
        f=1;       //   Flag-integer, starting at 1
    for(int i:L)   //   Inner loop over the integer in the list:
      f=p>(p=i)?   //    If `a>b` in a pair of integers `a,b`:
         0         //     Set the flag to 0
        :          //    Else (`a<=b`):
         f;        //     Leave the flag the same
    if(f>0)        //   If the flag is still 1 after the loop:
      return L;}}  //    Return the list as result
— কেভিন ক্রুইজসেন
সূত্র
n->{for(;n.reduce((1<<31)+0d,(a,b)->a==.5|b<a?.5:b)==.5;n=n.skip(n.count()/2));return n;} স্ট্রিমগুলি ব্যবহার করে সংক্ষিপ্ত করা হয়, তবে কীভাবে java.lang.IllegalStateException: stream has already been operated upon or closedপ্রবাহটি ফিরে আসার পরে ত্রুটিটি এড়ানো যায় তা আমি বুঝতে সক্ষম হয়ে উঠতে পারি না
— অজ্ঞতার প্রতিমূর্তি ২
অ্যাম্বোডিমেন্টফ অজানা এটি ঘটায় কারণ reduceএটি একটি টার্মিনাল অপারেশন যা প্রবাহ বন্ধ করে। আপনি কখনও reduceএকই স্ট্রিমে দু'বার কল করতে পারবেন না । তবে আপনি একটি নতুন স্ট্রিম তৈরি করতে পারেন।
— অলিভিয়ের গ্রাগোয়ার
1
— অলিভিয়ার গ্রাগোয়ার
@ অলিভিগ্রগ্রোয়েয়ার এই আদেশটি এখন দেখতে দেখতে এত সহজ দেখাচ্ছে .. কখনও কখনও এটি অন্য কোনও কোণ থেকে একবার দেখে নেওয়া হয় তবে অন্যরা শুরুতে আমার অনুমান অনুভব করতে পারে না। :) ধন্যবাদ!
— কেভিন ক্রুইজসেন
1
কোনও উদ্বেগ নেই, এটি স্পষ্ট ছিল না: আমি সেখানে পৌঁছানোর জন্য কাজ করেছি। এটির সন্ধান করার আগে আমি কমপক্ষে 10 টি সংস্করণ পরীক্ষা করেছি;)
— অলিভিয়ের গ্রাগোয়ার
8

ওল্ফ্রাম ভাষা (ম্যাথমেটিকা) , 30 বাইট

#//.x_/;Sort@x!=x:>x[[;;;;2]]&

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

@ ডুরকনব 12 টি বাইট সংরক্ষণ করেছে

— J42161217
সূত্র
1
প্রথমার্ধটি গ্রহণের পরিবর্তে, আপনি প্রতিটি অন্যান্য উপাদান ( x[[;;;;2]]) নিয়ে কিছু বাইট সংরক্ষণ করতে পারেন ।
— Doorknob
@ ডুরকনব অবশ্যই হ্যাঁ ...
— J42161217
ভেবেছি ব্যবহার করে কিছু সঞ্চয় হতে পারে OrderedQতবে তা কাজ করতে পারেনি
— গ্রেগ মার্টিন
@ গ্রেগমার্টিন আমি OrderedQআমার প্রথম পদ্ধতির ব্যবহার করেছি (সম্পাদনাগুলি দেখুন)
— জে 212161217
6

05 এ বি 1 ই , 8 7 বাইট

[Ð{Q#ιн

-1 বাইট @ এমিগানাকে ধন্যবাদ ।

এন-12তালিকা-আকারটি বিজোড় হলে আইটেম।

এটি অনলাইনে চেষ্টা করুন বা আরও কিছু পরীক্ষার কেস যাচাই করুন যাচাই করুন (বা প্রতিটি পুনরাবৃত্তির জন্য ধাপে ধাপে সেই পরীক্ষার কেসগুলি যাচাই করুন )।

@ গ্রিমির দ্বারা 7 বাইট বিকল্প :

ΔÐ{Ê>äн

এন2এন-12তালিকা-আকারটি বিজোড় হলে আইটেম) প্রতিটি পুনরাবৃত্তি।

এটি অনলাইনে চেষ্টা করুন বা আরও কিছু পরীক্ষার কেস যাচাই করুন যাচাই করুন (বা প্রতিটি পুনরাবৃত্তির জন্য ধাপে ধাপে সেই পরীক্ষার কেসগুলি যাচাই করুন )।

ব্যাখ্যা:

[        # Start an infinite loop:
 Ð       #  Triplicate the list (which is the implicit input-list in the first iteration)
  {Q     #  Sort a copy, and check if they are equal
    #    #   If it is: Stop the infinite loop (and output the result implicitly)
  ι      #  Uninterweave: halve the list into two parts; first containing all even-indexed
         #  items, second containing all odd-indexed items (0-indexed)
         #   i.e. [4,5,2,8,1] → [[4,2,1],[5,8]]
   н     #  And only leave the first part

Δ        # Loop until the result no longer changes:
 Ð       #  Triplicate the list (which is the implicit input-list in the first iteration)
  {Ê     #  Sort a copy, and check if they are NOT equal (1 if truthy; 0 if falsey)
    >    #  Increase this by 1 (so 1 if the list is sorted; 2 if it isn't sorted)
     ä   #  Split the list in that many parts
      н  #  And only leave the first part
         # (and output the result implicitly after it no longer changes)
— কেভিন ক্রুইজসেন
সূত্র
3
আপনি ব্যবহার করতে পারেন ιপরিবর্তে 2äআপনি একটি স্যুইচ রাখা প্রত্যেক অন্যান্য উপাদান কৌশল।
— এমিগানা
1
"শেষের অর্ধেকটি সরান" কৌশলটি ব্যবহার করে বিকল্প 7:ΔÐ{Ê>äн
— গ্রিমি
@ গ্রিমি এটিও বেশ সুন্দর পদ্ধতি। আমি কি এটি আমার পোস্টে যুক্ত করব (অবশ্যই আপনাকে জমা দিয়ে দিচ্ছি), না আপনি আলাদা পোস্ট হিসাবে পোস্ট করতে চান?
— কেভিন ক্রুইজসেন
এটি যোগ করতে নির্দ্বিধায়।
— গ্রিমি
6

টিআই-বেসিক (টিআই -84), 47 42 45 44 বাইট

-১ বাইট @ সলোমনউকোকে ধন্যবাদ!

Ans→L1:Ans→L2:SortA(L1:While max(L1≠Ans:iPart(.5dim(Ans→dim(L2:L2→L1:SortA(L1:End:Ans

ইনপুট তালিকা রয়েছে Ans।
আউটপুটটি রয়েছে Ansএবং স্পষ্টভাবে মুদ্রিত হয়েছে।

ব্যাখ্যা:

Ans→L1                  ;store the input into two lists
Ans→L2
SortA(L1                ;sort the first list
                        ; two lists are needed because "SortA(" edits the list it sorts
While max(L1≠Ans        ;loop until both lists are strictly equal
iPart(.5dim(Ans→dim(L2  ;remove the latter half of the second list
                        ; removes (n+1)/2 elements if list has an odd length
L2→L1                   ;store the new list into the first list (updates "Ans")
SortA(L1                ;sort the first list
End
Ans                     ;implicitly output the list when the loop ends

দ্রষ্টব্য: টিআই-বেসিক একটি টোকেনাইজড ভাষা। অক্ষর গণনা বাইট গণনা সমান হয় না ।

— টাও
সূত্র
আমার মনে হয় আপনি প্রতিস্থাপন করতে পারেন not(min(L1=Ansসঙ্গে max(L1≠Ansএকটি বাইট সংরক্ষণ করুন।
— সলোমন উকো
3

হাস্কেল , 57 55 বাইট (কেবলমাত্র ASCII- এর জন্য ধন্যবাদ)

f x|or$zipWith(>)x$tail x=f$take(div(length x)2)x|1>0=x

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

আসল কোড:

f x|or$zipWith(>)x(tail x)=f(take(div(length x)2)x)|1>0=x

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

Ungolfed:

f xs | sorted xs = f (halve xs)
     | otherwise = xs

sorted xs = or (zipWith (>) xs (tail xs))

halve xs = take (length xs `div` 2) xs
— Sachera
সূত্র
1
পিপিসিজিতে আপনাকে স্বাগতম!
— Rɪᴋᴇʀ
56
— এএসসিআইআই-কেবল
— ASCII- কেবল
55
— ASCII- কেবলমাত্র
3

অক্টাভা , 49 বাইট

l=input('');while(~issorted(l))l=l(1:2:end);end;l

এটি অনলাইন চেষ্টা করুন!এটি এমন একটি যাত্রা ছিল যেখানে আরও বোরিং আরও ভাল। নীচে দুটি আরও আকর্ষণীয় এন্ট্রি নোট করুন:

50 বাইট

function l=q(l)if(~issorted(l))l=q(l(1:2:end));end

এটি অনলাইন চেষ্টা করুন!উদ্বেগজনক অত্যাবশ্যক সমাধানের পরিবর্তে, আমরা কেবল একটি অতিরিক্ত বাইটের জন্য একটি পুনরাবৃত্ত সমাধান করতে পারি।

53 বাইট

f(f=@(g)@(l){l,@()g(g)(l(1:2:end))}{2-issorted(l)}())

এটি অনলাইন চেষ্টা করুন! হাঁ। একটি পুনরাবৃত্তিমূলক অজ্ঞাতনামা ফাংশন, আমার টিপস প্রশ্নে @ সিলিংক্যাটের উজ্জ্বল উত্তরের জন্য ধন্যবাদ । একটি বেনাম ফাংশন যা তার যুক্তি তালিকায় নিজেকে সংজ্ঞায়িত করে পুনরাবৃত্তকারী বেনামে ফাংশন দেয়। আমি বেনামে ফাংশন পছন্দ করি। হুমম।

— Sanchises
সূত্র
2

এমএটিএল , 11 বাইট

tv`1L)ttS-a

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

এটি প্রতিটি দ্বিতীয় আইটেম সরিয়ে কাজ করে।

ব্যাখ্যা

t      % Take a row vector as input (implicit). Duplicate
v      % Vertically concatenate the two copies of the row vector. When read with
       % linear indexing (down, then across), this effectively repeats each entry
`      % Do...while
  1L)  %   Keep only odd-indexed entries (1-based, linear indexing)
  t    %   Duplicate. This will leave a copy for the next iteration
  tS   %   Duplicate, sort
  -a   %   True if the two arrays differ in any entry
       % End (implicit). A new iteration starts if the top of the stack is true
       % Display (implicit). Prints the array that is left on the stack
— লুইস মেন্ডো
সূত্র
2
প্রাথমিকভাবে সাজানো তালিকার জন্য ভাঙা: [1, 2, 3, 4, 5] থাকা উচিত [1, 2, 3, 4, 5]
— ফ্যালকো
@ ফ্যালকো ধন্যবাদ! এখনই সংশোধন করা হয়েছে
— লুইস মেন্ডো
2

জাভা (জেডিকে) , 102 বাইট

n->{for(;n.stream().reduce((1<<31)+0d,(a,b)->a==.5|b<a?.5:b)==.5;n=n.subList(0,n.size()/2));return n;}

ইতিমধ্যে একটি সি # উত্তর রয়েছে, তাই আমি জাভা উত্তরের জন্য আমার হাত চেষ্টা করার সিদ্ধান্ত নিয়েছি।

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

— অজ্ঞতার প্রতিমূর্তি
সূত্র
এফ # :) চেষ্টা করার সময়
— a এলোডডিগ
2

হুশ , 6 5 বাইট

জগারবকে 1 বাইট সংরক্ষণ করা হয়েছে

ΩΛ<Ċ2

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

ব্যাখ্যা

ΩΛ<Ċ2
Ω         Repeat until
 Λ<         all adjacent pairs are sorted (which means the list is sorted)
   Ċ2         drop every second element from the list
— সিংহরাশি
সূত্র
এই 11 বাইট, নয় 6.> প্রতিধ্বনি -n "ΩΛ <(← গণমাধ্যমে" | wc---bytes 11
— মাইক Holler
— Xan
@ মাইকহোলার অন্যান্য গল্ফিংয়ের মতো আরও অনেকগুলি চরিত্রের অ্যাক্সেস পেতে হুস একটি কাস্টম কোড পৃষ্ঠা ব্যবহার করে: github.com/barbuz/Husk/wiki/Codepage
— লিও ২
আপনাকে ধন্যবাদ, আমি আজ কিছু শিখেছি :)
— মাইক হোলার
1
বাইট সংরক্ষণ করার Ċ2পরিবর্তে ব্যবহার করুন (←½।
— Zgarb
2

জুলিয়া 1.0 , 30 বাইট

-x=x>sort(x) ? -x[1:2:end] : x

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

বাছাই না করা থাকলে অ্যারের প্রতিটি দ্বিতীয় উপাদান নেয়।

— niczky12
সূত্র
-20 বাইটের মতো একটি এএসসিআইআই অপারেটর ব্যবহার করুন । এছাড়াও আমরা প্রায় সবসময় চরিত্র গণনা করি না: | সুতরাং এটি ভালো লাগবে যদি এটিকে শিরোলেখ থেকে সরিয়ে দেওয়া হয়
— ASCII- কেবল
পরিবর্তন হয়েছে। 2 বাইট জন্য ধন্যবাদ!
— নিকজকি 12
2

সি ++ (জিসিসি) , 103 বাইট

আমি মন্তব্য করতে পারি না, তবে আমি মুভ্যাটিকা থেকে সংস্করণগুলি হ্রাস করে এবং অটো ব্যবহার করে উন্নত করেছি।

-২ বাইট: সিলিংক্যাট
-2 বাইট: কেবলমাত্র এসসিআইআই

#include<regex>
auto f(auto l){while(!std::is_sorted(l.begin(),l.end()))l.resize(l.size()/2);return l;}

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

— peterzuger
সূত্র
1
কোন কারণে আপনি শুধু ব্যবহার করতে পারবেন না l.size()/2?
— এএসসিআইআই-কেবল
হ্যাঁ, এটি সেভাবে কাজ করে না :)
— পিটারজুগার
1
আপনি কি বোঝাতে চেয়েছেন? আকারের একটি তালিকা ফেরত দেওয়া (n+1)/2বা (n-1)/2উভয়ই বৈধ। হুম ....
— ASCII-
ওহহ
— উফস
1

ভিডিএম-এসএল , 99 বাইট

f(i)==if forall x in set inds i&x=1or i(x-1)<=i(x) then i else f([i(y)|y in set inds i&y mod 2=0])

এর আগে কখনও ভিডিএম-তে জমা দেওয়া হয়নি, সুতরাং ভাষা নির্দিষ্ট নিয়মে নির্দিষ্ট নয়। সুতরাং আমি একটি ফাংশন সংজ্ঞা হিসাবে জমা দিয়েছি যা গ্রহণ করে seq of intএবং একটি প্রদান করেseq of int

চালানোর জন্য একটি সম্পূর্ণ প্রোগ্রামটি দেখতে এরকম হতে পারে: 

functions
f:seq of int +>seq of int
f(i)==if forall x in set inds i&x=1or i(x-1)<=i(x) then i else f([i(y)|y in set inds i&y mod 2=0])
— মেয়াদোত্তীর্ণ ডেটা
সূত্র
1

পাইথ, 10 বাইট

.W!SIHhc2Z

এটি এখানে অনলাইনে চেষ্টা করুন । এটি প্রতিটি পুনরাবৃত্তির দ্বিতীয়ার্ধকে গোল করে নিচে সরিয়ে দেয়। এটি পরিবর্তন করতে প্রথমার্ধে মুছে ফেলার জন্য, আপ rounding পরিবর্তন hকরতে e।

.W!SIHhc2ZQ   Q=eval(input())
              Trailing Q inferred
  !SIH        Condition function - input variable is H
   SIH          Is H invariant under sorting?
  !             Logical not
      hc2Z    Iteration function - input variable is Z
       c2Z      Split Z into 2 halves, breaking ties to the left
      h         Take the first half
.W        Q   With initial value Q, execute iteration function while condition function is true
— সোক
সূত্র
তালিকার প্রতিটি অন্যান্য উপাদান নেওয়া সংক্ষিপ্ত। hcসঙ্গে প্রতিস্থাপন %। এটি আপনাকে পিছনের ল্যাম্বদা ভেরিয়েবল মুছতে দেয় Zএবং পাইথ এটি মোটামুটি 2 বাইট সংরক্ষণের জন্য স্পষ্টভাবে পূরণ করতে দেয়।
— hakr14
1

সি ++ (জিসিসি) , 139 137 116 বাইট

সিলিংক্যাট থেকে টেক্স -২ বাইট, পিটারজুগার থেকে -২১ বাইট থেক্স

#include<regex>
auto f(std::vector<int>l){while(!std::is_sorted(l.begin(),l.end()))l.resize(-~l.size()/2);return l;}

এটির বাছাই না হওয়া অবধি ভেক্টরটিকে এর প্রথমার্ধে পুনরায় আকার দিন।

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

— movatica
সূত্র
1
আমদানি বাইট গণনা অন্তর্ভুক্ত করা rquired হয়, তাই আপনি যোগ আছে includeগুলি
— অজ্ঞতা প্রতিমূর্তি
থ্যাঙ্কস, আমি তাদের যুক্ত করব।
— মুভিটিকা
1

কে (ওকে) , 22 20 বাইট

সমাধান:

{(*2 0N#x;x)x~x@<x}/

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

এটি বাছাই করা না হওয়া পর্যন্ত ইনপুটটি নিয়ে ইট্রেটারেট করুন ... যদি এটি সাজানো না হয় তবে প্রথম এন / 2 আইটেম নিন।

{(*2 0N#x;x)x~x@<x}/ / the solution
{                 }/ / lambda that iterates
                <x   / indices that sort x ascending (<)
              x@     / apply (@) these indices back to x
            x~       / matches (~) x? returns 0 or 1
 (       ; )         / 2-item list which we index into
          x          / original input (ie if list was sorted)
       #x            / reshape (#) x
   2 0N              / as 2 rows
  *                  / take the first one

সম্পাদনা:

  • -2 বাইট ধন্যবাদ এনএনজি থেকে
— streetster
সূত্র
1
(.5*#x)#x->*2 0N#x
— এনজিএন
আমি করাকে বিবেচনা করেছি 2 0Nতবে ধরে নিয়েছি এটি আরও দীর্ঘ হবে (পরীক্ষা ছাড়াই), ধন্যবাদ!
— স্ট্রিস্টার
0

রেটিনা , 38 বাইট

\d+
*
/(_+),(?!\1)/+`,_+(,?)
$1
_+
$.&

এটি অনলাইন চেষ্টা করুন! কমা-বিচ্ছিন্ন সংখ্যা নেয়। ব্যাখ্যা:

\d+
*

অ্যানারিতে রূপান্তর করুন।

/(_+),(?!\1)/+`

তালিকাটি সাজানো না থাকলে পুনরাবৃত্তি করুন ...

,_+(,?)
$1

... প্রতিটি এমনকি উপাদান মুছুন।

_+
$.&

দশমিক রূপান্তর।

— নীল
সূত্র
0

সি (জিসিসি) , 66 বাইট

প্রতিটি পুনরাবৃত্তির তালিকার দ্বিতীয়ার্ধে স্ন্যাপ করে ( n/2+1দৈর্ঘ্যটি বিজোড় হলে উপাদানগুলি)।

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

intএর দৈর্ঘ্য অনুসারে একটি অ্যারের শুরুতে পয়েন্টার হিসাবে ইনপুট নেয় । অ্যারের নতুন দৈর্ঘ্য (স্থানে সাজানো) ফিরিয়ে আউটপুট।

t(a,n,i)int*a;{l:for(i=0;i<n-1;)if(a[i]>a[++i]){n/=2;goto l;}a=n;}

অবরুদ্ধ সংস্করণ:

t(a, n, i) int *a; { // take input as a pointer to an array of int, followed by its length; declare a loop variable i
  l: // jump label, will be goto'ed after each snap
  for(i = 0; i < n - 1; ) { // go through the whole array …
    if(a[i] > a[++i]) { // … if two elements are in the wrong order …
      n /= 2; // … snap off the second half …
      goto l; // … and start over
    }
  }
  a = n; // implicitly return the new length
}
— OOBalance
সূত্র
সুপারিশ ~i+nপরিবর্তেi<n-1
— ceilingcat
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.