山岳地帯のスライスを取得すると、これは次のような形状になります。

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]左端のポイントが4ではなく$3$ため、2番目の谷がさらに右に伸びないことに注意してください。さらに、エンドポイントが最後から2番目のポイントよりも高い必要があるため、残りの2つの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Ḣ)Ṁ‘

オンラインでお試しください！

または、テストスイートを参照してください（以前に失敗したテストケースを2つ追加しました）。

どうやって？

Ẇµ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バイト

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

オンラインでお試しください！

Retina 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,|$

最初の行のコンマの数に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