Hopping Iterator

Author: Deepak Malik

README.md

@@ -31,7 +31,7 @@ Implementation of Algorithms in Java, Most of these names are picked up from Gee
 	- [X] [Standard Iterator](../master/src/com/deepak/algorithms/Iterators/StandardIterator.java)
 	- [ ] Deep Iterator
 	- [ ] Filtering Iterator
-	- [ ] Hopping Iterator
+	- [X] [Hopping Iterator](../master/src/com/deepak/algorithms/Iterators/HoppingIterator.java)
 	- [ ] InOrder Iterator
 	- [X] [LevelOrder Iterator](../master/src/com/deepak/algorithms/Iterators/LevelOrderIterator.java)
 	- [ ] MaxIterator Iterator

src/com/deepak/algorithms/Iterators/HoppingIterator.java

@@ -0,0 +1,113 @@
+/**
+ * Algorithms-In-Java
+ * HoppingIterator.java
+ */
+package com.deepak.algorithms.Iterators;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/**
+ * <br> Problem Statement :
+ * 
+ * Implement an iterator that hops specified number of times and then returns the next
+ * element after the hop. Note: the iterator always returns the first element as
+ * it is, and starts hopping only after the first element.
+ *
+ * Examples:
+ *
+ * If the original iterator returns: [1, 2, 3, 4, 5] in order, then the hopping
+ * iterator will return [1, 3, 5] in order when the hop value is 1.
+ *
+ * If the original iterator returns: [1, 2, 3, 4, 5] in order, then the hopping
+ * iterator will return [1, 4] in order when the hop value is 2.
+ *
+ * If the original iterator returns: [1, 2, 3, 4, 5] in order, then the hopping
+ * iterator will return [1, 5] in order when the hop value is 3.
+ * 
+ * Methods expected to be implemented:
+ *  
+ * public class HoppingIterator<T> implements Iterator<T> {
+ * 		public HoppingIterator(Iterator<T> iterator, int numHops) {...}
+ * 		public boolean hasNext() {...}
+ * 		public T next() {...}
+ * }
+ * 
+ * </br>
+ * 
+ * @author Deepak
+ */
+public class HoppingIterator<T> implements Iterator<T> {
+
+	/* Iterator */
+	private final Iterator<T> iterator;
+	/* Variable to keep track of next item */
+	private T nextItem;
+	/* Number of hops needed */
+	private final int numOfHops;
+	/* Flag to check if it is first element */
+	private boolean first;
+
+	/**
+	 * Constructor 
+	 * 
+	 * @param iterator
+	 * @param numOfHops
+	 */
+	public HoppingIterator(Iterator<T> iterator, int numOfHops) {
+		if (numOfHops < 0) {
+			throw new IllegalArgumentException("Invalid value for number of hops!!");
+		}
+		this.iterator = iterator;
+		this.numOfHops = numOfHops;
+		nextItem = null;
+		first = true;
+	}
+
+	/**
+	 * Method to check of next element exists
+	 */
+	@Override
+	public boolean hasNext() {
+		/* If we already have next item, return true */
+		if (nextItem != null) {
+			return true;
+		}
+		/* If it is not first element, move till the next hop */
+		if (!first) {
+			for (int hop = 0; hop < numOfHops && iterator.hasNext(); hop++) {
+				iterator.next();
+			}
+		}
+		/* Now, if next element exits. move there and update first flag */
+		if (iterator.hasNext()) {
+			nextItem = iterator.next();
+			first = false;
+		}
+		return nextItem != null;
+	}
+
+	/**
+	 * Method to find next element in collection
+	 */
+	@Override
+	public T next() {
+		/* If no next element exits, collection has finished */
+		if (!hasNext()) {
+			throw new NoSuchElementException("No Element left in collection!!");
+		}
+		/* Else, find the next item, return it and set next item to null */
+		T itemToReturn = nextItem;
+		nextItem = null;
+		return itemToReturn;
+	}
+
+	/**
+	 * Method to remove the element
+	 */
+	@Override
+	public void remove() {
+		throw new UnsupportedOperationException("Remove not supported!!");
+	}
+
+}

test/com/deepak/algorithms/Iterators/HoppingIterator_Test.java

@@ -0,0 +1,104 @@
+/**
+ * Algorithms-in-Java
+ * HoppingIterator_Test.java
+ */
+package com.deepak.algorithms.Iterators;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Test cases for Hopping Iterator
+ * 
+ * @author Deepak
+ */
+public class HoppingIterator_Test {
+
+	/**
+	 * Test case for collection of integers
+	 */
+	@Test
+	public void testHoppingIteratorForIntegers() {
+		List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6);
+
+		/* Iterator with 0 hops, behaves the same way */
+		HoppingIterator<Integer> iteratorWith0Hops = new HoppingIterator<>(integerList.iterator(), 0);
+		Assert.assertTrue(iteratorWith0Hops.hasNext());
+		Assert.assertTrue(iteratorWith0Hops.next() == 1);
+		Assert.assertTrue(iteratorWith0Hops.next() == 2);
+		Assert.assertTrue(iteratorWith0Hops.next() == 3);
+		Assert.assertTrue(iteratorWith0Hops.hasNext());
+		Assert.assertTrue(iteratorWith0Hops.next() == 4);
+		Assert.assertTrue(iteratorWith0Hops.hasNext());
+		Assert.assertTrue(iteratorWith0Hops.next() == 5);
+		Assert.assertTrue(iteratorWith0Hops.next() == 6);
+
+		/* Iterator with 1 hop, jumps 1 */
+		HoppingIterator<Integer> iteratorWith1Hops = new HoppingIterator<>(integerList.iterator(), 1);
+		Assert.assertTrue(iteratorWith1Hops.hasNext());
+		Assert.assertTrue(iteratorWith1Hops.next() == 1);
+		Assert.assertTrue(iteratorWith1Hops.next() == 3);
+		Assert.assertTrue(iteratorWith1Hops.hasNext());
+		Assert.assertTrue(iteratorWith1Hops.next() == 5);
+
+		/* Iterator with 2 hops, jumps 2 */
+		HoppingIterator<Integer> iteratorWith2Hops = new HoppingIterator<>(integerList.iterator(), 2);
+		Assert.assertTrue(iteratorWith2Hops.hasNext());
+		Assert.assertTrue(iteratorWith2Hops.next() == 1);
+		Assert.assertTrue(iteratorWith2Hops.next() == 4);
+		Assert.assertFalse(iteratorWith2Hops.hasNext());
+
+		/* Iterator with 3 hops, jumps 3 */
+		HoppingIterator<Integer> iteratorWith3Hops = new HoppingIterator<>(integerList.iterator(), 3);
+		Assert.assertTrue(iteratorWith3Hops.hasNext());
+		Assert.assertTrue(iteratorWith3Hops.next() == 1);
+		Assert.assertTrue(iteratorWith3Hops.next() == 5);
+		Assert.assertFalse(iteratorWith3Hops.hasNext());
+	}
+
+	/**
+	 * Test case for collection of strings
+	 */
+	@Test
+	public void testHoppingIteratorForStrings() {
+		List<String> stringList = Arrays.asList("A", "B", "C", "D", "E", "F");
+
+		/* Iterator with 0 hops, behaves the same way */
+		HoppingIterator<String> iteratorWith0Hops = new HoppingIterator<>(stringList.iterator(), 0);
+		Assert.assertTrue(iteratorWith0Hops.hasNext());
+		Assert.assertTrue(iteratorWith0Hops.next() == "A");
+		Assert.assertTrue(iteratorWith0Hops.next() == "B");
+		Assert.assertTrue(iteratorWith0Hops.next() == "C");
+		Assert.assertTrue(iteratorWith0Hops.hasNext());
+		Assert.assertTrue(iteratorWith0Hops.next() == "D");
+		Assert.assertTrue(iteratorWith0Hops.hasNext());
+		Assert.assertTrue(iteratorWith0Hops.next() == "E");
+		Assert.assertTrue(iteratorWith0Hops.next() == "F");
+
+		/* Iterator with 1 hop, jumps 1 */
+		HoppingIterator<String> iteratorWith1Hops = new HoppingIterator<>(stringList.iterator(), 1);
+		Assert.assertTrue(iteratorWith1Hops.hasNext());
+		Assert.assertTrue(iteratorWith1Hops.next() == "A");
+		Assert.assertTrue(iteratorWith1Hops.next() == "C");
+		Assert.assertTrue(iteratorWith1Hops.hasNext());
+		Assert.assertTrue(iteratorWith1Hops.next() == "E");
+
+		/* Iterator with 2 hops, jumps 2 */
+		HoppingIterator<String> iteratorWith2Hops = new HoppingIterator<>(stringList.iterator(), 2);
+		Assert.assertTrue(iteratorWith2Hops.hasNext());
+		Assert.assertTrue(iteratorWith2Hops.next() == "A");
+		Assert.assertTrue(iteratorWith2Hops.next() == "D");
+		Assert.assertFalse(iteratorWith2Hops.hasNext());
+
+		/* Iterator with 3 hops, jumps 3 */
+		HoppingIterator<String> iteratorWith3Hops = new HoppingIterator<>(stringList.iterator(), 3);
+		Assert.assertTrue(iteratorWith3Hops.hasNext());
+		Assert.assertTrue(iteratorWith3Hops.next() == "A");
+		Assert.assertTrue(iteratorWith3Hops.next() == "E");
+		Assert.assertFalse(iteratorWith3Hops.hasNext());
+	}
+
+}