The next problem is a great example of problems that may be solved by recursion or by DP. Excellent to study for your SW interview

https://leetcode.com/problems/climbing-stairs/

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:**

**Input:** n = 2

**Output:** 2

**Explanation:** There are two ways to climb to the top.

1. 1 step + 1 step

2. 2 steps

**Example 2:**

**Input:** n = 3

**Output:** 3

**Explanation:** There are three ways to climb…

The next exercise will help you landing that software interview by using DP.

Problem #62. Unique Paths

A robot is located at the top-left corner of a `m x n`

grid (marked 'Start' in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked ‘Finish’ in the diagram below).

How many possible unique paths are there?

**Example 1:**

**Input:** m = 3, n = 7

**Output:** 28

**Example 2:**

**Input:** m = 3, n = 2

**Output:** 3

**Explanation:**

From the top-left corner…

The next exercise will help you landing that Software interview. Extracted from leetcode: https://leetcode.com/problems/decode-ways/

A message containing letters from `A-Z`

can be **encoded** into numbers using the following mapping:

`'A' -> "1"`

'B' -> "2"

...

'Z' -> "26"

To **decode** an encoded message, all the digits must be grouped then mapped back into letters using the reverse of the mapping above (there may be multiple ways). For example, `"11106"`

can be mapped into:

`"AAJF"`

with the grouping`(1 1 10 6)`

`"KJF"`

with the grouping`(11 10 6)`

Note that the grouping `(1 11 06)`

is invalid because `"06"`

…

The following leetcode excercise will help you to practice using strings and stacks. https://leetcode.com/problems/valid-parentheses/

Problem #20. Valid Parentheses

Given a string `s`

containing just the characters `'('`

, `')'`

, `'{'`

, `'}'`

, `'['`

and `']'`

, determine if the input string is valid.

An input string is valid if:

- Open brackets must be closed by the same type of brackets.
- Open brackets must be closed in the correct order.

**Example 1:**

**Input:** s = "()"

**Output:** true

**Example 2:**

**Input:** s = "()[]{}"

**Output:** true

**Example 3:**

**Input:** s = "(]"

**Output:** false

**Example 4:**

**Input:** s = "([)]"

**Output:** false

**Example 5:**

**…**

The following problem helps you to manage data structures and string manipulation

Problem #71. Simplify Path

https://leetcode.com/problems/simplify-path/

Given a string `path`

, which is an **absolute path** (starting with a slash `'/'`

) to a file or directory in a Unix-style file system, convert it to the simplified **canonical path**.

In a Unix-style file system, a period `'.'`

refers to the current directory, a double period `'..'`

refers to the directory up a level, and any multiple consecutive slashes (i.e. `'//'`

) are treated as a single slash `'/'`

. For this problem, any other format of periods such as `'...'`

…

The following leetcode exercise asks the user to implement a min stack. Link: https://leetcode.com/problems/min-stack

**Problem #**155. Min Stack

Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.

Implement the `MinStack`

class:

`MinStack()`

initializes the stack object.`void push(val)`

pushes the element`val`

onto the stack.`void pop()`

removes the element on the top of the stack.`int top()`

gets the top element of the stack.`int getMin()`

retrieves the minimum element in the stack.

**Example 1:**

Input

["MinStack","push","push","push","getMin","pop","top","getMin"]

[[],[-2],[0],[-3],[],[],[],[]]Output

[null,null,null,null,-3,null,0,-2]Explanation

MinStack minStack = new MinStack();

minStack.push(-2);

minStack.push(0);

minStack.push(-3);

minStack.getMin(); // return -3

minStack.pop();

minStack.top(); //…

The next medium level leetcode exercise provides a good understanding of search algorithms and array operations. Exercise: https://leetcode.com/problems/search-in-rotated-sorted-array/

Problem #33. Search in Rotated Sorted Array

There is an integer array `nums`

sorted in ascending order (with **distinct** values).

Prior to being passed to your function, `nums`

is **rotated** at an unknown pivot index `k`

(`0 <= k < nums.length`

) such that the resulting array is `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]`

(**0-indexed**). For example, `[0,1,2,4,5,6,7]`

might be rotated at pivot index `3`

and become `[4,5,6,7,0,1,2]`

.

Given the array `nums`

**after** the rotation and an integer `target`

, return *the…*

The next writting will contain my solution for the following leetcode problems: https://leetcode.com/problems/reverse-linked-list/ and https://leetcode.com/problems/rotate-list/

These two are fairly simple linked list problems. to handle these type of problem is usually recommended to use a dummy node prev that points your current element.

Problem # 206. Reverse Linked List

Given the `head`

of a singly linked list, reverse the list, and return *the reversed list*.

**Example 1:**

**Input:** head = [1,2,3,4,5]

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

**Example 2:**

From Leetcode excersice https://leetcode.com/problems/projection-area-of-3d-shapes/

We are solving this problem that covers arrays management and a little bit of mathematics and spatial intelligence.

You are given an `n x n`

`grid`

where we place some `1 x 1 x 1`

cubes that are axis-aligned with the `x`

, `y`

, and `z`

axes.

Each value `v = grid[i][j]`

represents a tower of `v`

cubes placed on top of the cell `(i, j)`

.

We view the projection of these cubes onto the `xy`

, `yz`

, and `zx`

planes.

A **projection** is like a shadow, that maps our **3-dimensional** figure to a **2-dimensional** plane. …

This is a popurri with good practices excercises for SW interviews

709. To Lower Case

Implement function ToLowerCase() that has a string parameter str, and returns the same string in lowercase.

**Example 1:**

**Input: **"Hello"

**Output: **"hello"

**Example 2:**

**Input: **"here"

**Output: **"here"

**Example 3:**

**Input: **"LOVELY"

**Output: **"lovely"

**Solution:**

`class Solution {`

public String toLowerCase(String str) {

StringBuilder st=new StringBuilder();

for(char c: str.toCharArray()){

if(c <= 'Z' && c >= 'A'){

c= (char) (c+0x20);

}

st.append(c);

}

return st.toString();

}

}

1614. Maximum Nesting Depth of the Parentheses

A string is a **valid parentheses string** (denoted **VPS**) if it meets…