Add files via upload

Subhamnation · web-flow · commit 9c3e0ed8cb6b · 2026-01-27T03:27:16.000+05:30
diff --git a/interview_prep/practice_coding_round/Array/matrix_multiplication.py b/interview_prep/practice_coding_round/Array/matrix_multiplication.py
@@ -0,0 +1,14 @@
+A = [[1,2,3],
+     [4,5,6],
+     [7,8,9]]
+
+B = [[9,8,7],
+     [6,5,4],
+     [3,2,1]]
+
+import numpy as np
+A = np.array(A)
+B = np.array(B)
+
+pdkt = np.dot(A,B)
+print(pdkt)
diff --git a/interview_prep/practice_coding_round/Basics/Armstrong.py b/interview_prep/practice_coding_round/Basics/Armstrong.py
@@ -0,0 +1,23 @@
+### Core logic: 
+
+# An Armstrong number is a number that is equal to the sum of its own digits each raised to the power of the number of digits.
+
+# For example:
+
+# 153 = 1³ + 5³ + 3³ = 153 (Armstrong number)
+# 120 ≠ 1³ + 2³ + 0³ = 9 (Not an Armstrong number)
+
+x = int(input("Enter the number"))
+temp = x
+rev = 0
+power = len(str(x))
+
+while x > 0:
+    d = x % 10
+    rev = rev + (d ** power)
+    x = x //10
+
+if temp == rev:
+    print(f"{temp} is Armstrong number")
+else:
+    print(f"{temp} is not Armstrong number")
diff --git a/interview_prep/practice_coding_round/Basics/common_letters.py b/interview_prep/practice_coding_round/Basics/common_letters.py
@@ -0,0 +1,8 @@
+a = str(input("Enter first string: "))
+b = str(input("Enter second string: "))
+a1 = set(a) # convert string to set why? to get unique letters
+b1 = set(b) # convert string to set why? to get unique letters
+print(a1)
+print(b1)
+c = a1 & b1 # intersection why? to get common letters
+print(c)
diff --git a/interview_prep/practice_coding_round/Basics/count_digits_list.py b/interview_prep/practice_coding_round/Basics/count_digits_list.py
@@ -0,0 +1,12 @@
+lst = [1, 2, 2, 3, 4, 1, 2, 5, 5, 5,23, 34, 34, 23, 1]
+
+freq = {} # empty dictionary to store frequency
+
+
+for i in lst: # iterate through each element in the list
+    if i in freq:  # check if element already in dictionary
+        freq[i] += 1 # increment count if found
+    else: 
+        freq[i] = 1 # initialize count if not found
+
+print("Frequency Dictionary:", freq)
diff --git a/interview_prep/practice_coding_round/Basics/counts_digit.py b/interview_prep/practice_coding_round/Basics/counts_digit.py
@@ -0,0 +1,28 @@
+### Core logic: Digit frequency is found by iterating through each digit and incrementing a counter when a match is found.
+
+## Single digit count
+
+# x = input("Enter the number:" )
+# digit = input("Enter the digit to be counted: ")
+# count = 0
+
+# for i in x:
+#     if i == digit:
+#         count+= 1
+# print(f"The digit frequency of {digit} in {x} is:" ,count)
+
+###########################################
+
+## All digit frequency count
+
+x = input("Enter the number: ")
+
+freq = {} # empty dictionary to store frequency
+
+for d in x: # iterate through each digit in the number
+    if d in freq: # check if digit already in dictionary
+        freq[d] += 1 # increment count if found
+    else:
+        freq[d] = 1 # initialize count if not found
+
+print("Digit Frequency Dictionary:", freq)
diff --git a/interview_prep/practice_coding_round/Basics/factorial.py b/interview_prep/practice_coding_round/Basics/factorial.py
@@ -0,0 +1,14 @@
+### Core logic: Factorial is computed using iterative multiplication from 1 to n
+
+x = int(input("Enter a number to find factorial: "))
+fact = 1
+for i in range(1, x+1):
+    fact = fact * i
+print(f"The factorial of {x} is:", fact)
+
+
+## Math opearator based 
+
+# import math
+# x = int(input("Enter number: "))
+# print(math.factorial(x))
diff --git a/interview_prep/practice_coding_round/Basics/fibonacci.py b/interview_prep/practice_coding_round/Basics/fibonacci.py
@@ -0,0 +1,30 @@
+# Core logic: To print the Fibonacci sequence in Python, we need to generate a series of numbers where each number is the sum of the two preceding ones, starting from 0 and 1. The Fibonacci sequence follows a specific pattern that begins with 0 and 1, and every subsequent number is the sum of the two previous numbers.
+
+# Mathematically, the Fibonacci sequence can be represented as:
+
+# F(n) = F(n-1) + F(n-2)
+
+# Where:
+# F(0) = 0
+# F(1) = 1
+# F(n) for n > 1 is the sum of the two preceding numbers.
+
+### Recursion
+
+# def fib(n):
+#     if n <= 1:
+#         return n
+#     return fib(n-1) + fib(n-2)
+# print(fib(10)) 
+
+n = int(input("Enter till when you want the series:"))
+a = 0
+b =1
+next =b     
+count = 1
+while count <= n:
+    print(next, end = " ") #👉 prints current Fibonacci number
+    count = count + 1 # 👉 keeps track of how many numbers printed - Increase the counter
+    a, b = b, next # It moves the sequence forward
+    next = a + b # 👉 next fibonacci number = sum of previous two numbers
+print()
diff --git a/interview_prep/practice_coding_round/Basics/lamda_functions.py b/interview_prep/practice_coding_round/Basics/lamda_functions.py
@@ -0,0 +1,19 @@
+# addition = lambda a, b: a + b
+# print(addition(3, 5))  # Returns 8
+
+
+### Even and odd 
+
+# def even(num):
+#     if num % 2 == 0:
+#         print("Even")
+#     else:
+#         print("Odd")
+# even(25)
+
+# even_1 = lambda a: a % 2 == 0
+# print(even_1(22))
+
+
+addition_1 = lambda x,y,z : x+y+z
+print(addition_1(2,3,4))
diff --git a/interview_prep/practice_coding_round/Basics/lcm_gcd.py b/interview_prep/practice_coding_round/Basics/lcm_gcd.py
@@ -0,0 +1,22 @@
+# ## Core logic: 
+
+# ## GCD (Greatest Common Divisor) and LCM (Least Common Multiple) of two numbers are calculated using mathematical algorithms.
+
+# GCD is computed using the Euclidean algorithm by repeatedly replacing (a, b) with (b, a mod b) until b becomes zero.
+
+# LCM:
+
+# LCM is calculated using the relationship: LCM(a, b) = (a × b) / GCD(a, b).
+
+def gcd (a,b):
+    while b != 0: 
+        a,b = b, a%b
+    return a
+x = int(input("Enter the first number: "))
+y = int(input("Enter the second number: "))
+print("GCD:",gcd(x,y))
+
+def lcm(a, b):
+    return (a * b) // gcd(a, b)
+
+print("LCM:",lcm(x,y))
diff --git a/interview_prep/practice_coding_round/Basics/list_comprehension.py b/interview_prep/practice_coding_round/Basics/list_comprehension.py
@@ -0,0 +1,27 @@
+list_a = [1,2,3,4,5,6,7,8]
+
+#sqr = lambda i : i * i 
+
+#for i in list_a:
+    #print(sqr(i))
+
+#print(list(map(sqr,list_a)))
+
+# cube = lambda x: x ** 3
+# for x in list_a:
+#     if x % 2 == 0:
+#         print(cube(x))
+#     else:
+#         continue
+
+#### Dictionary mapping 
+
+sqr_dict = {x: x**2 for x in list_a}
+for x in list_a:
+    if x % 2 == 0:
+        print(sqr_dict[x])
+    else:
+        continue
+
+#print(sqr_dict)
+
diff --git a/interview_prep/practice_coding_round/Basics/lists_to_Dict.py b/interview_prep/practice_coding_round/Basics/lists_to_Dict.py
@@ -0,0 +1,16 @@
+
+### Convert two lists to dictionary
+def list_to_dict():
+    keys = [1,2,"Ram"]
+    values = ["One","Two", "Three"]
+    result = dict(zip(keys,values))
+    print(result)
+list_to_dict()
+
+
+### Convert dictionary to tuple of key-value pairs
+def dict_to_tupule():
+    x = {1: 'One', 2: 'Two', 'Ram': 'Three'}
+    for i in x.items():
+        print(i)
+dict_to_tupule()
diff --git a/interview_prep/practice_coding_round/Basics/map_functions.py b/interview_prep/practice_coding_round/Basics/map_functions.py
@@ -0,0 +1,21 @@
+# list_a = [1,2,3,4,5,6,7,8]
+# def even_odd(i):
+#     for i in list_a:
+#         if i % 2 == 0:
+#             print(i, " is Even")
+#         else:
+#             print(i, "is Odd")
+# even_odd(list_a)
+
+
+list_a = [101,200,30,41,55,96,7777,58]
+def even_odd(i):
+    for i in list_a:
+        if i % 2 == 0:
+            print(f"{i} is Even")
+        else:
+            print(f"{i} is Odd")
+# even_odd(list_a)
+
+
+print(list(map(even_odd,list_a)))
diff --git a/interview_prep/practice_coding_round/Basics/palindrome.py b/interview_prep/practice_coding_round/Basics/palindrome.py
@@ -0,0 +1,30 @@
+
+### Core logic: A palindrome is checked by comparing the original value with its reversed representation, either using string slicing or mathematical digit reversal.
+
+
+# #### String wise 
+
+# x = input("Enter the number: ")
+# temp = x
+# y = x[::-1]
+# if temp == y:
+#     print(f"{x} is Palindrome number")
+# else:
+#     print(f"{x} is not Palindrome number")
+
+
+#### Math wise 
+
+x = int(input("Enter the number: "))
+rev = 0
+original = x
+while x > 0:
+    d = x % 10
+    rev = rev * 10 + d
+    x = x // 10
+print ("The reverse number is", rev)
+
+if original == rev:
+    print(f"{original} is Palindromic")
+else:
+    print(f"{original} is non-palindromic")
diff --git a/interview_prep/practice_coding_round/Basics/prime_number.py b/interview_prep/practice_coding_round/Basics/prime_number.py
@@ -0,0 +1,19 @@
+
+#### Core logic: To check if a number n is prime, first see if it's less than 2 — if so, it's not prime. Otherwise, try dividing n by every number from 2 to n - 1. If any number divides it evenly, then n is not prime. If none do, then n is a prime number.
+
+
+
+def prime_check(num):
+    if num <= 1:
+        print(f"{num} is non-prime")
+        return
+
+    for i in range(2, num):
+        if num % i == 0:
+            print(f"{num} is non-prime")
+            return   # stop checking further
+
+    print(f"{num} is Prime")  # runs only if no divisor found
+
+
+prime_check(28)
diff --git a/interview_prep/practice_coding_round/Basics/reverse_a_number.py b/interview_prep/practice_coding_round/Basics/reverse_a_number.py
@@ -0,0 +1,33 @@
+### String wise
+
+# x = input("Enter the number: ")
+# print(x[::-1])
+
+### Core logic: To reverse a number, convert it to a string and use slicing to reverse the string representation. Then print the reversed string
+## We reverse a number by repeatedly extracting the last digit using modulo, shifting the reversed number left using multiplication by 10, appending the digit, and removing the last digit using integer division.
+
+############
+
+# pure math wise 
+
+# def rev_num(num, rev=0):
+#     if num == 0:
+#         return rev
+#     d = num % 10
+#     rev = rev * 10 + d
+#     return rev_num(num // 10, rev)
+
+# print(rev_num(3454567))
+
+
+### Best Response 
+
+n = int(input("Enter the number: "))
+rev = 0
+
+while n > 0:
+    d = n % 10
+    rev = rev * 10 + d
+    n //= 10
+
+print(rev)
diff --git a/interview_prep/practice_coding_round/Basics/test_1.py b/interview_prep/practice_coding_round/Basics/test_1.py
@@ -0,0 +1,10 @@
+### Pass a list. Find all the evens. Square those and cube of all even only and store it in dictionary. 
+
+list_a = [20,45,5,56,78,4,6,8,9,0,3,52]
+
+result_dict = {
+    #x:{"Square": x**2,"Cube":x**3}
+    x:{x**2,x**3}
+    for x in list_a if x % 2 == 0
+}
+print(result_dict)
diff --git a/interview_prep/practice_coding_round/Dictionary/Generating_dict.py b/interview_prep/practice_coding_round/Dictionary/Generating_dict.py
@@ -0,0 +1,21 @@
+# A dictionary is another Python data structure to store heterogeneous objects that are immutable but unordered. This means that when you try to access the elements, they might not be in exactly the same order as the one in which you inserted them.
+
+# But what sets dictionaries apart from lists is how elements are stored. Elements in a dictionary are accessed via their key values instead of their index, as we did in a list. So, dictionaries contain key-value pairs instead of just single elements.
+
+### Hashing: 
+# Dictionaries are handy to access items quickly because, unlike lists and tuples, a dictionary does not have to iterate over all the items to find a value. Dictionary uses the item key to find the item value quickly. This concept is called hashing.
+
+adict = {
+    "name": "John",
+    "age": 30,
+    "city": "New York"
+}
+print(adict)
+# Accessing elements in a dictionary
+print(adict["name"])
+print(adict["age"])
+print(adict["city"])
+
+# Accessing Keys and Values
+print(adict.keys())   # prints all keys
+print(adict.values()) # prints all values
diff --git a/interview_prep/practice_coding_round/Lists/Count_bit_patterns.py b/interview_prep/practice_coding_round/Lists/Count_bit_patterns.py
@@ -0,0 +1,16 @@
+### Core logic: We group bit patterns using a dictionary where each unique pattern is a key and its number of occurrences is stored as the value.
+
+
+bit_patterns = [
+    "0011", "000111", "010101", "0011", "010101", "0011",
+    "111", "000111", "010101", "111"
+]
+
+grps = {}
+for pattern in bit_patterns:
+    if pattern in grps:
+        grps[pattern] += 1
+    else:
+        grps[pattern] = 1
+for pattern, count in grps.items():
+    print(f"{pattern} → {count}")
diff --git a/interview_prep/practice_coding_round/Lists/Square_of_a_list.py b/interview_prep/practice_coding_round/Lists/Square_of_a_list.py
diff --git a/interview_prep/practice_coding_round/Lists/duplicate_removal.py b/interview_prep/practice_coding_round/Lists/duplicate_removal.py
diff --git a/interview_prep/practice_coding_round/Lists/max_min_find.py b/interview_prep/practice_coding_round/Lists/max_min_find.py
diff --git a/interview_prep/practice_coding_round/Pandas/dataframe.py b/interview_prep/practice_coding_round/Pandas/dataframe.py
diff --git a/interview_prep/practice_coding_round/Set/Set_comparison.py b/interview_prep/practice_coding_round/Set/Set_comparison.py
diff --git a/interview_prep/practice_coding_round/Set/Set_operations.py b/interview_prep/practice_coding_round/Set/Set_operations.py
