Forem: MD ARIFUL HAQUE

2452. Words Within Two Edits of Dictionary

MD ARIFUL HAQUE — Wed, 22 Apr 2026 16:51:19 +0000

2452. Words Within Two Edits of Dictionary

Difficulty: Medium

Topics: Senior, Array, String, Trie, Biweekly Contest 90

You are given two string arrays, queries and dictionary. All words in each array comprise of lowercase English letters and have the same length.

In one edit you can take a word from queries, and change any letter in it to any other letter. Find all words from queries that, after a maximum of two edits, equal some word from dictionary.

Return a list of all words from queries, that match with some word from dictionary after a maximum of two edits. Return the words in the same order they appear in queries.

Example 1:

Input: queries = ["word","note","ants","wood"], dictionary = ["wood","joke","moat"]
Output: ["word","note","wood"]
Explanation:
- Changing the 'r' in "word" to 'o' allows it to equal the dictionary word "wood".
- Changing the 'n' to 'j' and the 't' to 'k' in "note" changes it to "joke".
- It would take more than 2 edits for "ants" to equal a dictionary word.
- "wood" can remain unchanged (0 edits) and match the corresponding dictionary word.
- Thus, we return ["word","note","wood"].

Example 2:

Input: queries = ["yes"], dictionary = ["not"]
Output: []
Explanation: Applying any two edits to "yes" cannot make it equal to "not". Thus, we return an empty array.

Constraints:

1 <= queries.length, dictionary.length <= 100
n == queries[i].length == dictionary[j].length
1 <= n <= 100
All queries[i] and dictionary[j] are composed of lowercase English letters.

Hint:

Try brute-forcing the problem.
For each word in queries, try comparing to each word in dictionary.
If there is a maximum of two edit differences, the word should be present in answer.

Solution:

The problem requires identifying which words from queries can be transformed into any word from dictionary with at most two letter changes (edits). The brute-force approach compares each query word with each dictionary word, counting character mismatches, and stops early if more than two mismatches are found.

Approach:

Brute-force comparison between each query and each dictionary word.
Character-by-character mismatch counting for each pair.
Early termination if mismatch count exceeds 2.
Order preservation by processing queries in their original order.

Let's implement this solution in PHP: 2452. Words Within Two Edits of Dictionary

<?php
/**
 * @param String[] $queries
 * @param String[] $dictionary
 * @return String[]
 */
function twoEditWords(array $queries, array $dictionary): array
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Test cases
echo twoEditWords(["word","note","ants","wood"], ["wood","joke","moat"]) . "\n";    // Output: ["word","note","wood"]
echo twoEditWords(["yes"], ["not"]) . "\n";                                         // Output: []
?>

Explanation:

Step 1 — Initialize result array: An empty array $result is created to store query words that meet the condition.
Step 2 — Iterate through queries: For each $query, assume initially it’s not matched ($matched = false).
Step 3 — Compare with dictionary: Loop through $dictionary. For each $dictWord, compare characters with $query.
Step 4 — Count differences: Track $diffCount for positions where characters differ.
Step 5 — Early stop: If $diffCount > 2, break out of the inner loop for that dictionary word.
Step 6 — Match found: If $diffCount <= 2, set $matched = true and break out of the dictionary loop.
Step 7 — Add to result: If $matched, append $query to $result.
Step 8 — Return result: After processing all queries, return $result.

Complexity

Time Complexity:
- O(q . d . n) where q = number of queries, d = size of dictionary, n = length of each word.
- In worst case, each comparison checks all n characters (up to 100), and q, d ≤ 100, so at most 100 . 100 . 100 = 10⁶ operations, which is acceptable.
Space Complexity:
- O(q) for the result array (excluding input storage).
- No additional data structures proportional to input size beyond the result.

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

LinkedIn
GitHub

1722. Minimize Hamming Distance After Swap Operations

MD ARIFUL HAQUE — Tue, 21 Apr 2026 16:36:08 +0000

1722. Minimize Hamming Distance After Swap Operations

Difficulty: Medium

Topics: Staff, Array, Depth-First Search, Union-Find, Weekly Contest 223

You are given two integer arrays, source and target, both of length n. You are also given an array allowedSwaps where each allowedSwaps[i] = [aᵢ, bᵢ] indicates that you are allowed to swap the elements at index aᵢ and index bᵢ (0-indexed) of array source. Note that you can swap elements at a specific pair of indices multiple times and in any order.

The Hamming distance of two arrays of the same length, source and target, is the number of positions where the elements are different. Formally, it is the number of indices i for 0 <= i <= n-1 where source[i] != target[i] (0-indexed).

Return the minimum Hamming distance of source and target after performing any amount of swap operations on array source.

Example 1:

Input: source = [1,2,3,4], target = [2,1,4,5], allowedSwaps = [[0,1],[2,3]]
Output: 1
Explanation:
- source can be transformed the following way:
- Swap indices 0 and 1: source = [2,1,3,4]
- Swap indices 2 and 3: source = [2,1,4,3]
- The Hamming distance of source and target is 1 as they differ in 1 position: index 3.

Example 2:

Input: source = [1,2,3,4], target = [1,3,2,4], allowedSwaps = []
Output: 2
Explanation:
- There are no allowed swaps.
- The Hamming distance of source and target is 2 as they differ in 2 positions: index 1 and index 2.

Example 3:

Input: source = [5,1,2,4,3], target = [1,5,4,2,3], allowedSwaps = [[0,4],[4,2],[1,3],[1,4]]
Output: 0

Constraints:

n == source.length == target.length
1 <= n <= 10⁵
1 <= source[i], target[i] <= 10⁵
0 <= allowedSwaps.length <= 10⁵
allowedSwaps[i].length == 2
0 <= aᵢ, bᵢ <= n - 1
aᵢ != bᵢ

Hint:

The source array can be imagined as a graph where each index is a node and each allowedSwaps[i] is an edge.
Nodes within the same component can be freely swapped with each other.
For each component, find the number of common elements. The elements that are not in common will contribute to the total Hamming distance.

Solution:

This problem is about minimizing the Hamming distance between two arrays by swapping elements in source using allowed swaps.

The key insight is that indices connected through allowed swaps form components where any permutation of values is possible.

Thus, within each component, we can rearrange source values freely to match as many target values as possible.

The solution uses a Union-Find (Disjoint Set Union) data structure to group indices into connected components, then counts mismatches per component.

Approach:

Union-Find (DSU) is used to group indices that are directly or indirectly connected via allowedSwaps.
For each component, collect all source and target values.
Count frequency of each value in source and target within the component.
For each value, the number of matches = min(source_count, target_count).
The Hamming distance for the component = component_size - matches.
Sum over all components to get total minimum Hamming distance.

Let's implement this solution in PHP: 1722. Minimize Hamming Distance After Swap Operations

<?php
/**
 * @param Integer[] $source
 * @param Integer[] $target
 * @param Integer[][] $allowedSwaps
 * @return Integer
 */
function minimumHammingDistance(array $source, array $target, array $allowedSwaps): int
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Test cases
echo minimumHammingDistance([1,2,3,4], [2,1,4,5], [[0,1],[2,3]]) . "\n";                                // Output: 1
echo minimumHammingDistance([1,2,3,4], [1,3,2,4], []) . "\n";                                           // Output: 2
echo minimumHammingDistance([5,1,2,4,3], [1,5,4,2,3], [[0,4],[4,2],[1,3],[1,4]]) . "\n";                // Output: 0
?>

Explanation:

Graph interpretation:
- Each index is a node, each allowed swap is an undirected edge.
- Nodes in the same connected component can be rearranged arbitrarily.
Union-Find:
- Merges indices connected by swaps.
- After processing all swaps, find(i) gives the root of the component containing i.
Group indices: Use a map from root → list of indices.
Count matches per component: Since we can permute freely, the best we can do is match as many target values as possible from the multiset of source values in that component.
Compute mismatches:
- component_size - matches gives the number of positions that cannot be fixed in that component.
- Summing over all components gives the minimum possible Hamming distance.

Complexity

Time Complexity:
- Building DSU: O(α(n) * m) where m = len(allowedSwaps) and α is inverse Ackermann (near constant).
- Grouping indices: O(n).
- Counting frequencies per component: total O(n) across all components.
- Overall: O(n + m * α(n)).
Space Complexity:
- DSU arrays: O(n).
- Component grouping: O(n).
- Frequency maps per component: total O(n) across all components.
- Overall: O(n).

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

LinkedIn
GitHub

2078. Two Furthest Houses With Different Colors

MD ARIFUL HAQUE — Mon, 20 Apr 2026 17:31:14 +0000

2078. Two Furthest Houses With Different Colors

Difficulty: Easy

Topics: Mid Level, Array, Greedy, Weekly Contest 268

There are n houses evenly lined up on the street, and each house is beautifully painted. You are given a 0-indexed integer array colors of length n, where colors[i] represents the color of the iᵗʰ house.

Return the maximum distance between two houses with different colors.

The distance between the iᵗʰ and jᵗʰ houses is abs(i - j), where abs(x) is the absolute value of x.

Example 1:

Input: colors = [1,1,1,6,1,1,1]
Output: 3
Explanation:
- In the above image, color 1 is blue, and color 6 is red.
- The furthest two houses with different colors are house 0 and house 3.
- House 0 has color 1, and house 3 has color 6. The distance between them is abs(0 - 3) = 3.
- Note that houses 3 and 6 can also produce the optimal answer.

Example 2:

Input: colors = [1,8,3,8,3]
Output: 4
Explanation:
- In the above image, color 1 is blue, color 8 is yellow, and color 3 is green.
- The furthest two houses with different colors are house 0 and house 4.
- House 0 has color 1, and house 4 has color 3. The distance between them is abs(0 - 4) = 4.

Example 3:

Input: colors = [0,1]
Output: 1
Explanation:
- The furthest two houses with different colors are house 0 and house 1.
- House 0 has color 0, and house 1 has color 1. The distance between them is abs(0 - 1) = 1.

Constraints:

n == colors.length
2 <= n <= 100
0 <= colors[i] <= 100
Test data are generated such that at least two houses have different colors.

Hint:

The constraints are small. Can you try the combination of every two houses?
Greedily, the maximum distance will come from either the pair of the leftmost house and possibly some house on the right with a different color, or the pair of the rightmost house and possibly some house on the left with a different color.

Solution:

The problem asks for the maximum distance between two houses with different colors.

A brute-force solution (checking all pairs) would be O(n²), but an O(n) greedy approach works by focusing only on the leftmost and rightmost houses.

Approach:

Observation: The maximum distance will always involve either the leftmost house (index 0) paired with the farthest house to the right that has a different color, or the rightmost house (index n-1) paired with the farthest house to the left that has a different color.
Why greedy works:
- If the leftmost and rightmost houses have different colors, the distance n-1 is already maximal.
- If they have the same color, the farthest house with a different color from the leftmost house must be somewhere on the right side, and from the rightmost house on the left side.
- The optimal distance will be one of these two candidates, because any interior pair would have a smaller span than extending to one of the ends.

Let's implement this solution in PHP: 2078. Two Furthest Houses With Different Colors

<?php
/**
 * @param Integer[] $colors
 * @return Integer
 */
function maxDistance(array $colors): int
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Test cases
echo maxDistance([1,1,1,6,1,1,1]) . "\n";           // Output: 3
echo maxDistance([1,8,3,8,3]) . "\n";               // Output: 4
echo maxDistance([0,1]) . "\n";                     // Output: 1
?>

Explanation:

Case 1 – Start from leftmost house: Scan from the right end toward the left, stop at the first house with a color different from colors[0]. Compute distance and update maxDist.
Case 2 – Start from rightmost house: Scan from the left end toward the right, stop at the first house with a color different from colors[n-1]. Compute distance and update maxDist.
Why both cases are needed: The farthest different-colored house from the left end might be closer to the right end than the farthest different-colored house from the right end. We must consider both to cover the true maximum.
Return the maximum of the two candidates.

Complexity

Time Complexity: O(n) – at most two linear scans.
Space Complexity: O(1) – only a few variables used.

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

LinkedIn
GitHub

1855. Maximum Distance Between a Pair of Values

MD ARIFUL HAQUE — Sun, 19 Apr 2026 14:04:18 +0000

1855. Maximum Distance Between a Pair of Values

Difficulty: Medium

Topics: Senior, Array, Two Pointers, Binary Search, Weekly Contest 240

You are given two non-increasing 0-indexed integer arrays nums1 and nums2.

A pair of indices (i, j), where 0 <= i < nums1.length and 0 <= j < nums2.length, is valid if both i <= j and nums1[i] <= nums2[j]. The distance of the pair is j - i.

Return the maximum distance of any valid pair (i, j). If there are no valid pairs, return 0.

An array arr is non-increasing if arr[i-1] >= arr[i] for every 1 <= i < arr.length.

Example 1:

Input: nums1 = [55,30,5,4,2], nums2 = [100,20,10,10,5]
Output: 2
Explanation:
- The valid pairs are (0,0), (2,2), (2,3), (2,4), (3,3), (3,4), and (4,4).
- The maximum distance is 2 with pair (2,4).

Example 2:

Input: nums1 = [2,2,2], nums2 = [10,10,1]
Output: 1
Explanation:
- The valid pairs are (0,0), (0,1), and (1,1).
- The maximum distance is 1 with pair (0,1).

Example 3:

Input: nums1 = [30,29,19,5], nums2 = [25,25,25,25,25]
Output: 2
Explanation:
- The valid pairs are (2,2), (2,3), (2,4), (3,3), and (3,4).
- The maximum distance is 2 with pair (2,4).

Constraints:

1 <= nums1.length, nums2.length <= 10⁵
1 <= nums1[i], nums2[j] <= 10⁵
Both nums1 and nums2 are non-increasing.

Hint:

Since both arrays are sorted in a non-increasing way this means that for each value in the first array. We can find the farthest value smaller than it using binary search.
There is another solution using a two pointers approach since the first array is non-increasing the farthest j such that nums2[j] ≥ nums1[i] is at least as far as the farthest j such that nums2[j] ≥ nums1[i-1]

Solution:

We need to find the maximum j - i such that i <= j and nums1[i] <= nums2[j], given both arrays are non-increasing.

The solution uses a two-pointer technique to efficiently find the farthest valid j for each i, leveraging the sorted property to avoid nested loops.

Approach:

Two-pointer traversal: One pointer i for nums1, one pointer j for nums2.
Greedy expansion of j: If nums1[i] <= nums2[j], we have a valid pair, so we try to increase j to maximize distance.
Adjusting i when condition fails: If nums1[i] > nums2[j], we move i forward (since arrays are non-increasing, nums1[i] will decrease, possibly satisfying condition later).
Maintain j >= i: When moving i forward, we ensure j is at least i to keep j - i non-negative.

Let's implement this solution in PHP: 1855. Maximum Distance Between a Pair of Values

<?php
/**
 * @param Integer[] $nums1
 * @param Integer[] $nums2
 * @return Integer
 */
function maxDistance(array $nums1, array $nums2): int
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Test cases
echo maxDistance([55,30,5,4,2], [100,20,10,10,5]) . "\n";           // Output: 2
echo maxDistance([2,2,2], [10,10,1]) . "\n";                        // Output: 1
echo maxDistance([30,29,19,5], [25,25,25,25,25]) . "\n";            // Output: 2
?>

Explanation:

Start with i = 0, j = 0, ans = 0.
While i < n and j < m:
- If nums1[i] <= nums2[j]:
  - It's a valid pair, so update ans = max(ans, j - i).
  - Move j forward to try to get a larger j for same i.
- Else (nums1[i] > nums2[j]):
  - Condition fails, so move i forward (since nums1[i] will decrease, may become <= later).
  - If j < i, set j = i to maintain j >= i.
Return ans.

Complexity

Time Complexity: O(n + m), Each pointer moves at most n + m times.
Space Complexity: O(1), Only a few integer variables used.

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

LinkedIn
GitHub

3783. Mirror Distance of an Integer

MD ARIFUL HAQUE — Sat, 18 Apr 2026 14:32:03 +0000

3783. Mirror Distance of an Integer

Difficulty: Easy

Topics: Mid Level, Math, Weekly Contest 481

You are given an integer n.

Define its mirror distance as: abs(n - reverse(n)) where reverse(n) is the integer formed by reversing the digits of n.

Return an integer denoting the mirror distance of n.

abs(x) denotes the absolute value of x.

Example 1:

Input: n = 25
Output: 27
Explanation:
- reverse(25) = 52.
- Thus, the answer is abs(25 - 52) = 27.

Example 2:

Input: n = 10
Output: 9
Explanation:
- reverse(10) = 01 which is 1.
- Thus, the answer is abs(10 - 1) = 9.

Example 3:

Input: n = 7
Output: 0
Explanation:
- reverse(7) = 7.
- Thus, the answer is abs(7 - 7) = 0.

Example 4:

Input: n = 100
Output: 99

Constraints:

1 <= n <= 10⁹

Hint:

Simulate as described

Solution:

The function calculates the mirror distance of an integer by reversing its digits, then returning the absolute difference between the original number and its reverse.

Approach:

Convert the integer to its digit-reversed form without converting to a string.
Use a loop to extract digits from the original number and build the reversed number.
Return the absolute difference between the original and reversed numbers.

Let's implement this solution in PHP: 3783. Mirror Distance of an Integer

<?php
/**
 * @param Integer $n
 * @return Integer
 */
function mirrorDistance(int $n): int
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Test cases
echo mirrorDistance(25) . "\n";         // Output: 27
echo mirrorDistance(10) . "\n";         // Output: 9
echo mirrorDistance(7) . "\n";          // Output: 0
echo mirrorDistance(100) . "\n";        // Output: 99
?>

Explanation:

Reverse the digits:
- Repeatedly take the last digit of n using n % 10.
- Append it to reversed by multiplying reversed by 10 and adding the digit.
- Remove the last digit from n using integer division by 10.
- Continue until n becomes 0.
Handle leading zeros:
- The reversal process automatically discards leading zeros because they don’t contribute to the integer value (e.g., 10 → 1).
Compute mirror distance:
- Use abs(original - reversed) to get the positive difference.

Complexity

Time Complexity: O(d) where d is the number of digits in n (at most 10, since n ≤ 10⁹).
Space Complexity: O(1) — only a few integer variables used.

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

LinkedIn
GitHub

3761. Minimum Absolute Distance Between Mirror Pairs

MD ARIFUL HAQUE — Fri, 17 Apr 2026 16:36:06 +0000

3761. Minimum Absolute Distance Between Mirror Pairs

Difficulty: Medium

Topics: Staff, Array, Hash Table, Math, Weekly Contest 478

You are given an integer array nums.

A mirror pair is a pair of indices (i, j) such that:

0 <= i < j < nums.length, and
reverse(nums[i]) == nums[j], where reverse(x) denotes the integer formed by reversing the digits of x. Leading zeros are omitted after reversing, for example reverse(120) = 21.

Return the minimum absolute distance between the indices of any mirror pair. The absolute distance between indices i and j is abs(i - j).

If no mirror pair exists, return -1.

Example 1:

Input: nums = [12,21,45,33,54]
Output: 1
Explanation:
- The mirror pairs are:
  - (0, 1) since reverse(nums[0]) = reverse(12) = 21 = nums[1], giving an absolute distance abs(0 - 1) = 1.
  - (2, 4) since reverse(nums[2]) = reverse(45) = 54 = nums[4], giving an absolute distance abs(2 - 4) = 2.
- The minimum absolute distance among all pairs is 1.

Example 2:

Input: nums = [120,21]
Output: 1
Explanation:
- There is only one mirror pair (0, 1) since reverse(nums[0]) = reverse(120) = 21 = nums[1].
- The minimum absolute distance is 1.

Example 3:

Input: nums = [21,120]
Output: -1
Explanation: There are no mirror pairs in the array.

Example 4:

Input: nums = [1,10,100,1,10]
Output: 1

Constraints:

1 <= nums.length <= 10⁵
1 <= nums[i] <= 10⁹

Hint:

Scan left to right with a hash map: for each nums[i], if the map contains key nums[i] then set ans = min(ans, i - map[nums[i]]).
Store/update the current index under key reverse(nums[i]), so future matches use the most recent index.

Solution:

This solution finds the minimum absolute distance between indices of mirror pairs in an array. A mirror pair consists of two numbers where one is the digit-reversed version of the other. The algorithm uses a single pass with a hash map to track the most recent index of each number's reverse, efficiently finding the smallest index gap in O(n) time.

Approach:

Single-pass traversal with hash map storage
Reverse number computation for each array element
Look for existing matches before storing current index
Track minimum distance by comparing current index with previously stored index of the same number
Store current index under the reversed number key for future matches

Let's implement this solution in PHP: 3761. Minimum Absolute Distance Between Mirror Pairs

<?php
/**
 * @param Integer[] $nums
 * @return Integer
 */
function minMirrorPairDistance(array $nums): int
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Test cases
echo minAbsoluteDistanceMirrorPairs([12, 21, 45, 33, 54]) . "\n";           // Output: 1
echo minAbsoluteDistanceMirrorPairs([120, 21]) . "\n";                      // Output: 1
echo minAbsoluteDistanceMirrorPairs([21, 120]) . "\n";                      // Output: -1
echo minAbsoluteDistanceMirrorPairs([1,10,100,1,10]) . "\n";                // Output: 1
?>

Explanation:

Key Insight: When scanning left to right, if we encounter a number that matches a previously stored reversed number, they form a mirror pair. The reverse of the previous number equals the current number, and vice versa.
Hash Map Strategy: Store each number's latest index under the key equal to its reverse. This ensures that when we later see a number that matches a previously stored reverse, we can calculate the distance immediately.
Distance Calculation: Since we always store the latest index for each reversed number, we minimize the distance for each potential pair. Using abs(i - j) simplifies to i - j because i is always greater than j during forward traversal.
Edge Cases:
- Numbers with trailing zeros (e.g., 120 → 21) are handled correctly by converting to integer after reversal
- Single-element arrays or arrays with no mirror pairs return -1
- Multiple occurrences of the same number are handled by overwriting the map entry, which actually helps find smaller gaps

Complexity

Time Complexity: O(n) - single pass through the array with O(1) operations per element (reversal of digits is O(log₁₀(num)) which is effectively constant as numbers ≤ 10⁹ have at most 10 digits)
Space Complexity: O(n) - in worst case, the hash map stores a unique entry for each distinct reversed number in the array

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

LinkedIn
GitHub

3488. Closest Equal Element Queries

MD ARIFUL HAQUE — Thu, 16 Apr 2026 17:17:19 +0000

3488. Closest Equal Element Queries

Difficulty: Medium

Topics: Senior, Array, Hash Table, Binary Search, Weekly Contest 441

You are given a circular array nums and an array queries.

For each query i, you have to find the following:

The minimum distance between the element at index queries[i] and any other index j in the circular array, where nums[j] == nums[queries[i]]. If no such index exists, the answer for that query should be -1.

Return an array answer of the same size as queries, where answer[i] represents the result for query i.

Example 1:

Input: nums = [1,3,1,4,1,3,2], queries = [0,3,5]
Output: [2,-1,3]
Explanation:
- Query 0: The element at queries[0] = 0 is nums[0] = 1. The nearest index with the same value is 2, and the distance between them is 2.
- Query 1: The element at queries[1] = 3 is nums[3] = 4. No other index contains 4, so the result is -1.
- Query 2: The element at queries[2] = 5 is nums[5] = 3. The nearest index with the same value is 1, and the distance between them is 3 (following the circular path: 5 -> 6 -> 0 -> 1).

Example 2:

Input: nums = [1,2,3,4], queries = [0,1,2,3]
Output: [-1,-1,-1,-1]
Explanation: Each value in nums is unique, so no index shares the same value as the queried element. This results in -1 for all queries.

Example 3:

Input: nums = [5,5,5,1,2,5], queries = [0,3,5]
Output: [1, -1, 1]

Constraints:

1 <= queries.length <= nums.length <= 10⁵
1 <= nums[i] <= 10⁶
0 <= queries[i] < nums.length

Hint:

Use a dictionary that maps each unique value in the array to a sorted list of its indices.
For each query, use binary search on the sorted indices list to find the nearest occurrences of the target value.

Solution:

The problem asks for the minimum circular distance between a given index and any other index containing the same value.

The solution groups indices by value, uses binary search to find neighbors in the circular array, and computes distances with wrap-around logic.

If a value appears only once, the answer is -1.

Approach:

Group indices by value using a hash map (dictionary) where keys are array values and values are sorted lists of their indices.
For each query index:
- Retrieve the sorted list of indices for its value.
- If only one index exists → answer is -1.
- Use binary search to locate the query index within its value’s index list.
- Check the previous and next indices in the circular list (wrap around using modulo).
- Compute the circular distance between the query index and each candidate.
- Take the minimum of these distances as the answer.
Return an array of answers in the same order as queries.

Let's implement this solution in PHP: 3488. Closest Equal Element Queries

<?php
/**
 * @param Integer[] $nums
 * @param Integer[] $queries
 * @return Integer[]
 */
function solveQueries(array $nums, array $queries): array
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

/**
 * Binary search to find the exact position or insertion point
 *
 * @param $arr
 * @param $target
 * @return mixed
 */
function binarySearch($arr, $target): mixed
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

/**
 * Calculate circular distance between two indices
 *
 * @param $i
 * @param $j
 * @param $n
 * @return mixed
 */
function circularDistance($i, $j, $n): mixed
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Test cases
echo solveQueries([1,3,1,4,1,3,2], [0,3,5]) . "\n";         // Output: [2,-1,3]
echo solveQueries([1,2,3,4], [0,1,2,3]) . "\n";             // Output: [-1,-1,-1,-1]
echo solveQueries([5,5,5,1,2,5], [0,3,5]) . "\n";           // Output: [1, -1, 1]

?>

Explanation:

Grouping indices: We traverse the array once and store each index in a list corresponding to its value. This allows quick access to all positions of a given value.
Binary search for neighbors: For a query index q, we find its position in the sorted index list. Then, the nearest other indices with the same value are the ones immediately before and after it in that list (wrapping around at ends).
Circular distance: On a circular array of length n, the distance between indices i and j is min(|i - j|, n - |i - j|).
Handling uniqueness: If a value appears only once, there is no other index to compare, so we return -1.

Complexity

Time Complexity:
- Grouping indices: O(n)
- Each query: binary search O(log m) where m is the frequency of that value
- Total: O(n + q log n) worst case, but since q ≤ n, it’s efficient.
Space Complexity: Hash map storing all indices: O(n)

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

LinkedIn
GitHub

2515. Shortest Distance to Target String in a Circular Array

MD ARIFUL HAQUE — Wed, 15 Apr 2026 16:48:14 +0000

2515. Shortest Distance to Target String in a Circular Array

Difficulty: Easy

Topics: Mid Level, Array, String, Weekly Contest 325

You are given a 0-indexed circular string array words and a string target. A circular array means that the array's end connects to the array's beginning.

Formally, the next element of words[i] is words[(i + 1) % n] and the previous element of words[i] is words[(i - 1 + n) % n], where n is the length of words.

Starting from startIndex, you can move to either the next word or the previous word with 1 step at a time.

Return the shortest distance needed to reach the string target. If the string target does not exist in words, return -1.

Example 1:

Input: words = ["hello","i","am","leetcode","hello"], target = "hello", startIndex = 1
Output: 1
Explanation:
- We start from index 1 and can reach "hello" by
  - moving 3 units to the right to reach index 4.
  - moving 2 units to the left to reach index 4.
  - moving 4 units to the right to reach index 0.
  - moving 1 unit to the left to reach index 0.
- The shortest distance to reach "hello" is 1.

Example 2:

Input: words = ["a","b","leetcode"], target = "leetcode", startIndex = 0
Output: 1
Explanation:
- We start from index 0 and can reach "leetcode" by
  - moving 2 units to the right to reach index 2.
- moving 1 unit to the left to reach index 2.
- The shortest distance to reach "leetcode" is 1.

Example 3:

Input: words = ["cat","dog","bird"], target = "fish", startIndex = 1
Output: -1

Constraints:

1 <= words.length <= 100
1 <= words[i].length <= 100
words[i] and target consist of only lowercase English letters.
0 <= startIndex < words.length

Hint:

You have two options, either move straight to the left or move straight to the right.
Find the first target word and record the distance.
Choose the one with the minimum distance.

Solution:

This solution finds the minimum steps needed to reach a target string in a circular array starting from a given index. It calculates both clockwise and counterclockwise distances to each occurrence of the target and returns the smallest distance, or -1 if the target doesn't exist.

Approach:

Circular Distance Calculation: Use modulo arithmetic to compute distances in both directions around the circular array
Target Location: Iterate through all indices to find positions where words[i] equals the target
Distance Comparison: For each target occurrence, calculate both forward and backward distances and take the minimum
Global Minimum: Track the smallest distance across all target occurrences
Edge Case Handling: Return -1 if no target found

Let's implement this solution in PHP: 2515. Shortest Distance to Target String in a Circular Array

<?php
/**
 * @param String[] $words
 * @param String $target
 * @param Integer $startIndex
 * @return Integer
 */
function closestTarget(array $words, string $target, int $startIndex): int
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Test cases
echo closestTarget(["hello","i","am","leetcode","hello"], "hello", 1) . "\n";           // Output: 1
echo closestTarget(["a","b","leetcode"], "leetcode", 0) . "\n";                         // Output: 1
echo closestTarget(["cat","dog","bird"], "fish", 1) . "\n";                             // Output: -1
?>

Explanation:

Forward Distance Calculation: ($i - $startIndex + $n) % $n computes steps needed moving right (clockwise) from start to target index i
Backward Distance Calculation: ($startIndex - $i + $n) % $n computes steps needed moving left (counterclockwise) from start to target index i
Minimum per Occurrence: min($forward, $backward) gives the shortest path to that specific target occurrence
Global Optimization: Track the overall minimum distance across all target positions in the array
No Target Found: If $minDistance remains PHP_INT_MAX, the target doesn't exist, so return -1

Complexity

Time Complexity: O(n) where n is the length of the words array - single pass to check all indices
Space Complexity: O(1) - only uses a few variables regardless of input size

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

LinkedIn
GitHub

1848. Minimum Distance to the Target Element

MD ARIFUL HAQUE — Mon, 13 Apr 2026 15:38:35 +0000

1848. Minimum Distance to the Target Element

Difficulty: Easy

Topics: Mid Level, Array, Weekly Contest 239

Given an integer array nums (0-indexed) and two integers target and start, find an index i such that nums[i] == target and abs(i - start) is minimized. Note that abs(x) is the absolute value of x.

Return abs(i - start).

It is guaranteed that target exists in nums.

Example 1:

Input: nums = [1,2,3,4,5], target = 5, start = 3
Output: 1
Explanation: nums[4] = 5 is the only value equal to target, so the answer is abs(4 - 3) = 1.

Example 2:

Input: nums = [1], target = 1, start = 0
Output: 0
Explanation: nums[0] = 1 is the only value equal to target, so the answer is abs(0 - 0) = 0.

Example 3:

Input: nums = [1,1,1,1,1,1,1,1,1,1], target = 1, start = 0
Output: 0
Explanation: Every value of nums is 1, butnums[0] minimizes abs(i - start), which is abs(0 - 0) = 0.

Example 4:

Input: nums = [5,3,8,2,9,1,4,6,7], target = 9, start = 4
Output: 0

Example 5:

Input: nums = [1,5,2,5,3,5,4], target = 5, start = 3
Output: 0

Constraints:

1 <= nums.length <= 1000
1 <= nums[i] <= 10⁴
0 <= start < nums.length
target is in nums.

Hint:

Loop in both directions until you find the target element.
For each index i such that nums[i] == target calculate abs(i - start).

Solution:

The solution finds the minimum distance between a given starting index and any occurrence of a target value in an array. It iterates through the entire array once, computing the absolute distance for each matching element and tracking the smallest distance found.

Approach:

Linear scan with distance calculation: Iterate through all array elements once, checking each index where nums[i] == target
Absolute difference computation: For each matching element, calculate abs(i - start) as the distance
Minimum tracking: Maintain a running minimum distance value, updating whenever a smaller distance is found
Early optimization: Since we need the absolute minimum, we can't stop early without checking all elements (though theoretically we could optimize by expanding outward from start)

Let's implement this solution in PHP: 1848. Minimum Distance to the Target Element

<?php
/**
 * @param Integer[] $nums
 * @param Integer $target
 * @param Integer $start
 * @return Integer
 */
function getMinDistance(array $nums, int $target, int $start): int
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Test cases
echo getMinDistance([1,2,3,4,5], 5, 3) . "\n";                      // Output: 1
echo getMinDistance([1], 1, 0) . "\n";                              // Output: 0
echo getMinDistance([1,1,1,1,1,1,1,1,1,1], 1, 0) . "\n";            // Output: 0
echo getMinDistance([5,3,8,2,9,1,4,6,7], 9, 4) . "\n";              // Output: 0
echo getMinDistance([1,5,2,5,3,5,4], 5, 3) . "\n";                  // Output: 0
?>

Explanation:

Initialization: Start with minDistance set to PHP_INT_MAX (largest possible integer).
Iteration: Loop through the array with both index $i and value $num.
Condition check: When $num == $target, calculate the absolute difference between current index and start.
Comparison: If the calculated distance is less than current minDistance, update minDistance.
Return value: After checking all elements, return the minimum distance found.

Complexity

Time Complexity: O(n) - where n is the length of the array, as we potentially need to check every element.
Space Complexity: O(1) - only using a constant amount of extra space for variables.
Optimality: This is optimal for time complexity since we must examine all elements to find the minimum distance when the array is unsorted.

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

LinkedIn
GitHub

1974. Minimum Time to Type Word Using Special Typewriter

MD ARIFUL HAQUE — Sun, 12 Apr 2026 15:04:41 +0000

1974. Minimum Time to Type Word Using Special Typewriter

Difficulty: Easy

Topics: Mid Level, String, Greedy, Biweekly Contest 59

There is a special typewriter with lowercase English letters 'a' to 'z' arranged in a circle with a pointer. A character can only be typed if the pointer is pointing to that character. The pointer is initially pointing to the character 'a'.

Each second, you may perform one of the following operations:

Move the pointer one character counterclockwise or clockwise.
Type the character the pointer is currently on.

Given a string word, return the minimum number of seconds to type out the characters in word.

Example 1:

Input: word = "abc"
Output: 5
Explanation:
- The characters are printed as follows:
  - Type the character 'a' in 1 second since the pointer is initially on 'a'.
  - Move the pointer clockwise to 'b' in 1 second.
  - Type the character 'b' in 1 second.
  - Move the pointer clockwise to 'c' in 1 second.
  - Type the character 'c' in 1 second.

Example 2:

Input: word = "bza"
Output: 7
Explanation:
- The characters are printed as follows:
  - Move the pointer clockwise to 'b' in 1 second.
  - Type the character 'b' in 1 second.
  - Move the pointer counterclockwise to 'z' in 2 seconds.
  - Type the character 'z' in 1 second.
  - Move the pointer clockwise to 'a' in 1 second.
  - Type the character 'a' in 1 second.

Example 3:

Input: word = "zjpc"
Output: 34
Explanation:
- The characters are printed as follows:
  - Move the pointer counterclockwise to 'z' in 1 second.
  - Type the character 'z' in 1 second.
  - Move the pointer clockwise to 'j' in 10 seconds.
  - Type the character 'j' in 1 second.
  - Move the pointer clockwise to 'p' in 6 seconds.
  - Type the character 'p' in 1 second.
  - Move the pointer counterclockwise to 'c' in 13 seconds.
  - Type the character 'c' in 1 second.

Constraints:

2 <= word.length <= 300
word consists of uppercase English letters.

Hint:

There are only two possible directions you can go when you move to the next letter.
When moving to the next letter, you will always go in the direction that takes the least amount of time.

Solution:

The problem simulates a circular typewriter starting at 'a'. Each movement costs 1 second per step (clockwise or counterclockwise), and typing the current character costs 1 second. The goal is to minimize total time to type a given word by always choosing the shorter direction between consecutive characters.

The solution calculates the clockwise and counterclockwise distances between the current and target character on a circular alphabet (26 letters) and adds the typing time (1 second) for each character.

Approach:

Character to index mapping: Convert each character to a number from 0 to 25 based on its position in the alphabet.
Circular distance: For each step, compute both clockwise and counterclockwise distances. The minimal movement time is the smaller of the two.
Typing time: Add 1 second for typing the character after moving.
Iterate through the word: Keep track of the current character (starting with 'a'), update it after each step.

Let's implement this solution in PHP: 1974. Minimum Time to Type Word Using Special Typewriter

<?php
/**
 * @param String $word
 * @return Integer
 */
function minTimeToType(string $word): int
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Test cases
echo minTimeToType("abc");          // Output: 5
echo minTimeToType("bza");          // Output: 7
echo minTimeToType("zjpc");         // Output: 34
?>

Explanation:

Start with currentChar = 'a' and totalTime = 0.
For each character in word:
- Convert currentChar and targetChar to positions 0–25 using ASCII values.
- clockwise = abs(targetPos - currentPos) — direct forward distance.
- counterclockwise = 26 - clockwise — the other way around the circle.
- totalTime += min(clockwise, counterclockwise) + 1 (1 second for typing).
- Update currentChar = targetChar.
Return totalTime.

Complexity

Time Complexity: O(n) where n is the length of word — one pass through the string with constant-time operations.
Space Complexity: O(1) — only a few integer variables used.

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

LinkedIn
GitHub

1320. Minimum Distance to Type a Word Using Two Fingers

MD ARIFUL HAQUE — Sun, 12 Apr 2026 13:25:05 +0000

1320. Minimum Distance to Type a Word Using Two Fingers

Difficulty: Hard

Topics: Principal, String, Dynamic Programming, Weekly Contest 171

You have a keyboard layout as shown above in the X-Y plane, where each English uppercase letter is located at some coordinate.

For example, the letter 'A' is located at coordinate (0, 0), the letter 'B' is located at coordinate (0, 1), the letter 'P' is located at coordinate (2, 3) and the letter 'Z' is located at coordinate (4, 1).

Given the string word, return the minimum total distance to type such string using only two fingers.

The distance between coordinates (x₁, y₁) and (x₂, y₂) is |x₁ - x₂| + |y₁ - y₂|.

Note that the initial positions of your two fingers are considered free so do not count towards your total distance, also your two fingers do not have to start at the first letter or the first two letters.

Example 1:

Input: word = "CAKE"
Output: 3
Explanation:
- Using two fingers, one optimal way to type "CAKE" is:
- Finger 1 on letter 'C' -> cost = 0
- Finger 1 on letter 'A' -> cost = Distance from letter 'C' to letter 'A' = 2
- Finger 2 on letter 'K' -> cost = 0
- Finger 2 on letter 'E' -> cost = Distance from letter 'K' to letter 'E' = 1
- Total distance = 3

Example 2:

Input: word = "HAPPY"
Output: 6
Explanation:
- TUsing two fingers, one optimal way to type "HAPPY" is:
- Finger 1 on letter 'H' -> cost = 0
- Finger 1 on letter 'A' -> cost = Distance from letter 'H' to letter 'A' = 2
- Finger 2 on letter 'P' -> cost = 0
- Finger 2 on letter 'P' -> cost = Distance from letter 'P' to letter 'P' = 0
- Finger 1 on letter 'Y' -> cost = Distance from letter 'A' to letter 'Y' = 4
- Total distance = 6

Constraints:

2 <= word.length <= 300
word consists of uppercase English letters.

Hint:

Use dynamic programming.
dp[i][j][k]: smallest movements when you have one finger on i-th char and the other one on j-th char already having written k first characters from word.

Solution:

This solution uses dynamic programming to minimize the total distance when typing a word with two fingers on a QWERTY-style keyboard.

It keeps track of the position of one finger (the "free" finger) while the other finger types the current character.

The DP state is dp[f] = minimum total distance so far, with one finger at the last typed character and the other finger at position f.

At each step, we decide which finger moves to the next character.

Approach:

Precompute distances between all 26 letters based on their (row, column) coordinates on the keyboard.
DP definition: dp[f] = minimum total distance after typing up to the current character, where one finger is at the last typed character and the other finger is at letter index f.
Initial state: After typing the first character, one finger is on it, the other can be anywhere (cost 0 for all f).
Transition for each new character currChar:
1. Move the finger that was on lastChar to currChar → cost = dist[lastChar][currChar], other finger stays at f.
2. Move the finger that was on f to currChar → cost = dist[f][currChar], other finger becomes lastChar.
Update DP accordingly, tracking the new last character.
Final answer = minimum value in dp after processing all characters.

Let's implement this solution in PHP: 1320. Minimum Distance to Type a Word Using Two Fingers

<?php
/**
 * @param String $word
 * @return Integer
 */
function minimumDistance(string $word): int
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Test cases
echo minimumDistance("CAKE") . "\n";            // Output: 3
echo minimumDistance("HAPPY") . "\n";           // Output: 6
?>

Explanation:

Step 1 — Precompute distances:
- Each letter is mapped to a coordinate: (row = index / 6, col = index % 6).
- Manhattan distance between two letters is precomputed and stored in a 26×26 array.
Step 2 — Initialize DP: After first character word[0], one finger is on it, the other finger could be anywhere with zero distance so far.
Step 3 — Iterate through remaining characters: For each new character currChar, compute a new DP table nextDp with PHP_INT_MAX initial values.
Step 4 — Transition logic:
- For each possible f (position of the other finger):
- Case 1: Move the finger at lastChar to currChar → nextDp[f] = min(nextDp[f], dp[f] + dist[lastChar][currChar])
- Case 2: Move the finger at f to currChar → nextDp[lastChar] = min(nextDp[lastChar], dp[f] + dist[f][currChar])
Step 5 — Update state: Set dp = nextDp and lastChar = currChar.
Step 6 — Return result: Minimum value in dp after processing all characters.

Complexity

Time Complexity:
- Precomputation: O(26²) = O(1)
- DP: O(n × 26) where n is word length, because for each of n-1 steps, we iterate over 26 possible finger positions.
- Total: O(26n) = O(n) with a small constant factor.
Space Complexity:
- dist array: O(26²) = O(1)
- DP arrays: O(26)
- Total: O(1) extra space beyond input.

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

LinkedIn
GitHub

3741. Minimum Distance Between Three Equal Elements II

MD ARIFUL HAQUE — Sat, 11 Apr 2026 14:33:40 +0000

3741. Minimum Distance Between Three Equal Elements II

Difficulty: Medium

Topics: Senior, Array, Hash Table, Weekly Contest 475

You are given an integer array nums.

A tuple (i, j, k) of 3 distinct indices is good if nums[i] == nums[j] == nums[k].

The distance of a good tuple is abs(i - j) + abs(j - k) + abs(k - i), where abs(x) denotes the absolute value of x.

Return an integer denoting the minimum possible distance of a good tuple. If no good tuples exist, return -1.

Example 1:

Input: nums = [1,2,1,1,3]
Output: 6
Explanation:
- The minimum distance is achieved by the good tuple (0, 2, 3).
- (0, 2, 3) is a good tuple because nums[0] == nums[2] == nums[3] == 1. Its distance is abs(0 - 2) + abs(2 - 3) + abs(3 - 0) = 2 + 1 + 3 = 6.

Example 2:

Input: nums = [1,1,2,3,2,1,2]
Output: 8
Explanation:
- The minimum distance is achieved by the good tuple (2, 4, 6).
- (2, 4, 6) is a good tuple because nums[2] == nums[4] == nums[6] == 2. Its distance is abs(2 - 4) + abs(4 - 6) + abs(6 - 2) = 2 + 2 + 4 = 8.

Example 3:

Input: nums = [1]
Output: -1
Explanation: There are no good tuples. Therefore, the answer is -1.

Constraints:

1 <= n == nums.length <= 10⁵
1 <= nums[i] <= n

Hint:

The distance formula abs(i - j) + abs(j - k) + abs(k - i) simplifies to 2 * (max(i, j, k) - min(i, j, k)).
Group the indices for each unique number. For a number to form a good tuple, it must appear at least 3 times.
For each number that appears at least 3 times, we want to find three of its indices p < q < r that minimize r - p. This is achieved by considering every three consecutive indices in the sorted list of indices.

Solution:

We are given an array and need to find the minimum distance among three equal elements, where distance is defined as abs(i-j) + abs(j-k) + abs(k-i). This simplifies to 2 * (max(i,j,k) - min(i,j,k)). The solution groups indices by value, considers only values with at least three occurrences, and checks consecutive triples in sorted index lists to minimize the range between the smallest and largest index. The final answer is twice that minimum range.

Approach:

Group indices by value: Use a hash map to store all indices where each value appears.
Filter values with ≥3 occurrences: Only those can form a valid triple.
Sort indices for each value: Since we add indices in increasing order during iteration, they are naturally sorted.
Slide a window of size 3 over indices: For each consecutive triple (p, q, r) in sorted order, compute r - p and track the minimum.
Compute final distance: Multiply the minimum range by 2 to get the required distance.

Let's implement this solution in PHP: 3741. Minimum Distance Between Three Equal Elements II

<?php
/**
 * @param Integer[] $nums
 * @return float|int
 */
function minimumDistance(array $nums): float|int
{
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Test cases
echo minimumDistance([1,2,1,1,3]) . "\n";               // Output: 6
echo minimumDistance([1,1,2,3,2,1,2]) . "\n";           // Output: 8
echo minimumDistance([1]) . "\n";                       // Output: -1
?>

Explanation:

Distance simplification:
- For three indices i < j < k, the expression abs(i-j) + abs(j-k) + abs(k-i) becomes (j-i) + (k-j) + (k-i) = 2*(k-i).
- So minimizing the sum is equivalent to minimizing k - i.
Why consecutive indices in sorted order? For a given sorted list of indices, the smallest k - i for any triple occurs when we take three consecutive indices. Any triple with a gap between would have a larger spread.
Sliding window of size 3: Iterate through indices[0..m-3] and check (indices[i], indices[i+1], indices[i+2]). This is efficient (O(m)) and guarantees finding the minimal range.
Return -1 if no value appears at least 3 times

Complexity

Time Complexity: O(n)
- One pass to group indices into hash map.
- For each value, iterating over its indices in order takes O(m) per value, and sum of all m over values = n.
- Overall linear.
Space Complexity: O(1) - Hash map stores up to n indices in total.

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

LinkedIn
GitHub