चौड़ी घाटी का निर्धारण करें

Question

कल्पना कीजिए कि हमें कुछ पर्वतीय क्षेत्र का एक टुकड़ा मिलता है, इसके परिणामस्वरूप इसका आकार होगा:

4                   _
3   _    _       __/ \
2  / \__/ \    _/     \_   /
1 /        \  /         \_/
0           \/
  12322223210012233343221112

जैसा कि हम देख सकते हैं, हम पूर्णांक के अनुक्रम के साथ (एक निश्चित डिग्री तक) इसका प्रतिनिधित्व कर सकते हैं।

इस चुनौती के उद्देश्य के लिए हम एक घाटी को एक सन्निहित परवर्ती के रूप में परिभाषित करते हैं जहाँ मूल्य शुरू में कम हो रहे हैं और कुछ बिंदु से वे बढ़ते जा रहे हैं। अधिक औपचारिक रूप से एक दृश्य के लिए $(a_i)_{i=1}^n$ एक घाटी हो जाएगा सूचकांक $1 \leq s < r < t \leq n$ जिसके लिए निम्नलिखित रखती है:

• घाटी की शुरुआत और समापन बिंदु समान हैं: $a_s = a_t$
• घाटी प्रारंभ और समाप्त होता है एक बार क्षेत्र कम हो जाता है: $a_s > a_{s+1} \land a_{t-1} < a_t$
• घाटी फ्लैट नहीं है: $a_s \neq a_r \land a_r \neq a_t$
• घाटी शुरू में कम हो जाती है: $\forall i \in [s,r): a_i \geq a_{i+1}$
• $\forall j \in [r,t): a_j \leq a_{j+1}$

$[s,t]$$t-s+1$

चुनौती

एक ऊंचाई-प्रोफ़ाइल (गैर-नकारात्मक पूर्णांक का अनुक्रम) को देखते हुए, आपका काम सबसे चौड़ी घाटी की चौड़ाई निर्धारित करना है।

उदाहरण

ऊंचाई-प्रोफ़ाइल को देखते हुए [1,2,3,2,2,2,2,3,2,1,0,0,1,2,2,3,3,3,4,3,2,2,1,1,1,2], हम इसे पहले की तरह कल्पना कर सकते हैं:

4                   _
3   _    _       __/ \
2  / \__/ \    _/     \_   /
1 /        \  /         \_/
0           \/
  12322223210012233343221112
    aaaaaa             ccccc
         bbbbbbbbb

[3,2,1,0,0,1,2,2,3]$3$$4$$3$

$9$

नियम

• इनपुट नॉन-निगेटिव (सॉरी डच लोगों) पूर्णांकों का एक क्रम होगा
  • आप मान सकते हैं कि हमेशा कम से कम एक घाटी है
• जैसा कि ऊपर बताया गया है, आउटपुट चौड़ी घाटी का आकार होगा

परीक्षण के मामलों

[4,0,4] -> 3
[1,0,1,0,1] -> 3
[1,0,2,0,1,2] -> 4
[13,13,13,2,2,1,0,1,14,2,13,14] -> 4
[1,2,3,2,2,2,2,3,2,1,0,0,1,2,2,3,3,3,4,3,2,2,1,1,1,2] -> 9
[3,2,0,1,0,0,1,3] -> 4

Comments

टेस्ट मामला: [3,2,0,1,0,0,1,3]। सभी वर्तमान उत्तर 8 लौटते हैं, आपकी परिभाषा से मेरा मानना ​​है कि यह 4. होना चाहिए

— ज़र्बबर्ग

क्या पहाड़ की ढलान कभी 1 से भी ज्यादा चौड़ी होगी? (उदाहरण के लिए [3,1,2,3])

— दरवाज़े

@ जर्ब: यह सही है, हाँ। मैंने इसे टेस्टकेस में शामिल किया।

— ।

@Doorknob: वहाँ कुछ भी नहीं है कि रोकने, हाँ। उदाहरण के लिए [4,0,4]ऐसा मामला होगा।

— ბიმო

" इनपुट गैर-नकारात्मक (क्षमा करें डच लोग) पूर्णांक का एक क्रम होगा " लोल, एक डचमैन के रूप में जब मैंने इसे पढ़ा था। ;)

— केविन क्रूज़सेन

Answer 1

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

ẆµIṠḟ0ṢƑaMIḢ)Ṁ‘

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

या एक परीक्षण-सूट देखें (दो और परीक्षण मामले जोड़े जो मैं पहले पूरा करने में विफल रहा)।

कैसे?

ẆµIṠḟ0ṢƑaMIḢ)Ṁ‘ - Link: list of integers
Ẇ               - all contiguous substrings
 µ          )   - for each substring, X:
  I             -   deltas
   Ṡ            -   sign (-ve:-1, 0:0, +ve:1)
    ḟ0          -   filter out zeros
       Ƒ        -   is invariant under:
      Ṣ         -     sort
         M      -   get maximal indices of X
        a       -   (vectorising) logical AND
          I     -   deltas
           Ḣ    -   head
             Ṁ  - maximum
              ‘ - increment

Answer 2

जावास्क्रिप्ट (ईएस 6), 111 108 99 97 बाइट्स

a=>a.map(o=(p,x)=>a.some(P=q=>(~x?x<0?i?q<P:q>P&&i++:i=0:q>=p)||(o=o<--x|q==P|q-p?o:x,P=q,0)))|-o

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

टिप्पणी की गई

a =>                        // a[] = input array
  a.map(o =                 // initialize the output o to a non-numeric value
    (p, x) =>               // for each value p at position x in a[]:
    a.some(P =              //   initialize P to a non-numeric value
      q =>                  //   for each value q in a[]:
      (                     //     exit if something goes wrong:
        ~x ?                //       if x is not equal to -1:
          x < 0 ?           //         if x is negative:
            i ?             //           if we're in the increasing part:
              q < P         //             exit if q is less than P
            :               //           else:
              q > P && i++  //             increment i if q is greater than P
          :                 //         else:
            i = 0           //           initialize i to 0 (decreasing part)
        :                   //       else:
          q >= p            //         exit if q is greater than or equal to p
      ) || (                //     if we didn't exit:
        o =                 //       update the output o:
          o < --x |         //         decrement x; if o is less than x
          q == P |          //         or the last value is equal to the previous one
          q - p ?           //         or the last value is not equal to the first one
            o               //           leave o unchanged
          :                 //         else:
            x,              //           update o to x
        P = q,              //       update the previous value P to q
        0                   //       force this iteration to succeed
      )                     //
    )                       //   end of some()
  ) | -o                    // end of map(); return -o

Answer 3

पायथन 2 , 120 115 89 87 86 152 149 बाइट्स

lambda a:max(r-l+1for l,v in e(a)for r,w in e(a)if max(a[l+1:r]+[0])<v==w*any(s(a[l:i])[::-1]+s(a[i:r])==a[l:r]for i,_ in e(a)));e=enumerate;s=sorted

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

Answer 4

रेटिना 0.8.2 , 77 बाइट्स

\d+
$*
M&!`\b(1+),((?!\1)(?!1+\2)1*,)+((?!\1)1*(?(3)\3|\2))*\1\b
1

O^`
\G,|$

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

\d+
$*

यूनीरी में बदलें।

M&!`

सूची, गिनती के बजाय, ओवरलैपिंग मैच।

\b(1+),

घाटी की शुरुआत पर कब्जा कर लिया है \1। यह अंत तक फिर से मेल नहीं खाना चाहिए। चूंकि हम अल्पविराम पर कब्जा नहीं करते हैं, इसलिए यह उच्च मूल्यों को मिलान करने से रोकता है।

((?!\1)(?!1+\2)1*,)+

घटते मूल्यों का मिलान करें। (?!1+\2)पिछले की तुलना में अधिक होने से लूप के माध्यम से किसी भी पास से बचाता है। (पहली बार के माध्यम \2से सेट नहीं किया गया है इसलिए यह तुच्छ रूप से मेल करने में विफल रहता है।) कैप्चर में अनुगामी अल्पविराम भी शामिल है जो कि गोल्फर है।

((?!\1)1*(?(3)\3|\2))*

बढ़ते मूल्यों का मिलान करें। इस समय का ((?3)\3|\2)अर्थ है कि प्रत्येक मैच को कम से कम पिछले मूल्य के रूप में लंबे समय तक या आखिरी घटते हुए लूप के माध्यम से कब्जा करने की आवश्यकता होती है।

\1\b

अंत में घाटी का अंत शुरू होने के समान ही होना चाहिए।

1

अल्पविराम छोड़कर ऊँचाई हटाएं। (यह ऊंचाइयों को गिनने से थोड़ा आसान है क्योंकि उनमें से कुछ शून्य हो सकते हैं।)

O^`

रिवर्स ऑर्डर में क्रमबद्ध करें अर्थात सबसे पहले अल्पविराम।

\G,|$

पहली पंक्ति पर अल्पविरामों की संख्या, और एक की गणना करें।

Answer 5

भूसी , 13 बाइट्स

→▲mΓ€fȯΛEtġ≤Q

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

व्याख्या

मैं जोनाथन एलन के समान एल्गोरिथ्म का उपयोग करता हूं ।

→▲mΓ€fȯΛEtġ≤Q  Input is a list, say [3,1,0,1,1,0,2,3]
            Q  Nonempty slices: [[3],[1],[3,1],[0],...,[3,1,0,1,1,0,2,3]]
     f         Keep those that satisfy this:
                Argument is a slice, say [3,1,0,1,1,0,2]
          ġ≤    Cut into non-increasing pieces: [[3,1,0],[1,1,0],[2]]
         t      Drop first piece: [[1,1,0],[2]]
      ȯΛ        Each remaining piece
        E       has all elements equal: false, [1,1,0] has different elements
  m            Map over remaining slices:
                Argument is a slice, say [1,0,1,1]
   Γ            Break into head 1 and tail [0,1,1]
    €           Index of first occurrence of head in tail: 2
 ▲             Maximum: 2
→              Increment: 3

Answer 6

जाप , 31 बाइट्स

¡ãYÄÃrc k_ò< Åd_äa x}îbZvÃrÔ+2

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

जर्बेर के हुस्क जवाब से प्रेरणा लेकर 10 बाइट्स बचाए। मुझे अभी भी लगता है कि इसमें सुधार किया जा सकता है, लेकिन मुझे यह अभी तक नहीं मिला है।

स्पष्टीकरण:

¡ãYÄÃrc                            Get all segments
        k_           Ã             Remove ones where:
          ò<                        A non-increasing sub-segment
             Å                      Other than the first one
              d_äa x}               Has different heights
                      ®   Ã        For each remaining segment:
                       bZv          Get the second index of the first character
                           rÔ      Maximum
                             +2    Increase by 2