Day 24 and 25 of Learning DSA – Remove Duplicates, Remove Element, Sum of Natural Numbers, and Prime Number Checker

1. Remove Element

This solution removes all occurrences of a given value from an array in-place and returns the number of remaining elements. The relative order of the elements may be changed, and elements beyond the returned length are not guaranteed to be preserved.

🧠 Approach

1. Create a variable x and initialize it to 0. This pointer will track the next position to place a valid element (i.e., not equal to val).
2. Loop through the array using index j from 0 to nums.length - 1.
3. If nums[j] !== val, it means the element should be kept:
   • Assign nums[j] to nums[x].
   • Increment x by 1.
4. After the loop finishes, x will contain the number of elements that are not equal to val.
5. Return x as the new length of the modified array.

🧮 Complexity

• Time complexity:
  
  O(n) — We iterate through the array once.

• Space complexity:
  
  O(1) — We do not use any additional space; all operations are in-place.

🧑‍💻 Code

/** * @param {number[]} nums * @param {number} val * @return {number} */ var removeElement = function(nums, val) { let x = 0; for (let j = 0; j < nums.length; j++) { if (nums[j] !== val) { nums[x] = nums[j]; x = x + 1; } } return x; }; 

2. Remove Duplicates from Sorted Array

This solution removes duplicates from a sorted array in-place and returns the number of unique elements.

🧠 Approach

1. Create variable x and initialize it to 0.
2. Loop through the array using a from 0 to arr.length - 1.
3. Inside the loop, check if arr[x] < arr[a]:
   • If true, it means a new unique value is found.
4. Increment x.
5. Assign arr[a] to arr[x].
6. After the loop, return x + 1 as the count of unique elements in the array.

This approach works because the input array is sorted, which means all duplicates are adjacent.

⏱ Time Complexity: O(n)

• We go through the array only once from start to end.
• Each check and update inside the loop takes the same small amount of time.
• So the total time depends on how many items are in the array — that’s why it’s O(n).

🧠 Space Complexity: O(1)

• We don’t use any extra space like another array.
• We only use one variable (x) to help with tracking.
• Because we use a fixed amount of memory, no matter how big the array is, the space used stays the same — that’s O(1).

Example Code

/** * @param {number[]} nums * @return {number} */ var removeDuplicates = function(nums) { let x = 0; for(let j = 0 ; j < nums.length ; j++){ console.log(j) if(nums[x] < nums[j]){ x = x + 1; nums[x] = nums[j] } } return x +1; }; 

🧮 Prime Number Checker

This program checks whether a given number is a prime number or not using basic iteration logic.

✅ What is a Prime Number?

A prime number is a number greater than 1 that is divisible only by 1 and itself.

Examples of prime numbers: 2, 3, 5, 7, 11, 13, ...

🚀 Approach

1. Loop from i = 2 to i < num

   • We skip 1 because every number is divisible by 1.
   • We only check up to num - 1 to see if there's any divisor.

2. Check if num % i === 0

   • If true, then num is divisible by i, so it's not a prime number.

3. If num is divisible by any value other than 1 and itself

   • Return "num is not a prime number".

4. If loop completes without finding a divisor

   • Return "num is a prime number".

⚠️ Edge Cases

1. Number must be positive only

   • Negative numbers are not prime.

2. Input must be a number, not a string

   • Type check is required.

3. Number must be greater than 1

   • 0 and 1 are not prime numbers.

Example Usage

Input: 7 Output: 7 is a prime number Input: 10 Output: 10 is not a prime number 

Example

JavaScript Code

function checkPrimeNumber(num) { let isPrime = true; if (typeof num !== 'number' || !Number.isInteger(num)) { return `${num} is not a valid input (must be an integer).`; } if (num <= 1) { return `${num} is not a prime number (must be greater than 1).`; } for (let i = 2; i < num; i++) { if (num % i === 0) { return `${num} is not a prime number`; } } return `${num} is a prime number`; } console.log(checkPrimeNumber(7)); console.log(checkPrimeNumber(10)); 

Python Code

def checkPrimeNumber(num): if num <= 1: return f"{num} is not a valid input (must be an integer greater than 1)." if type(num) is not int: return f"{num} is not a valid input (must be an integer)." for i in range(2, int(num**0.5) + 1): if num % i == 0: return f"{num} is not a prime number." return f"{num} is a prime number." print(checkPrimeNumber(11)) # Output: 11 is a prime number. print(checkPrimeNumber(15)) # Output: 15 is not a prime number.  

Sum of Natural Numbers (Loop Approach)

This program calculates the sum of the first n natural numbers using a loop-based approach.

🚀 Approach

1. Create a variable sum and initialize it to 0
2. Use a loop to go from 1 to n
3. In each iteration, add the current number to sum
4. After the loop, return or print sum

#Example (n = 5)

 Input: 5 Output: 15 (1 + 2 + 3 + 4 + 5) 

Time and Space Complexity

• Time Complexity: O(n) --> Linear Search
• Space Complexity: O(1) --> we use a Fix Space

Example

JavaScript Code

function Sum_Of_Natural_Numbers(n) { if(n < 0 || typeof(n) !== "number") return 'Input must be a natural number greater than 0'; let sum = 0; for(let i = 1 ; i <= n; i++) { sum += i; } return sum; } console.log(Sum_Of_Natural_Numbers(10)); // Output: 55 

Python Code

def Sum_Of_Natural_Numbers(n): # Corrected isinstance check and logic  sum = 0 if not isinstance(n, int) or n < 0: return f"{n} must be an integer and greater than or equal to 0" for i in range(1 , n + 1): sum += i return sum # Updated test case with a valid integer input print(Sum_Of_Natural_Numbers(10))