Infosys Interview Preparation Guide

def reverse_array(arr):
    start, end = 0, len(arr) - 1
    while start < end:
        arr[start], arr[end] = arr[end], arr[start]
        start += 1
        end -= 1
    return arr

# Example usage
print(reverse_array([1, 2, 3, 4, 5]))  # Output: [5, 4, 3, 2, 1]

def is_palindrome(s):
    # Remove spaces and convert to lowercase
    s = s.replace(" ", "").lower()
    return s == s[::-1]

# Example usage
print(is_palindrome("racecar"))  # Output: True
print(is_palindrome("hello"))    # Output: False

def second_largest(arr):
    first = second = float('-inf')
    for n in arr:
        if n > first:
            second = first
            first = n
        elif n > second and n < first:
            second = n
    return second

# Example usage
print(second_largest([10, 20, 4, 45, 99]))  # Output: 45

def find_all_occurrences(text, pattern):
    positions = []
    start = 0
    while True:
        pos = text.find(pattern, start)
        if pos == -1:
            break
        positions.append(pos)
        start = pos + 1
    return positions

# Example usage
print(find_all_occurrences("abcabcabc", "abc"))  # Output: [0, 3, 6]

def are_anagrams(s1, s2):
    return sorted(s1.replace(" ", "").lower()) == sorted(s2.replace(" ", "").lower())

# Example usage
print(are_anagrams("listen", "silent"))  # Output: True
print(are_anagrams("hello", "world"))    # Output: False

def remove_duplicates(arr):
    if len(arr) == 0:
        return 0
    i = 0
    for j in range(1, len(arr)):
        if arr[i] != arr[j]:
            i += 1
            arr[i] = arr[j]
    return i + 1

# Example usage
arr = [1, 1, 2, 2, 3, 3, 4]
n = remove_duplicates(arr)
print(arr[:n])  # Output: [1, 2, 3, 4]

def rotate_array(arr, k):
    k = k % len(arr)
    return arr[-k:] + arr[:-k]

# Alternative approach (in-place)
def rotate_array_inplace(arr, k):
    def reverse(start, end):
        while start < end:
            arr[start], arr[end] = arr[end], arr[start]
            start += 1
            end -= 1
    k = k % len(arr)
    reverse(0, len(arr) - 1)
    reverse(0, k - 1)
    reverse(k, len(arr) - 1)

# Example usage
arr = [1, 2, 3, 4, 5]
print(rotate_array(arr, 2))  # Output: [4, 5, 1, 2, 3]

def find_pairs(arr, target):
    pairs = set()
    seen = set()
    for num in arr:
        complement = target - num
        if complement in seen:
            pairs.add((min(num, complement), max(num, complement)))
        seen.add(num)
    return list(pairs)

# Example usage
print(find_pairs([1, 5, 7, -1, 5], 6))  # Output: [(1, 5)]

def fibonacci(n):
    fib_sequence = []
    a, b = 0, 1
    for _ in range(n):
        fib_sequence.append(a)
        a, b = b, a + b
    return fib_sequence

# Example usage
print(fibonacci(10))  # Output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

def is_armstrong(num):
    digits = [int(d) for d in str(num)]
    n = len(digits)
    return sum(d**n for d in digits) == num

# Example usage
print(is_armstrong(153))  # Output: True (1^3 + 5^3 + 3^3 = 153)
print(is_armstrong(9474)) # Output: True (9^4 + 4^4 + 7^4 + 4^4 = 9474)

def count_char_frequency(s):
    char_count = {}
    for char in s:
        char_count[char] = char_count.get(char, 0) + 1
    return char_count

# Example usage
print(count_char_frequency("hello"))  # Output: {'h': 1, 'e': 1, 'l': 2, 'o': 1}

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

# Example usage
print(gcd(48, 18))  # Output: 6

def is_prime(n):
    if n < 2:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    for i in range(3, int(n**0.5) + 1, 2):
        if n % i == 0:
            return False
    return True

# Example usage
print(is_prime(17))  # Output: True
print(is_prime(20))  # Output: False

def string_to_int(s):
    s = s.strip()
    if not s:
        return 0
    sign = -1 if s[0] == '-' else 1
    result = 0
    start = 1 if s[0] in ['-', '+'] else 0
    for i in range(start, len(s)):
        if not s[i].isdigit():
            break
        result = result * 10 + int(s[i])
    return sign * result

# Example usage
print(string_to_int("123"))    # Output: 123
print(string_to_int("-456"))   # Output: -456

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

# Example usage
print(bubble_sort([64, 34, 25, 12, 22, 11, 90]))  # Output: [11, 12, 22, 25, 34, 64, 90]

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

# Example usage
print(binary_search([1, 3, 5, 7, 9, 11], 7))  # Output: 3
print(binary_search([1, 3, 5, 7, 9, 11], 6))  # Output: -1

def matrix_addition(matrix1, matrix2):
    result = []
    for i in range(len(matrix1)):
        row = []
        for j in range(len(matrix1[0])):
            row.append(matrix1[i][j] + matrix2[i][j])
        result.append(row)
    return result

# Example usage
m1 = [[1, 2], [3, 4]]
m2 = [[5, 6], [7, 8]]
print(matrix_addition(m1, m2))  # Output: [[6, 8], [10, 12]]

def factorial(n):
    if n < 0:
        return -1  # Error case
    elif n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

# Example usage
print(factorial(5))  # Output: 120

def sieve_of_eratosthenes(n):
    if n < 2:
        return []
    is_prime = [True] * (n + 1)
    is_prime[0] = is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if is_prime[i]:
            for j in range(i*i, n + 1, i):
                is_prime[j] = False
    return [i for i in range(2, n + 1) if is_prime[i]]

# Example usage
print(sieve_of_eratosthenes(30))  # Output: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

def find_common_elements(arr1, arr2):
    return list(set(arr1) & set(arr2))

# Example usage
print(find_common_elements([1, 2, 3, 4], [3, 4, 5, 6]))  # Output: [3, 4]

def lcm(a, b):
    def gcd(x, y):
        while y:
            x, y = y, x % y
        return x
    return (a * b) // gcd(a, b)

# Example usage
print(lcm(12, 18))  # Output: 36

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def reverse_linked_list(head):
    prev = None
    current = head
    while current:
        next_temp = current.next
        current.next = prev
        prev = current
        current = next_temp
    return prev

def find_middle(head):
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    return slow.data

class Stack:
    def __init__(self):
        self.items = []
    
    def push(self, item):
        self.items.append(item)
    
    def pop(self):
        return self.items.pop() if not self.is_empty() else None
    
    def is_empty(self):
        return len(self.items) == 0
    
    def peek(self):
        return self.items[-1] if not self.is_empty() else None

def is_balanced(s):
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    for char in s:
        if char in mapping:
            if not stack or stack[-1] != mapping[char]:
                return False
            stack.pop()
        else:
            stack.append(char)
    return len(stack) == 0

# Example usage
print(is_balanced("({[]})"))  # Output: True
print(is_balanced("({[}])"))  # Output: False