import java.util.*;

public class Test5 {
    public static void main(String[] args) {
        List<String> values = Arrays.asList(new String[] { "aaa", "bb", "c", "ddd", "eee", "f", "ggg", "hh", "i", "j", "kkk", "l", "mmm", "nn", "oo" });
        List<String> expected = Arrays.asList(new String[] { "c", "f", "i", "j", "l", "bb", "hh", "nn", "oo", "aaa", "ddd", "eee", "ggg", "kkk", "mmm"});
        Queue<String> q = new LinkedList<String>(values);

        System.out.println("before:   " + q);
        separate(q);
        System.out.println("after:    " + q);
        System.out.println("expected: " + expected);
        printPoints(q);
    }

    public static void separate(Queue<String> q) {
        // fill in your solution here
        // you can also rename the parameter above

        // the solution is attached below
        Stack<String> s = new Stack<String>();
        int size = q.size();
        // Move length 1 to stack
        for (int i = 0; i < size; i++) {
            String str = q.remove();
            if (str.length() == 3) {
                s.push(str);
            } else {
                q.add(str);
            }
        }
        size = q.size();
        // Move length 2 to stack
        for (int i = 0; i < size; i++) {
            String str = q.remove();
            if (str.length() == 2) {
                s.push(str);
            } else {
                q.add(str);
            }
        }
        // Move length 3 (the rest) to stack
        q2s(q, s);
        // Reverse contents of everything
        s2q(s, q);
        q2s(q, s);
        s2q(s, q);
    }

    public static <T> void s2q(Stack<T> s, Queue<T> q) {
        while (!s.isEmpty()) {
            q.add(s.pop());
        }
    }

    public static <T> void q2s(Queue<T> q, Stack<T> s) {
        while (!q.isEmpty()) {
            s.push(q.remove());
        }
    }

    public static void printPoints(Queue<String> actual) {
        Case expected8 = new Case("correct",
                "c", "f", "i", "j", "l", "bb", "hh", "nn", "oo", "aaa", "ddd", "eee", "ggg", "kkk", "mmm");
        Case expected5 = new Case("reverse all. Need a q2s and s2q.",
                "mmm", "kkk", "ggg", "eee", "ddd", "aaa", "oo", "nn", "hh", "bb", "l", "j", "i", "f", "c");

        Case expected4 = new Case("F2/F3/F1",
                "bb", "hh", "nn", "oo", "aaa", "ddd", "eee", "ggg", "kkk", "mmm", "c", "f", "i", "j", "l");
        Case expected4_2 = new Case("F3/F1/F2",
                "aaa", "ddd", "eee", "ggg", "kkk", "mmm", "c", "f", "i", "j", "l", "bb", "hh", "nn", "oo");

        Case expected3 = new Case("R3/F1/F2",
                "mmm", "kkk", "ggg", "eee", "ddd", "aaa", "c", "f", "i", "j", "l", "bb", "hh", "nn", "oo");
        Case expected3_2 = new Case("R3/R2/F1",
                "mmm", "kkk", "ggg", "eee", "ddd", "aaa", "oo", "nn", "hh", "bb", "c", "f", "i", "j", "l");

        Case expected1 = new Case("R1/R2/R3",
                "l", "j", "i", "f", "c", "oo", "nn", "hh", "bb", "mmm", "kkk", "ggg", "eee", "ddd", "aaa");
        Case expected1_2 = new Case("R2/R3/F1",
                "oo", "nn", "hh", "bb", "mmm", "kkk", "ggg", "eee", "ddd", "aaa", "c", "f", "i", "j", "l");
        Case expected1_3 = new Case("F1/F2/R3",
                "c", "f", "i", "j", "l", "bb", "hh", "nn", "oo", "mmm", "kkk", "ggg", "eee", "ddd", "aaa");

        Case expected0 = new Case("F1/F3/F2",
                "c", "f", "i", "j", "l", "aaa", "ddd", "eee", "ggg", "kkk", "mmm", "bb", "hh", "nn", "oo");
        Case expected0_2 = new Case("F1/R2/R3",
                "c", "f", "i", "j", "l", "oo", "nn", "hh", "bb", "mmm", "kkk", "ggg", "eee", "ddd", "aaa");
        Case expected0_3 = new Case("F1/R3/F2",
                "c", "f", "i", "j", "l", "mmm", "kkk", "ggg", "eee", "ddd", "aaa", "bb", "hh", "nn", "oo");
        Case expected0_4 = new Case("F2/R1/F3",
                "bb", "hh", "nn", "oo", "c", "f", "i", "j", "l", "aaa", "ddd", "eee", "ggg", "kkk", "mmm");
        Case expected0_5 = new Case("F3/F2/F1",
                "aaa", "ddd", "eee", "ggg", "kkk", "mmm", "bb", "hh", "nn", "oo", "c", "f", "i", "j", "l");

        Case[] cases = { expected8, expected5, expected4, expected4_2, expected3, expected3_2,
            expected1, expected1_2, expected1_3, expected0, expected0_2,
            expected0_3, expected0_4, expected0_5 };

        Case applied = null;
        for (Case c : cases) {
            if (c.q.equals(actual)) {
                applied = c;
            }
        }


        if (applied == null) {
            System.out.println("Does no match any common mistakes. Most likely did "
                    + "not have proper loop bounds or did not split from queue properly. ");
        } else if (applied.type.equals("correct")) {
            System.out.println("CORRECT");
        } else {
            System.out.println("Matches: " + applied.type);
            System.out.println();
            System.out.println("How to read - \"R2/F3/F1\" means your queue started with ");
            System.out.println("length 2 strings in reverse-expected order, followed by ");
            System.out.println("length 3 strings in expected order, followed by ");
            System.out.println("length 1 strings in expected order.");
            System.out.println();
            System.out.println("Common mistakes include not looping the correct");
            System.out.println("number of times or did not split the different ");
            System.out.println("length strings in the correct order.");
        }
    }

    private static class Case {
        Queue<String> q;
        String type;

        Case(String type, String... sequence) {
            this.q = new LinkedList<>(Arrays.asList(sequence));
            this.type = type;
        }
    }
}