## beta-recsys v0.1 版本发布啦！🎉🎉🎉

我们的 beta-recsys v0. 1 版本发布了！这是一个基于 pytorch 的推荐系统来源平台，我们致力于整合更多的推荐系统模型，为推荐系统这个社区提供一个公平比较的平台，同时推进代码的可复现性！**Github**: https://github.com/beta-team/beta-recsys

**teaser video:**https://vimeo.com/456391232

0%

我们的 beta-recsys v0. 1 版本发布了！这是一个基于 pytorch 的推荐系统来源平台，我们致力于整合更多的推荐系统模型，为推荐系统这个社区提供一个公平比较的平台，同时推进代码的可复现性！**Github**: https://github.com/beta-team/beta-recsys

**teaser video:**https://vimeo.com/456391232

Alice and Bob take turns playing a game, with **Alice starting first**.

There are `n`

stones arranged in a row. On each player’s turn, they can **remove** either the leftmost stone or the rightmost stone from the row and receive points equal to the **sum** of the remaining stones’ values in the row. The winner is the one with the higher score when there are no stones left to remove.

Bob found that he will always lose this game (poor Bob, he always loses), so he decided to **minimize the score’s difference**. Alice’s goal is to **maximize the difference** in the score.

Given an array of integers `stones`

where `stones [i]`

represents the value of the `ith`

stone **from the left**, return *the difference in Alice and Bob’s score if they both play optimally.*

You are given a **0-indexed** integer array `nums`

and an integer `k`

.

You are initially standing at index `0`

. In one move, you can jump at most `k`

steps forward without going outside the boundaries of the array. That is, you can jump from index `i`

to any index in the range `[i + 1, min (n - 1, i + k)]`

**inclusive**.

You want to reach the last index of the array (index `n - 1`

). Your **score** is the **sum** of all `nums [j]`

for each index `j`

you visited in the array.

Return *the maximum score you can get*.

You are given two integers `n`

and `k`

and two integer arrays `speed`

and `efficiency`

both of length `n`

. There are `n`

engineers numbered from `1`

to `n`

. `speed [i]`

and `efficiency [i]`

represent the speed and efficiency of the `ith`

engineer respectively.

Choose **at most** `k`

different engineers out of the `n`

engineers to form a team with the maximum **performance**.

The performance of a team is the sum of their engineers’ speeds multiplied by the minimum efficiency among their engineers.

Return *the maximum performance of this team*. Since the answer can be a huge number, return it **modulo** `109 + 7`

.

You have a lock in front of you with 4 circular wheels. Each wheel has 10 slots: `'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'`

. The wheels can rotate freely and wrap around: for example we can turn `'9'`

to be `'0'`

, or `'0'`

to be `'9'`

. Each move consists of turning one wheel one slot.

The lock initially starts at `'0000'`

, a string representing the state of the 4 wheels.

You are given a list of `deadends`

dead ends, meaning if the lock displays any of these codes, the wheels of the lock will stop turning and you will be unable to open it.

Given a `target`

representing the value of the wheels that will unlock the lock, return the minimum total number of turns required to open the lock, or -1 if it is impossible.