share your ideas

Websites To Increase Your Problem-Solving Skills

LeetCode: LeetCode is widely used for practicing coding problems, especially for preparing for technical interviews. It has a vast collection of problems categorized by difficulty and topic.

HackerRank: HackerRank offers challenges in various domains like algorithms, data structures, artificial intelligence, and more. It is also a good platform for preparing for coding interviews.

CodeSignal: CodeSignal provides a variety of coding challenges and also has a feature to simulate technical interviews.

Codeforces: Codeforces is a competitive programming platform that hosts regular contests. It’s a great place to practice algorithmic problems and improve your speed and accuracy.

AtCoder: AtCoder is a Japanese competitive programming site that offers regular contests and a rich set of problems to solve.

TopCoder: TopCoder is one of the original competitive programming platforms. It offers Single Round Matches (SRMs) and has a large problem archive.

Exercism: Exercism offers exercises in various programming languages with mentor feedback.

Codewars: Codewars provides a community-driven platform where you can solve coding challenges and compare solutions with others.

## Intuition
To solve this problem, we can use a sliding window approach along with a hash map (dictionary) to efficiently check for duplicate elements within a given range. The idea is to maintain a window of size k and check if any element within this window is duplicated.

## Algorithm
1. Initialize an empty hash map (dictionary) to store the most recent index of each element.
2. Iterate over the array nums:
- For each element nums[i]:
- If nums[i] is already in the hash map and the difference between the current index i and the stored index j is less than or equal to k, return true.
- Update the hash map to store the current index i of nums[i].
3. If no duplicates within the range k are found, return false.

## Code

def containsNearbyDuplicate(nums, k):
    num_indices = {}
    
    for i, num in enumerate(nums):
        if num in num_indices and i - num_indices[num] <= k:
            return True
        num_indices[num] = i
    
    return False

# Example 1
print(containsNearbyDuplicate([1, 2, 3, 1], 3))  # Output: True

# Example 2
print(containsNearbyDuplicate([1, 0, 1, 1], 1))  # Output: True

# Example 3
print(containsNearbyDuplicate([1, 2, 3, 1, 2, 3], 2))  # Output: False

## Complexity Analysis
- Time Complexity: O(n), where n is the length of the array nums. We only need to iterate through the array once.
- Space Complexity: O(min(n, k)), where n is the length of the array. The space used by the hash map is proportional to the number of unique elements within any window of size k. In the worst case, this is O(n), but usually, it's limited by k.

This algorithm ensures that we efficiently find any duplicates within a specified range, making use of the hash map for quick lookups and updates.

#leet_code_Q_14 #Q_2269 #easy #Sliding_window
2269. Find the K-Beauty of a Number
The k-beauty of an integer num is defined as the number of substrings of num when it is read as a string that meet the following conditions:

It has a length of k.
It is a divisor of num.
Given integers num and k, return the k-beauty of num.

Note:

Leading zeros are allowed.
0 is not a divisor of any value.
A substring is a contiguous sequence of characters in a string.



Example 1:

Input: num = 240, k = 2
Output: 2
Explanation: The following are the substrings of num of length k:
- "24" from "240": 24 is a divisor of 240.
- "40" from "240": 40 is a divisor of 240.
Therefore, the k-beauty is 2.
Constraints:

1 <= num <= 109
1 <= k <= num.length (taking num as a string)

#leet_code_Q15 #Q_209 #Medium #Sliding_window
209. Minimum Size Subarray Sum
Given an array of positive integers nums and a positive integer target, return the minimal length of a
subarray
whose sum is greater than or equal to target. If there is no such subarray, return 0 instead.

Example 1:

Input: target = 7, nums = [2,3,1,2,4,3]
Output: 2
Explanation: The subarray [4,3] has the minimal length under the problem constraint.
Example 2:

Input: target = 4, nums = [1,4,4]
Output: 1
Example 3:

Input: target = 11, nums = [1,1,1,1,1,1,1,1]
Output: 0

Constraints:

1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 104

Follow up: If you have figured out the O(n) solution, try coding another solution of which the time complexity is O(n log(n)).

out of topic
You are in a room with three light switches. Each switch controls one of three light bulbs in an adjacent room, but you do not know which switch controls which bulb. You can only go into the room once to check the state of the bulbs. How can you determine which switch controls which bulb?

Solution:

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        minm = len(nums) + 1
        left = 0
        tot = 0
        
        for i in range(len(nums)):
            tot += nums[i]
            while tot >= target:
                minm = min(minm, i - left + 1)
                tot -= nums[left]
                left += 1
        
        if minm > len(nums):
            return 0
        return minm

Explanation:
Initialize Variables:

minm is initialized to a value greater than the length of nums to ensure any valid subarray length found will be smaller.
left is the starting index of the current subarray.
tot is the sum of the current subarray.
Iterate Through nums:

Add each element to tot as we iterate through the array with index i.
Adjust left Pointer:

If tot is greater than or equal to target, adjust the left pointer to find the minimal subarray length.
Continuously subtract the value at nums[left] from tot and increment left until tot is less than target.
During this process, update minm with the length of the current valid subarray if it's smaller than the previously recorded minm.
Return Result:

If no valid subarray is found, minm will remain greater than len(nums) and the function will return 0.
Otherwise, it returns the minimal length of the subarray.
This approach ensures an efficient solution with a time complexity of O(n), where n is the length of the input array nums. The sliding window technique optimally finds the minimal subarray length in a single pass through the array.

The behavior difference between mutable objects (like lists) and immutable objects (like integers) in Python explains why changing the value of a variable affects another variable when dealing with arrays (lists) but not when dealing with integers.

Mutable vs. Immutable Objects
Mutable objects: These can be changed in place. Examples include lists, dictionaries, and sets.
Immutable objects: These cannot be changed in place. Examples include integers, strings, and tuples.
Immutable Example (Integers)
When you assign an integer to another variable, Python creates a new reference to the integer object. Since integers are immutable, changing the value of one variable does not affect the other.

a = 10
b = a  # b now references the same integer object as a
b = 20  # b now references a new integer object
print(a)  # output: 10
print(b)  # output: 20

In this example, when b is assigned the value 20, it does not change the value of a because integers are immutable. Assigning 20 to b makes b reference a new integer object.

Mutable Example (Lists)
When you assign a list to another variable, both variables reference the same list object. Since lists are mutable, changes made through one variable are reflected in the other.

a = [1, 2, 3]
b = a  # b now references the same list as a
b[0] = 99  # modify the first element of the list referenced by b
print(a)  # output: [99, 2, 3]
print(b)  # output: [99, 2, 3]

In this example, both a and b reference the same list object. Changing the list through b affects the list referenced by a because lists are mutable.

Why This Happens
Immutable objects: Variables referencing immutable objects (like integers) create a new reference when reassigned.
Mutable objects: Variables referencing mutable objects (like lists) point to the same object unless explicitly copied.

ከመሞት ባተርፋት
ሀገሬን ጫኑልኝ ይዣት እጠፋለሁ ልባችሁ ሲረጋ
ቀልባችሁ ሲሰክን፣ እምልሳታለሁ።

Prefix Sum Array – Implementation and Applications in Competitive Programming

Given an array arr[] of size N, find the prefix sum of the array. A prefix sum array is another array prefixSum[] of the same size, such that the value of prefixSum[i] is arr[0] + arr[1] + arr[2] . . . arr[i].

Examples:
Input: arr[] = {10, 20, 10, 5, 15}
Output: prefixSum[] = {10, 30, 40, 45, 60}
Explanation: While traversing the array, update the element by adding it with its previous element.
prefixSum[0] = 10,
prefixSum[1] = prefixSum[0] + arr[1] = 30,
prefixSum[2] = prefixSum[1] + arr[2] = 40 and so on.

write your answer in the group or send it with the bot i will review it.