public static void main(String[] args) {
// TriangularNumbers obj = new TriangularNumbers();
// System.out.println(obj.getTriangularNumber(7));
// Scanner in = new Scanner(System.in);
// int[] searchArray = new int[5];
// int key = 0;
// int i =0;
// while(i<searchArray.length){
// System.out.println("Enter value for array elements");
// searchArray[i] = in.nextInt();
// i++;
// }
//
// System.out.println("Enter the value to be searched");
// key = in.nextInt();
// BinarySearch search = new BinarySearch();
// //System.out.println(search.doSearch(searchArray43, key));
// System.out.println(search.recursiveSearch(searchArray,key,0,searchArray.length));
// TowerOfHanoi tw= new TowerOfHanoi(64);
// tw.moveTowerOfHanoi(64, "A", "B", "C");
int[] A = {5, 2, 6, 8, 3};
// QuickSort sort = new QuickSort(7);
// sort.insertElements();
// sort.doQuick();
Anagram g = new Anagram();
List<String> list = g.doAnagram("kind");
for (String s : list) {
System.out.println(s);
}
System.out.println(list.size());
}
@Test
public void testIdenticalWordIsNotAnagram() {
Anagram detector = new Anagram("corn");
List<String> anagrams =
detector.match(Arrays.asList("corn", "dark", "Corn", "rank", "CORN", "cron", "park"));
assertThat(anagrams).containsExactly("cron");
}
@Test
public void testMultipleAnagrams() {
Anagram detector = new Anagram("allergy");
List<String> anagrams =
detector.match(
Arrays.asList("gallery", "ballerina", "regally", "clergy", "largely", "leading"));
assertThat(anagrams).contains("gallery", "largely", "regally");
}
private static void hashQuery(
LinkedList<LinkedList<Anagram>>[] dictList, Scanner queryScan, PrintWriter outputWriter) {
Anagram queryItem;
int index;
LinkedList<Anagram> printPoint;
while (queryScan.hasNext()) {
printPoint = null;
queryItem = new Anagram(queryScan.nextLine());
index = queryItem.cantorHash();
if (dictList[index] != null) {
for (LinkedList<Anagram> a : dictList[index]) {
if (queryItem.getKey().compareTo(a.peek().getKey()) == 0) {
printPoint = a;
break;
}
}
}
writeAnagramsToFile(printPoint, outputWriter, queryItem);
}
}
private static int hashStash(String input, LinkedList<LinkedList<Anagram>>[] dictList) {
int collCount = 0;
Anagram addition = new Anagram(input);
// int index = Math.abs(addition.getKey().hashCode()) % 199967;
int index = addition.cantorHash();
// int index = Math.abs(input.hashCode()) % 199967;
if (dictList[index] == null) {
dictList[index] = new LinkedList<LinkedList<Anagram>>();
}
for (LinkedList<Anagram> a : dictList[index]) {
if (a.peek() != null && addition.getKey().equals(a.element().getKey())) {
a.addFirst(addition);
return collCount;
}
collCount++;
}
dictList[index].addFirst(new LinkedList<Anagram>());
dictList[index].element().addFirst(addition);
return collCount;
}
private static void writeAnagramsToFile(
LinkedList<Anagram> anagramList, PrintWriter outputWriter, Anagram queryItem) {
if (anagramList == null) {
outputWriter.println(queryItem.getWord() + " 0");
return;
}
int count = 0;
outputWriter.print(queryItem.getWord());
for (Anagram a : anagramList) {
if (a.compareTo(queryItem) != 0) {
count++;
}
}
outputWriter.print(" " + count);
for (Anagram a : anagramList) {
if (a.compareTo(queryItem) != 0) {
outputWriter.print(" " + a.getWord());
}
}
outputWriter.println();
}
@Test
public void testDetectAnagrams() {
Anagram detector = new Anagram("listen");
List<String> anagrams = detector.match(Arrays.asList("enlists", "google", "inlets", "banana"));
assertThat(anagrams).contains("inlets");
}
@Test
public void testEliminateAnagramSubsets() {
Anagram detector = new Anagram("good");
assertThat(detector.match(Arrays.asList("dog", "goody"))).isEmpty();
}
@Test
public void testEliminateAnagramsWithSameChecksum() {
Anagram detector = new Anagram("mass");
assertThat(detector.match(Arrays.asList("last")).isEmpty());
}
@Test
public void testDoesNotConfuseDifferentDuplicates() {
Anagram detector = new Anagram("galea");
List<String> anagrams = detector.match(Arrays.asList("eagle"));
assertThat(anagrams).isEmpty();
}
@Test
public void testSimpleAnagram() {
Anagram detector = new Anagram("ant");
List<String> anagram = detector.match(Arrays.asList("tan", "stand", "at"));
assertThat(anagram).containsExactly("tan");
}
private void assertAnagram(List<String> expected, String word, String... words) {
Anagram anagram = new Anagram(words);
List<String> actual = anagram.fetch(word);
assertEquals(expected, actual);
}
@Test
public void empty_string_return_empty_list() {
Anagram anagram = new Anagram("a", "b");
List<String> actual = anagram.fetch("");
assertEquals(expected(), actual);
}
@Test
public void testAnagramsAreCaseInsensitive() {
Anagram detector = new Anagram("Orchestra");
List<String> anagrams = detector.match(Arrays.asList("cashregister", "Carthorse", "radishes"));
assertThat(anagrams).contains("Carthorse");
}
@Test
public void testDetectMultipleAnagrams() {
Anagram detector = new Anagram("master");
List<String> anagrams = detector.match(Arrays.asList("stream", "pigeon", "maters"));
assertThat(anagrams).contains("maters", "stream");
}
@Test
public void testNoMatches() {
Anagram detector = new Anagram("diaper");
assertThat(detector.match(Arrays.asList("hello", "world", "zombies", "pants"))).isEmpty();
}
public void Assert(String expected, String toSend) {
Anagram anagram = new Anagram();
assertEquals(expected, anagram.run(toSend));
}
