Discussion on Java Dequeue Challenge

Sort 284 Discussions, By:

4 days 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();

    int maxUniqueIntegers = 0;
    Set<Integer> uniqueIntegers = new HashSet<>();
    for (int i = 0; i < n; i++) {
        int num = in.nextInt();
       deque.offer(num);
       uniqueIntegers.add(num);
       if (deque.size() == m) {
           if (uniqueIntegers.size() > maxUniqueIntegers) {
               maxUniqueIntegers = uniqueIntegers.size();
           }
           Integer removed = deque.pop();
           if (!deque.contains(removed)) {
               uniqueIntegers.remove(removed);
           }
       }
    }

    System.out.println(maxUniqueIntegers);
    }
}

2 weeks ago+ 0 comments

If you want to execute with time < 3s , you need to use HashMap to check how many unique element in list

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

    for (int i = 0; i < n; i++) {
      int num = in.nextInt();
      deque.add(num);
      if (map.containsKey(num)) {
        map.put(num, map.get(num) + 1);
      } else {
        map.put(num, 1);
      }
      if (deque.size() == m + 1) {
        int firstEle = deque.poll();
        if (map.get(firstEle) > 1) {
          map.put(firstEle, map.get(firstEle) - 1);
        } else {
          map.remove(firstEle);
        }

      }

      if (deque.size() == m) {
        max = Math.max(max, map.size());
      }
    }

    System.out.println(max);
  }

3 weeks ago+ 0 comments

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 *
 * @author Thinh_Nguyen
 */
public class javaanhlocday 
{
    public static void solve(int n, int m, ArrayList<Integer> arr)
    {
        Deque<Integer> d=new ArrayDeque<>();
        int ans=-1;
        HashMap<Integer,Integer> mp=new HashMap<>();
        for(int num:arr)
        {
            d.add(num);
            if(mp.containsKey(num))
                mp.put(num,mp.get(num)+1);
            else
                mp.put(num, 1);
            ///////////////
            if(d.size()==m+1)
            {
                int first=d.remove();
                if(mp.containsKey(first))
                {
                    int count=mp.get(first);
                    if(count>1)
                        mp.put(first,count-1);
                    else
                        mp.remove(first);
                }
            }
            //////////////
            if(d.size()==m)
                ans=Math.max(ans,mp.size());
        }
        System.out.println(ans);
    }
    public static void main(String[] args) 
    {
        Scanner sc = new Scanner(System.in);
        ArrayList<Integer> arr=new ArrayList<>();
        int n=sc.nextInt(), m=sc.nextInt();
        for(int i=0;i<n;i++)
            arr.add(sc.nextInt());
        solve(n, m, arr);
    }
}

4 weeks ago+ 0 comments

//Java 7

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();
        
        int maxUnique = 0;
        Map<Integer, Integer> uniqueCounts = new HashMap<>();

        for (int i = 0; i < n; i++) {
            int num = in.nextInt();
            deque.add(num);
            
            if (uniqueCounts.containsKey(num)) {
                uniqueCounts.put(num, uniqueCounts.get(num) + 1);
            } else {
                uniqueCounts.put(num, 1);
            }

            if (deque.size() == m + 1) {
                int removed = deque.remove();
                if (uniqueCounts.containsKey(removed)) {
                    int count = uniqueCounts.get(removed);
                    if (count > 1) {
                        uniqueCounts.put(removed, count - 1);
                    } else {
                        uniqueCounts.remove(removed);
                    }
                }
            }

            if (deque.size() == m) {
                maxUnique = Math.max(maxUnique, uniqueCounts.size());
            }
        }

        System.out.println(maxUnique);
    }
}

1 month ago+ 0 comments

I tried to write the code, it passes all the testcases except the last one because of taking long time to execute. Can anyone help...?

    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();
            Set <Integer> set1 = new HashSet<>();
            //ArrayList<Integer> list = new ArrayList<>();
            int max = 0;
            int size;
            for (int i = 0; i < n; i++) {
                int num = in.nextInt();
                deque.addLast(num);
                if(deque.size() ==m){
                    set1.clear();
                    set1.addAll(deque);
                    //list.add(set1.size());
                    size = set1.size();
                    if(max < size){
                        max = size;
                    }
                    deque.pollFirst();
                }
                
            }
            //System.out.println(Collections.max(list));
            System.out.println(max);
        }
    }

Load more conversations