Dağlık bir bölgeden bir dilim aldığımızı düşünün, bu buna benzer bir şekle neden olacaktır:

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

Gördüğümüz gibi, bunu (belirli bir dereceye kadar) bir tamsayı dizisiyle temsil edebiliriz.

Bu zorluğun amacı için, bir vadiyi başlangıçta değerlerin azaldığı ve bir noktadan itibaren arttığı bitişik bir alt çizgi olarak tanımlıyoruz. Daha resmi bir sekans için bir vadi aşağıdakilerin sahip olduğu endeksleri olacaktır :$(a_i)_{i=1}^n$$1 \leq s < r < t \leq n$

• vadinin başlangıç ​​ve bitiş noktaları aynı:$a_s = a_t$
• bölge azaldığında vadi başlar ve biter:$a_s > a_{s+1} \land a_{t-1} < a_t$
• vadi düz değil:$a_s \neq a_r \land a_r \neq a_t$
• vadi başlangıçta azalır:$\forall i \in [s,r): a_i \geq a_{i+1}$
• vadi bir noktada artacak:$\forall j \in [r,t): a_j \leq a_{j+1}$

Şimdi böyle bir vadinin genişliğini, indekslerin büyüklüğü , yani. .$[s,t]$$t-s+1$

Meydan okuma

Bir yükseklik profili (negatif olmayan tamsayılar dizisi) verildiğinde, göreviniz en geniş vadinin genişliğini belirlemektir.

Misal

Yükseklik profili göz önüne alındığında, [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]daha önce olduğu gibi görselleştirebiliriz:

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

İkinci vadi nasıl [3,2,1,0,0,1,2,2,3]sağa doğru daha fazla uzanmaz, çünkü en soldaki nokta değil . Ayrıca geri kalan iki saniyeyi de eklemiyoruz çünkü son noktanın ikinci son noktadan daha yüksek olmasını istiyoruz.$3$$4$$3$

Bu nedenle en geniş vadinin genişliği .$9$

kurallar

• Girdi, negatif olmayan (özür dilerim Hollandalılar) tamsayılar dizisi olacak
  • her zaman en az bir vadi olduğunu varsayabilirsiniz.
• Çıktı, yukarıda tanımlandığı gibi en geniş vadinin büyüklüğü olacaktır

testcases

[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

Jöle , 15 bayt

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

Çevrimiçi deneyin!

Veya bir test takımına bakın (daha önce gerçekleştiremediğim iki test örneği daha eklendi).

Nasıl?

Ẇµ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

JavaScript (ES6), 111 108 99 97 bayt

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

Çevrimiçi deneyin!

Yorumlananlar

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

Piton 2 , 120 115 89 87 86 152 149 bayt

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

Çevrimiçi deneyin!

Retina 0.8.2 , 77 bayt

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

O^`
\G,|$

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir. Açıklama:

\d+
$*

Tekli'ye dönüştür.

M&!`

Üst üste gelen eşleşmeleri saymak yerine listeleyin.

\b(1+),

Vadinin başlangıcı ele geçirilir \1. Bu daha sonra sonuna kadar eşleşmemelidir. Virgül yakalamadığımız için bu, daha yüksek değerlerin eşleşmesini de önler.

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

Azalan değerleri eşleştirin. (?!1+\2)Önceki daha büyüktür gelen halkanın içinden bir geçiş önler. (İlk kez \2ayarlanmadı, bu yüzden önemsiz bir şekilde eşleşmiyor.) Yakalama, golfçü olduğu için sondaki virgül içeriyor.

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

Artan değerleri eşleştirin. Bu süre ((?3)\3|\2), her bir eşleşmenin en az bir önceki değere veya son azalan yakalamanın döngü boyunca ilk kez olması gerektiği anlamına gelir.

\1\b

Sonunda vadinin sonu başlangıç ​​ile aynı yükseklikte olmalıdır.

1

Virgül bırakarak yükseklikleri silin. (Bu, bazıları sıfır olabileceğinden yükseklik saymaktan biraz daha kolaydır.)

O^`

Ters sırayla, yani önce en virgülle sıralayın.

\G,|$

İlk satırdaki virgül sayısını artı bir tane sayın.

Kabuk , 13 bayt

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

Çevrimiçi deneyin!

açıklama

Jonathan Allan ile benzer bir algoritma kullanıyorum .

→▲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

Japt , 31 bayt

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

Çevrimiçi deneyin!

Zgarb'ın Husk cevabından ilham alarak 10 bayt kurtardı. Hala bunun geliştirilebileceğini düşünüyorum, ama henüz bulamadım.

Açıklama:

¡ã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