Skip to content

Added test file and support for Iterables #3

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
prateek2211 wants to merge 3 commits into
base: master
Choose a base branch
from
Open

Added test file and support for Iterables #3

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
7b930c5
Update Itertools.java
prateek2211 Feb 3, 2019
28a80ad
Added 6 algorithms to support iterables
prateek2211 Feb 3, 2019
a6ee9f5
Create ItertoolsTest.java
prateek2211 Feb 3, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
139 changes: 82 additions & 57 deletions src/Itertools.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,24 +31,26 @@ public static Iterable<Integer> count(int start) {
return count(start, 1);
}

public static <T> Iterable<T> cycle(List<T> list) {
public static <T> Iterable<T> cycle(Iterable<T> list) {
return () -> new Iterator<T>() {
int count = -1;
Iterator<T> iterator = list.iterator();

@Override
public boolean hasNext() {
count++;
return true;
}

@Override
public T next() {
count = count % list.size();
return list.get(count);
try {
return (T) iterator.next();
} catch (Exception e) {
iterator = list.iterator();
return (T) iterator.next();
}
}
};
}

/**
* @param t
* @param n
Expand Down Expand Up @@ -91,121 +93,141 @@ public T next() {
};
}


/**
* @param iterables
* @param <T>
* @param <T>
* @return
*/
public static <T> Iterable<T> chain(List<T>... iterables) {
int size = 0;
for (List<T> list :
iterables) {
size += list.size();
}
int finalSize = size;
public static <T> Iterable<T> chain(Iterable<T>... iterables) {
int no_of_iterables = iterables.length;
return () -> new Iterator<T>() {
int counter = -1;
int iterableNo = 0;
int sizeTillNow = 0;
Iterator<T> iterator = iterables[iterableNo].iterator();

@Override
public boolean hasNext() {
counter++;
return counter < finalSize;
if (iterableNo == no_of_iterables - 1) {
return iterator.hasNext();
}
return true;
}

@Override
public T next() {
int presentIterableIndex = counter - sizeTillNow;
while (presentIterableIndex >= iterables[iterableNo].size()) {
sizeTillNow += iterables[iterableNo].size();
presentIterableIndex = counter - sizeTillNow;
iterableNo++;
if (iterator.hasNext()) {
return (T) iterator.next();
} else {
while (!iterator.hasNext()) {
iterableNo++;
iterator = iterables[iterableNo].iterator();
}
return (T) iterator.next();
}
return iterables[iterableNo].get(presentIterableIndex);
}
};
}

/**
/**
* @param data
* @param selectors
* @param <T>
* @param <T>
* @return
*/
public static <T> Iterable<T> compress(List<T> data, List<Boolean> selectors) {
public static <T> Iterable<T> compress(Iterable<T> data, List<Boolean> selectors) {
Iterator<T> iterator = data.iterator();
return () -> new Iterator<T>() {
int index = -1;

@Override
public boolean hasNext() {
index++;
while (index < data.size() && !selectors.get(index))
while (index < selectors.size() && !selectors.get(index)) {
index++;
return index < data.size();
iterator.next();
}
return index < selectors.size();
}

@Override
public T next() {
return data.get(index);
return iterator.next();
}
};
}

/**
/**
* @param pred
* @param seq
* @param <T>
* @param <T>
* @return
*/
public static <T> Iterable<T> dropWhile(Predicate<T> pred, List<T> seq) {
public static <T> Iterable<T> dropWhile(Predicate<T> pred, Iterable<T> seq) {
Iterator<T> iterator = seq.iterator();
return () -> new Iterator<T>() {
boolean next = false;
int index = -1;
boolean firstElement = true;
T obj = iterator.next();

@Override
public boolean hasNext() {
index++;
while (!next && index < seq.size() && pred.pred(seq.get(index))) {
while (!next && pred.pred(obj)) {
obj = iterator.next();
index++;
}
next = true;
return index < seq.size();
return iterator.hasNext();
}

@Override
public T next() {
return seq.get(index);
if (firstElement) {
firstElement = false;
return obj;
}
return iterator.next();
}
};
}

/**
/**
* @param predicate
* @param list
* @param <T>
* @param <T>
* @return
*/
public static <T> Iterable<T> ifilter(Predicate<T> predicate, List<T> list) {
public static <T> Iterable<T> ifilter(Predicate<T> predicate, Iterable<T> list) {
Iterator<T> iterator = list.iterator();
return () -> new Iterator<T>() {
int index = -1;

T obj;
boolean nex;
@Override
public boolean hasNext() {
index++;
while (index < list.size() && !predicate.pred(list.get(index)))
index++;
return index < list.size();
nex=iterator.hasNext();
if(nex)
obj = iterator.next();
if (!predicate.pred(obj)) {
for (int i = 0; ; i++) {
nex=iterator.hasNext();
if(!nex)
return false;
obj=iterator.next();
if (predicate.pred(obj))
return nex;
}
}
return nex;
}

@Override
public T next() {
return list.get(index);
return obj;
}
};
}


public static <T> Iterable<T> ifilterfalse(Predicate<T> predicate, List<T> list) {
return () -> new Iterator<T>() {
int index = -1;
Expand Down Expand Up @@ -272,24 +294,27 @@ public U next() {
};
}

public static <T> Iterable<T> takeWhile(Predicate<T> pred, List<T> seq) {
public static <T> Iterable<T> takeWhile(Predicate<T> pred, Iterable<T> seq) {
Iterator<T> iterator = seq.iterator();
return () -> new Iterator<T>() {
boolean next = false;
int index = -1;
T obj = iterator.next();
boolean firstElement = true;

@Override
public boolean hasNext() {
index++;
while (!next && index < seq.size() && !pred.pred(seq.get(index))) {
index++;
if (pred.pred(obj)) {
if (firstElement)
firstElement = false;
else
obj = iterator.next();
return iterator.hasNext() && pred.pred(obj);
}
next = true;
return index < seq.size();
return false;
}

@Override
public T next() {
return seq.get(index);
return obj;
}
};
}
Expand Down
70 changes: 70 additions & 0 deletions src/ItertoolsTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,70 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ItertoolsTest {

public static void main(String[] args) {

new ItertoolsTest().chainTest();
new ItertoolsTest().cycleTest();
new ItertoolsTest().compressTest();
new ItertoolsTest().ifilterTest();
new ItertoolsTest().takewhileTest();
new ItertoolsTest().dropwhileTest();
}

public void cycleTest() {
int i = 4;
for (String s : Itertools.cycle(Arrays.asList("Shanu", "Sammy", "Samagra", "Bhanu"))) {
System.out.println(s);
i++;
if (i > 100)
break;
}
}

public void chainTest() {
String[] strings = { "Hello", "World", "Samagra", "Sammy", "P", "NP", "PSPACE" };
int i = 0;
for (String s : Itertools.chain(Arrays.asList(strings[0], strings[1], strings[2]), Arrays.asList(),
Arrays.asList(strings[3], strings[4], strings[5], strings[6]))) {
System.out.println(s);
i++;
}
}

public void compressTest() {
String[] data = { "Hello", "World", "Samagra", "Sammy", "P", "NP", "PSPACE" };
Boolean[] selector = { true, true, true, false, false, false, true };
int i = 0;
for (String s : Itertools.compress(Arrays.asList(data), Arrays.asList(selector))) {
System.out.println(s);
i++;
}
}

public void dropwhileTest() {
int i = 0;
for (int a : Itertools.dropWhile(integer -> integer < 5, new ArrayList<>(Arrays.asList(1, 5, 6, 4, 1)))) {
System.out.println(a);
i++;
}
}

public void ifilterTest() {
int i = 0;
for (int a : Itertools.ifilter(integer -> (integer % 2) == 0, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9))) {
System.out.println(a);
i++;
}
}

public void takewhileTest() {
int i = 0;
for (int a : Itertools.takeWhile(integer -> integer < 4, new ArrayList<>(Arrays.asList(1, 4, 6, 4, 1)))) {
System.out.println(a);
i++;
}
}
}