Forem: Manasi Patil

5 Linux Commands that makes you feel like a Hacker

Manasi Patil — Tue, 03 Mar 2026 05:39:20 +0000

5 Linux Commands that makes you feel like a Hacker

ranger - navigate and read your files
lazygit - to see all the operations you performed on git
lazydocker - to see all the containers running and all the operations on docker
glances - to see all the process running on your machine
cmatrix - provides you hacker like vibes

PS: you need to install them first on your system

Day 100 of 100 days dsa coding challenge

Manasi Patil — Mon, 12 Jan 2026 05:43:33 +0000

🔥 100 Days Completed! 🔥
Taking on the GeeksforGeeks POTD challenge has been one of the best decisions — 100 days of consistency, learning, debugging, and levelling up! 💻🚀

From tricky edge cases to satisfying ACs, every day taught me something new.
Here’s to staying consistent and growing further — one problem at a time! 💪✨

100DaysOfCode #CodingChallenge #ProblemSolving #GeeksforGeeks #DeveloperJourney

Problem:

https://www.geeksforgeeks.org/problems/maximum-of-all-subarrays-of-size-k3101/1

K Sized Subarray Maximum
Difficulty: Medium Accuracy: 26.04%
Given an array arr[] of positive integers and an integer k. You have to find the maximum value for each contiguous subarray of size k. Return an array of maximum values corresponding to each contiguous subarray.

Examples:
Input: arr[] = [1, 2, 3, 1, 4, 5, 2, 3, 6], k = 3
Output: [3, 3, 4, 5, 5, 5, 6]
Explanation:
1st contiguous subarray [1, 2, 3], max = 3
2nd contiguous subarray [2, 3, 1], max = 3
3rd contiguous subarray [3, 1, 4], max = 4
4th contiguous subarray [1, 4, 5], max = 5
5th contiguous subarray [4, 5, 2], max = 5
6th contiguous subarray [5, 2, 3], max = 5
7th contiguous subarray [2, 3, 6], max = 6

Input: arr[] = [5, 1, 3, 4, 2], k = 1
Output: [5, 1, 3, 4, 2]
Explanation: When k = 1, each element in the array is its own subarray, so the output is simply the same array
Constraints:
1 ≤ arr.size() ≤ 106
1 ≤ k ≤ arr.size()
0 ≤ arr[i] ≤ 109

Solution:
from collections import deque

class Solution:
def maxOfSubarrays(self, arr, k):
dq = deque()
res = []

    for i in range(len(arr)):
        if dq and dq[0] == i - k:
            dq.popleft()
        while dq and arr[dq[-1]] <= arr[i]:
            dq.pop()
        dq.append(i)
        if i >= k - 1:
            res.append(arr[dq[0]])

    return res

Day 99 of 100 days dsa coding challenge

Manasi Patil — Sun, 11 Jan 2026 06:21:11 +0000

Taking on a new challenge: solving GeeksforGeeks POTD daily and sharing my solutions! 💻🔥
The goal: sharpen problem-solving skills, level up coding, and learn something new every day. Follow my journey! 🚀

100DaysOfCode #CodingChallenge #ProblemSolving #GeeksforGeeks #DeveloperJourney

Problem:

https://www.geeksforgeeks.org/problems/minimum-window-subsequence/1

Minimum Window Subsequence

Difficulty: Medium Accuracy: 49.43%

You are given two strings, s1 and s2. Your task is to find the smallest substring in s1 such that s2 appears as a subsequence within that substring.

The characters of s2 must appear in the same sequence within the substring of s1.
If there are multiple valid substrings of the same minimum length, return the one that appears first in s1.
If no such substring exists, return an empty string. Note: Both the strings contain only lowercase english letters.

Examples:
Input: s1 = "geeksforgeeks", s2 = "eksrg"
Output: "eksforg"
Explanation: "eksforg" satisfies all required conditions. s2 is its subsequence and it is smallest and leftmost among all possible valid substrings of s1.
Input: s1 = "abcdebdde", s2 = "bde"
Output: "bcde"
Explanation: "bcde" and "bdde" are two substring of s1 where s2 occurs as subsequence but "bcde" occur first so we return that.

Input: s1 = "ad", s2 = "b"
Output: ""
Explanation: There is no substring exists.
Constraints:
1 ≤ s1.length ≤ 104
1 ≤ s2.length ≤ 50

Solution:
class Solution:
def minWindow(self, s1, s2):
n,m=len(s1),len(s2)
inf = 10**9
dp = {}

    def solve(i,j):
        if j==m:
            return i

        if i==n:
            return inf

        if (i,j) in dp:
            return dp[(i,j)]

        if s1[i]==s2[j]:
            dp[(i,j)] = solve(i+1,j+1)
        else:
            dp[(i,j)] = solve(i+1,j)
        return dp[(i,j)]

    start=-1
    min_ = inf

    for i in range(n):
        if s1[i]==s2[0]:
            end = solve(i,0)
            if end!=inf and end-i<min_:
                min_ = end-i
                start = i

    return "" if start==-1 else s1[start:start+min_]

Day 98 of 100 days dsa coding challenge

Manasi Patil — Sat, 10 Jan 2026 17:01:59 +0000

100DaysOfCode #CodingChallenge #ProblemSolving #GeeksforGeeks #DeveloperJourney

Problem:

https://www.geeksforgeeks.org/problems/count-number-of-substrings4528/1

Substrings with K Distinct
Difficulty: Medium Accuracy: 20.46%
You are given a string s consisting of lowercase characters and an integer k, You have to count all possible substrings that have exactly k distinct characters.
Examples :
Input: s = "abc", k = 2
Output: 2
Explanation: Possible substrings are ["ab", "bc"]
Input: s = "aba", k = 2
Output: 3
Explanation: Possible substrings are ["ab", "ba", "aba"]
Input: s = "aa", k = 1
Output: 3
Explanation: Possible substrings are ["a", "a", "aa"]
Constraints:
1 ≤ s.size() ≤ 106
1 ≤ k ≤ 26

Solution:
class Solution:
def countSubstr(self, s, k):
return self.atMost(s, k) - self.atMost(s, k - 1)

def atMost(self, s, k):
    if k == 0:
        return 0

    count = {}
    left = 0
    res = 0

    for right in range(len(s)):
        count[s[right]] = count.get(s[right], 0) + 1

        while len(count) > k:
            count[s[left]] -= 1
            if count[s[left]] == 0:
                del count[s[left]]
            left += 1

        res += right - left + 1

    return res

Day 97 of 100 days dsa coding challenge

Manasi Patil — Fri, 09 Jan 2026 02:23:02 +0000

100DaysOfCode #CodingChallenge #ProblemSolving #GeeksforGeeks #DeveloperJourney

Problem:

https://www.geeksforgeeks.org/problems/subarrays-with-at-most-k-distinct-integers/1

Subarrays With At Most K Distinct Integers

Difficulty: Medium Accuracy: 62.09%

You are given an array arr[] of positive integers and an integer k, find the number of subarrays in arr[] where the count of distinct integers is at most k.
Note: A subarray is a contiguous part of an array.

Examples:
Input: arr[] = [1, 2, 2, 3], k = 2
Output: 9
Explanation: Subarrays with at most 2 distinct elements are: [1], [2], [2], [3], [1, 2], [2, 2], [2, 3], [1, 2, 2] and [2, 2, 3].
Input: arr[] = [1, 1, 1], k = 1
Output: 6
Explanation: Subarrays with at most 1 distinct element are: [1], [1], [1], [1, 1], [1, 1] and [1, 1, 1].
Input: arr[] = [1, 2, 1, 1, 3, 3, 4, 2, 1], k = 2
Output: 24
Explanation: There are 24 subarrays with at most 2 distinct elements.
Constraints:
1 ≤ arr.size() ≤ 2*104
1 ≤ k ≤ 2*104
1 ≤ arr[i] ≤ 109

Solution:
class Solution:
def countAtMostK(self, arr, k):
# Code here
from collections import Counter

    cnt = Counter()
    left = 0
    ans = 0

    for r, e in enumerate(arr):
        cnt[e] += 1
        while len(cnt) > k and left <= r:
            cnt[arr[left]] -= 1
            if cnt[arr[left]] == 0:
                cnt.pop(arr[left])
            left += 1
        ans += r-left+1
    return ans

Day 96 of 100 days dsa coding challenge

Manasi Patil — Thu, 08 Jan 2026 02:35:30 +0000

100DaysOfCode #CodingChallenge #ProblemSolving #GeeksforGeeks #DeveloperJourney

Problem:

https://www.geeksforgeeks.org/problems/count-subarray-with-k-odds/1

Count Subarray with k odds

Difficulty: Medium Accuracy: 53.77%

You are given an array arr[] of positive integers and an integer k. You have to count the number of subarrays that contain exactly k odd numbers.
Examples:
Input: arr[] = [2, 5, 6, 9], k = 2
Output: 2
Explanation: There are 2 subarrays with 2 odds: [2, 5, 6, 9] and [5, 6, 9].
Input: arr[] = [2, 2, 5, 6, 9, 2, 11], k = 2
Output: 8
Explanation: There are 8 subarrays with 2 odds: [2, 2, 5, 6, 9], [2, 5, 6, 9], [5, 6, 9], [2, 2, 5, 6, 9, 2], [2, 5, 6, 9, 2], [5, 6, 9, 2], [6, 9, 2, 11] and [9, 2, 11].
Constraint:
1 ≤ k ≤ arr.size() ≤ 105
1 ≤ arr[i] ≤ 109

Solution:
class Solution:
def countSubarrays(self, arr, k):
mp = {0: 1}
prefix = 0
ans = 0
for x in arr:
prefix += (x & 1)
if prefix - k in mp:
ans += mp[prefix - k]
mp[prefix] = mp.get(prefix, 0) + 1
return ans

Day 95 of 100 days dsa coding challenge

Manasi Patil — Wed, 07 Jan 2026 06:25:09 +0000

100DaysOfCode #CodingChallenge #ProblemSolving #GeeksforGeeks #DeveloperJourney

Problem:

https://www.geeksforgeeks.org/problems/count-distinct-elements-in-every-window/1

Count distinct elements in every window

Difficulty: Medium Accuracy: 41.83%

Given an integer array arr[] and a number k. Find the count of distinct elements in every window of size k in the array.

Examples:
Input: arr[] = [1, 2, 1, 3, 4, 2, 3], k = 4
Output: [3, 4, 4, 3]
Explanation:
First window is [1, 2, 1, 3], count of distinct numbers is 3.
Second window is [2, 1, 3, 4] count of distinct numbers is 4.
Third window is [1, 3, 4, 2] count of distinct numbers is 4.
Fourth window is [3, 4, 2, 3] count of distinct numbers is 3.
Input: arr[] = [4, 1, 1], k = 2
Output: [2, 1]
Explanation:
First window is [4, 1], count of distinct numbers is 2.
Second window is [1, 1], count of distinct numbers is 1.
Input: arr[] = [1, 1, 1, 1, 1], k = 3
Output: [1, 1, 1]
Explanation: Every window of size 3 in the array [1, 1, 1, 1, 1], contains only the element 1, so the number of distinct elements in each window is 1.
Constraints:
1 ≤ k ≤ arr.size() ≤ 105
1 ≤ arr[i] ≤ 105

Solution:
class Solution:
def countDistinct(self, arr, k):
from collections import defaultdict
freq = defaultdict(int)
res = []
n = len(arr)
for i in range(k):
freq[arr[i]] += 1
res.append(len(freq))
for i in range(k, n):
freq[arr[i-k]] -= 1
if freq[arr[i-k]] == 0:
del freq[arr[i-k]]
freq[arr[i]] += 1
res.append(len(freq))
return res

Day 94 of 100 days dsa coding challenge

Manasi Patil — Tue, 06 Jan 2026 04:36:47 +0000

100DaysOfCode #CodingChallenge #ProblemSolving #GeeksforGeeks #DeveloperJourney

Problem:

https://www.geeksforgeeks.org/problems/max-xor-subarray-of-size-k/1

Max Xor Subarray of size K

Difficulty: Medium Accuracy: 70.74%

Given an array of integers arr[] and a number k. Return the maximum xor of a subarray of size k.
Note: A subarray is a contiguous part of any given array.

Examples:
Input: arr[] = [2, 5, 8, 1, 1, 3], k = 3
Output: 15
Explanation: arr[0] ^ arr[1] ^ arr[2] = 15, which is maximum.
Input: arr[] = [1, 2, 4, 5, 6] , k = 2
Output: 6
Explanation: arr[1] ^ arr[2] = 6, which is maximum.
Constraints:
1 ≤ arr.size() ≤ 106
0 ≤ arr[i] ≤ 106
1 ≤ k ≤ arr.size()

Solution:
class Solution:
def maxSubarrayXOR(self, arr, k):
n = len(arr)
xr = 0
for i in range(k):
xr ^= arr[i]
ans = xr
for i in range(k, n):
xr ^= arr[i-k]
xr ^= arr[i]
ans = max(ans, xr)
return ans

Day 93 of 100 days dsa coding challenge

Manasi Patil — Mon, 05 Jan 2026 03:09:33 +0000

100DaysOfCode #CodingChallenge #ProblemSolving #GeeksforGeeks #DeveloperJourney

Problem:

https://www.geeksforgeeks.org/problems/max-sum-subarray-of-size-k5313/1

Max Sum Subarray of size K

Difficulty: Easy Accuracy: 49.6%

Given an array of integers arr[] and a number k. Return the maximum sum of a subarray of size k.
Note: A subarray is a contiguous part of any given array.

Examples:
Input: arr[] = [100, 200, 300, 400], k = 2
Output: 700
Explanation: arr2 + arr3 = 700, which is maximum.
Input: arr[] = [1, 4, 2, 10, 23, 3, 1, 0, 20], k = 4
Output: 39
Explanation: arr1 + arr2 + arr3 + arr4 = 39, which is maximum.

Input: arr[] = [100, 200, 300, 400], k = 1
Output: 400
Explanation: arr3 = 400, which is maximum.
Constraints:
1 ≤ arr.size() ≤ 106
1 ≤ arr[i] ≤ 106
1 ≤ k ≤ arr.size()

Solution:
class Solution:
def maxSubarraySum(self, arr, k):
n = len(arr)
curr = sum(arr[:k])
ans = curr
for i in range(k, n):
curr += arr[i] - arr[i-k]
ans = max(ans, curr)
return ans

Day 92 of 100 days dsa coding challenge

Manasi Patil — Sun, 04 Jan 2026 12:42:21 +0000

100DaysOfCode #CodingChallenge #ProblemSolving #GeeksforGeeks #DeveloperJourney

Problem:

https://www.geeksforgeeks.org/problems/sort-an-array-of-0s-1s-and-2s4231/1

Sort 0s, 1s and 2s

Difficulty: Medium Accuracy: 50.58%

Given an array arr[] containing only 0s, 1s, and 2s. Sort the array in ascending order.
Note: You need to solve this problem without utilizing the built-in sort function.

Examples:
Input: arr[] = [0, 1, 2, 0, 1, 2]
Output: [0, 0, 1, 1, 2, 2]
Explanation: 0s, 1s and 2s are segregated into ascending order.
Input: arr[] = [0, 1, 1, 0, 1, 2, 1, 2, 0, 0, 0, 1]
Output: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
Explanation: 0s, 1s and 2s are segregated into ascending order.
Follow up: Could you come up with a one-pass algorithm using only constant extra space?
Constraints:
1 ≤ arr.size() ≤ 106
0 ≤ arr[i] ≤ 2

Solution:
class Solution:
def sort012(self, arr):
low, mid, high = 0, 0, len(arr) - 1
while mid <= high:
if arr[mid] == 0:
arr[low], arr[mid] = arr[mid], arr[low]
low += 1
mid += 1
elif arr[mid] == 1:
mid += 1
else:
arr[high], arr[mid] = arr[mid], arr[high]
high -= 1
return arr

Day 91 of 100 days dsa coding challenge

Manasi Patil — Sat, 03 Jan 2026 04:40:54 +0000

100DaysOfCode #CodingChallenge #ProblemSolving #GeeksforGeeks #DeveloperJourney

Problem:

https://www.geeksforgeeks.org/problems/flattening-a-linked-list/1

Flattening a Linked List

Difficulty: Medium Accuracy: 51.53%

Given a linked list containing n head nodes where every node in the linked list contains two pointers:
(i) next points to the next node in the list.
(ii) bottom points to a sub-linked list where the current node is the head.
Each of the sub-linked lists nodes and the head nodes are sorted in ascending order based on their data. Flatten the linked list such that all the nodes appear in a single level while maintaining the sorted order.
Note:

↓ represents the bottom pointer and → represents the next pointer.
The flattened list will be printed using the bottom pointer instead of the next pointer.

Examples:
Input:

Output: 5 -> 7 -> 8 -> 10 -> 19 -> 20 -> 22 -> 28 -> 40 -> 45.
Explanation:
Bottom pointer of 5 is pointing to 7.
Bottom pointer of 7 is pointing to 8.
Bottom pointer of 10 is pointing to 20 and so on.
So, after flattening the linked list the sorted list will be
5 -> 7 -> 8 -> 10 -> 19 -> 20 -> 22 -> 28 -> 40 -> 45.
Input:

Output: 5 -> 7 -> 8 -> 10 -> 19 -> 22 -> 28 -> 30 -> 50
Explanation:
Bottom pointer of 5 is pointing to 7.
Bottom pointer of 7 is pointing to 8.
Bottom pointer of 8 is pointing to 30 and so on.
So, after flattening the linked list the sorted list will be
5 -> 7 -> 8 -> 10 -> 19 -> 22 -> 28 -> 30 -> 50.
Constraints:
0 ≤ n ≤ 100
1 ≤ number of nodes in sub-linked list(mi) ≤ 50
1 ≤ node->data ≤ 104

Solution:
class Solution:
def merge(self, a, b):
if not a:
return b
if not b:
return a
if a.data < b.data:
result = a
result.bottom = self.merge(a.bottom, b)
else:
result = b
result.bottom = self.merge(a, b.bottom)
result.next = None
return result

def flatten(self, root):
    if not root or not root.next:
        return root
    root.next = self.flatten(root.next)
    root = self.merge(root, root.next)
    return root

Day 90 of 100 days dsa coding challenge

Manasi Patil — Fri, 02 Jan 2026 03:41:17 +0000

100DaysOfCode #CodingChallenge #ProblemSolving #GeeksforGeeks #DeveloperJourney

Problem:

https://www.geeksforgeeks.org/problems/sort-an-array-of-0s-1s-and-2s4231/1

Sort 0s, 1s and 2s

Difficulty: Medium Accuracy: 50.58%

Given an array arr[] containing only 0s, 1s, and 2s. Sort the array in ascending order.
Note: You need to solve this problem without utilizing the built-in sort function.