DeltaX Round 2 – All 20 Java Solutions

// DeltaX Round 2 – Online Coding Problems (Java Templates)

import java.util.*;

class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
class TreeNode {
int val;
TreeNode left, right;
TreeNode(int v){ val=v; }
}

// 1. Two Sum
class TwoSum {
public int[] twoSum(int[] nums, int target) {
Map<Integer,Integer> map = new HashMap<>();
for (int i=0;i<nums.length;i++){
int diff=target-nums[i];
if(map.containsKey(diff)) return new int[]{map.get(diff),i};
map.put(nums[i],i);
}
return new int[]{};
}
}

// 2. Valid Parentheses
class ValidParentheses {
public boolean isValid(String s) {
Map<Character,Character> pairs = Map.of(')', '(', ']', '[', '}', '{');
Stack<Character> st=new Stack<>();
for(char c:s.toCharArray()){
if(pairs.containsValue(c)) st.push(c);
else if(st.isEmpty()||st.pop()!=pairs.get(c)) return false;
}
return st.isEmpty();
}
}

// 3. Merge Two Sorted Lists

class MergeTwoLists {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode dummy=new ListNode(0),tail=dummy;
while(l1!=null&&l2!=null){
if(l1.val<=l2.val){ tail.next=l1;l1=l1.next;}
else{ tail.next=l2;l2=l2.next;}
tail=tail.next;
}
tail.next=(l1!=null)?l1:l2;
return dummy.next;
}
}

// 4. Remove Duplicates from Sorted Array

class RemoveDuplicates {
public int removeDuplicates(int[] nums){
if(nums.length==0) return 0;
int w=1;
for(int i=1;i<nums.length;i++){
if(nums[i]!=nums[w-1]) nums[w++]=nums[i];
}
return w;
}
}

// 5. Maximum Subarray
class MaxSubArray {
public int maxSubArray(int[] nums){
int cur=nums[0],best=nums[0];
for(int i=1;i<nums.length;i++){
 cur=Math.max(nums[i],cur+nums[i]);
best=Math.max(best,cur);
}
return best;
}
}

// 6. Longest Substring Without Repeating Characters

class LongestSubstring {
public int lengthOfLongestSubstring(String s){
Map<Character,Integer> last=new HashMap<>();
int start=0,best=0;
for(int i=0;i<s.length();i++){
char c=s.charAt(i);
if(last.containsKey(c)&&last.get(c)>=start) start=last.get(c)+1;
last.put(c,i);
best=Math.max(best,i-start+1);
}
return best;
}
}

// 7. Kth Largest Element

class KthLargest {
public int findKthLargest(int[] nums,int k){
return quickSelect(nums,0,nums.length-1,nums.length-k);
}
private int quickSelect(int[] a,int l,int r,int k){
if(l==r) return a[l];
int pivot=a[(l+r)/2],i=l,j=r;
while(i<=j){
while(a[i]<pivot) i++;
while(a[j]>pivot) j--;
if(i<=j){ int t=a[i];a[i]=a[j];a[j]=t;i++;j--; }
}
if(k<=j) return quickSelect(a,l,j,k);
if(k>=i) return quickSelect(a,i,r,k);
return a[k];
}
}

// 8. Top K Frequent Elements

class TopKFrequent {
public int[] topKFrequent(int[] nums,int k){
Map<Integer,Integer> freq=new HashMap<>();
for(int n:nums) freq.put(n,freq.getOrDefault(n,0)+1);
List<Integer>[] buckets=new ArrayList[nums.length+1];
for(int n:freq.keySet()){
int f=freq.get(n);
if(buckets[f]==null) buckets[f]=new ArrayList<>();
buckets[f].add(n);
}
int[] ans=new int[k];int idx=0;
for(int i=buckets.length-1;i>=0&&idx<k;i--){
if(buckets[i]!=null){
for(int n:buckets[i]){
ans[idx++]=n;
if(idx==k) return ans;
}
}
}
return ans;
}
}

// 9. Group Anagrams
class GroupAnagrams {
public List<List<String>> groupAnagrams(String[] strs){
Map<String,List<String>> map=new HashMap<>();
for(String s:strs){
char[] arr=s.toCharArray();
Arrays.sort(arr);
String key=new String(arr);
map.computeIfAbsent(key,x->new ArrayList<>()).add(s);
}
return new ArrayList<>(map.values());
 }
}

// 10. Find Peak Element

class PeakElement {
public int findPeakElement(int[] nums){
int l=0,r=nums.length-1;
while(l<r){
int m=(l+r)/2;
if(nums[m]<nums[m+1]) l=m+1;
else r=m;
}
return l;
}
}

// 11. Sort Colors

class SortColors {
public void sortColors(int[] a){
int l=0,i=0,r=a.length-1;
while(i<=r){
if(a[i]==0){ int t=a[l];a[l]=a[i];a[i]=t;l++;i++; }
else if(a[i]==2){ int t=a[r];a[r]=a[i];a[i]=t;r--; }
else i++;
}
}
}

// 12. Subarray Sum Equals K

class SubarraySumK {
public int subarraySum(int[] nums,int k){
Map<Integer,Integer> cnt=new HashMap<>();
cnt.put(0,1);
int s=0,ans=0;
for(int x:nums){
s+=x;
ans+=cnt.getOrDefault(s-k,0);
cnt.put(s,cnt.getOrDefault(s,0)+1);
}
return ans;
}
}

// 13. Rotate Image

class RotateImage {
public void rotate(int[][] m){
int n=m.length;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
int t=m[i][j];m[i][j]=m[j][i];m[j][i]=t;
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n/2;j++){
int t=m[i][j];m[i][j]=m[i][n-1-j];m[i][n-1-j]=t;
}
}
}
}

// 14. Number of Islands

class NumIslands {
public int numIslands(char[][] g){
if(g.length==0) return 0;
int R=g.length,C=g[0].length,res=0;
for(int r=0;r<R;r++) for(int c=0;c<C;c++) if(g[r][c]=='1'){res++;dfs(g,r,c);}
return res;
}
private void dfs(char[][] g,int r,int c){
int R=g.length,C=g[0].length;
if(r<0||c<0||r>=R||c>=C||g[r][c]!='1') return;
g[r][c]='0';
dfs(g,r+1,c);dfs(g,r-1,c);dfs(g,r,c+1);dfs(g,r,c-1);
}
}
// 15. Word Ladder (length)
class WordLadder {
public int ladderLength(String begin,String end,List<String> wordList){
Set<String> dict=new HashSet<>(wordList);
if(!dict.contains(end)) return 0;
Queue<String> q=new LinkedList<>();q.add(begin);
Set<String> vis=new HashSet<>();vis.add(begin);
int steps=1;
while(!q.isEmpty()){
int sz=q.size();
for(int i=0;i<sz;i++){
String w=q.poll();
if(w.equals(end)) return steps;
char[] arr=w.toCharArray();
for(int j=0;j<arr.length;j++){
char orig=arr[j];
for(char ch='a';ch<='z';ch++){
arr[j]=ch;String nw=new String(arr);
if(dict.contains(nw)&&vis.add(nw)) q.add(nw);
}
arr[j]=orig;
}
}
steps++;
}
return 0;
}
}

// 16. Median of Two Sorted Arrays

class MedianTwoArrays {
public double findMedianSortedArrays(int[] A,int[] B){
if(A.length>B.length) return findMedianSortedArrays(B,A);
int m=A.length,n=B.length,total=(m+n+1)/2;
int lo=0,hi=m;
while(lo<=hi){
int i=(lo+hi)/2;int j=total-i;
int Aleft=(i==0)?Integer.MIN_VALUE:A[i-1];
int Aright=(i==m)?Integer.MAX_VALUE:A[i];
int Bleft=(j==0)?Integer.MIN_VALUE:B[j-1];
int Bright=(j==n)?Integer.MAX_VALUE:B[j];
if(Aleft<=Bright&&Bleft<=Aright){
if((m+n)%2==1) return Math.max(Aleft,Bleft);
return (Math.max(Aleft,Bleft)+Math.min(Aright,Bright))/2.0;
} else if(Aleft>Bright) hi=i-1; else lo=i+1;
}
return 0.0;
}
}

// 17. LFU Cache

class LFUCache {
private final int cap;private int minf;
private Map<Integer,Integer> val=new HashMap<>(),freq=new HashMap<>();
private Map<Integer,LinkedHashSet<Integer>> lists=new HashMap<>();
public LFUCache(int capacity){cap=capacity;}
public int get(int key){
if(!val.containsKey(key)) return -1;
int f=freq.get(key);freq.put(key,f+1);
lists.get(f).remove(key);
lists.computeIfAbsent(f+1,x->new LinkedHashSet<>()).add(key);
if(lists.get(f).isEmpty()){lists.remove(f);if(minf==f) minf++;}
return val.get(key);
}
public void put(int key,int value){
if(cap==0) return;
if(val.containsKey(key)){val.put(key,value);get(key);return;}
if(val.size()>=cap){
LinkedHashSet<Integer> set=lists.get(minf);
int evict=set.iterator().next();
set.remove(evict);if(set.isEmpty()) lists.remove(minf);
val.remove(evict);freq.remove(evict);
}
val.put(key,value);freq.put(key,1);
lists.computeIfAbsent(1,x->new LinkedHashSet<>()).add(key);
minf=1;
}
}

// 18. Trapping Rain Water

class TrapRainWater {
public int trap(int[] h){
int l=0,r=h.length-1,lm=0,rm=0,ans=0;
while(l<r){
if(h[l]<h[r]){
if(h[l]>=lm) lm=h[l]; else ans+=lm-h[l];
l++;
} else {
if(h[r]>=rm) rm=h[r]; else ans+=rm-h[r];
r--;
}
}
return ans;
}
}

// 19. Serialize and Deserialize Binary Tree

class Codec {
public String serialize(TreeNode root){
if(root==null) return "";
StringBuilder sb=new StringBuilder();Queue<TreeNode> q=new LinkedList<>();q.add(root);
while(!q.isEmpty()){
TreeNode node=q.poll();
if(node==null){sb.append("null,");continue;}
sb.append(node.val).append(",");q.add(node.left);q.add(node.right);
}
return sb.toString();
}
public TreeNode deserialize(String data){
if(data.isEmpty()) return null;
String[] vals=data.split(",");TreeNode root=new TreeNode(Integer.parseInt(vals[0]));
Queue<TreeNode> q=new LinkedList<>();q.add(root);int i=1;
while(!q.isEmpty()&&i<vals.length){
TreeNode node=q.poll();
if(!vals[i].equals("null")){node.left=new TreeNode(Integer.parseInt(vals[i]));q.add(node.left);}
if(i<vals.length&&!vals[i].equals("null")){node.right=new TreeNode(Integer.parseInt(vals[i]));q.
}
return root;
}
}

// 20. Alien Dictionary

class AlienDictionary {
public String alienOrder(String[] words){
Map<Character,Set<Character>> g=new HashMap<>();
Map<Character,Integer> indeg=new HashMap<>();
for(String w:words) for(char c:w.toCharArray()){g.putIfAbsent(c,new HashSet<>());indeg.putIfAbsent(c
for(int i=0;i<words.length-1;i++){
String w1=words[i],w2=words[i+1];
if(w1.length()>w2.length()&&w1.startsWith(w2)) return "";
int len=Math.min(w1.length(),w2.length());
for(int j=0;j<len;j++){char a=w1.charAt(j),b=w2.charAt(j);
if(a!=b){if(g.get(a).add(b)) indeg.put(b,indeg.get(b)+1);break;}
}
}
Queue<Character> q=new LinkedList<>();for(char c:indeg.keySet()) if(indeg.get(c)==0) q.add(c);
StringBuilder sb=new StringBuilder();
while(!q.isEmpty()){char c=q.poll();sb.append(c);for(char nei:g.get(c)){indeg.put(nei,indeg.get(nei)
return sb.length()==indeg.size()?sb.toString():"";
}
}