// ט.כניסה - מקבל מספר
// ט.יציאה - מחזיר האם המספר מופיע יותר מפעם אחת
// לא הורס את התור

	public static boolean isLongerThanOne(Queue<Integer> q, int x) {

		int count = 0;
		Queue<Integer> temp = new Queue<Integer>();
		while (!q.isEmpty()) {

			if (q.head() == x) {

				count++;

			}

			temp.insert(q.remove());

		}

		while (!temp.isEmpty()) {

			q.insert(temp.remove());

		}

		if (count > 1) {

			return true;

		}
		else {

			return false;

		}

	}

// ט.כניסה - מקבל תור של זמנים
// ט.יציאה - מחזיר זמן שהוא ההפרש בין הזמן האחרון לראשון

	public static Time func(Queue<Time> q) {

		int count = 0;
		int count2 = 0;
		int hour = 0,minute = 0,second = 0;
		int hour2 = 0,minute2 = 0,second2 = 0;
		Queue<Time> temp = new Queue<Time>();
		while(!q.isEmpty()) {

			count++;
			temp.insert(q.remove());

		}
		while(!temp.isEmpty()) {

			count2++;
			if (count2 == 1) {

				hour = temp.head().getHour();
				minute = temp.head().getMinute();
				second = temp.head().getSecond();

			}
			else if (count2 == count) {

				hour2 = temp.head().getHour();
				minute2 = temp.head().getMinute();
				second2 = temp.head().getSecond();

			}
			q.insert(temp.remove());
		}

		Time time = new Time(hour,minute,second);
		Time time2 = new Time(hour2,minute2,second2);
		Time time3 = diff(time,time2);
		return time3;

	}

// ט.כניסה - מקבל שני זמנים
// ט.יציאה - מחזיר את זמן שהוא הפרש הזמנים

	public static Time diff(Time time, Time time2) {
		if (time.getHour() > time2.getHour()) {

			return arrange(time,time2);

		}
		else if (time.getHour() == time2.getHour()){

			if (time.getMinute() > time2.getMinute()) {

				return arrange(time,time2);

			}
			else if (time.getMinute() == time2.getMinute()){

				if (time.getSecond() > time2.getSecond()) {

					return arrange(time,time2);

				}
				else if (time.getSecond() == time2.getSecond()){

					return arrange(time,time2);

				}
				else {

					return arrange(time2,time);

				}
			}
			else {

				return arrange(time2,time);

			}
		}
		else {

			return arrange(time2,time);

		}
	}

// ט.כניסה - מקבל 2 זמנים
// ט.יציאה - מסדר את השניות / דקות / שעות בסדר הגיוני

	private static Time arrange(Time time, Time time2) {

		int hour = time2.getHour() - time.getHour();
		int minute = time2.getMinute() - time.getMinute();
		int second = time2.getSecond() - time.getSecond();

		if (second > 0) {

			second = 60 - second;
			minute ++;

		}
		else {

			second = Math.abs(second);

		}

		if (minute > 0) {

			minute = 60 - minute;
			hour ++;

		}
		else {

			minute = Math.abs(minute);

		}

		hour = Math.abs(hour);

		Time time3 = new Time(hour,minute,second);
		return time3;

	}

	public static Queue<Integer> once(Queue<Integer> q) {

		Queue<Integer> temp = new Queue<Integer>();
		while(!q.isEmpty()) {

			if (temp.isEmpty()) {

				temp.insert(q.remove());

			}
			else {

				if (!isThere(temp,q.head())) {
					temp.insert(q.remove());

				}
				else {

					q.remove();

				}

			}

		}
		while(!temp.isEmpty()) {

			q.insert(temp.remove());

		}

		return q;

	}

// ט.כניסה - מקבל תור ומספר
// ט.יציאה - מחזיר האם המספר נמצא בתור
// לא הורס את התור

	public static boolean isThere(Queue<Integer> q, int x) {

		boolean check = false;
		Queue<Integer> temp = new Queue<Integer>();
		while (!q.isEmpty()) {

			if (q.head() == x) {

				check = true;

			}
			temp.insert(q.remove());

		}
		while(!temp.isEmpty()) {

			q.insert(temp.remove());

		}
		return check;

	}

// ט.כניסה - מקבל תור של מחרוזות ומספר
// ט.יציאה - התור מוציא ומכניס את מחרוזת שבראש כמספר הפעמים כערך המספר שהכניסו ומחזיר האם המחרוזת שכעת היא בראש התור שווה לערך מסויים במקרה הזה
// "g" האות
// הורס את התור

	public static boolean lottery(Queue<String> q, int x) {

		for (int i = 1 ; i <= x ; i++) {

			String str = q.remove();
			q.insert(str);

		}
		return q.head().equals("g");
	}

// ט.כניסה - מקבל תור
// ט.יציאה - ממיין את התור
	public static Stack<Integer> orderedStack(Queue<Integer> q){

		q.insert(null);
		int min = q.head();
		int count = 0;
		Stack<Integer> s = new Stack<Integer>();
		while(q.head() != null) {

			count++;
			if (min > q.head()) {

				min = q.head();

			}
			q.insert(q.remove());

		}
		for (int i = 0 ; i < count ; i++) {
			q.insert(q.remove());
			while (q.head() != null) {

				if (q.head() == min) {

					s.push(min);

				}
				q.insert(q.remove());

			}
			min++;
		}

		return s;

	}

// ט.כניסה - מקבל תור עבודות וזמן
// ט.יציאה - מדפיס את קוד העבודות שניתן לסיים בפרק הזמן הנתון
// לכל עבודה יש תכונה של קוד וזמן שלוקח לעשות את העבודה

	public static void jobsDone(Queue<Job> q, int t) {

		int t2 = 0;
		q.insert(null);
		while (q.head() != null) {

			if (q.head().getTime() + t2 <= t) {

				t2 += q.head().getTime();
				System.out.println(q.head().getCode());
				q.remove();

			}
			else {

				q.insert(q.remove());

			}

		}
		q.remove();

	}

// ט.כניסה - מקבל שני תורים
// ט.יציאה - מחזיר תור כך שבתור החדש כל מקום שני זה מספר מהתור השני שקיבלנו אבל אם התור הראשון נגמר זה פשוט שם את מה שנשאר מהתור השני
// דוגמה:
/*
 * queue1 : [ 9,8,23,0]
 * queue2: [13,18,23,6,10,27]
 * new queue: [9,13,8,18,23,23,0,6,10,27]
 */

	public static Queue<Integer> sortQueues(Queue<Integer> q1, Queue<Integer> q2){

		q1.insert(null);
		q2.insert(null);
		Queue<Integer> temp = new Queue<Integer>();
		int count = 1;
		boolean check = true;
		while (q1.head() != null && check) {

			if (q2.head() != null) {
				if (count % 2 == 0)
					temp.insert(q2.remove());
				else
					temp.insert(q1.remove());
			}
			else
				check = false;
			count++;

		}
		while(q2.head() != null) {
			temp.insert(q2.remove());
		}
		q1.remove();
		q2.remove();
		return temp;

	}