# Climbing Stairs

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

# Problem #70. Climbing Stairs

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 = 2Output: 2Explanation: There are two ways to climb to the top.1. 1 step + 1 step2. 2 steps`

Example 2:

`Input: n = 3Output: 3Explanation: There are three ways to climb…`

# Unique Paths

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 = 7Output: 28`

Example 2:

`Input: m = 3, n = 2Output: 3Explanation:From the top-left corner…`

# Decode Ways

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

# Problem #91. 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"`

# Valid Parentheses.

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:

1. Open brackets must be closed by the same type of brackets.
2. 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:

`…`

# Simplify Path. String exercises

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 `'...'`

# Implement Min Stack

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],,[-3],[],[],[],[]]Output[null,null,null,null,-3,null,0,-2]ExplanationMinStack minStack = new MinStack();minStack.push(-2);minStack.push(0);minStack.push(-3);minStack.getMin(); // return -3minStack.pop();minStack.top();    //…`

# Search in Rotated Array

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, nums, ..., 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…

# Reverse linked List I and II

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:

# 883. Projection Area of 3D Shapes

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. …

# Strings Excercises For Interview Prep

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… ## Jesus PF

I am en electronics engineer, graduated from ITESM. Experienced working as functional validation and software development.