valid-elements-in-an-array

java

python3

python

javascript

typescript

csharp

golang

kotlin

swift

rust

ruby

dart

scala

elixir

erlang

racket

cangjie

bash

mysql

mssql

postgresql

oraclesql

pythondata

Precompute the maximum left and right for each index.

Algorithms

You are given an integer array <code>nums</code>.

An element <code>nums[i]</code> is considered valid if it satisfies at least one of the following conditions:

<ul>
	<li>It is strictly greater than every element to its left.</li>
	<li>It is strictly greater than every element to its right.</li>
</ul>

The first and last elements are always valid.

Return an array of all valid elements in the same order as they appear in <code>nums</code>.

&nbsp;
Example 1:

<div class="example-block">
Input: nums = [1,2,4,2,3,2]

Output: [1,2,4,3,2]

Explanation:

<ul>
	<li><code>nums[0]</code> and <code>nums[5]</code> are always valid.</li>
	<li><code>nums[1]</code> and <code>nums[2]</code> are strictly greater than every element to their left.</li>
	<li><code>nums[4]</code> is strictly greater than every element to its right.</li>
	<li>Thus, the answer is <code>[1, 2, 4, 3, 2]</code>.</li>
</ul>
</div>

Example 2:

<div class="example-block">
Input: nums = [5,5,5,5]

Output: [5,5]

Explanation:

<ul>
	<li>The first and last elements are always valid.</li>
	<li>No other elements are strictly greater than all elements to their left or to their right.</li>
	<li>Thus, the answer is <code>[5, 5]</code>.</li>
</ul>
</div>

Example 3:

<div class="example-block">
Input: nums = [1]

Output: [1]

Explanation:

Since there is only one element, it is always valid. Thus, the answer is <code>[1]</code>.
</div>

&nbsp;
Constraints:

<ul>
	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
	<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
</ul>

第 499 场周赛

weekly-contest-499

findValidElements

中级工程师

Valid Elements in an Array

Array

给你一个整数数组 <code>nums</code>。

如果元素 <code>nums[i]</code> 满足以下&nbsp;至少一个&nbsp;条件，则认为它是&nbsp;有效&nbsp;元素：

<ul>
	<li>它&nbsp;严格大于&nbsp;其左侧的所有元素。</li>
	<li>它&nbsp;严格大于&nbsp;其右侧的所有元素。</li>
</ul>

第一个元素和最后一个元素始终有效。

返回所有有效元素组成的数组，顺序与它们在 <code>nums</code> 中出现的顺序相同。

&nbsp;

示例 1：

<div class="example-block">
输入： nums = [1,2,4,2,3,2]

输出： [1,2,4,3,2]

解释：

<ul>
	<li><code>nums[0]</code> 和 <code>nums[5]</code> 始终有效。</li>
	<li><code>nums[1]</code> 和 <code>nums[2]</code> 都严格大于其左侧的所有元素。</li>
	<li><code>nums[4]</code> 严格大于其右侧的所有元素。</li>
	<li>因此，答案为 <code>[1, 2, 4, 3, 2]</code>。</li>
</ul>
</div>

示例 2：

<div class="example-block">
输入： nums = [5,5,5,5]

输出： [5,5]

解释：

<ul>
	<li>第一个元素和最后一个元素始终有效。</li>
	<li>其他元素既不严格大于其左侧的所有元素，也不严格大于其右侧的所有元素。</li>
	<li>因此，答案为 <code>[5, 5]</code>。</li>
</ul>
</div>

示例 3：

<div class="example-block">
输入： nums = [1]

输出： [1]

解释：

由于数组中只有一个元素，它始终有效。因此，答案为 <code>[1]</code>。
</div>

&nbsp;

提示：

<ul>
	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
	<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
</ul>

数组中的有效元素

执行通过

错误解答

超出内存限制

超出输出限制

超出时间限制

执行出错

内部出错

编译出错

超时

Restrictions Failed

给你一个整数数组 nums。

如果元素 nums[i] 满足以下 至少一个 条件，则认为它是 有效 元素：

 * 它 严格大于 其左侧的所有元素。
 * 它 严格大于 其右侧的所有元素。

第一个元素和最后一个元素始终有效。

返回所有有效元素组成的数组，顺序与它们在 nums 中出现的顺序相同。

 

示例 1：

输入： nums = [1,2,4,2,3,2]

输出： [1,2,4,3,2]

解释：

 * nums[0] 和 nums[5] 始终有效。
 * nums[1] 和 nums[2] 都严格大于其左侧的所有元素。
 * nums[4] 严格大于其右侧的所有元素。
 * 因此，答案为 [1, 2, 4, 3, 2]。

示例 2：

输入： nums = [5,5,5,5]

输出： [5,5]

解释：

 * 第一个元素和最后一个元素始终有效。
 * 其他元素既不严格大于其左侧的所有元素，也不严格大于其右侧的所有元素。
 * 因此，答案为 [5, 5]。

示例 3：

输入： nums = [1]

输出： [1]

解释：

由于数组中只有一个元素，它始终有效。因此，答案为 [1]。

 

提示：

 * 1 <= nums.length <= 100
 * 1 <= nums[i] <= 100