If you are a newbie in the world of CP, here are some great platforms to begin your competitive programming journey.

For all those seeking the platforms to start their CP journey, have a look at these cool awesome websites, you would love to begin with.

I would suggest you begin your journey with Hackerrank as this website has good UI, along with that, you can improve your skills as per topics.

It has good inflation, the more you practice the more your rank increases. HackerRank focuses on computer science topics so it provides challenges for several domains such as…

We have a list of `points`

on the plane. Find the `K`

closest points to the origin `(0, 0)`

.

(Here, the distance between two points on a plane is the Euclidean distance.)

You may return the answer in any order. The answer is guaranteed to be unique (except for the order that it is in).

**Example 1:**

**Input: **points = [[1,3],[-2,2]], K = 1

**Output: **[[-2,2]]

**Explanation: **

The distance between (1, 3) and the origin is sqrt(10).

The distance between (-2, 2) and the origin is sqrt(8).

Since sqrt(8) < sqrt(10), (-2, 2) is closer to the origin. …

Given a string, sort it in decreasing order based on the frequency of characters.

**Example 1:**

**Input:**

"tree"

**Output:**

"eert"

**Explanation:**

'e' appears twice while 'r' and 't' both appear once.

So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.

**Example 2:**

**Input:**

"cccaaa"

**Output:**

"cccaaa"

**Explanation:**

Both 'c' and 'a' appear three times, so "aaaccc" is also a valid answer.

Note that "cacaca" is incorrect, as the same characters must be together.

**Example 3:**

**Input:**

"Aabb"

**Output:**

"bbAa"

**Explanation:**

"bbaA" is also a valid answer, but "Aabb" is incorrect. …

Given a `m * n`

matrix of ones and zeros, return how many **square** submatrices have all ones.

**Example 1:**

**Input:** matrix =

[

[0,1,1,1],

[1,1,1,1],

[0,1,1,1]

]

**Output:** 15

**Explanation:**

There are **10** squares of side 1.

There are **4** squares of side 2.

There is **1** square of side 3.

Total number of squares = 10 + 4 + 1 = **15**.

**Example 2:**

**Input:** matrix =

[

[1,0,1],

[1,1,0],

[1,1,0]

]

**Output:** 7

**Explanation:**

There are **6** squares of side 1.

There is **1** square of side 2. …

Write a class `StockSpanner`

which collects daily price quotes for some stock, and returns the *span* of that stock's price for the current day.

The span of the stock’s price today is defined as the maximum number of consecutive days (starting from today and going backwards) for which the price of the stock was less than or equal to today’s price.

For example, if the price of a stock over the next 7 days were `[100, 80, 60, 70, 60, 75, 85]`

, then the stock spans would be `[1, 1, 1, 2, 1, 4, 6]`

.

**Example 1:**

**Input: **["StockSpanner","next","next","next","next","next","next","next"], [[],[100],[80],[60],[70],[60],[75],[85]]

**Output…**

Given a string **s** and a **non-empty** string **p**, find all the start indices of **p**’s anagrams in **s**.

Strings consists of lowercase English letters only and the length of both strings **s** and **p** will not be larger than 20,100.

The order of output does not matter.

**Example 1:**

**Input:**

s: "cbaebabacd" p: "abc"

**Output:**

[0, 6]

**Explanation:**

The substring with start index = 0 is "cba", which is an anagram of "abc".

The substring with start index = 6 is "bac", which is an anagram of "abc".

**Example 2:**

Input:

s: "abab" p: "ab"Output:

[0, 1, 2]…

Given an array arr[] of integers and the sum value, we have to find whether there is a subset whose value is equal to sum our array arr[].

If it exists, return true else false.

Example :

**Input:** arr[] = {3, 34, 4, 12, 5, 2}, sum = 9

**Output:** True

**Explanation:** There is a subset (4, 5) with sum 9.

**Input:** arr[] = {3, 34, 4, 12, 5, 2}, sum = 30

**Output:** False

**Explanation: ** There is no subset that add up to 30.

Solution:

There can be more than one approach to solve this question, a naive approach…

Given a **circular array** **C** of integers represented by `A`

, find the maximum possible sum of a non-empty subarray of **C**.

Here, a *circular array* means the end of the array connects to the beginning of the array. (Formally, `C[i] = A[i]`

when `0 <= i < A.length`

, and `C[i+A.length] = C[i]`

when `i >= 0`

.)

Also, a subarray may only include each element of the fixed buffer `A`

at most once. (Formally, for a subarray `C[i], C[i+1], ..., C[j]`

, there does not exist `i <= k1, k2 <= j`

with `k1 % A.length = k2 % A.length`

).

**Example 1:**

**…**

Given a non-negative integer *num* represented as a string, remove *k* digits from the number so that the new number is the smallest possible.

**NOTE:**

**. **The length of *num* is less than 10002 and will be ≥ *k*.

**. **The given *num* does not contain any leading zero.

**Example 1:**

`Input: num = "1432219", k = 3`

Output: "1219"

Explanation: Remove the three digits 4, 3, and 2 to form the new number 1219 which is the smallest.

**Example 2:**

`Input: num = "10200", k = 1`

Output: "200"

Explanation: Remove the leading 1 and the number is 200. Note that…