Discussion on Java Dequeue Challenge

Sort 223 Discussions, By:

4 days ago+ 0 comments

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Deque<Integer> deque = new ArrayDeque<Integer>();
        int n = in.nextInt();
        int m = in.nextInt();
        Set<Integer> hs = new HashSet<Integer>();

        int maxsize = 0;

        int lastsize = 0;
        int newval;
        int poped;
        for (int i = 0; i < n; i++) {
            newval = in.nextInt();
            deque.add(newval);
            hs.add(newval);
            if (i >= m) {

                poped = deque.pollFirst();
                if (!deque.contains(poped))
                    hs.remove(poped);

                lastsize = hs.size();
                if (lastsize == m) {
                    maxsize = m;

                    break;
                } else {
                    maxsize = Math.max(lastsize, maxsize);
                }
            }

        }

        if (n == m) {
            maxsize = (new HashSet<Integer>(deque)).size();
        }
        System.out.println(maxsize);

    }

3 weeks ago+ 0 comments

I solved this issue using Java 15, also works with Java 17:

    public static void main(String[] args) {
        final var scanner = new Scanner(System.in);
        final var queue = new ArrayDeque<Integer>();
        final var set = new HashSet<Integer>();

        final var n = scanner.nextInt();
        final var m = scanner.nextInt();

        final var output = IntStream.rangeClosed(1, n)
            .mapToLong(i -> {
                final var input = scanner.nextInt();
                var max = Integer.MIN_VALUE;
                queue.add(input);
                set.add(input);
                if (queue.size() == m) {
                    max = set.size();
                    final var first = (int) queue.remove();
                    if (!queue.contains(first))
                        set.remove(first);
                }
                return max;
            })
            .max()
            .orElse(0);

        System.out.println(output);
    }

3 weeks ago+ 0 comments

    import java.util.*;
    public class test {
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            Deque deque = new ArrayDeque<>();
            int n = in.nextInt();
            int m = in.nextInt();
            Set<Integer> set = new HashSet<>();
            int max_count =0;
            for (int i = 0; i < n; i++) {
                int num = in.nextInt();
                deque.add(num);
                set.add(num);
                if (deque.size()==m){
                    if (max_count<set.size()) max_count = set.size();
                    //System.out.println(set);
                    //System.out.println(deque);
                    Object removed_val = deque.pollFirst();
                    if (!deque.contains(removed_val)) set.remove(removed_val);
                    
                }
            }
            System.out.println(max_count);
        }
    }

3 weeks ago+ 0 comments

My first impulse here was a solution with a HashMap and a for loop, no deque.

I guess you can use a deque to maintain a rolling subarray as you read in values. That would save you some memory, especially if n is large and m is small. The tradeoff is an expensive call to deque.contains() every time you pop a number out of the deque.

Implementing a bfs (deque as a queue) or testing for palindromity (deque as a stack) would be a better simple practice problem for deques.

1 month ago+ 0 comments

import java.util.*;
public class test {
    public static void main(String[] args) {
         Scanner in = new Scanner(System.in);
    Deque<Integer> deque = new ArrayDeque<>();
    int n = in.nextInt();
    int m = in.nextInt();
    // System.out.println(n);
    // System.out.println(m);
    int max = 0;
    Set<Integer> set = new HashSet<>();

    for (int i = 0; i < n; i++) {
        int num = in.nextInt();
      deque.add(num);
      set.add(num);

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

        }

    }
  System.out.println(max);
 }

}

Load more conversations