# 2022-05-26

### Description

You are climbing a staircase. It takes `n`

steps to reach the top.

Each time you can either climb `1`

or `2`

steps. In how many distinct ways can you climb to the top?

**Example 1:**

**Example 2:**

**Constraints:**

`1 <= n <= 45`

### Solution

#### Approach #0

### Description

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and **it will automatically contact the police if two adjacent houses were broken into on the same night**.

Given an integer array `nums`

representing the amount of money of each house, return *the maximum amount of money you can rob tonight ** without alerting the police*.

**Example 1:**

**Example 2:**

**Constraints:**

`1 <= nums.length <= 100`

`0 <= nums[i] <= 400`

### Solution

#### Approach #0

### Description

Given a `triangle`

array, return *the minimum path sum from top to bottom*.

For each step, you may move to an adjacent number of the row below. More formally, if you are on index `i`

on the current row, you may move to either index `i`

or index `i + 1`

on the next row.

**Example 1:**

**Example 2:**

**Constraints:**

`1 <= triangle.length <= 200`

`triangle[0].length == 1`

`triangle[i].length == triangle[i - 1].length + 1`

`-104 <= triangle[i][j] <= 104`

**Follow up:** Could you do this using only `O(n)`

extra space, where `n`

is the total number of rows in the triangle?

### Solution

#### Approach #0: Better than the official solution

### Description

There are several squares being dropped onto the X-axis of a 2D plane.

You are given a 2D integer array `positions`

where `positions[i] = [lefti, sideLengthi]`

represents the `ith`

square with a side length of `sideLengthi`

that is dropped with its left edge aligned with X-coordinate `lefti`

.

Each square is dropped one at a time from a height above any landed squares. It then falls downward (negative Y direction) until it either lands **on the top side of another square** or **on the X-axis**. A square brushing the left/right side of another square does not count as landing on it. Once it lands, it freezes in place and cannot be moved.

After each square is dropped, you must record the **height of the current tallest stack of squares**.

Return *an integer array *`ans`

* where *`ans[i]`

* represents the height described above after dropping the *`ith`

* square*.

**Example 1:**

**Example 2:**

**Constraints:**

`1 <= positions.length <= 1000`

`1 <= lefti <= 10^8`

`1 <= sideLengthi <= 10^6`

### Solution

#### Approach #0

### Description

Given an integer array `nums`

and an integer `val`

, remove all occurrences of `val`

in `nums`

**in-place**. The relative order of the elements may be changed.

Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the **first part** of the array `nums`

. More formally, if there are `k`

elements after removing the duplicates, then the first `k`

elements of `nums`

should hold the final result. It does not matter what you leave beyond the first `k`

elements.

Return `k`

* after placing the final result in the first *`k`

* slots of *`nums`

.

Do **not** allocate extra space for another array. You must do this by **modifying the input array ****in-place** with O(1) extra memory.

**Custom Judge:**

The judge will test your solution with the following code:

If all assertions pass, then your solution will be **accepted**.

**Example 1:**

**Example 2:**

**Constraints:**

`0 <= nums.length <= 100`

`0 <= nums[i] <= 50`

`0 <= val <= 100`

### Solution

#### Approach #0

#### Approach #1

Last updated