Imagine que temos uma fatia de alguma região montanhosa, isso resultaria em uma forma semelhante a esta:

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

Como podemos ver, podemos representar isso (até certo ponto) com uma sequência de números inteiros.

Para o propósito deste desafio, definimos um vale como uma subsequência contígua em que os valores inicialmente estão diminuindo e, a partir de algum momento, estão aumentando. Mais formalmente para uma sequência um vale terá índices para os quais o seguinte é válido:$(a_i)_{i=1}^n$$1 \leq s < r < t \leq n$

• o início e o ponto final do vale são os mesmos:$a_s = a_t$
• o vale começa e termina quando a região fica mais baixa:$a_s > a_{s+1} \land a_{t-1} < a_t$
• o vale não é plano:$a_s \neq a_r \land a_r \neq a_t$
• o vale inicialmente diminui:$\forall i \in [s,r): a_i \geq a_{i+1}$
• em algum momento o vale aumentará:$\forall j \in [r,t): a_j \leq a_{j+1}$

Agora, definimos a largura de um vale como o tamanho dos índices , ie. .$[s,t]$$t-s+1$

Desafio

Dado um perfil de altura (sequência de números inteiros não negativos), sua tarefa é determinar a largura do vale mais largo.

Exemplo

Dado o perfil de altura [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], podemos visualizá-lo como antes:

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

Observe como o segundo vale [3,2,1,0,0,1,2,2,3]não se estende mais para a direita porque o ponto mais à esquerda é e não . Além disso, não adicionamos os dois s restantes porque exigimos que o terminal seja mais alto que o segundo último ponto.$3$$4$$3$

Portanto, a largura do vale mais largo é .$9$

Regras

• A entrada será uma sequência de números inteiros não negativos (desculpe povo holandês)
  • você pode assumir que sempre há pelo menos um vale
• A saída será do tamanho do vale mais largo, conforme definido acima

Casos de teste

[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

Gelatina , 15 bytes

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

Experimente online!

Ou veja uma suíte de testes (foram adicionados mais dois casos de teste que anteriormente não cumpri).

Quão?

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

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

Experimente online!

Comentado

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 bytes

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

Experimente online!

Retina 0.8.2 , 77 bytes

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

O^`
\G,|$

Experimente online! O link inclui casos de teste. Explicação:

\d+
$*

Converta para unário.

M&!`

Listar, em vez de contar, correspondências sobrepostas.

\b(1+),

O início do vale é capturado \1. Isso não deve corresponder novamente até o final. Como não capturamos a vírgula, isso também impede a correspondência de valores mais altos.

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

Combine os valores decrescentes. O (?!1+\2)impede a qualquer passagem através do loop de ser maior do que a anterior. (A primeira vez que o processo \2não está definido, ela falha em corresponder trivialmente.) A captura inclui a vírgula à direita, pois é mais golfista.

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

Combine os valores crescentes. Esse tempo ((?3)\3|\2)significa que cada correspondência deve ter pelo menos o valor anterior ou a última captura decrescente pela primeira vez no loop.

\1\b

Finalmente, o fim do vale deve ter a mesma altura do início.

1

Exclua as alturas, deixando as vírgulas. (Isso é um pouco mais fácil do que contar as alturas, pois algumas podem ser zero.)

O^`

Classifique na ordem inversa, isto é, a maioria das vírgulas primeiro.

\G,|$

Conte o número de vírgulas na primeira linha, mais uma.

Casca , 13 bytes

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

Experimente online!

Explicação

Eu uso um algoritmo semelhante ao 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

Japonês , 31 bytes

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

Experimente online!

Economizou 10 bytes inspirando-se na resposta de Zgarb Husk. Ainda acho que isso pode ser melhorado, mas ainda não o encontrei.

Explicação:

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