You can also read the full story on The Swift Nerd blog with the link above.

There are several cards **arranged in a row**, and each card has an associated number of points The points are given in the integer array `cardPoints`

.

In one step, you can take one card from the beginning or from the end of the row. You have to take exactly `k`

cards. Your score is the sum of the points of the cards you have taken.

Given the integer array `cardPoints`

and the integer `k`

, return the *maximum score* you can obtain.

**Input:** cardPoints =…

You can check out the full explanation on The Swift Nerd blog along with other cool posts on the link above.

Count the number of prime numbers less than a non-negative number, `n`

.

Input:n = 10Output:4Explanation:There are 4 prime numbers less than 10, they are 2, 3, 5, 7.Input:n = 0Output:0Input:n = 1Output:0

`0 <= n <= 5 * 106`

The problem is pretty self evident and is simple to solve but a bit tricky to optimise. A prime number is a number which is only divisible…

You can check out the full story on The Swift Nerd blog with the link above.

Given the `head`

of a singly linked list where elements are **sorted in ascending order**, convert it to a height balanced BST.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of *every* node never differ by more than 1.

**Example 1:**

Follow the link above for more detailed solution and other interesting posts.

Given an array of non-negative integers `nums`

, you are initially positioned at the first index of the array. Each element in the array represents your maximum jump length at that position.

Your goal is to reach the last index in the minimum number of jumps. You can assume that you can always reach the last index.

**Examples**

**Input:** nums = [2,3,1,1,4]

**Output:** 2

**Explanation:** The minimum number of jumps to reach the last index is 2. …

You can also read the full story on The Swift Nerd blog with the link above.

Given an array `nums`

. We define a running sum of an array as `runningSum[i] = sum(nums[0]…nums[i])`

.

Return the running sum of `nums`

.

Input:nums = [1,2,3,4]Output:[1,3,6,10]Explanation:Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].Input:nums = [1,1,1,1,1]Output:[1,2,3,4,5]Explanation:Running sum is obtained as follows: [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1].Input:nums = [3,1,2,10,1]Output:[3,4,6,16,17]

`1 <= nums.length <= 1000`

`-10^6 <= nums[i] <= 10^6`

You can also read the full story on The Swift Nerd blog along with other interesting articles on the link above.

Given three integers x, y, and `bound`

, return *a list of all the **powerful integers** that have a value less than or equal to* bound.

An integer is **powerful** if it can be represented as xi + yj for some integers i >= 0 and j >= 0. You may return the answer in **any order**. In your answer, each value should occur **at most once**.

**Example 1:**

**Input:** x = 2, y = 3, bound = 10 **Output…**

Binary Search Magic with Swift (Leetcode 34) ✅ ✅ ✅

You can also read the full story on The Swift Nerd blog along with other interesting stories on link above.

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]`

.

**Follow up:** Could you write an algorithm with `O(log n)`

runtime complexity?

Input:nums = [5,7,7,8,8,10], target = 8Output:[3,4]Input:nums = [], target = 0Output:[-1,-1]

`0 <= nums.length <= 105`

`-109 <= nums[i]…`

You can also read the full story on The Swift Nerd blog along with other interesting stories by clicking the link above.

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

Now consider if some obstacles are added to the grids. How many unique paths would there be?

An obstacle and space is marked as `1`

and…

You can also check out the discussion on my blog along with other interesting posts.

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.

**Example 1:**

You can also read the full story along with other interesting ones on **TheSwiftNerd** blog with the link above.

Give a string `s`

, count the number of non-empty (contiguous) substrings that have the same number of 0’s and 1’s, and all the 0’s and all the 1’s in these substrings are grouped consecutively.

Substrings that occur multiple times are counted the number of times they occur.

**Example 1:**

Input:"00110011"Output:6Explanation:There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".Notice that some of these substrings repeat…

Senior iOS Engineer. Writer at https://theswiftnerd.com