HackerRank Java Dequeue problem solution

In this HackerRank Java Dequeue problem in the java programming language, you are given N integers. You need to find the maximum number of unique integers among all the possible contiguous subarrays of size M.

HackerRank Java Dequeue problem solution.

```import java.util.*;

public class test {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
final Deque<Integer> deque = new ArrayDeque<Integer>();
final Map<Integer, Integer> map = new HashMap<Integer, Integer>();
final int n = in.nextInt();
final int m = in.nextInt();

int res = 0;
for (int i = 0; i < n; i++) {
final int num = in.nextInt();
deque.addLast(num);
if (map.containsKey(num)) {
map.put(num, map.get(num).intValue() + 1);
} else {
map.put(num, 1);
}

if (deque.size() == m + 1) {
final int key = deque.removeFirst();
final int v = map.get(key);
if (v == 1) {
map.remove(key);
} else {
map.put(key, v - 1);
}
}

final int cnt = map.size();
if (cnt > res) { res = cnt; }
}
System.out.println(res);
}
}```

Second solution

```    import java.util.*;
public class test {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Deque<Integer> deque = new ArrayDeque<Integer>();
HashMap<Integer, Integer> freqs = new HashMap<Integer, Integer>();
int n = in.nextInt();
int m = in.nextInt();
int ans = 0, countDistinct = 0;

for (int i = 0; i < n; i++) {
int num = in.nextInt();
deque.addLast(num);
if (freqs.get(num) == null) freqs.put(num,0);

freqs.put(num,freqs.get(num)+1);
if (freqs.get(num)==1) countDistinct++;

if (deque.size()==m+1){
int rem = deque.removeFirst();
freqs.put(rem,freqs.get(rem)-1);
if (freqs.get(rem) == 0) countDistinct--;
}
if (deque.size()==m){
if (countDistinct > ans) ans = countDistinct;
}

}
System.out.println(ans);
}
}```

A solution in java8 programming.

```    import java.util.*;

public class test {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Deque<Integer> deque = new ArrayDeque<>();
HashSet<Integer> set = new HashSet<>();

int n = in.nextInt();
int m = in.nextInt();
int max = Integer.MIN_VALUE;

for (int i = 0; i < n; i++) {
int input = in.nextInt();

deque.add(input);
set.add(input);

if (deque.size() == m) {
if (set.size() > max) max = set.size();
int first = deque.remove();
if (!deque.contains(first)) set.remove(first);
}
}

System.out.println(max);
}
}

```

1 Comments

1. Man, that HashSet approach was clever. Great work.