Deloitte coding

import java.util.Scanner;
public class InchesToCentimeters {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double inches = sc.nextDouble();
        double cm = inches * 2.54;
        System.out.printf("%.2f%n", cm);
    }
}

inches = float(input())
cm = inches * 2.54
print(f"{cm:.2f}")

public class KadanesAlgorithm {
    public static int maxSubArray(int[] nums) {
        int maxSoFar = nums[0];
        int maxEndingHere = nums[0];
        for (int i = 1; i < nums.length; i++) {
            maxEndingHere = Math.max(nums[i], maxEndingHere + nums[i]);
            maxSoFar = Math.max(maxSoFar, maxEndingHere);
        }
        return maxSoFar;
    }

    public static void main(String[] args) {
        System.out.println(maxSubArray(new int[]{-2, 1, -3, 4, -1, 2, 1, -5, 4}));
    }
}

def max_sub_array(nums):
    max_so_far = nums[0]
    max_ending_here = nums[0]
    for num in nums[1:]:
        max_ending_here = max(num, max_ending_here + num)
        max_so_far = max(max_so_far, max_ending_here)
    return max_so_far

print(max_sub_array([-2, 1, -3, 4, -1, 2, 1, -5, 4]))

public class MissingAndRepeating {
    public static int[] findMissingAndRepeating(int[] arr) {
        int n = arr.length;
        int[] freq = new int[n + 1];
        int repeating = -1, missing = -1;

        for (int num : arr) freq[num]++;

        for (int i = 1; i <= n; i++) {
            if (freq[i] == 2) repeating = i;
            if (freq[i] == 0) missing = i;
        }
        return new int[]{repeating, missing};
    }

    public static void main(String[] args) {
        int[] result = findMissingAndRepeating(new int[]{3, 1, 3});
        System.out.println("Repeating = " + result[0] + ", Missing = " + result[1]);
    }
}

import java.util.*;
public class PairsWithGivenSum {
    public static void findPairs(int[] arr, int target) {
        Set<Integer> seen = new HashSet<>();
        for (int num : arr) {
            int complement = target - num;
            if (seen.contains(complement)) {
                System.out.println("(" + complement + ", " + num + ")");
            }
            seen.add(num);
        }
    }

    public static void main(String[] args) {
        findPairs(new int[]{2, 7, 11, 15, -2, 9}, 9);
    }
}

public class LongestPalindromicSubstring {
    public static String longestPalindrome(String s) {
        if (s == null || s.length() < 1) return "";
        int start = 0, end = 0;
        for (int i = 0; i < s.length(); i++) {
            int len1 = expand(s, i, i);
            int len2 = expand(s, i, i + 1);
            int len = Math.max(len1, len2);
            if (len > end - start) {
                start = i - (len - 1) / 2;
                end = i + len / 2;
            }
        }
        return s.substring(start, end + 1);
    }

    private static int expand(String s, int left, int right) {
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            left--;
            right++;
        }
        return right - left - 1;
    }

    public static void main(String[] args) {
        System.out.println(longestPalindrome("babad"));
    }
}

import java.util.PriorityQueue;
public class MergeKSortedLists {
    static class Node {
        int val;
        Node next;
        Node(int val) { this.val = val; }
    }

    public static Node mergeKLists(Node[] lists) {
        PriorityQueue<Node> pq = new PriorityQueue<>((a, b) -> a.val - b.val);
        for (Node node : lists) {
            if (node != null) pq.add(node);
        }

        Node dummy = new Node(0);
        Node curr = dummy;
        while (!pq.isEmpty()) {
            Node smallest = pq.poll();
            curr.next = smallest;
            curr = curr.next;
            if (smallest.next != null) pq.add(smallest.next);
        }
        return dummy.next;
    }
}

public class LongestPathInGrid {
    static int maxLen = -1;

    public static int longestPath(char[][] grid, int sr, int sc, int tr, int tc) {
        boolean[][] visited = new boolean[grid.length][grid[0].length];
        dfs(grid, sr, sc, tr, tc, visited, 0);
        return maxLen;
    }

    private static void dfs(char[][] grid, int r, int c, int tr, int tc, boolean[][] visited, int len) {
        if (r < 0 || r >= grid.length || c < 0 || c >= grid[0].length || grid[r][c] == '#' || visited[r][c]) return;

        if (r == tr && c == tc) {
            maxLen = Math.max(maxLen, len);
            return;
        }

        visited[r][c] = true;
        int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};
        for (int[] d : dirs) {
            dfs(grid, r + d[0], c + d[1], tr, tc, visited, len + 1);
        }
        visited[r][c] = false;
    }
}