ICICI Bank Interview Preparation

SELECT DISTINCT salary FROM employees 
ORDER BY salary DESC LIMIT 1 OFFSET 1;

def two_pointer_sum(arr, target):
    left, right = 0, len(arr) - 1
    while left < right:
        current_sum = arr[left] + arr[right]
        if current_sum == target:
            return [left, right]
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return []

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

def max_product_subarray(arr):
    if not arr:
        return 0
    max_prod = min_prod = max_result = arr[0]
    for i in range(1, len(arr)):
        max_prod = max(arr[i], max_prod * arr[i], min_prod * arr[i])
        min_prod = min(arr[i], min_prod * arr[i], min_prod * arr[i])
        max_result = max(max_result, max_prod)
    return max_result

def replace_spaces(s):
    return s.replace(' ', '%20')

# Or using list
def replace_spaces_v2(s):
    return ''.join(['%20' if c == ' ' else c for c in s])

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

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

def has_cycle(head):
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            return True
    return False

class Queue:
    def __init__(self):
        self.items = []
    def enqueue(self, x):
        self.items.append(x)
    def dequeue(self):
        return self.items.pop(0) if self.items else None

import heapq

def find_kth_largest(arr, k):
    return heapq.nlargest(k, arr)[-1]

def is_valid_parens(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 rotate(arr, k):
    k = k % len(arr)
    return arr[-k:] + arr[:-k]

def flatten(nested_list):
    result = []
    for item in nested_list:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result

def max_profit(prices):
    if not prices:
        return 0
    min_price = float('inf')
    max_profit_val = 0
    for price in prices:
        max_profit_val = max(max_profit_val, price - min_price)
        min_price = min(min_price, price)
    return max_profit_val

def reverse_words(s):
    return ' '.join(s.split()[::-1])

def majority_element(arr):
    count = 0
    candidate = None
    for num in arr:
        if count == 0:
            candidate = num
        count += (1 if num == candidate else -1)
    return candidate