With the increasing seniority in software development, comes up with multiple tasks to manage. I used to struggle between different meetings, completing my tasks, addressing the team’s issues and ad hoc productions bugs. Time used to fly like anything with very less productivity.

Some startups I worked with, did not have a proper tool for bug tracking. They used to create tasks in Google Document or assign bugs on Slack. This created a lot of chaos with no visibility on my work progress. End of the day I did not get the satisfaction of the work being done. …

Given a **non-empty** array of decimal digits representing a non-negative integer, increment one to the integer.

The digits are stored such that the most significant digit is at the head of the list, and each element in the array contains a single digit.

You may assume the integer does not contain any leading zero, except the number 0 itself.

Problem statement taken from: https://leetcode.com/problems/plus-one

**Example 1:**

`Input: digits = [1, 2, 3]`

Output: [1, 2, 4]

Explanation: The array represents the integer 123.

**Example 2:**

`Input: digits = [4, 3, 2, 1]`

Output: [4, 3, 2, 2]

Explanation: The array represents the…

Implement **strStr()**.

Return the index of the first occurrence of needle in haystack, or **-1** if **needle** is not part of **haystack**.

**Clarification:**

What should we return when **needle** is an empty string? This is a great question to ask during an interview.

For the purpose of this problem, we will return 0 when **needle** is an empty string. This is consistent to C’s **strstr()** and Java’s **indexOf()**.

Problem statement taken from: https://leetcode.com/problems/implement-strstr

**Example 1:**

`Input: haystack = "hello", needle = "ll"`

Output: 2

**Example 2:**

`Input: haystack = "aaaaa", needle = "bba"`

Output: -1

**Example 3:**

`Input: haystack =…`

You are given two integer arrays **nums1** and **nums2**, sorted in **non-decreasing** order, and two integers **m** and **n**, representing the number of elements in **nums1** and **nums2** respectively.

**Merge** **nums1** and **nums2** into a single array sorted in **non-decreasing order**.

The final sorted array should not be returned by the function, but instead, be stored inside the array **nums1**. To accommodate this, **nums1** has a length of **m + n**, where the first **m** elements denote the elements that should be merged, and the last **n** elements are set to **0** and should be ignored. **…**

Given an array **nums** with **n** objects colored red, white, or blue, sort them **in-place** so that objects of the same color are adjacent, with the colors in the order red, white, and blue.

We will use the integers **0**, **1**, and **2** to represent the color red, white, and blue, respectively.

You must solve this problem without using the library’s sort function.

Problem statement taken from: https://leetcode.com/problems/sort-colors

**Example 1:**

`Input: nums = [2, 0, 2, 1, 1, 0]`

Output: [0, 0, 1, 1, 2, 2]

**Example 2:**

`Input: nums = [2, 0, 1]`

Output: [0, 1, 2]

**Example 3:**

`…`

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.

Problem statement taken from: https://leetcode.com/problems/valid-parentheses

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

`Input: s = "{[]}"`

Output: true

**Constraints:**

`- 1 <= s.length…`

You are given an **n x n** 2D **matrix** representing an image, rotate the image by **90** degrees (clockwise).

You have to rotate the image **in-place**, which means you have to modify the input 2D matrix directly. **DO NOT** allocate another 2D matrix and do the rotation.

Problem statement taken from: https://leetcode.com/problems/rotate-image

**Example 1:**

`Input: matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]`

Output: [[7, 4, 1], [8, 5, 2], [9, 6, 3]]

**Example 2:**

`Input: matrix = [[5, 1, 9, 11], [2, 4, 8, 10], [13, 3, 6, 7], [15, 14, 12, 16]]`

Output: [[15, 13, 2…

Given an integer array **nums**, find the contiguous subarray (containing at least one number) which has the largest sum and return *its sum*.

Problem statement taken from: https://leetcode.com/problems/maximum-subarray

**Example 1:**

`Input: nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]`

Output: 6

Explanation: [4, -1, 2, 1] has the largest sum = 6.

**Example 2:**

`Input: nums = [1]`

Output: 1

**Example 3:**

`Input: nums = [5, 4, -1, 7, 8] `

Output: 23

**Constraints:**

`- 1 <= nums.length <= 3 * 10^4 - `

-10^5 <= nums[i] <= 10^5

The brute force approach is to generate all subarrays and…

Given an array of integers **nums** sorted in ascending order, find the starting and ending position of a given **target** value.

If **target** is not found in the array, return **[-1, -1]**.

Problem statement taken from: https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array

**Example 1:**

`Input: nums = [5, 7, 7, 8, 8, 10], target = 8`

Output: [3, 4]

**Example 2:**

`Input: nums = [5, 7, 7, 8, 8, 10], target = 6`

Output: [-1, -1]

**Example 3:**

`Input: nums = [], target = 0`

Output: [-1, -1]

**Constraints:**

`- 0 <= nums.length <= 10^5`

- -10^9 <= nums[i] <= 10^9

- nums is a non-decreasing array.

…

Given a sorted array **nums**, remove the duplicates in-place such that each element appears only once and returns the new length.

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

Problem statement taken from: https://leetcode.com/problems/remove-duplicates-from-sorted-array

**Example 1:**

`Input: nums = [1, 1, 2]`

Output: 2, nums = [1, 2]

Explanation: Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively. It doesn't matter what you leave beyond the returned length.

**Example 2:**

`Input: nums = [0, 0, 1…`

Software Engineer. Working Saeloun. My portfolio https://alkeshghorpade.me