सबसे छोटी संख्या में सन्निहित मोनोटोनिक परवर्ती

Question

चुनौती का वर्णन

एक मोनोटोनिक परिकल्पना[a1, a2, ..., an] इस तरह की संख्याओं का एक क्रम है

a1 <= a2 <= ... <= anया a1 >= a2 >= ... >= an। [1, 3, 3, 7, 9, 13, 13, 100]एक मोनोटोनिक (गैर-घटती) परवर्तीता है, साथ ही [9, 4, 4, 3, 0, -10, -12](यह एक गैर-बढ़ती है), लेकिन [1, 3, 6, 9, 8]नहीं है। पूर्णांकों की सूची (किसी भी उचित प्रारूप में) को देखते हुए, सबसे छोटी संख्या को Nऐसे आउटपुट करें कि इन पूर्णांकों के Nअनुक्रम को मोनोटोनिक अनुक्रमों में विभाजित किया जा सके ।

उदाहरण

[1, 3, 7, 5, 4, 2] -> [[1, 3, 7], [5, 4, 2]] -> 2
[1, 2, 3, 4, 5, 6] -> [1, 2, 3, 4, 5, 6]     -> 1
[3, 1, 5, 5, 6]    -> [[3, 1], [5, 5, 6]]    -> 2
[4, 6, 8, 9, 1, 6] -> [[4, 6, 8, 9], [1, 6]] -> 2
[3, 3, 3, 3]       -> [[3, 3, 3, 3]]         -> 1
[7]                -> [[7]]                  -> 1
[]                 -> []                     -> anything (you don't actually have to handle an empty list case)
[1, 3, 2, -1, 6, 9, 10, 2, 1, -12] -> [[1, 3], [2, -1], [6, 9, 10], [2, 1, -12]] -> 4

Comments

स्पष्ट करने के लिए, बाद में सन्निहित होना चाहिए, है ना?

— जर्बग

@Zgarb हाँ, वे करते हैं।

— शुकी

मैं एक परीक्षण मामले को जोड़ने की सलाह दूंगा जहां अनुक्रम हमेशा उल्टी दिशा में नहीं जाते हैं: [4,4,8,8,1,4,5] -> 2

— नाथन मेरिल

@NathanMerrill: अच्छी बात है, एक जोड़ा।

— शौकी

जब आप लिखते हैं कि कोई रिक्त स्ट्रिंग के लिए, परिणाम है 0 / undefined, यह लग रहा है जैसे कि यह या तो 0 या का प्रतिनिधित्व होना चाहिए undefinedहमारी भाषा में है, लेकिन जोनाथन एलन की जेली जवाब पर अपनी टिप्पणी से, यह की तरह लग रहा undefinedसाधन anything... कौन सा यह है ? दूसरे मामले में, मैं anythingइसके बजाय लिखने का सुझाव undefined

— दादा

Answer 1

ब्रेकीलॉग , 12 बाइट्स

~c:{<=|>=}al

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

यह false.खाली सूची के लिए देता है []।

व्याख्या

(?)~c                 Take a list of sublists which when concatenated result in the Input
     :{<=|>=}a        Each sublist must be either increasing or decreasing
              l(.)    Output is the length of that list

यह सबसे छोटी को लौटाएगा क्योंकि ~cसबसे छोटी संख्या से सबलिस्ट की सबसे बड़ी संख्या के लिए पसंद अंक उत्पन्न करेगा।

Comments

TIO लिंक में "Z" का क्या तर्क है? (यह कमांड लाइन तर्क की तरह कार्यक्रम का हिस्सा लगता है)।

— जोनाथन एलन

@JonathanAllan यह तर्क आउटपुट है। आदर्श रूप से यदि हम TIO के इंटरफ़ेस को अनुकूलित कर सकते हैं, तो इनपुट और आउटपुट और कोई तर्क नहीं होगा। तर्क है Zक्योंकि Zएक चर नाम है; इसलिए हम कह रहे हैं "आउटपुट के साथ इस प्रोग्राम को एक चर के रूप में कॉल करें"। आप बदल सकते हैं Zकरने के लिए किसी अन्य अपरकेस अक्षर ; यह सिर्फ एक चर नाम है। इस तर्क के मौजूद होने का कारण एक चर के बजाय वास्तव में कुछ को आउटपुट सेट करने की संभावना को अनुमति देना है।

— घातक

(उदाहरण के लिए यदि आप के लिए उत्पादन सेट 4कि उदाहरण में, यह आपको पता चलेगा कि यह सही है या नहीं )

— Fatalize

@JonathanAllan भाषा की तरह कोई भी प्रस्तावना इस तरह है: विधेय केवल सफल या असफल हो सकता है और कोई मूल्य वापस नहीं करता है। तो एक आउटपुट प्राप्त करने के लिए विधेय के लिए एक चर तर्क होना चाहिए जो परिणाम के लिए एकीकृत हो जाएगा।

— घातक

@JonathanAllan यह अंततः विफल हो जाएगा 3क्योंकि यह सब्लोटिस्ट की कोई सूची नहीं खोजेगा, जहां सभी मोनोटोनिक और लंबाई के हैं 3। यह सिर्फ एक लंबा समय लेता है क्योंकि यह सब्लिस्ट्स की सभी संभावित सूचियों की कोशिश करेगा, यहां तक ​​कि जो वास्तव में 3 तत्वों से अधिक लंबा है क्योंकि सूची खोजने के बाद लंबाई की जांच की जाती है। इसके लिए 5कहते हैं trueक्योंकि 5मोनोटोनिक सब्लिस्ट के साथ लंबाई की कम से कम एक सूची है जो काम करती है। इसलिए यह प्रोग्राम छोटी लंबाई देता है जब आउटपुट एक चर होता है और क्या उस लंबाई की कोई सूची होती है जो आउटपुट पूर्णांक होती है।

— घातक

Answer 2

पर्ल, 65 बाइट्स

-nध्वज के लिए कोड + 3 बाइट्स के 62 बाइट्स ।

monot_seq.pl:

#!perl -n
s/\S+ /($_<=>$&)*($&<=>$')-$g>=0?$g=1:$.++;$g--;$_=$&/ge,$_=$.

अंतिम न्यूलाइन के बिना इनपुट दें, रिक्त स्थान से अलग संख्या के साथ:

$ echo -n "1 3 2 -1 6 9 10 2 1 -12" | perl -M5.010 monot_seq.pl
4

-5 बाइट्स @ गैब्रिएल बेनामी को धन्यवाद।

Comments

बदल कर 5 बाइट्स सहेजें ($&<=>$1)*($1<=>$2)||$1==$2में($&<=>$1)*($1<=>$2)>=0

— गेब्रियल Benamy

@GabrielBenamy वास्तव में, धन्यवाद।

— दादा

Answer 3

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

d=#[[2]]-#[[1]]&;r=Rest;f@{n_}:=1;f@k__:=If[d@k==0,f@r@k,g[k Sign@d@k]];g@{n_}:=1;g@k__:=If[d@k>0,g@r@k,1+f@r@k]

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

d = #[[2]] - #[[1]] &;         function: difference of the first two elements
r = Rest;                      function: a list with its first element dropped
f@{n_} := 1;                   f of a length-1 list equals 1
f@k__ := If[d@k == 0, f@r@k,   if the first two elements are equal, drop one
                                 element and call f again ...
            g[k Sign@d@k]];  ... otherwise call the helper function g on the
                                 list, multiplying by -1 if necessary to ensure
                                 that the list starts with an increase
g@{n_} := 1;                   g of a length-1 list equals 1
g@k__ := If[d@k > 0, g@r@k,    if the list starts with an increase, drop one
                                 element and call g again ...
            1 + f@r@k];        ... otherwise drop one element, call f on the
                                 resulting list, and add 1

Comments

d=#2-#&@@#&;इसके अलावा, fया तो gएकतरफा ऑपरेटर के रूप में परिभाषित करने ±से शायद कुछ बाइट्स बचेंगे।

— मार्टिन एंडर

Answer 4

जेली , 19 बाइट्स

IṠḟ0E
ŒṖÇ€€0e$Ðḟḅ1Ṃ

TryItOnline! या सभी परीक्षण चलाएं (रिक्त सूची परिणाम1)

कैसे?

IṠḟ0E - Link 1, test for monotonicity: a sublist
I     - incremental differences
 Ṡ    - sign {fall:-1; same:0; rise:1}
  ḟ0  - filter out the zeros
    E - all equal?

ŒṖÇ€€0e$Ðḟḅ1Ṃ - Main link
ŒṖ            - all partitions of the input list
  Ç€€         - call last link (1) as a monad for €ach for €ach
        Ðḟ    - filter out results:
       $      -    last two links as a monad
     0e       -        contains zero?
          ḅ1  - convert from unary (vectorises)
            Ṃ - minimum

(मुझे यकीन नहीं है कि यह बाइट काउंट को कम करने के लिए सबसे उपयुक्त तरीका है)

Comments

@shooqie - क्या हम "अपरिभाषित" टिप्पणी दी गई खाली सूची के लिए कोई मूल्य वापस कर सकते हैं ? यह रिटर्न 1(जो मुझे वास्तव में लगता है कि इससे अधिक समझ में आता है 0)।

— जोनाथन एलन

मेरा मतलब है, undefinedइसका मतलब है - परिणाम अप्रासंगिक है।

— शौकी

Answer 5

पर्ल, 98 97 96 79 बाइट्स

($a,$b)=($a<=>$b)*($b<=>$c)<0?($c,shift,$d++):($b,$c)while$c=shift;say$d+1 if$a

इनपुट संख्या की सूची के रूप में प्रदान किया जाता है, रिक्त स्थान द्वारा अलग किया जाता है, रनटाइम पर प्रदान किया जाता है, जैसे

perl -M5.010 monotonic.pl 1 3 2 -1 6 9 10 2 1 -12
4

(4 आउटपुट है)

पठनीय:

($a,$b)=($a<=>$b)*($b<=>$c)<0
    ?($c,shift,$d++)
    :($b,$c)
  while$c=shift;
say$d+1
  if$a

'अंतरिक्ष यान ऑपरेटर' <=>रिटर्न -1 अगर एलएचएस <आरएचएस, 0 यदि एलएचएस = आरएचएस, और +1 अगर एलएचएस> आरएचएस। तीन अनुक्रमिक तत्वों की तुलना करते समय $a,$b,$cयदि वे एकरस हैं, तो यह निर्धारित करना आवश्यक है कि ऐसा नहीं है कि वास्तव में एक है $a<=>$b, $b<=>$c1 है और दूसरा -1 है - जो केवल तब होता है जब उनका उत्पाद -1 होता है। यदि दोनों में से $a==$bया $b==$c, तो अनुक्रम monotonic है, और उत्पाद 0. तो है $a < $b < $c, तो -1 में दोनों परिणाम, और -1 * -1 = 1. यदि $a > $b > $cहै, तो वे दोनों 1 में परिणाम है, और 1 * 1 = 1। किसी भी मामले में, अनुक्रम एकरस है, और हम जारी रखना चाहते हैं।

यदि उत्पाद 0 से कम है, तो हम जानते हैं कि अनुक्रम मोनोटोनिक नहीं है, और हम $a,$bवर्तमान में पकड़े हुए मूल्यों को त्याग देते हैं, और हमारे बाद के काउंटर को बढ़ाते हैं। अन्यथा, हम एक नंबर आगे बढ़ते हैं।

यदि इनपुट खाली है, तो कुछ भी नहीं लौटाता है, अन्यथा छोटी संख्या में सन्निहित मोनोटोनिक बाद की रिटर्न देता है

Comments

आप के बीच एक स्थान की जरूरत नहीं है 1और if(या हो सकता है कि आप पुराने पर्ल्स पर करते हैं, लेकिन हाल ही में जो आप नहीं करते हैं)। इसके अलावा आप (शायद) shiftद्वारा प्रतिस्थापित कर सकते हैं pop। हालांकि, कुछ परीक्षण मामले हैं जिन पर आपका कोड काम नहीं करता है: 6 3 6 3(आप 2 के बजाय 3 प्रिंट करते हैं ), 4 3 2 1(आप 1 के बजाय 2 प्रिंट करते हैं)। हल popकरने के बजाय shiftउन का उपयोग करें लेकिन नए बनाएं ( 1 2 3 41 के बजाय 3 प्रिंट करें) ...

— दादा

Answer 6

सी # 6, 297 209 बाइट्स

using System.Linq;int G(int[] a)=>a.Any()?a.SkipWhile((x,i)=>i<1||x>=a[i-1]).Count()<a.SkipWhile((x,i)=>i<1||x<=a[i-1]).Count()?G(a.Select(x=>-x).ToArray()):G(a.SkipWhile((x,i)=>i<1||x<=a[i-1]).ToArray())+1:0;

स्पष्टीकरण के साथ अघोषित

int G(int[] a)=>
    a.Any()
        ?a.SkipWhile((x,i)=>i<1||x>=a[i-1]).Count()<a.SkipWhile((x,i)=>i<1||x<=a[i-1]).Count()   // If a begins by decreasing (including whole a decreasing)...
            ?G(a.Select(x=>-x).ToArray())   // ... Then flip sign to make a begins by increasing
            :G(a.SkipWhile((x,i)=>i<1||x<=a[i-1]).ToArray())+1   // ... Else skip the increasing part, recursively find the remaining part number, then add 1
        :0;   // Return 0 if a is empty

Answer 7

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

f=(d,c,b,...a)=>1/b?(d>c)*(b>c)+(d<c)*(b<c)?1+f(b,...a):f(d,b,...a):1

इनपुट को कई मापदंडों के रूप में लेता है। पहले तीन तत्वों की पुनरावृत्ति करके यह देखने के लिए काम करता है कि क्या वे मोनोटोनिक हैं, यदि हां, तो बीच के तत्व को हटा देता है क्योंकि यह बेकार है, यदि नहीं, तो पहले दो तत्वों को हटा देता है और एक नया क्रम शुरू करता है।

Answer 8

क्लोजर, 97 बाइट्स

#((reduce(fn[[C i]s](let[S(conj C s)](if(or(apply <= S)(apply >= S))[S i][[s](inc i)])))[[]1]%)1)

reduceवर्तमान उत्तरार्द्ध का ट्रैक रखता है और गणना करता है कि कितनी बार <=और >=स्थितियां विफल होती हैं। अंतिम 1परिणाम (काउंटर होने i) से दूसरा तत्व लेता है ।