थानोस छँटाई एल्गोरिथ्म को लागू करें

93

छँटाई एल्गोरिथ्म इस तरह है:

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

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

इनपुट सूची में एक अनियंत्रित राशि हो सकती है (कारण के भीतर, 1000 आइटम तक कह सकते हैं), न केवल 2 ^ n आइटम की पूरी तरह से विभाज्य सूची। यदि सूची विषम है, तो हार्डकोड या रनटाइम के दौरान रैंडम तरीके से निर्णय लेने पर आपको या तो हटाना होगा (n + 1) / 2 (n-1) / 2 आइटम। अपने लिए तय करें: यदि ब्रह्मांड में जीवित चीजों की विषम मात्रा है तो थानोस क्या करेगा?

यदि कोई आइटम किसी भी पिछले आइटम से छोटा है, तो सूची को क्रमबद्ध किया जाता है। इनपुट में डुप्लिकेट हो सकता है, और आउटपुट में हो सकता है।

आपके कार्यक्रम को पूर्णांक के एक सरणी में होना चाहिए (स्टड के माध्यम से या पैरामीटर के रूप में, या तो व्यक्तिगत आइटम या एक सरणी पैरामीटर), और सॉर्ट किए गए सरणी को वापस लौटाएं (या इसे stdout में प्रिंट करें)।

उदाहरण:

// 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 @JoKing और @Quuxplusone को धन्यवाद

— सारा जे
स्रोत
2
— जो किंग
39 बाइट्स ने TFeld के अवलोकन के लिए धन्यवाद दिया कि कोई भी क्रमपरिवर्तन != sorted(t)अवश्य होना चाहिए > sorted(t)।
— क्क्सप्लसोन
12

ब्रेकीलॉग (v2), 6 बाइट्स

≤₁|ḍt↰

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

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

व्याख्या

≤₁|ḍ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
@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 बाइट्स @ OlivierGrégoire को धन्यवाद ।

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

केवल हर पुनरावृत्ति सूची के पहले पड़ाव को छोड़ दें, और 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कि स्ट्रीम वापस करने के बाद त्रुटि से बचने के लिए
— अज्ञानता
@EmbodimentofIgnorance ऐसा इसलिए होता है क्योंकि reduceएक टर्मिनल ऑपरेशन है जो स्ट्रीम को बंद कर देता है। आप कभी भी reduceएक ही स्ट्रीम पर दो बार कॉल नहीं कर पाएंगे । आप एक नई स्ट्रीम बना सकते हैं, हालाँकि।
— ओलिवियर ग्रेजायर
1
— ओलिवियर ग्रेजायर
@ OlivierGrégoire यह आदेश अब इतना सरल लग रहा है कि मैं इसे देख रहा हूं .. कभी-कभी यह दूसरे कोण से एक नज़र लेता है ताकि स्पष्ट रूप से दूसरों को शुरू में याद आ सके। :) धन्यवाद!
— केविन क्रूज़सेन
1
कोई चिंता नहीं, यह स्पष्ट नहीं था: मैंने वहां पहुंचने के लिए काम किया। मैंने उस खोज से पहले कम से कम 10 संस्करणों का परीक्षण किया;)
— ओलिवियर ग्राएगोइरे
8

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 30 बाइट्स

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

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

@ डॉर्कनोब ने 12 बाइट्स बचाए

— J42161217
स्रोत
1
पहली छमाही लेने के बजाय, आप हर दूसरे तत्व ( x[[;;;;2]]) को ले कर कुछ बाइट्स बचा सकते थे ।
— दरवाज़े
@ डोरकोनब हाँ बिल्कुल ...
— J42161217
सोचा कि उपयोग करके कुछ बचत हो सकती है OrderedQ, लेकिन यह काम नहीं कर सका
— ग्रेग मार्टिन
@GregMartin मैंने OrderedQअपने पहले दृष्टिकोण में इस्तेमाल किया (संपादन देखें)
— J42161217
6

05AB1E , 8 7 बाइट्स

[Ð{Q#ιн

-1 बाइट @ @ मिग्ना के लिए धन्यवाद ।

हर पुनरावृत्ति को सभी विषम 0-अनुक्रमित वस्तुओं को हटाता है, इसलिए को हटाता हैn-12

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें (या प्रत्येक पुनरावृत्ति के लिए चरण-दर-चरण उन परीक्षण मामलों को सत्यापित करें )।

7 बाइट्स वैकल्पिक द्वारा @Grimy :

ΔÐ{Ê>äн

अंतिम हटाता हैn2n-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 "पिछली छमाही को हटा दें" रणनीति का उपयोग करते हुए:ΔÐ{Ê>äн
— ग्रैमी
@Grimy यह एक बहुत अच्छा तरीका है। क्या मैं इसे अपनी पोस्ट में शामिल करूंगा (आपको निश्चित रूप से श्रेय), या क्या आप इसे एक अलग उत्तर के रूप में पोस्ट करना चाहते हैं?
— केविन क्रूज़सेन
इसे जोड़ने के लिए स्वतंत्र महसूस करें।
— ग्रिम
6

TI-BASIC (TI-84), 47 42 45 44 बाइट्स

-1 बाइट धन्यवाद @SolomonUcko को!

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

नोट: TI-BASIC एक टोकन भाषा है। कैरेक्टर काउंट बाइट काउंट नहीं के बराबर होता है ।

— ताउ
स्रोत
मुझे लगता है कि आप की जगह ले सकता 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
PPCG में आपका स्वागत है!
— आर
56
— एएससीआईआई-केवल
— ASCII- केवल
55
— एएससीआईआई-केवल
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)}())

इसे ऑनलाइन आज़माएं! हां। एक पुनरावर्ती अनाम फ़ंक्शन, मेरे सुझावों के सवाल पर @ छत के शानदार जवाब के लिए धन्यवाद । एक अनाम फ़ंक्शन जो अपनी तर्क सूची में स्वयं को परिभाषित करके एक पुनरावर्ती अनाम फ़ंक्शन देता है। मुझे अनाम फ़ंक्शंस पसंद हैं। Mmmmm।

— Sanchises
स्रोत
2

MATL , 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]
— फाल्को
@Falco धन्यवाद! अब ठीक किया गया
— लुइस मेंडो
2

जावा (JDK) , 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;}

पहले से ही C # उत्तर है, इसलिए मैंने जावा उत्तर पर अपना हाथ आजमाने का फैसला किया।

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

— अज्ञान का अवतार
स्रोत
एफ # :) की कोशिश करने का समय
— अलाउद्दग
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. ›इको-एन" ← <(½ | "| wc --bytes 11
— माइक हॉलर
— Xan
@ माइकहोलर कई अन्य गोल्फ भाषाओं के रूप में, हुस्क एक कस्टम कोड पेज का उपयोग करता है, ताकि अधिक अलग-अलग पात्रों तक पहुंच हो सके: github.com/barbuz/Husk/wiki/Codepage
— Leo
धन्यवाद, मैंने आज कुछ सीखा :)
— माइक हॉलर
1
बाइट को बचाने के Ċ2बजाय उपयोग करें (←½।
— ज़र्गब
2

जूलिया 1.0 , 30 बाइट्स

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

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

यदि सॉर्ट नहीं किया जाता है, तो सरणी का हर दूसरा तत्व लेता है।

— niczky12
स्रोत
-20 बाइट्स के लिए ASCII ऑपरेटर का उपयोग करें । हम भी लगभग हमेशा गिनती नहीं करते हैं: | इसलिए यह अच्छा होगा यदि इसे हेडर से हटा दिया जाए
— ASCII- केवल
वह बदल गया। 2 बाइट्स के लिए धन्यवाद!
— niczky12
2

C ++ (gcc) , 103 बाइट्स

मैं टिप्पणी नहीं कर सकता, लेकिन मैंने शामिलों को कम करके और ऑटो का उपयोग करके संस्करण को Movatica से बेहतर बनाया।

-2 बाइट्स: सीलिंगकैट
-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?
— ASCII- केवल
हां, यह उस तरह से काम नहीं करता है :)
— पीटरज़ुगर
1
आपका मतलब क्या है? आकार की सूची लौटना (n+1)/2या (n-1)/2दोनों वैध हैं। हम्म ....
— ASCII- केवल
ओह उफ़ नहीं देखा कि धन्यवाद
— पीटर
1

VDM-SL , 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])

इससे पहले कभी vdm में प्रस्तुत नहीं किया गया, इसलिए भाषा विशिष्ट नियमों पर निश्चित नहीं है। इसलिए मैंने एक फ़ंक्शन परिभाषा के रूप में प्रस्तुत किया है जो एक लेता है 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

इसे यहाँ ऑनलाइन आज़माएँ । यह प्रत्येक पुनरावृत्ति पर दूसरी छमाही को हटा देता है, नीचे चक्कर लगाता है। इसे बदलने के लिए पहली छमाही दूर करने के लिए, ऊपर गोलाई, बदलने 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

C ++ (gcc) , 139 137 116 बाइट्स

-2 बाइट्स थैंक्स टू सीलिंगकैट, -21 बाइट्स थैंक्स टू पीटरज़ुगर

#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
आयातों को बाइट की गिनती में शामिल किया जाता है, इसलिए आपको includeएस जोड़ना होगा
— अज्ञानता का अवतार
थैंक्स, मैं उन्हें जोड़ दूँगा।
— २१:२
1

के (ओके) , 22 20 बाइट्स

उपाय:

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

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

जब तक इसे सॉर्ट नहीं किया जाता है, तब तक इनपुट पर Iterate करें ... अगर यह सॉर्ट नहीं किया गया है तो पहले n / 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 बाइट्स ngn के लिए धन्यवाद
— streetster
स्रोत
1
(.5*#x)#x->*2 0N#x
— ngn
मैंने ऐसा करने 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;}

Ungolfed संस्करण:

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
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.