restore-finishing-order

java

python3

python

javascript

typescript

csharp

golang

kotlin

swift

rust

ruby

dart

scala

elixir

erlang

racket

cangjie

bash

mysql

mssql

postgresql

oraclesql

pythondata

Use a hash set for quick friend lookups from <code>friends</code>.

Iterate over <code>order</code>, checking the set to collect your friends in finishing order.

Algorithms

You are given an integer array <code>order</code> of length <code>n</code> and an integer array <code>friends</code>.

<ul>
	<li><code>order</code> contains every integer from 1 to <code>n</code> exactly once, representing the IDs of the participants of a race in their finishing order.</li>
	<li><code>friends</code> contains the IDs of your friends in the race sorted in strictly increasing order. Each ID in friends is guaranteed to appear in the <code>order</code> array.</li>
</ul>

Return an array containing your friends&#39; IDs in their finishing order.

&nbsp;
Example 1:

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

Output: [3,1,4]

Explanation:

The finishing order is <code>[3, 1, 2, 5, 4]</code>. Therefore, the finishing order of your friends is <code>[3, 1, 4]</code>.
</div>

Example 2:

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

Output: [5,2]

Explanation:

The finishing order is <code>[1, 4, 5, 3, 2]</code>. Therefore, the finishing order of your friends is <code>[5, 2]</code>.
</div>

&nbsp;
Constraints:

<ul>
	<li><code>1 &lt;= n == order.length &lt;= 100</code></li>
	<li><code>order</code> contains every integer from 1 to <code>n</code> exactly once</li>
	<li><code>1 &lt;= friends.length &lt;= min(8, n)</code></li>
	<li><code>1 &lt;= friends[i] &lt;= n</code></li>
	<li><code>friends</code> is strictly increasing</li>
</ul>

第 465 场周赛

weekly-contest-465

recoverOrder

中级工程师

Restore Finishing Order

Array

Hash Table

给你一个长度为 <code>n</code> 的整数数组 <code>order</code> 和一个整数数组 <code>friends</code>。

<ul>
	<li><code>order</code> 包含从 1 到 <code>n</code> 的每个整数，且&nbsp;恰好出现一次&nbsp;，表示比赛中参赛者按照&nbsp;完成顺序&nbsp;的 ID。</li>
	<li><code>friends</code> 包含你朋友们的 ID，按照&nbsp;严格递增&nbsp;的顺序排列。<code>friends</code> 中的每个 ID 都保证出现在 <code>order</code> 数组中。</li>
</ul>

请返回一个数组，包含你朋友们的 ID，按照他们的&nbsp;完成顺序&nbsp;排列。

&nbsp;

示例 1：

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

输出：[3,1,4]

解释：

完成顺序是 <code>[3, 1, 2, 5, 4]</code>。因此，你朋友的完成顺序是 <code>[3, 1, 4]</code>。
</div>

示例 2：

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

输出：[5,2]

解释：

完成顺序是 <code>[1, 4, 5, 3, 2]</code>。因此，你朋友的完成顺序是 <code>[5, 2]</code>。
</div>

&nbsp;

提示：

<ul>
	<li><code>1 &lt;= n == order.length &lt;= 100</code></li>
	<li><code>order</code> 包含从 1 到 <code>n</code> 的每个整数，且恰好出现一次</li>
	<li><code>1 &lt;= friends.length &lt;= min(8, n)</code></li>
	<li><code>1 &lt;= friends[i] &lt;= n</code></li>
	<li><code>friends</code> 是严格递增的</li>
</ul>

重排完成顺序

执行通过

错误解答

超出内存限制

超出输出限制

超出时间限制

执行出错

内部出错

编译出错

超时

Restrictions Failed

给你一个长度为 n 的整数数组 order 和一个整数数组 friends。

 * order 包含从 1 到 n 的每个整数，且 恰好出现一次 ，表示比赛中参赛者按照 完成顺序 的 ID。
 * friends 包含你朋友们的 ID，按照 严格递增 的顺序排列。friends 中的每个 ID 都保证出现在 order 数组中。

请返回一个数组，包含你朋友们的 ID，按照他们的 完成顺序 排列。

 

示例 1：

输入：order = [3,1,2,5,4], friends = [1,3,4]

输出：[3,1,4]

解释：

完成顺序是 [3, 1, 2, 5, 4]。因此，你朋友的完成顺序是 [3, 1, 4]。

示例 2：

输入：order = [1,4,5,3,2], friends = [2,5]

输出：[5,2]

解释：

完成顺序是 [1, 4, 5, 3, 2]。因此，你朋友的完成顺序是 [5, 2]。

 

提示：

 * 1 <= n == order.length <= 100
 * order 包含从 1 到 n 的每个整数，且恰好出现一次
 * 1 <= friends.length <= min(8, n)
 * 1 <= friends[i] <= n
 * friends 是严格递增的