class HW08A extends Cow {

	static void runAutograder() {
		PRINT("RUNNING AUTOGRADER");
		PRINT("==================");

		LinkedList list = new LinkedList("Abe -> Ben");

		PRINT();
		PRINT("get");
		PRINT("---");

		LinkedList._grade(list.get(0), "Abe");
		LinkedList._grade(list.get(1), "Ben");

		PRINT();
		PRINT("append + remove");
		PRINT("---------------");

		list.add("Cam");    list._grade("Abe -> Ben -> Cam");
		list.add("Dan");    list._grade("Abe -> Ben -> Cam -> Dan");
		list.remove("Cam"); list._grade("Abe -> Ben -> Dan");
		list.remove("Dan"); list._grade("Abe -> Ben");
		list.remove("Abe"); list._grade("Ben");
		list.remove("Ben"); list._grade(null);

		PRINT();
		PRINT("insert");
		PRINT("------");

		list = new LinkedList("Gus -> Ivy");
		list.add(1, "Hal"); list._grade("Gus -> Hal -> Ivy");
		list.add(3, "Jax"); list._grade("Gus -> Hal -> Ivy -> Jax");
		list.add(0, "Fid"); list._grade("Fid -> Gus -> Hal -> Ivy -> Jax");

		PRINT();
		PRINT("reverse");
		PRINT("-------");

		list.reverse();     list._grade("Jax -> Ivy -> Hal -> Gus -> Fid");

		list.head = null;
		list.reverse();     list._grade(null); // Reversing an empty list does nothing.
		list.add("Zeb");    list._grade("Zeb");

		PRINT();
		PRINT("hasCycle");
		PRINT("--------");

		list = new LinkedList("Abe");                      LinkedList._grade(list.hasCycle(), false);
		list = new LinkedList("Abe -> Ben -> Cam -> Dan"); LinkedList._grade(list.hasCycle(), false);
		list.head.next.next.next.next = list.head.next;    LinkedList._grade(list.hasCycle(), true);

		// PRINT(list); // TODO (A+)

		list = new LinkedList("Carl");
		list.head.next = list.head;    LinkedList._grade(list.hasCycle(), true);

	}

	////////////////////////////////////////////////////////////////////////
	//  YOUR CODE STARTS HERE //////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////

	public static void main(String[] arguments) {
		// NOTE: Feel free to write your own little tests in main!
		//       Just make sure you pass the autograder before you submit.

		// LinkedList list = new LinkedList("Abe -> Ben");
		// PRINT(list);

		runAutograder();
	}

	static class Node {
		String value; // The actual data stored on the node
		Node next; // A reference (link) to the next node in the list (chain)

		// A simple constructor that sets the node's value
		Node(String value) {
			this.value = value;
			this.next = null; // This line is optional (this.next is cleared to null)
		}

		public String toString() {
			return value;
		}
	}


	static class LinkedList {
		Node head;

		String get(int index) {
			int currIndex = 0;
			Node curr = head;
			while (curr != null) {
				if (currIndex++ == index) {
					return curr.value;
				}
				curr = curr.next;
			}
			assert false;
			return null;
		}

		// Worst and Best Case: O(n)
		// because has to walk along the whole list regardlessl
		void add(String value) {
			if (head == null) {
				head = new Node(value);
				return;
			}

			Node curr = head;
			while (curr.next != null) {
				curr = curr.next;
			}
			curr.next = new Node(value);
		}

		// Worst Case: O(n) because if value is not in list,
		//             then has to walk along the whole list.
		// Best Case: O(1) because if value is found on the head.
		void remove(String value) {
			Node prev = null;
			Node curr = head;
			while (curr != null) {
				if (curr.value.equals(value)) {
					if (prev == null) {
						head = curr.next;
					} else {
						prev.next = curr.next;
					}
					break;
				}
				prev = curr;
				curr = curr.next;
			}
		}

		// Worst Case: O(n)
                // (append -- see above)
		//
		// Best Case: O(1)
		// (prepend -- just add it to the front and return)
		void add(int index, String value) {
			Node newNode = new Node(value);

			if (head == null) {
				ASSERT(index == 0);
			}

			if (index == 0) {
				newNode.next = head;
				head = newNode;
				return;
			}

			int currIndex = 0;
			Node prev = null;
			Node curr = head;
			do {
				if (currIndex++ == index) {
					prev.next = newNode;
					newNode.next = curr;
					return;
				}
				prev = curr;
				curr = curr.next;
			} while (prev != null);

			assert false;
		}

		// Worst and Best Case: O(n)
		// because walks along the entire list once no matter what
		void reverse() {
			if (head == null) {
				return;
			}

			Node prev = null;
			Node curr = head;
			while (curr != null) {
				Node tmpNext = curr.next;
				curr.next = prev;
				prev = curr;
				curr = tmpNext;
			}
			head = prev;
		}

		// Worst and Best Case: O(n)
		// (examine all cases)
		// - if list has no cycle, will take rabbit n/2 to the end
		// - if list is one big cycle, will take rabbit n to the hit turtle
		// - if list is linear section, followed by cycle of some size,
		//   will take turtle (and rabbit) O(n) to enter cycle
		//   and will then take rabbit O(n) to catch turtle,
		//   since distance between turtle and rabbit goes down by one
		//   each iteration
		boolean hasCycle() {
			if (head == null) {
				return false;
			}
			if (head.next == null) {
				return false;
			}

			Node turtle = head;
			Node rabbit = head.next;

			while (true) {
				if (rabbit == turtle) {
					return true;
				}

				turtle = turtle.next;

				if (rabbit.next == null) {
					return false;
				}
				if (rabbit.next.next == null) {
					return false;
				}
				rabbit = rabbit.next.next;
			}
		}

		////////////////////////////////////////////////////////////////////////
		// YOUR CODE STOPS HERE ////////////////////////////////////////////////
		////////////////////////////////////////////////////////////////////////

		// Construct a list from a String of the form "Abe -> Ben -> Cam".
		// For this example input, constructor is equivalent to:
		//    head = new Token("Abe");
		//    head.next = new Token("Ben");
		//    head.next.next = new Token("Cam");
		LinkedList(String _string) {
			String[] array = _tokenize(_string);
			head = null;
			if (array.length > 0) {
				head = new Node(array[0]);
				Node curr = head;
				for (int i = 1; i < array.length; ++i) {
					curr.next = new Node(array[i]);
					curr = curr.next;
				}
			}
		}

		// Get the list as a String of the form "Abe -> Ben -> Cam".
		public String toString() {
			if (head == null) return "null";
			String result = head.toString();
			Node curr = head;
			while (curr.next != null) {
				result += " -> ";
				result += curr.next;
				curr = curr.next;
			}
			return result;
		}

		// Compare the list to a String of the form "Abe -> Ben -> Cam".
		void _grade(String _string) {
			String[] array = _tokenize(_string);
			boolean isCorrect;
			if (array == null) {
				isCorrect = (head == null);
			} else {
				isCorrect = true;
				int currIndex = 0;
				Node prev = null;
				Node curr = head;
				while (curr != null) {
					if (currIndex >= array.length) break;
					isCorrect &= (array[currIndex++].equals(curr.value));
					curr = curr.next;
				}
				isCorrect &= (currIndex == array.length);
			}
			_gradeHelper(isCorrect, this.toString(), _string);
		}

		static void _grade(String studentAnswer, String correctAnswer) {
			_gradeHelper(correctAnswer.equals(studentAnswer), studentAnswer, correctAnswer);
		}

		static void _grade(boolean studentAnswer, boolean correctAnswer) {
			_gradeHelper(studentAnswer == correctAnswer, "" + studentAnswer, "" + correctAnswer);
		}

		static void _gradeHelper(boolean isCorrect, String studentAnswer, String correctAnswer) {
			System.out.print(isCorrect ? "[+] " : "[-] ");
			System.out.print(studentAnswer);
			if (!isCorrect) System.out.print(" (EXPECTED: " + correctAnswer + ")");
			PRINT();
		}

		// Converts "Abe -> Ben -> Cam" to ["Abe", "Ben", "Cam"].
		static String[] _tokenize(String _string) {
			if (_string == null) return null;
			String[] result = _string.split("->");
			for (int i = 0; i < result.length; ++i) result[i] = result[i].trim();
			return result;
		}
	}

}