Question Set 2 (10Q)

Author: Rudra-G-23

005_Problem_Sloving_with_Python/Q-02/11.py

@@ -0,0 +1,28 @@
+""" 
+Write a function named group_even_odd that
+takes a list of integers and returns:
+{
+  "even": [...],
+  "odd": [...]
+}
+
+"""
+def group_even_odd(nums):
+    even_odd_dict = {"even": [], "odd": []}
+    
+    if not nums:
+        return even_odd_dict
+    
+    for n in nums:
+        if n %2 == 0:
+            even_odd_dict['even'].append(n)
+        else:
+            even_odd_dict['odd'].append(n)
+    
+    return even_odd_dict
+    
+print(group_even_odd([1, 2, 3, 4, 5, 6]))
+# {'even': [2, 4, 6], 'odd': [1, 3, 5]}
+
+print(group_even_odd([]))
+# {'even': [], 'odd': []}

005_Problem_Sloving_with_Python/Q-02/12.py

@@ -0,0 +1,36 @@
+""" 
+Write a function named group_words_by_vowel_start 
+that takes a list of words and groups them 
+into two lists:
+
+{
+  "vowel": [...],
+  "consonant": [...]
+}
+
+"""
+
+def group_words_by_vowel_start(words):
+    result = {"vowel": [], "consonant": []}
+    vowels = {'a', 'e', 'i', 'o', 'u'}
+    
+    if not words:
+        return result
+    
+    for w in words:
+        first_char  = w[0].lower()
+        if first_char  in vowels:
+            result['vowel'].append(w)
+        else:
+            result['consonant'].append(w)
+    
+    return result
+
+print(group_words_by_vowel_start(["apple", "banana", "orange", "grape", "umbrella"]))
+# {'vowel': ['apple', 'orange', 'umbrella'], 'consonant': ['banana', 'grape']}
+
+print(group_words_by_vowel_start([]))
+# {'vowel': [], 'consonant': []}
+
+print(group_words_by_vowel_start(None))
+# {'vowel': [], 'consonant': []}

005_Problem_Sloving_with_Python/Q-02/13.py

@@ -0,0 +1,28 @@
+""" 
+Write a function named group_numbers_by_digits
+that takes a list of integers and groups them
+by number of digits.
+"""
+
+def group_numbers_by_digits(nums):
+    if not nums:
+        return {}
+    
+    result = {}
+    for n in nums:
+        count = len(str(n))
+        if count in result:
+            result[count].append(n)
+        else:
+            result[count] = [n]
+    return result
+        
+
+print(group_numbers_by_digits([1, 22, 333, 4, 55, 6666]))
+# {1: [1, 4], 2: [22, 55], 3: [333], 4: [6666]}
+
+print(group_numbers_by_digits([]))
+# {}
+
+print(group_numbers_by_digits(None))
+# {}

005_Problem_Sloving_with_Python/Q-02/14.py

@@ -0,0 +1,18 @@
+""" 
+Write a function named is_sorted_ascending 
+that takes a list of numbers and returns
+True if the list is sorted in ascending order,
+otherwise False.
+"""
+
+def is_sorted_ascending(nums):
+    if not nums:
+        return True
+    
+    sort_nums = sorted(nums)
+    return nums == sort_nums
+
+print(is_sorted_ascending([1, 2, 3, 4])) # True
+print(is_sorted_ascending([1, 3, 2])) # False
+print(is_sorted_ascending([])) # True
+print(is_sorted_ascending([5])) # True

005_Problem_Sloving_with_Python/Q-02/15.py

@@ -0,0 +1,29 @@
+""" 
+Write a function named square_even_numbers
+that takes a list of numbers and returns a
+new list containing the square of only the
+even numbers.
+"""
+
+def square_even_numbers(nums):
+    if not nums:
+        return []
+    
+    even_list = []
+    
+    for n in nums:
+        if n % 2 == 0:
+            nn = n** 2
+            even_list.append(nn)
+
+    return even_list
+
+
+print(square_even_numbers([1, 2, 3, 4, 5]))
+# [4, 16]
+
+print(square_even_numbers([]))
+# []
+
+print(square_even_numbers([1, 3, 5]))
+# []

005_Problem_Sloving_with_Python/Q-02/16.py

@@ -0,0 +1,30 @@
+""" 
+Write a function named has_duplicates that
+returns True if a list contains any duplicate
+values, otherwise False.
+"""
+# M1
+def has_duplicates(nums):
+    if not nums:
+        return False
+    unique = []
+
+    for w in nums:
+        if w not in unique:
+            unique.append(w)
+    
+    return nums != unique
+
+# M2
+def has_duplicates(nums):
+    seen = set()
+    for n in nums:
+        if n in seen:
+            return True
+        seen.add(n)
+    return False
+
+print(has_duplicates([1, 2, 3, 4])) # False
+print(has_duplicates([1, 2, 3, 2])) # True
+print(has_duplicates([])) # False
+print(has_duplicates([5])) # False

005_Problem_Sloving_with_Python/Q-02/17.py

@@ -0,0 +1,12 @@
+""" 
+Write a function named reverse_list
+that reverses a list without using 
+.reverse().
+"""
+
+def reverse_list(nums):
+    return nums[::-1]
+
+print(reverse_list([1, 2, 3, 4])) # [4, 3, 2, 1]
+print(reverse_list([])) # []
+print(reverse_list([5])) # [5]

005_Problem_Sloving_with_Python/Q-02/18.py

@@ -0,0 +1,17 @@
+""" 
+Write a function named running_sum that
+returns a list where each element is the
+sum of all previous elements including itself.
+"""
+
+def running_sum(nums):
+    new_list = []
+    total = 0
+    for n in nums:
+        total += n
+        new_list.append(total)
+    return new_list
+
+print(running_sum([1, 2, 3, 4])) # [1, 3, 6, 10]
+print(running_sum([])) # []
+print(running_sum([5])) # [5]

005_Problem_Sloving_with_Python/Q-02/19.py

@@ -0,0 +1,24 @@
+""" 
+Write a function named second_largest that returns
+the second largest number in a list.
+
+- Do not use sorted()
+- Assume the list has at least two distinct numbers
+"""
+
+def second_largest(nums):
+    first = float('-inf')
+    second = float('-inf')
+    
+    for n in nums:
+        if n > first:
+            second = first
+            first = n
+        elif n < first and n > second:
+            second = n
+            
+    return first, second
+
+print(second_largest([10, 5, 20, 8])) # 10
+print(second_largest([1, 2, 3, 4])) # 3
+print(second_largest([5, 5, 3, 2, 5])) # 3

005_Problem_Sloving_with_Python/Q-02/20.py

@@ -0,0 +1,20 @@
+""" 
+Write a function named max_difference that returns
+the maximum difference between two numbers in a list
+such that the larger number comes after the smaller one
+without using sort.
+Ex-
+max_difference([2, 3, 10, 6, 4, 8, 1]) # 8  (10 - 2)
+"""
+
+def max_difference(nums):
+    min_so_far = nums[0]
+    max_diff = nums[1] - nums[0]
+    
+    for i in range(1, len(nums)):
+        max_diff = max(max_diff, nums[i] - min_so_far)
+        min_so_far = min(nums[i], min_so_far)
+    
+    return max_diff
+
+print(max_difference([2, 3, 10, 6, 4, 8, 1]))