우리가 산악 지역의 한 조각을 얻는다고 상상해보십시오. 이렇게하면 비슷한 모양이됩니다.

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$
• 밸리는 평평하지 : S ≠ R ∧ R ≠ 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$

도전

높이 프로파일 (음수가 아닌 정수의 순서)이 주어지면 가장 넓은 계곡의 너비를 결정해야합니다.

예

height-profile이 주어지면 [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

젤리 , 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

자바 스크립트 (ES6) 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

파이썬 (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

온라인으로 사용해보십시오!

레티 나 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

쉼표를 남기고 높이를 삭제하십시오. (일부는 0 일 수 있으므로 높이를 계산하는 것보다 약간 더 쉽습니다.)

O^`

대부분의 쉼표를 역순으로 정렬하십시오.

\G,|$

첫 번째 줄의 쉼표 수에 1을 더한 수를 세십시오.

껍질 , 13 바이트

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

온라인으로 사용해보십시오!

설명

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 바이트

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

온라인으로 사용해보십시오!

Zgarb의 Husk 답변에서 영감을 얻어 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