Hãy tưởng tượng chúng ta có được một lát của một số khu vực miền núi, điều này sẽ dẫn đến một hình dạng tương tự như sau:

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

Như chúng ta có thể thấy, chúng ta có thể biểu diễn điều này (ở một mức độ nhất định) bằng một chuỗi các số nguyên.

Với mục đích của thách thức này, chúng tôi xác định một thung lũng là một dãy tiếp giáp nơi các giá trị ban đầu đang giảm và từ một số điểm trên chúng đang tăng lên. Chính thức hơn cho một chuỗi $(a_i)_{i=1}^n$ một thung lũng sẽ là các chỉ số $1 \leq s < r < t \leq n$ mà sau đây giữ:

• điểm bắt đầu và điểm cuối của thung lũng giống nhau: $a_s = a_t$
• thung lũng bắt đầu và kết thúc một lần khu vực được thấp hơn: $a_s > a_{s+1} \land a_{t-1} < a_t$
• thung lũng không bằng phẳng: $a_s \neq a_r \land a_r \neq a_t$
• thung lũng ban đầu giảm: $\forall i \in [s,r): a_i \geq a_{i+1}$
• thung lũng chí tại một số tăng điểm: $\forall j \in [r,t): a_j \leq a_{j+1}$

Bây giờ chúng tôi xác định chiều rộng của một thung lũng như kích thước của các chỉ số $[s,t]$ , tức là. $t-s+1$ .

Thử thách

Đưa ra một cấu hình chiều cao (chuỗi các số nguyên không âm), nhiệm vụ của bạn là xác định chiều rộng của thung lũng rộng nhất.

Thí dụ

Với cấu hình chiều cao [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], chúng ta có thể hình dung nó như trước:

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

Lưu ý cách thung lũng thứ hai [3,2,1,0,0,1,2,2,3]không mở rộng thêm về bên phải vì điểm ngoài cùng bên trái là $3$ chứ không phải $4$ . Hơn nữa, chúng tôi không thêm hai 3 còn lại$3$ giây vì chúng tôi yêu cầu điểm cuối cao hơn điểm cuối thứ hai.

Do đó chiều rộng của thung lũng rộng nhất là $9$ .

Quy tắc

• Đầu vào sẽ là một chuỗi các số nguyên không âm (xin lỗi người Hà Lan)
  • bạn có thể cho rằng luôn có ít nhất một thung lũng
• Đầu ra sẽ là kích thước của thung lũng rộng nhất như được xác định ở trên

Tủ thử

[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

Thạch , 15 byte

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

Hãy thử trực tuyến!

Hoặc xem một bộ thử nghiệm (đã thêm hai trường hợp thử nghiệm mà trước đây tôi không thực hiện được).

Làm sao?

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

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

Hãy thử trực tuyến!

Đã bình luận

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

Python 2 , 120 115 89 87 86 152 149 byte

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

Hãy thử trực tuyến!

Võng mạc 0.8.2 , 77 byte

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

O^`
\G,|$

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

\d+
$*

Chuyển đổi sang unary.

M&!`

Danh sách, thay vì đếm, trùng khớp.

\b(1+),

Bắt đầu của thung lũng được bắt vào \1. Điều này sau đó không phải phù hợp một lần nữa cho đến khi kết thúc. Vì chúng tôi không chụp dấu phẩy, điều này cũng ngăn các giá trị cao hơn khớp với nhau.

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

Khớp các giá trị giảm dần. Việc (?!1+\2)ngăn chặn bất kỳ đi qua vòng lặp là lớn hơn trước. (Lần đầu tiên thông qua \2không được đặt để nó không khớp với tầm thường.) Ảnh chụp bao gồm dấu phẩy khi đó là gôn thủ.

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

Phù hợp với các giá trị ngày càng tăng. Lần này ((?3)\3|\2)có nghĩa là mỗi trận đấu được yêu cầu ít nhất phải bằng giá trị trước đó hoặc lần giảm cuối cùng bắt lần đầu tiên qua vòng lặp.

\1\b

Cuối cùng, phần cuối của thung lũng phải có cùng độ cao với điểm bắt đầu.

1

Xóa các độ cao, để lại dấu phẩy. (Điều này dễ hơn một chút so với việc đếm độ cao vì một số trong số chúng có thể bằng không.)

O^`

Sắp xếp theo thứ tự ngược nghĩa là hầu hết các dấu phẩy đầu tiên.

\G,|$

Đếm số lượng dấu phẩy trên dòng đầu tiên, cộng với một dấu phẩy.

Husk , 13 byte

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

Hãy thử trực tuyến!

Giải trình

Tôi sử dụng một thuật toán tương tự như Jonathan Allan .

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

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

Hãy thử trực tuyến!

Đã lưu 10 byte bằng cách lấy cảm hứng từ câu trả lời Husk của Zgarb. Tôi vẫn nghĩ rằng điều này có thể được cải thiện, nhưng tôi chưa tìm thấy nó.

Giải trình:

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