Scribd
Upload
2 views

Mohit Java 9

The document contains Java code solutions for four programming problems: finding the length of the longest substring without repeating characters, determining the next greater element for an array, displaying a table of food orders in a restaurant, and finding minimum height trees in a graph. Each solution is encapsulated in a class named 'Solution' with a public method that implements the respective algorithm. The code is structured and includes necessary data structures such as HashMap, HashSet, and Queue.

Uploaded by

Ɯԋιƚҽ Ԃҽʋιʅ
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
2 views

Mohit Java 9

The document contains Java code solutions for four programming problems: finding the length of the longest substring without repeating characters, determining the next greater element for an array, displaying a table of food orders in a restaurant, and finding minimum height trees in a graph. Each solution is encapsulated in a class named 'Solution' with a public method that implements the respective algorithm. The code is structured and includes necessary data structures such as HashMap, HashSet, and Queue.

Uploaded by

Ɯԋιƚҽ Ԃҽʋιʅ
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 5

Day-9

Name –Rohit Raj

Uid-21BCS9914

Sub - Java

Section- CC-627 / A

Q.1 Longest Substring Without Repeating Characters


Code:
class Solution {
public int lengthOfLongestSubstring(String s)
{int n = s.length();
int maxLength = 0;
Set<Character> charSet = new
HashSet<>(); int left = 0;
for (int right = 0; right < n; right++) {
if (!charSet.contains(s.charAt(right)))
{ charSet.add(s.charAt(right));
maxLength = Math.max(maxLength, right - left + 1); }
else { while
(charSet.contains(s.charAt(right))) {
charSet.remove(s.charAt(left)); left++;
}
charSet.add(s.charAt(right));
}
}

return maxLength;
}
}
Output:
Q.2 Next Greater Element I
Code:
class Solution {
public int[] nextGreaterElement(int[] nums1, int[] nums2)
{HashMap<Integer, Integer> hMap = new HashMap<>();
Stack<Integer> st = new Stack<>(); for (int i =
nums2.length - 1; i >= 0; i--) { while (!st.isEmpty()
&& st.peek() <= nums2[i]) st.pop(); if
(!st.isEmpty()) hMap.put(nums2[i], st.peek());
else hMap.put(nums2[i], -1);
st.push(nums2[i]);
} for (int i = 0; i < nums1.length; i++)
{nums1[i] =
hMap.get(nums1[i]);
}
return nums1;
}
}
Output:
Q.3 Display Table of Food Orders in a Restaurant
Code:
class Solution { public List<List<String>> displayTable(final
List<List<String>> orders) { final TreeMap<Integer, Map<String,
Integer>> tables = new TreeMap<>(); final TreeSet<String> meals =
new TreeSet<>();
for(final List<String> order : orders) { final int
tableNum = Integer.valueOf(order.get(1));
tables.putIfAbsent(tableNum, new
HashMap<>());
final Map<String, Integer> table = tables.get(tableNum);

table.put(order.get(2), table.getOrDefault(order.get(2), 0) + 1);

meals.add(order.get(2));
}

final List<List<String>> result = new ArrayList<>();

result.add(new ArrayList<>());
result.get(0).add("Table");
result.get(0).addAll(meals);

for(final int tableNum : tables.keySet()) {


final List<String> tableOrders = new ArrayList<>();
tableOrders.add(String.valueOf(tableNum)); final
Map<String, Integer> table =
tables.get(tableNum);

for(int i = 1; i < result.get(0).size(); ++i) {


final String meal = result.get(0).get(i);
tableOrders.add(table.containsKey(meal) ?
String.valueOf(table.get(meal)) : "0");
}

result.add(tableOrders);
}

return result;
}
}
Output:

Q.4 Minimum Height Trees


Code:
class Solution { public List<Integer> findMinHeightTrees(int
n, int[][] edges)
{if(n == 1) return Collections.singletonList(0);

int ind[] = new int[n];


Map<Integer, List<Integer>> map = new HashMap();
for(int[] edge: edges) {
ind[edge[0]]++; ind[edge[1]]++;
map.putIfAbsent(edge[0], new
ArrayList()); map.putIfAbsent(edge[1],
new ArrayList());
map.get(edge[0]).add(edge[1]);
map.get(edge[1]).add(edge[0]);
}

Queue<Integer> queue = new


LinkedList(); for(int
i=0;i<ind.length;i++) { if(ind[i] == 1) {
queue.add(i);
}
}

int processed = 0;
while(n - processed > 2)
{int size = queue.size();
processed += size;
for(int i=0;i<size;i++) {
int poll =
queue.poll(); for(int
adj: map.get(poll))
{if(--ind[adj] == 1) {
queue.add(adj);
}
}
}
}

List<Integer> list = new


ArrayList(); list.addAll(queue);
return list;
}
}
Output:

You might also like