TCS Interview Preparation (NQT)

def reverse_string(s):
    return s[::-1]

def is_leap_year(year):
    return (year % 400 == 0) or (year % 4 == 0 and year % 100 != 0)

def convert_vowels(s):
    return ''.join([c.upper() if c in 'aeiou' else c for c in s])

def is_palindrome(s):
    s = s.replace(' ', '').lower()
    return s == s[::-1]

import math
def hypotenuse(a, b):
    return math.sqrt(a**2 + b**2)

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

def two_sum(nums, target):
    seen = {}
    for num in nums:
        if target - num in seen:
            return [seen[target - num], nums.index(num)]
        seen[num] = nums.index(num)
    return []

def merge(arr1, arr2):
    result = []
    i = j = 0
    while i < len(arr1) and j < len(arr2):
        if arr1[i] <= arr2[j]:
            result.append(arr1[i])
            i += 1
        else:
            result.append(arr2[j])
            j += 1
    return result + arr1[i:] + arr2[j:]

def find_max(arr):
    return max(arr) if arr else None

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

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

def factorial(n):
    if n < 2:
        return 1
    return n * factorial(n - 1)

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

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

def are_anagrams(s1, s2):
    return sorted(s1) == sorted(s2)

def count_freq(s):
    freq = {}
    for c in s:
        freq[c] = freq.get(c, 0) + 1
    return freq

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

def is_valid(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

def max_subarray(arr):
    max_sum = curr_sum = arr[0]
    for num in arr[1:]:
        curr_sum = max(num, curr_sum + num)
        max_sum = max(max_sum, curr_sum)
    return max_sum

def sum_of_digits(n):
    return sum(int(d) for d in str(n))