From 765da1a46a36a912ce1ed3dc5395d28d1deda408 Mon Sep 17 00:00:00 2001 From: chang-hyunmungai Date: Thu, 14 Sep 2023 12:48:29 -0400 Subject: [PATCH 01/19] Edit linkedlist and binarytree practice Added function to check if binarytree is balanced as well as test cases. Edited linkedlist to handle empty inputs --- Code Practice/src/solutions/LinkedList.java | 27 ++++++------ .../src/solutions/TreesAndGraphs.java | 44 +++++++++++++++++-- Code Practice/src/structures/BinaryTree.java | 11 ----- .../{LLNode.java => LinkedListNode.java} | 32 ++++++++------ Code Practice/src/structures/LocalQueue.java | 10 ++--- Code Practice/src/structures/LocalStack.java | 8 ++-- Code Practice/src/structures/MinStack.java | 8 ++-- .../src/structures/StackOfPlates.java | 6 +-- .../src/testSuite/TestArraysnStrings.java | 8 ++-- .../src/testSuite/TestLinkedList.java | 29 ++++++------ .../src/testSuite/TestTreesAndGraphs.java | 24 +++++++++- 11 files changed, 129 insertions(+), 78 deletions(-) delete mode 100644 Code Practice/src/structures/BinaryTree.java rename Code Practice/src/structures/{LLNode.java => LinkedListNode.java} (57%) diff --git a/Code Practice/src/solutions/LinkedList.java b/Code Practice/src/solutions/LinkedList.java index 9fc7fd2..a2b83fe 100644 --- a/Code Practice/src/solutions/LinkedList.java +++ b/Code Practice/src/solutions/LinkedList.java @@ -1,26 +1,25 @@ package solutions; -import structures.LLNode; +import structures.LinkedListNode; public class LinkedList { //ctci:P2.1 - public static LLNode removeDuplicates(LLNode head){ - LLNode n = head; + public static LinkedListNode removeDuplicates(LinkedListNode head){ + LinkedListNode n = head; int ndata; while (n.getNext() != null) { ndata=n.getData(); - n.setNext(LLNode.deleteNode(n.getNext(),ndata)); + n.setNext(LinkedListNode.deleteNode(n.getNext(),ndata)); n = n.getNext(); if (n == null){return head;} } return head; } - //ctci:P2.2 - public static LLNode findNthLastElement(LLNode head, int nth){ - LLNode n = head; + public static LinkedListNode findNthLastElement(LinkedListNode head, int nth){ + LinkedListNode n = head; int nf=0; while (n.getNext() != null) { n = n.getNext(); @@ -37,22 +36,22 @@ public static LLNode findNthLastElement(LLNode head, int nth){ } //ctci:P2.3 - public static void deleteMiddleNode(LLNode middle){ - LLNode next=middle.getNext(); + public static void deleteMiddleNode(LinkedListNode middle){ + LinkedListNode next=middle.getNext(); middle.setData(next.getData()); middle.setNext(next.getNext()); } //ctci:P2.4 - public static LLNode addLL(LLNode left, LLNode right){ + public static LinkedListNode addLL(LinkedListNode left, LinkedListNode right){ if (left == null){ return right;} else if (right == null){return left;} else{ - LLNode cleft=left.getNext(); - LLNode cright=right.getNext(); + LinkedListNode cleft=left.getNext(); + LinkedListNode cright=right.getNext(); int resultdata = left.getData() + right.getData(); - LLNode result=new LLNode(resultdata % 10); - LLNode cresult=result; + LinkedListNode result=new LinkedListNode(resultdata % 10); + LinkedListNode cresult=result; resultdata /= 10; while (cleft != null && cright != null){ resultdata+=cleft.getData()+cright.getData(); diff --git a/Code Practice/src/solutions/TreesAndGraphs.java b/Code Practice/src/solutions/TreesAndGraphs.java index 4985d5d..5b28313 100644 --- a/Code Practice/src/solutions/TreesAndGraphs.java +++ b/Code Practice/src/solutions/TreesAndGraphs.java @@ -6,11 +6,41 @@ public class TreesAndGraphs { static Random random = new Random(); - // p4.6 Design an algorithm and write code to find the first common ancestor of two nodes - // in a binary tree. Avoid storing additional nodes in a data structure. NOTE: This is not - // necessarily a binary search tree. - //preorder-traversal (left and right first) compare lists + //ctci:P2.1 + public static boolean isBalanced(BinaryTreeNode root) { + return isBalancedRecursive(root) >= 0; + } + + private static int isBalancedRecursive(BinaryTreeNode root) { + if(root == null) { + return 0; + } + + if(root.left == null && root.right == null) { //leaf + return 1; + } + + if(root.left == null) { + if(isBalancedRecursive(root.right) == 1) { //right is leaf + return 2; + } + return -1; + } + + if(root.right == null) { + if(isBalancedRecursive(root.left) == 1) { //left is leaf + return 2; + } + return -1; + } + int left = isBalancedRecursive(root.left); + int right = isBalancedRecursive(root.right); + if(left == -1 || right == -1 || Integer.max(left-right, right-left)>1) { + return -1; + } + return 1+Integer.max(left, right); + } //ctci:P4.3 public static BinaryTreeNode makeTree(int[] num){ @@ -51,5 +81,11 @@ static BinaryTreeNode makeTreeRecursive(int[] num, int s, int e){ } + // p4.6 Design an algorithm and write code to find the first common ancestor of two nodes + // in a binary tree. Avoid storing additional nodes in a data structure. NOTE: This is not + // necessarily a binary search tree. + + //preorder-traversal (left and right first) compare lists + } diff --git a/Code Practice/src/structures/BinaryTree.java b/Code Practice/src/structures/BinaryTree.java deleted file mode 100644 index c337962..0000000 --- a/Code Practice/src/structures/BinaryTree.java +++ /dev/null @@ -1,11 +0,0 @@ -package structures; - -public class BinaryTree { - BinaryTree left=null; - BinaryTree right=null; - int data; - - public BinaryTree(int d){ - data=d; - } -} diff --git a/Code Practice/src/structures/LLNode.java b/Code Practice/src/structures/LinkedListNode.java similarity index 57% rename from Code Practice/src/structures/LLNode.java rename to Code Practice/src/structures/LinkedListNode.java index a8dbb53..a6662c0 100644 --- a/Code Practice/src/structures/LLNode.java +++ b/Code Practice/src/structures/LinkedListNode.java @@ -1,31 +1,35 @@ package structures; //Linked list node -public class LLNode { - LLNode next = null; +public class LinkedListNode { + LinkedListNode next = null; int data; - public LLNode(int d) { data = d; } + public LinkedListNode(int d) { data = d; } - public static LLNode linkedListFromArray(int[] da) { - LLNode head = new LLNode(da[0]); - LLNode n=head; + public static LinkedListNode linkedListFromArray(int[] da) { + if (da == null || da.length == 0) { + return null; + } + + LinkedListNode head = new LinkedListNode(da[0]); + LinkedListNode n=head; for(int i=1; i < da.length;i++){ - n.next=new LLNode(da[i]); + n.next=new LinkedListNode(da[i]); n=n.next; } return head; } public void appendToTail(int d) { - LLNode end = new LLNode(d); - LLNode n = this; + LinkedListNode end = new LinkedListNode(d); + LinkedListNode n = this; while (n.next != null) { n = n.next; } n.next = end; } - public static LLNode deleteNode(LLNode head, int d) { - LLNode n = head; + public static LinkedListNode deleteNode(LinkedListNode head, int d) { + LinkedListNode n = head; if (n.data == d) { return head.next; /* moved head */ } @@ -42,7 +46,7 @@ public static LLNode deleteNode(LLNode head, int d) { public void printLinkedList(){ System.out.print("LL: "); System.out.print(this.data); - LLNode n = this; + LinkedListNode n = this; while (n.next != null) { n = n.next; System.out.print("->"); @@ -59,11 +63,11 @@ public void setData(int data2) { this.data=data2; } - public LLNode getNext() { + public LinkedListNode getNext() { return this.next; } - public void setNext(LLNode next2) { + public void setNext(LinkedListNode next2) { this.next=next2; } } diff --git a/Code Practice/src/structures/LocalQueue.java b/Code Practice/src/structures/LocalQueue.java index cc2cda2..66c4bef 100644 --- a/Code Practice/src/structures/LocalQueue.java +++ b/Code Practice/src/structures/LocalQueue.java @@ -1,20 +1,20 @@ package structures; public class LocalQueue { - LLNode first, last; + LinkedListNode first, last; void enqueue(int item){ if (first == null){ - last = new LLNode(item); + last = new LinkedListNode(item); first=last; }else{ - last.setNext(new LLNode(item)); + last.setNext(new LinkedListNode(item)); last=last.next; } } - LLNode dequeue(LLNode n){ + LinkedListNode dequeue(LinkedListNode n){ if (first != null){ - LLNode item=first; + LinkedListNode item=first; first = first.getNext(); return item; } diff --git a/Code Practice/src/structures/LocalStack.java b/Code Practice/src/structures/LocalStack.java index a5aba26..c055114 100644 --- a/Code Practice/src/structures/LocalStack.java +++ b/Code Practice/src/structures/LocalStack.java @@ -1,13 +1,13 @@ package structures; public class LocalStack { - LLNode top; + LinkedListNode top; public LocalStack() {} - LLNode pop(){ + LinkedListNode pop(){ if (top != null){ - LLNode item=top; + LinkedListNode item=top; top=top.getNext(); return item; } @@ -15,7 +15,7 @@ LLNode pop(){ } void push(int item){ - LLNode t = new LLNode(item); + LinkedListNode t = new LinkedListNode(item); t.next = top; top=t; } diff --git a/Code Practice/src/structures/MinStack.java b/Code Practice/src/structures/MinStack.java index af9272f..df20af1 100644 --- a/Code Practice/src/structures/MinStack.java +++ b/Code Practice/src/structures/MinStack.java @@ -2,12 +2,12 @@ //P3.2 public class MinStack extends LocalStack{ - LLNode min; + LinkedListNode min; int minData; @Override - LLNode pop(){ - LLNode toReturn=super.pop(); + LinkedListNode pop(){ + LinkedListNode toReturn=super.pop(); if (toReturn == min){ updateMin(); } @@ -20,7 +20,7 @@ private void updateMin() { }else{ min=this.top; minData=this.top.getData(); - LLNode n = this.top; + LinkedListNode n = this.top; while(n.next != null){ n=n.next; if (n.getData() < minData){ diff --git a/Code Practice/src/structures/StackOfPlates.java b/Code Practice/src/structures/StackOfPlates.java index afa5c65..69eb52f 100644 --- a/Code Practice/src/structures/StackOfPlates.java +++ b/Code Practice/src/structures/StackOfPlates.java @@ -12,17 +12,17 @@ public class StackOfPlates extends LocalStack{ int currentStackSize; @Override - LLNode pop(){ + LinkedListNode pop(){ if (currentStack != null){ if (currentStack.top != null){ - LLNode item=currentStack.top; + LinkedListNode item=currentStack.top; currentStack.top=currentStack.top.getNext(); currentStackSize--; return item; }else if (currentStackIndex != 0){ currentStackIndex--; currentStack= toStack.get(currentStackIndex); - LLNode item=currentStack.top; + LinkedListNode item=currentStack.top; currentStack.top=currentStack.top.getNext(); currentStackSize=maxElements-1; return item; diff --git a/Code Practice/src/testSuite/TestArraysnStrings.java b/Code Practice/src/testSuite/TestArraysnStrings.java index 66a8660..7525217 100644 --- a/Code Practice/src/testSuite/TestArraysnStrings.java +++ b/Code Practice/src/testSuite/TestArraysnStrings.java @@ -10,14 +10,14 @@ public class TestArraysnStrings { @Test public void testisUnique() { - assertEquals("'hi' must be true", true, ArraysnStrings.isUnique("hi")); - assertEquals("'hih' must be false", false, ArraysnStrings.isUnique("hih")); + assertTrue("'hi' must be true", ArraysnStrings.isUnique("hi")); + assertFalse("'hih' must be false", ArraysnStrings.isUnique("hih")); } @Test public void testisUniqueWOAddStructs() { - assertEquals("'hi' must be true", true, ArraysnStrings.isUniqueWOAddStructs("hi")); - assertEquals("'hih' must be false", false, ArraysnStrings.isUniqueWOAddStructs("hih")); + assertTrue("'hi' must be true", ArraysnStrings.isUniqueWOAddStructs("hi")); + assertFalse("'hih' must be false", ArraysnStrings.isUniqueWOAddStructs("hih")); } @Test diff --git a/Code Practice/src/testSuite/TestLinkedList.java b/Code Practice/src/testSuite/TestLinkedList.java index 7b63497..7b71456 100644 --- a/Code Practice/src/testSuite/TestLinkedList.java +++ b/Code Practice/src/testSuite/TestLinkedList.java @@ -5,26 +5,29 @@ import org.junit.Test; import solutions.LinkedList; -import structures.LLNode; +import structures.LinkedListNode; public class TestLinkedList { @Test public void testNode() { - int[] lLIA={0,0,1,1,2,2,3,3,4,4,5}; - LLNode lL=LLNode.linkedListFromArray(lLIA); + int[] lla={0,0,1,1,2,2,3,3,4,4,5}; + LinkedListNode lL=LinkedListNode.linkedListFromArray(lla); lL.printLinkedList(); + int[] lla1={}; + LinkedListNode lL1=LinkedListNode.linkedListFromArray(lla1); + assertNull(lL1); } @Test public void testremoveDuplicates() { int[] lLIA={0,0,1,1,2,2,3,3,4,4,5}; - LLNode lL=LLNode.linkedListFromArray(lLIA); + LinkedListNode lL=LinkedListNode.linkedListFromArray(lLIA); //lL.printLinkedList(); lL=LinkedList.removeDuplicates(lL); //lL.printLinkedList(); - int[] lLIA2={0,0,1,1,2,2,3,3,4,4,}; - LLNode lL2=LLNode.linkedListFromArray(lLIA2); + int[] lLIA2={0,0,1,1,2,2,3,3,4,4}; + LinkedListNode lL2=LinkedListNode.linkedListFromArray(lLIA2); //lL2.printLinkedList(); lL2=LinkedList.removeDuplicates(lL2); //lL2.printLinkedList(); @@ -33,17 +36,17 @@ public void testremoveDuplicates() { @Test public void testfindNthLastElement(){ int[] lLIA={0,1,2,3,4,5}; - LLNode lL=LLNode.linkedListFromArray(lLIA); - LLNode thirdlast = LinkedList.findNthLastElement(lL, 3); + LinkedListNode lL=LinkedListNode.linkedListFromArray(lLIA); + LinkedListNode thirdlast = LinkedList.findNthLastElement(lL, 3); assertEquals("3rd last element is 2", 2, thirdlast.getData()); } @Test public void testdeleteMiddleNode(){ int[] lLIA={0,1,2,3,4,5}; - LLNode lL=LLNode.linkedListFromArray(lLIA); + LinkedListNode lL=LinkedListNode.linkedListFromArray(lLIA); lL.printLinkedList(); - LLNode middle=lL.getNext(); + LinkedListNode middle=lL.getNext(); LinkedList.deleteMiddleNode(middle); lL.printLinkedList();; } @@ -52,12 +55,12 @@ public void testdeleteMiddleNode(){ public void testAddLL(){ System.out.println("p2.4"); int[] lLIA={1,3,5}; - LLNode lL=LLNode.linkedListFromArray(lLIA); + LinkedListNode lL=LinkedListNode.linkedListFromArray(lLIA); lL.printLinkedList(); int[] lLIA2={2,5,5,9}; - LLNode lL2=LLNode.linkedListFromArray(lLIA2); + LinkedListNode lL2=LinkedListNode.linkedListFromArray(lLIA2); lL2.printLinkedList(); - LLNode result=LinkedList.addLL(lL, lL2); + LinkedListNode result=LinkedList.addLL(lL, lL2); result.printLinkedList(); } diff --git a/Code Practice/src/testSuite/TestTreesAndGraphs.java b/Code Practice/src/testSuite/TestTreesAndGraphs.java index b4b3d3b..ffe546b 100644 --- a/Code Practice/src/testSuite/TestTreesAndGraphs.java +++ b/Code Practice/src/testSuite/TestTreesAndGraphs.java @@ -1,5 +1,7 @@ package testSuite; +import static org.junit.Assert.assertEquals; + import java.util.ArrayList; import java.util.Collections; import java.util.List; @@ -10,9 +12,27 @@ import structures.BinaryTreeNode; public class TestTreesAndGraphs { - + + @Test + public void testisBalanced() { + BinaryTreeNode unbal = new BinaryTreeNode(5); + unbal.left = new BinaryTreeNode(3); + unbal.left.left = new BinaryTreeNode(2); + unbal.left.right = new BinaryTreeNode(4); + BTreePrinter.printNode(unbal); + assertEquals("unbal must be false", false, TreesAndGraphs.isBalanced(unbal)); + BinaryTreeNode bal = new BinaryTreeNode(5); + bal.left = new BinaryTreeNode(3); + bal.left.left = new BinaryTreeNode(2); + bal.left.right = new BinaryTreeNode(4); + bal.right = new BinaryTreeNode(7); + bal.right.right = new BinaryTreeNode(8); + BTreePrinter.printNode(bal); + assertEquals("bal must be true", true, TreesAndGraphs.isBalanced(bal)); + } + @Test - public void test() { + public void testmakeTree() { int[] num = {1,2,3,4,5,6,7}; BTreePrinter.printNode(TreesAndGraphs.makeTree(num)); } From 26c041bb148fe95f8648874aa9d61ea6b4b126a9 Mon Sep 17 00:00:00 2001 From: chang-hyunmungai Date: Fri, 15 Sep 2023 10:21:02 -0400 Subject: [PATCH 02/19] Add function to create debt linkedlists from bst --- .../src/solutions/TreesAndGraphs.java | 39 ++++++++++++++++++- .../src/structures/LinkedListNode.java | 2 +- .../src/testSuite/TestTreesAndGraphs.java | 33 ++++++++++++++-- 3 files changed, 69 insertions(+), 5 deletions(-) diff --git a/Code Practice/src/solutions/TreesAndGraphs.java b/Code Practice/src/solutions/TreesAndGraphs.java index 5b28313..0c5946a 100644 --- a/Code Practice/src/solutions/TreesAndGraphs.java +++ b/Code Practice/src/solutions/TreesAndGraphs.java @@ -1,8 +1,10 @@ package solutions; +import java.util.ArrayList; import java.util.Random; import structures.BinaryTreeNode; +import structures.LinkedListNode; public class TreesAndGraphs { static Random random = new Random(); @@ -53,7 +55,7 @@ public static BinaryTreeNode makeTree(int[] num){ } //s inclusive, e exclusive - static BinaryTreeNode makeTreeRecursive(int[] num, int s, int e){ + private static BinaryTreeNode makeTreeRecursive(int[] num, int s, int e){ if(e-s == 0){ return null; }else if (e-s == 1){ @@ -81,6 +83,41 @@ static BinaryTreeNode makeTreeRecursive(int[] num, int s, int e){ } + //ctci:4.4 + public static LinkedListNode[] linkedListPerDepth(BinaryTreeNode bst){ + if(bst == null) { + return new LinkedListNode[0]; + } + ArrayList arr=new ArrayList(); + arr = linkedListPerDepthRecursive(bst, arr, 1); + + LinkedListNode[] sol = new LinkedListNode[arr.size()]; + return arr.toArray(sol); + } + + private static ArrayList linkedListPerDepthRecursive( + BinaryTreeNode bst, ArrayList arr, int d){ + if (bst == null) { + return arr; + } + + if(arr.size() < d) { + arr.add(new LinkedListNode(bst.val)); + }else{ + arr.get(d-1).appendToTail(bst.val); + } + + if(bst.left != null) { + arr = linkedListPerDepthRecursive(bst.left, arr, d+1); + } + + if(bst.right != null) { + arr = linkedListPerDepthRecursive(bst.right, arr, d+1); + } + + return arr; + } + // p4.6 Design an algorithm and write code to find the first common ancestor of two nodes // in a binary tree. Avoid storing additional nodes in a data structure. NOTE: This is not // necessarily a binary search tree. diff --git a/Code Practice/src/structures/LinkedListNode.java b/Code Practice/src/structures/LinkedListNode.java index a6662c0..c8c7a35 100644 --- a/Code Practice/src/structures/LinkedListNode.java +++ b/Code Practice/src/structures/LinkedListNode.java @@ -40,7 +40,7 @@ public static LinkedListNode deleteNode(LinkedListNode head, int d) { } n = n.next; } - return head; /* head didn�t change */ + return head; /* head didn't change */ } public void printLinkedList(){ diff --git a/Code Practice/src/testSuite/TestTreesAndGraphs.java b/Code Practice/src/testSuite/TestTreesAndGraphs.java index ffe546b..ec7a318 100644 --- a/Code Practice/src/testSuite/TestTreesAndGraphs.java +++ b/Code Practice/src/testSuite/TestTreesAndGraphs.java @@ -1,6 +1,6 @@ package testSuite; -import static org.junit.Assert.assertEquals; +import static org.junit.Assert.*; import java.util.ArrayList; import java.util.Collections; @@ -10,6 +10,7 @@ import solutions.TreesAndGraphs; import structures.BinaryTreeNode; +import structures.LinkedListNode; public class TestTreesAndGraphs { @@ -20,7 +21,7 @@ public void testisBalanced() { unbal.left.left = new BinaryTreeNode(2); unbal.left.right = new BinaryTreeNode(4); BTreePrinter.printNode(unbal); - assertEquals("unbal must be false", false, TreesAndGraphs.isBalanced(unbal)); + assertFalse("unbal must be false", TreesAndGraphs.isBalanced(unbal)); BinaryTreeNode bal = new BinaryTreeNode(5); bal.left = new BinaryTreeNode(3); bal.left.left = new BinaryTreeNode(2); @@ -28,7 +29,7 @@ public void testisBalanced() { bal.right = new BinaryTreeNode(7); bal.right.right = new BinaryTreeNode(8); BTreePrinter.printNode(bal); - assertEquals("bal must be true", true, TreesAndGraphs.isBalanced(bal)); + assertTrue("bal must be true", TreesAndGraphs.isBalanced(bal)); } @Test @@ -36,6 +37,32 @@ public void testmakeTree() { int[] num = {1,2,3,4,5,6,7}; BTreePrinter.printNode(TreesAndGraphs.makeTree(num)); } + + @Test + public void testlinkedListPerDepth() { + BinaryTreeNode bal = new BinaryTreeNode(5); + bal.left = new BinaryTreeNode(3); + bal.left.left = new BinaryTreeNode(2); + bal.left.right = new BinaryTreeNode(4); + bal.right = new BinaryTreeNode(7); + bal.right.right = new BinaryTreeNode(8); + LinkedListNode[] llpd = TreesAndGraphs.linkedListPerDepth(bal); + assertNotNull("llpd not null",llpd); + assertEquals("llpd must have 3 linked lists", 3, llpd.length); + assertNotNull("1st linked list not null",llpd[0]); + assertEquals("1st element in 1st linked list is 5", 5, llpd[0].getData()); + + assertNotNull("2nd linked list not null",llpd[1]); + LinkedListNode ll = llpd[1]; + boolean isSeven = false; + boolean isThree = false; + while(ll != null) { + if(ll.getData() == 7) {isSeven = true;} + if(ll.getData() == 3) {isThree = true;} + ll=ll.getNext(); + } + assertTrue("2nd linked list contains 5 and 7", isSeven && isThree); + } } From 637463dd70f569ad61ba5060d65a55e7ed626afc Mon Sep 17 00:00:00 2001 From: chang-hyunmungai Date: Thu, 23 May 2024 10:27:20 -0400 Subject: [PATCH 03/19] Add FamilyTree problem --- Code Practice/src/solutions/FamilyTree.java | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 Code Practice/src/solutions/FamilyTree.java diff --git a/Code Practice/src/solutions/FamilyTree.java b/Code Practice/src/solutions/FamilyTree.java new file mode 100644 index 0000000..1043ea9 --- /dev/null +++ b/Code Practice/src/solutions/FamilyTree.java @@ -0,0 +1,5 @@ +package solutions; + +public class FamilyTree { + +} From f0aecb20330620ec9585b3f3cf1cd04e344e9ae0 Mon Sep 17 00:00:00 2001 From: chang-hyunmungai Date: Wed, 19 Jun 2024 13:48:48 -0400 Subject: [PATCH 04/19] Added more code --- Code Practice/src/solutions/FamilyTree.java | 5 ----- .../src/solutions/family_tree/FamilyTree.java | 9 +++++++++ .../src/structures/BinaryTreeNode.java | 8 ++++++++ .../family_tree/FamilyDemograpgic.java | 20 +++++++++++++++++++ 4 files changed, 37 insertions(+), 5 deletions(-) delete mode 100644 Code Practice/src/solutions/FamilyTree.java create mode 100644 Code Practice/src/solutions/family_tree/FamilyTree.java create mode 100644 Code Practice/src/structures/family_tree/FamilyDemograpgic.java diff --git a/Code Practice/src/solutions/FamilyTree.java b/Code Practice/src/solutions/FamilyTree.java deleted file mode 100644 index 1043ea9..0000000 --- a/Code Practice/src/solutions/FamilyTree.java +++ /dev/null @@ -1,5 +0,0 @@ -package solutions; - -public class FamilyTree { - -} diff --git a/Code Practice/src/solutions/family_tree/FamilyTree.java b/Code Practice/src/solutions/family_tree/FamilyTree.java new file mode 100644 index 0000000..fb98158 --- /dev/null +++ b/Code Practice/src/solutions/family_tree/FamilyTree.java @@ -0,0 +1,9 @@ +package solutions.family_tree; + +import structures.BinaryTreeNode; + +public class FamilyTree { + public static BinaryTreeNode familyTree(FamilyDemographic fd, string name) { + BinaryTreeNode(x) + } +} diff --git a/Code Practice/src/structures/BinaryTreeNode.java b/Code Practice/src/structures/BinaryTreeNode.java index fca415d..c11d3fe 100644 --- a/Code Practice/src/structures/BinaryTreeNode.java +++ b/Code Practice/src/structures/BinaryTreeNode.java @@ -2,6 +2,7 @@ public class BinaryTreeNode { public int val; + public Object data; public BinaryTreeNode left; public BinaryTreeNode right; @@ -10,4 +11,11 @@ public BinaryTreeNode(int x){ left=null; right=null; } + + public BinaryTreeNode(int x, Object input){ + val=x; + left=null; + right=null; + data=input; + } } diff --git a/Code Practice/src/structures/family_tree/FamilyDemograpgic.java b/Code Practice/src/structures/family_tree/FamilyDemograpgic.java new file mode 100644 index 0000000..9a291b4 --- /dev/null +++ b/Code Practice/src/structures/family_tree/FamilyDemograpgic.java @@ -0,0 +1,20 @@ +package structures.family_tree; + +import structures.BinaryTreeNode; + +public final class FamilyDemograpgic { + int type = 0; //0 = orphan, 1 = single family, 2 = full family + + public static BinaryTreeNode FamilyDemograpgic(int dem) { + int error = dem % 2; + if (error == 0) { + BinaryTreeNode(dem); + }; + return null; + } + + private static void BinaryTreeNode(int dem) { + // TODO Auto-generated method stub + + } +} From f6608ee50d8a4833c1a96a78aab98ae139a8014e Mon Sep 17 00:00:00 2001 From: chang-hyunmungai Date: Wed, 19 Jun 2024 21:44:28 -0400 Subject: [PATCH 05/19] Scramble --- .../src/solutions/family_tree/FamilyTree.java | 25 +++++++++++-- .../family_tree/FamilyDemograpgic.java | 18 +++------- .../src/testSuite/TestFamilyTree.java | 35 +++++++++++++++++++ 3 files changed, 63 insertions(+), 15 deletions(-) create mode 100644 Code Practice/src/testSuite/TestFamilyTree.java diff --git a/Code Practice/src/solutions/family_tree/FamilyTree.java b/Code Practice/src/solutions/family_tree/FamilyTree.java index fb98158..cede638 100644 --- a/Code Practice/src/solutions/family_tree/FamilyTree.java +++ b/Code Practice/src/solutions/family_tree/FamilyTree.java @@ -1,9 +1,30 @@ package solutions.family_tree; import structures.BinaryTreeNode; +import structures.family_tree.FamilyDemograpgic; public class FamilyTree { - public static BinaryTreeNode familyTree(FamilyDemographic fd, string name) { - BinaryTreeNode(x) + public static BinaryTreeNode familyTree(FamilyDemograpgic fd, String name, int size) { + System.out.print("size is.. "); + System.out.println(size); + if(size == 0) { //no name + System.out.println("anonymous"); + return null; + }else if(size == 1) { //one person + System.out.println("single"); + return new BinaryTreeNode(1, name); + }else if (size == 2) { // single parent + System.out.println("one parent"); + return new BinaryTreeNode(1, name); + }else if (size == 3) { // family + System.out.println("one parent"); + return new BinaryTreeNode(1, name); + }else if(size == 5) { // community + System.out.println("family"); + return new BinaryTreeNode(1, name); + }else { + System.out.println("family"); + return new BinaryTreeNode(1, name); + } } } diff --git a/Code Practice/src/structures/family_tree/FamilyDemograpgic.java b/Code Practice/src/structures/family_tree/FamilyDemograpgic.java index 9a291b4..4538205 100644 --- a/Code Practice/src/structures/family_tree/FamilyDemograpgic.java +++ b/Code Practice/src/structures/family_tree/FamilyDemograpgic.java @@ -1,20 +1,12 @@ package structures.family_tree; -import structures.BinaryTreeNode; - public final class FamilyDemograpgic { int type = 0; //0 = orphan, 1 = single family, 2 = full family - public static BinaryTreeNode FamilyDemograpgic(int dem) { - int error = dem % 2; - if (error == 0) { - BinaryTreeNode(dem); - }; - return null; - } - - private static void BinaryTreeNode(int dem) { - // TODO Auto-generated method stub - + public FamilyDemograpgic(int dem){ + if(dem % 2 >= 2) { + type = -1; + } + type = dem; } } diff --git a/Code Practice/src/testSuite/TestFamilyTree.java b/Code Practice/src/testSuite/TestFamilyTree.java new file mode 100644 index 0000000..cf720be --- /dev/null +++ b/Code Practice/src/testSuite/TestFamilyTree.java @@ -0,0 +1,35 @@ +package testSuite; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +import org.junit.Test; + +import structures.BinaryTreeNode; +import structures.family_tree.FamilyDemograpgic; +import solutions.family_tree.FamilyTree; + +public class TestFamilyTree { + + @Test + public void testGirl() { + System.out.println("lily says.. "); + BinaryTreeNode lily = FamilyTree.familyTree(new FamilyDemograpgic(2), "Lily Wilslet", 3); + assertEquals(lily.val,1); + assertNull(lily.left); + assertNull(lily.right); + System.out.println("lily says do my homework between here ?!?!?!"); + } + + @Test + public void testChang() { + System.out.println("Chang says..5 grown BP people "); + System.out.println("Chang says..4 brothers 1 sister"); + BinaryTreeNode mbuguss = FamilyTree.familyTree(new FamilyDemograpgic(2), "Chang-Hyun Mungai", 7); + assertEquals(mbuguss.val,1); + assertNull(mbuguss.left); + assertNull(mbuguss.right); + System.out.println("Chang-Hyun says do my homework between here ?!?!?!"); + } + +} From 3e9f621d3a85071f47063046e664286dd19c9752 Mon Sep 17 00:00:00 2001 From: chang-hyunmungai Date: Wed, 19 Jun 2024 21:59:54 -0400 Subject: [PATCH 06/19] Update demographics --- .../src/solutions/family_tree/FamilyTree.java | 22 +++++++++---------- .../src/structures/BinaryTreeNode.java | 15 +++++++++++++ 2 files changed, 26 insertions(+), 11 deletions(-) diff --git a/Code Practice/src/solutions/family_tree/FamilyTree.java b/Code Practice/src/solutions/family_tree/FamilyTree.java index cede638..7bfc71f 100644 --- a/Code Practice/src/solutions/family_tree/FamilyTree.java +++ b/Code Practice/src/solutions/family_tree/FamilyTree.java @@ -4,27 +4,27 @@ import structures.family_tree.FamilyDemograpgic; public class FamilyTree { - public static BinaryTreeNode familyTree(FamilyDemograpgic fd, String name, int size) { + public static BinaryTreeNode familyTree(FamilyDemograpgic fd, String name, int place) { System.out.print("size is.. "); - System.out.println(size); - if(size == 0) { //no name + System.out.println(place); + if(place == 0) { //no name System.out.println("anonymous"); return null; - }else if(size == 1) { //one person + }else if(place == 1) { //one person System.out.println("single"); return new BinaryTreeNode(1, name); - }else if (size == 2) { // single parent + }else if (place == 2) { // single parent System.out.println("one parent"); - return new BinaryTreeNode(1, name); - }else if (size == 3) { // family + return new BinaryTreeNode(2, name); + }else if (place == 3) { // family System.out.println("one parent"); - return new BinaryTreeNode(1, name); - }else if(size == 5) { // community + return new BinaryTreeNode(3, name); + }else if(place == 5) { // community System.out.println("family"); - return new BinaryTreeNode(1, name); + return new BinaryTreeNode(5, name); }else { System.out.println("family"); - return new BinaryTreeNode(1, name); + return new BinaryTreeNode(place, name); } } } diff --git a/Code Practice/src/structures/BinaryTreeNode.java b/Code Practice/src/structures/BinaryTreeNode.java index c11d3fe..0669a27 100644 --- a/Code Practice/src/structures/BinaryTreeNode.java +++ b/Code Practice/src/structures/BinaryTreeNode.java @@ -1,5 +1,7 @@ package structures; +import java.util.List; + public class BinaryTreeNode { public int val; public Object data; @@ -18,4 +20,17 @@ public BinaryTreeNode(int x, Object input){ right=null; data=input; } + + public BinaryTreeNode BinaryTreeNode(int x, Object input, int size, List others){ + val=x; + if (size == 0) { + return null; + }else if (size == 1) { + return new BinaryTreeNode(x, input); + } + left=null; + right=null; + data=input; + return null; + } } From 26e359a459d591a271d838febd22f9197b48bb85 Mon Sep 17 00:00:00 2001 From: chang-hyunmungai Date: Fri, 21 Jun 2024 08:27:35 -0400 Subject: [PATCH 07/19] Updated BinaryTree Structure --- .../src/solutions/family_tree/FamilyTree.java | 26 +++++++++++++++++++ .../src/structures/BinaryTreeNode.java | 17 +++++++----- 2 files changed, 36 insertions(+), 7 deletions(-) diff --git a/Code Practice/src/solutions/family_tree/FamilyTree.java b/Code Practice/src/solutions/family_tree/FamilyTree.java index 7bfc71f..8bec6c6 100644 --- a/Code Practice/src/solutions/family_tree/FamilyTree.java +++ b/Code Practice/src/solutions/family_tree/FamilyTree.java @@ -1,5 +1,7 @@ package solutions.family_tree; +import java.util.List; + import structures.BinaryTreeNode; import structures.family_tree.FamilyDemograpgic; @@ -27,4 +29,28 @@ public static BinaryTreeNode familyTree(FamilyDemograpgic fd, String name, int p return new BinaryTreeNode(place, name); } } + + public static BinaryTreeNode familyTreeList(FamilyDemograpgic fd, List names) { + System.out.print("size is.. "); + System.out.println(names.size()); + if(names.size() == 0) { //no name + System.out.println("anonymous"); + return null; + }else if(names.size() == 1) { //one person + System.out.println("single"); + return new BinaryTreeNode(1, names.get(0)); + }else if (names.size() == 2) { // single parent + System.out.println("one parent"); + return new BinaryTreeNode(2, names); + }else if (names.size() == 3) { // family + System.out.println("one parent"); + return new BinaryTreeNode(3, names); + }else if(names.size() == 5) { // community + System.out.println("family"); + return new BinaryTreeNode(5, names); + }else { + System.out.println("family"); + return new BinaryTreeNode(names.size(), names); + } + } } diff --git a/Code Practice/src/structures/BinaryTreeNode.java b/Code Practice/src/structures/BinaryTreeNode.java index 0669a27..9be84b2 100644 --- a/Code Practice/src/structures/BinaryTreeNode.java +++ b/Code Practice/src/structures/BinaryTreeNode.java @@ -21,16 +21,19 @@ public BinaryTreeNode(int x, Object input){ data=input; } - public BinaryTreeNode BinaryTreeNode(int x, Object input, int size, List others){ - val=x; + public BinaryTreeNode(int index, Object input, int size, List others){ // ? + val=index; + left=null; + right=null; if (size == 0) { - return null; + return; }else if (size == 1) { - return new BinaryTreeNode(x, input); + return; + }else if (size == 2) {// ? + left= new BinaryTreeNode(index, input); //others 0 ? + return; } - left=null; - right=null; data=input; - return null; + return; } } From 52e7c4403fd9b2962658e672465fdc48079ea240 Mon Sep 17 00:00:00 2001 From: chang-hyunmungai Date: Wed, 26 Jun 2024 23:18:16 -0400 Subject: [PATCH 08/19] Added More Binary Tree Cases --- Code Practice/src/structures/BinaryTreeNode.java | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/Code Practice/src/structures/BinaryTreeNode.java b/Code Practice/src/structures/BinaryTreeNode.java index 9be84b2..6e8f58e 100644 --- a/Code Practice/src/structures/BinaryTreeNode.java +++ b/Code Practice/src/structures/BinaryTreeNode.java @@ -28,9 +28,18 @@ public BinaryTreeNode(int index, Object input, int size, List others){ / if (size == 0) { return; }else if (size == 1) { + data = input; return; - }else if (size == 2) {// ? - left= new BinaryTreeNode(index, input); //others 0 ? + }else if (size == 2) {// 2 node tree + left= new BinaryTreeNode(0, others.get(0)); + data = others.get(1); + val=1; + return; + }else if (size == 3) {// 3 node tree + left= new BinaryTreeNode(0, others.get(0)); + data = others.get(1); + val=1; + right= new BinaryTreeNode(2, others.get(2)); return; } data=input; From 7187be50b15734a85206aa2eb448db3236686d6b Mon Sep 17 00:00:00 2001 From: chang-hyunmungai Date: Wed, 26 Jun 2024 23:58:17 -0400 Subject: [PATCH 09/19] Added Shosho says --- Code Practice/src/testSuite/TestFamilyTree.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Code Practice/src/testSuite/TestFamilyTree.java b/Code Practice/src/testSuite/TestFamilyTree.java index cf720be..54bd867 100644 --- a/Code Practice/src/testSuite/TestFamilyTree.java +++ b/Code Practice/src/testSuite/TestFamilyTree.java @@ -31,5 +31,10 @@ public void testChang() { assertNull(mbuguss.right); System.out.println("Chang-Hyun says do my homework between here ?!?!?!"); } + + @Test + public void testShosho() { + System.out.println("Shosho says chiefs and fighters "); + } } From 2249fda27ae40ad3ddef65db66a23c9b21b87170 Mon Sep 17 00:00:00 2001 From: chang-hyunmungai Date: Thu, 27 Jun 2024 18:08:19 -0400 Subject: [PATCH 10/19] Formatted Trees test --- Code Practice/src/testSuite/TestTreesAndGraphs.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Code Practice/src/testSuite/TestTreesAndGraphs.java b/Code Practice/src/testSuite/TestTreesAndGraphs.java index ec7a318..a9e092e 100644 --- a/Code Practice/src/testSuite/TestTreesAndGraphs.java +++ b/Code Practice/src/testSuite/TestTreesAndGraphs.java @@ -21,7 +21,9 @@ public void testisBalanced() { unbal.left.left = new BinaryTreeNode(2); unbal.left.right = new BinaryTreeNode(4); BTreePrinter.printNode(unbal); + assertFalse("unbal must be false", TreesAndGraphs.isBalanced(unbal)); + BinaryTreeNode bal = new BinaryTreeNode(5); bal.left = new BinaryTreeNode(3); bal.left.left = new BinaryTreeNode(2); From cb51c627d23ec65d106f65992cf303c6e6afb18d Mon Sep 17 00:00:00 2001 From: unboagable Date: Sat, 4 Jan 2025 09:54:25 -0500 Subject: [PATCH 11/19] Refactor project to Maven --- Code Practice/.classpath | 7 --- Code Practice/.gitignore | 1 - Code Practice/.project | 17 ------ .../.settings/org.eclipse.jdt.core.prefs | 11 ---- .../src/solutions/family_tree/FamilyTree.java | 56 ------------------- .../family_tree/FamilyDemograpgic.java | 12 ---- .../src/testSuite/TestFamilyTree.java | 40 ------------- Code Practice/input.txt => input.txt | 0 pom.xml | 16 ++++++ .../main/java}/solutions/ArraysnStrings.java | 6 +- .../main/java}/solutions/BitManipulation.java | 0 .../main/java}/solutions/HackerRank.java | 0 .../main/java}/solutions/LinkedList.java | 46 +++++++-------- .../main/java}/solutions/Recursive.java | 0 .../java}/solutions/SortingAndSearch.java | 0 .../main/java}/solutions/TreesAndGraphs.java | 0 .../main/java}/structures/BinaryTreeNode.java | 0 .../main/java}/structures/LinkedListNode.java | 20 +------ .../main/java}/structures/LocalQueue.java | 4 +- .../main/java}/structures/LocalStack.java | 2 +- .../main/java}/structures/MinStack.java | 15 +++-- .../main/java}/structures/MyQueue.java | 0 .../main/java}/structures/RandomSet.java | 0 .../main/java}/structures/StackOfPlates.java | 4 +- .../test/java}/TestArraysnStrings.java | 2 - .../test/java}/TestBitManipulation.java | 2 - .../test/java}/TestLinkedList.java | 6 +- .../test/java}/TestRandomSet.java | 3 - .../test/java}/TestRecursive.java | 3 - .../test/java}/TestSortingAndSearching.java | 2 - .../test/java}/TestStacksAndQueues.java | 2 - .../test/java}/TestTreesAndGraphs.java | 10 ++-- 32 files changed, 64 insertions(+), 223 deletions(-) delete mode 100644 Code Practice/.classpath delete mode 100644 Code Practice/.gitignore delete mode 100644 Code Practice/.project delete mode 100644 Code Practice/.settings/org.eclipse.jdt.core.prefs delete mode 100644 Code Practice/src/solutions/family_tree/FamilyTree.java delete mode 100644 Code Practice/src/structures/family_tree/FamilyDemograpgic.java delete mode 100644 Code Practice/src/testSuite/TestFamilyTree.java rename Code Practice/input.txt => input.txt (100%) create mode 100644 pom.xml rename {Code Practice/src => src/main/java}/solutions/ArraysnStrings.java (97%) rename {Code Practice/src => src/main/java}/solutions/BitManipulation.java (100%) rename {Code Practice/src => src/main/java}/solutions/HackerRank.java (100%) rename {Code Practice/src => src/main/java}/solutions/LinkedList.java (63%) rename {Code Practice/src => src/main/java}/solutions/Recursive.java (100%) rename {Code Practice/src => src/main/java}/solutions/SortingAndSearch.java (100%) rename {Code Practice/src => src/main/java}/solutions/TreesAndGraphs.java (100%) rename {Code Practice/src => src/main/java}/structures/BinaryTreeNode.java (100%) rename {Code Practice/src => src/main/java}/structures/LinkedListNode.java (81%) rename {Code Practice/src => src/main/java}/structures/LocalQueue.java (82%) rename {Code Practice/src => src/main/java}/structures/LocalStack.java (93%) rename {Code Practice/src => src/main/java}/structures/MinStack.java (76%) rename {Code Practice/src => src/main/java}/structures/MyQueue.java (100%) rename {Code Practice/src => src/main/java}/structures/RandomSet.java (100%) rename {Code Practice/src => src/main/java}/structures/StackOfPlates.java (93%) rename {Code Practice/src/testSuite => src/test/java}/TestArraysnStrings.java (98%) rename {Code Practice/src/testSuite => src/test/java}/TestBitManipulation.java (97%) rename {Code Practice/src/testSuite => src/test/java}/TestLinkedList.java (93%) rename {Code Practice/src/testSuite => src/test/java}/TestRandomSet.java (94%) rename {Code Practice/src/testSuite => src/test/java}/TestRecursive.java (97%) rename {Code Practice/src/testSuite => src/test/java}/TestSortingAndSearching.java (96%) rename {Code Practice/src/testSuite => src/test/java}/TestStacksAndQueues.java (94%) rename {Code Practice/src/testSuite => src/test/java}/TestTreesAndGraphs.java (97%) diff --git a/Code Practice/.classpath b/Code Practice/.classpath deleted file mode 100644 index 28e2b79..0000000 --- a/Code Practice/.classpath +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/Code Practice/.gitignore b/Code Practice/.gitignore deleted file mode 100644 index 5e56e04..0000000 --- a/Code Practice/.gitignore +++ /dev/null @@ -1 +0,0 @@ -/bin diff --git a/Code Practice/.project b/Code Practice/.project deleted file mode 100644 index 71f5873..0000000 --- a/Code Practice/.project +++ /dev/null @@ -1,17 +0,0 @@ - - - my-java-code-samples - - - - - - org.eclipse.jdt.core.javabuilder - - - - - - org.eclipse.jdt.core.javanature - - diff --git a/Code Practice/.settings/org.eclipse.jdt.core.prefs b/Code Practice/.settings/org.eclipse.jdt.core.prefs deleted file mode 100644 index 416f4fb..0000000 --- a/Code Practice/.settings/org.eclipse.jdt.core.prefs +++ /dev/null @@ -1,11 +0,0 @@ -eclipse.preferences.version=1 -org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled -org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 -org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve -org.eclipse.jdt.core.compiler.compliance=1.5 -org.eclipse.jdt.core.compiler.debug.lineNumber=generate -org.eclipse.jdt.core.compiler.debug.localVariable=generate -org.eclipse.jdt.core.compiler.debug.sourceFile=generate -org.eclipse.jdt.core.compiler.problem.assertIdentifier=error -org.eclipse.jdt.core.compiler.problem.enumIdentifier=error -org.eclipse.jdt.core.compiler.source=1.5 diff --git a/Code Practice/src/solutions/family_tree/FamilyTree.java b/Code Practice/src/solutions/family_tree/FamilyTree.java deleted file mode 100644 index 8bec6c6..0000000 --- a/Code Practice/src/solutions/family_tree/FamilyTree.java +++ /dev/null @@ -1,56 +0,0 @@ -package solutions.family_tree; - -import java.util.List; - -import structures.BinaryTreeNode; -import structures.family_tree.FamilyDemograpgic; - -public class FamilyTree { - public static BinaryTreeNode familyTree(FamilyDemograpgic fd, String name, int place) { - System.out.print("size is.. "); - System.out.println(place); - if(place == 0) { //no name - System.out.println("anonymous"); - return null; - }else if(place == 1) { //one person - System.out.println("single"); - return new BinaryTreeNode(1, name); - }else if (place == 2) { // single parent - System.out.println("one parent"); - return new BinaryTreeNode(2, name); - }else if (place == 3) { // family - System.out.println("one parent"); - return new BinaryTreeNode(3, name); - }else if(place == 5) { // community - System.out.println("family"); - return new BinaryTreeNode(5, name); - }else { - System.out.println("family"); - return new BinaryTreeNode(place, name); - } - } - - public static BinaryTreeNode familyTreeList(FamilyDemograpgic fd, List names) { - System.out.print("size is.. "); - System.out.println(names.size()); - if(names.size() == 0) { //no name - System.out.println("anonymous"); - return null; - }else if(names.size() == 1) { //one person - System.out.println("single"); - return new BinaryTreeNode(1, names.get(0)); - }else if (names.size() == 2) { // single parent - System.out.println("one parent"); - return new BinaryTreeNode(2, names); - }else if (names.size() == 3) { // family - System.out.println("one parent"); - return new BinaryTreeNode(3, names); - }else if(names.size() == 5) { // community - System.out.println("family"); - return new BinaryTreeNode(5, names); - }else { - System.out.println("family"); - return new BinaryTreeNode(names.size(), names); - } - } -} diff --git a/Code Practice/src/structures/family_tree/FamilyDemograpgic.java b/Code Practice/src/structures/family_tree/FamilyDemograpgic.java deleted file mode 100644 index 4538205..0000000 --- a/Code Practice/src/structures/family_tree/FamilyDemograpgic.java +++ /dev/null @@ -1,12 +0,0 @@ -package structures.family_tree; - -public final class FamilyDemograpgic { - int type = 0; //0 = orphan, 1 = single family, 2 = full family - - public FamilyDemograpgic(int dem){ - if(dem % 2 >= 2) { - type = -1; - } - type = dem; - } -} diff --git a/Code Practice/src/testSuite/TestFamilyTree.java b/Code Practice/src/testSuite/TestFamilyTree.java deleted file mode 100644 index 54bd867..0000000 --- a/Code Practice/src/testSuite/TestFamilyTree.java +++ /dev/null @@ -1,40 +0,0 @@ -package testSuite; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; - -import org.junit.Test; - -import structures.BinaryTreeNode; -import structures.family_tree.FamilyDemograpgic; -import solutions.family_tree.FamilyTree; - -public class TestFamilyTree { - - @Test - public void testGirl() { - System.out.println("lily says.. "); - BinaryTreeNode lily = FamilyTree.familyTree(new FamilyDemograpgic(2), "Lily Wilslet", 3); - assertEquals(lily.val,1); - assertNull(lily.left); - assertNull(lily.right); - System.out.println("lily says do my homework between here ?!?!?!"); - } - - @Test - public void testChang() { - System.out.println("Chang says..5 grown BP people "); - System.out.println("Chang says..4 brothers 1 sister"); - BinaryTreeNode mbuguss = FamilyTree.familyTree(new FamilyDemograpgic(2), "Chang-Hyun Mungai", 7); - assertEquals(mbuguss.val,1); - assertNull(mbuguss.left); - assertNull(mbuguss.right); - System.out.println("Chang-Hyun says do my homework between here ?!?!?!"); - } - - @Test - public void testShosho() { - System.out.println("Shosho says chiefs and fighters "); - } - -} diff --git a/Code Practice/input.txt b/input.txt similarity index 100% rename from Code Practice/input.txt rename to input.txt diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..d04f708 --- /dev/null +++ b/pom.xml @@ -0,0 +1,16 @@ + + 4.0.0 + com.example + my-java-code-samples + 1.0-SNAPSHOT + + + junit + junit + 4.13.2 + test + + + diff --git a/Code Practice/src/solutions/ArraysnStrings.java b/src/main/java/solutions/ArraysnStrings.java similarity index 97% rename from Code Practice/src/solutions/ArraysnStrings.java rename to src/main/java/solutions/ArraysnStrings.java index 4b4ff60..41e3502 100644 --- a/Code Practice/src/solutions/ArraysnStrings.java +++ b/src/main/java/solutions/ArraysnStrings.java @@ -12,6 +12,8 @@ public class ArraysnStrings { //ctci:P1.1 public static Boolean isUnique(String input){ + if(input == null || input.isEmpty()){ return true;} + Set seenCharacters = new HashSet(); for (char ch: input.toCharArray()){ if (seenCharacters.contains(ch)){ @@ -24,7 +26,9 @@ public static Boolean isUnique(String input){ //ctci:P1.1 public static Boolean isUniqueWOAddStructs(String input){ - int slen = input.length(); + if(input == null || input.isEmpty()){ return true;} + + int slen = input.length(); for (int i=0; i < slen-1; i++ ){ for (int j=i+1; j < slen; j++){ if (input.charAt(i) == input.charAt(j)){ diff --git a/Code Practice/src/solutions/BitManipulation.java b/src/main/java/solutions/BitManipulation.java similarity index 100% rename from Code Practice/src/solutions/BitManipulation.java rename to src/main/java/solutions/BitManipulation.java diff --git a/Code Practice/src/solutions/HackerRank.java b/src/main/java/solutions/HackerRank.java similarity index 100% rename from Code Practice/src/solutions/HackerRank.java rename to src/main/java/solutions/HackerRank.java diff --git a/Code Practice/src/solutions/LinkedList.java b/src/main/java/solutions/LinkedList.java similarity index 63% rename from Code Practice/src/solutions/LinkedList.java rename to src/main/java/solutions/LinkedList.java index a2b83fe..29996b4 100644 --- a/Code Practice/src/solutions/LinkedList.java +++ b/src/main/java/solutions/LinkedList.java @@ -8,10 +8,10 @@ public class LinkedList { public static LinkedListNode removeDuplicates(LinkedListNode head){ LinkedListNode n = head; int ndata; - while (n.getNext() != null) { - ndata=n.getData(); - n.setNext(LinkedListNode.deleteNode(n.getNext(),ndata)); - n = n.getNext(); + while (n.next != null) { + ndata=n.data; + n.next=LinkedListNode.deleteNode(n.next,ndata); + n = n.next; if (n == null){return head;} } return head; @@ -21,8 +21,8 @@ public static LinkedListNode removeDuplicates(LinkedListNode head){ public static LinkedListNode findNthLastElement(LinkedListNode head, int nth){ LinkedListNode n = head; int nf=0; - while (n.getNext() != null) { - n = n.getNext(); + while (n.next != null) { + n = n.next; nf++; } @@ -30,16 +30,16 @@ public static LinkedListNode findNthLastElement(LinkedListNode head, int nth){ if (nth <= 0){return head;} n = head; for (int i=0; iEND"); } - - public int getData(){ - return this.data; - } - - public void setData(int data2) { - this.data=data2; - } - - public LinkedListNode getNext() { - return this.next; - } - - public void setNext(LinkedListNode next2) { - this.next=next2; - } } diff --git a/Code Practice/src/structures/LocalQueue.java b/src/main/java/structures/LocalQueue.java similarity index 82% rename from Code Practice/src/structures/LocalQueue.java rename to src/main/java/structures/LocalQueue.java index 66c4bef..20418d4 100644 --- a/Code Practice/src/structures/LocalQueue.java +++ b/src/main/java/structures/LocalQueue.java @@ -7,7 +7,7 @@ void enqueue(int item){ last = new LinkedListNode(item); first=last; }else{ - last.setNext(new LinkedListNode(item)); + last.next =new LinkedListNode(item); last=last.next; } } @@ -15,7 +15,7 @@ void enqueue(int item){ LinkedListNode dequeue(LinkedListNode n){ if (first != null){ LinkedListNode item=first; - first = first.getNext(); + first = first.next; return item; } return null; diff --git a/Code Practice/src/structures/LocalStack.java b/src/main/java/structures/LocalStack.java similarity index 93% rename from Code Practice/src/structures/LocalStack.java rename to src/main/java/structures/LocalStack.java index c055114..786693d 100644 --- a/Code Practice/src/structures/LocalStack.java +++ b/src/main/java/structures/LocalStack.java @@ -8,7 +8,7 @@ public LocalStack() {} LinkedListNode pop(){ if (top != null){ LinkedListNode item=top; - top=top.getNext(); + top=top.next; return item; } return null; diff --git a/Code Practice/src/structures/MinStack.java b/src/main/java/structures/MinStack.java similarity index 76% rename from Code Practice/src/structures/MinStack.java rename to src/main/java/structures/MinStack.java index df20af1..e324ca5 100644 --- a/Code Practice/src/structures/MinStack.java +++ b/src/main/java/structures/MinStack.java @@ -16,16 +16,16 @@ LinkedListNode pop(){ private void updateMin() { if (this.top == null){ - min=null; + min = null; }else{ - min=this.top; - minData=this.top.getData(); + min = this.top; + minData = this.top.data; LinkedListNode n = this.top; while(n.next != null){ n=n.next; - if (n.getData() < minData){ + if (n.data < minData){ min=n; - minData=n.getData(); + minData=n.data; } } } @@ -37,14 +37,13 @@ void push(int item){ if (min == null){ super.push(item); min=this.top; - minData=this.top.getData(); + minData=this.top.data; }else{ if (minData > item){ super.push(item); min=this.top; - minData=this.top.getData(); + minData=this.top.data; } } } - } diff --git a/Code Practice/src/structures/MyQueue.java b/src/main/java/structures/MyQueue.java similarity index 100% rename from Code Practice/src/structures/MyQueue.java rename to src/main/java/structures/MyQueue.java diff --git a/Code Practice/src/structures/RandomSet.java b/src/main/java/structures/RandomSet.java similarity index 100% rename from Code Practice/src/structures/RandomSet.java rename to src/main/java/structures/RandomSet.java diff --git a/Code Practice/src/structures/StackOfPlates.java b/src/main/java/structures/StackOfPlates.java similarity index 93% rename from Code Practice/src/structures/StackOfPlates.java rename to src/main/java/structures/StackOfPlates.java index 69eb52f..8eb956f 100644 --- a/Code Practice/src/structures/StackOfPlates.java +++ b/src/main/java/structures/StackOfPlates.java @@ -16,14 +16,14 @@ LinkedListNode pop(){ if (currentStack != null){ if (currentStack.top != null){ LinkedListNode item=currentStack.top; - currentStack.top=currentStack.top.getNext(); + currentStack.top=currentStack.top.next; currentStackSize--; return item; }else if (currentStackIndex != 0){ currentStackIndex--; currentStack= toStack.get(currentStackIndex); LinkedListNode item=currentStack.top; - currentStack.top=currentStack.top.getNext(); + currentStack.top=currentStack.top.next; currentStackSize=maxElements-1; return item; } diff --git a/Code Practice/src/testSuite/TestArraysnStrings.java b/src/test/java/TestArraysnStrings.java similarity index 98% rename from Code Practice/src/testSuite/TestArraysnStrings.java rename to src/test/java/TestArraysnStrings.java index 7525217..85081cc 100644 --- a/Code Practice/src/testSuite/TestArraysnStrings.java +++ b/src/test/java/TestArraysnStrings.java @@ -1,5 +1,3 @@ -package testSuite; - import static org.junit.Assert.*; import org.junit.Test; diff --git a/Code Practice/src/testSuite/TestBitManipulation.java b/src/test/java/TestBitManipulation.java similarity index 97% rename from Code Practice/src/testSuite/TestBitManipulation.java rename to src/test/java/TestBitManipulation.java index eee1957..e2b4c67 100644 --- a/Code Practice/src/testSuite/TestBitManipulation.java +++ b/src/test/java/TestBitManipulation.java @@ -1,5 +1,3 @@ -package testSuite; - import static org.junit.Assert.*; import org.junit.Test; diff --git a/Code Practice/src/testSuite/TestLinkedList.java b/src/test/java/TestLinkedList.java similarity index 93% rename from Code Practice/src/testSuite/TestLinkedList.java rename to src/test/java/TestLinkedList.java index 7b71456..c507539 100644 --- a/Code Practice/src/testSuite/TestLinkedList.java +++ b/src/test/java/TestLinkedList.java @@ -1,5 +1,3 @@ -package testSuite; - import static org.junit.Assert.*; import org.junit.Test; @@ -38,7 +36,7 @@ public void testfindNthLastElement(){ int[] lLIA={0,1,2,3,4,5}; LinkedListNode lL=LinkedListNode.linkedListFromArray(lLIA); LinkedListNode thirdlast = LinkedList.findNthLastElement(lL, 3); - assertEquals("3rd last element is 2", 2, thirdlast.getData()); + assertEquals("3rd last element is 2", 2, thirdlast.data); } @Test @@ -46,7 +44,7 @@ public void testdeleteMiddleNode(){ int[] lLIA={0,1,2,3,4,5}; LinkedListNode lL=LinkedListNode.linkedListFromArray(lLIA); lL.printLinkedList(); - LinkedListNode middle=lL.getNext(); + LinkedListNode middle=lL.next; LinkedList.deleteMiddleNode(middle); lL.printLinkedList();; } diff --git a/Code Practice/src/testSuite/TestRandomSet.java b/src/test/java/TestRandomSet.java similarity index 94% rename from Code Practice/src/testSuite/TestRandomSet.java rename to src/test/java/TestRandomSet.java index 3ab716f..daaacb5 100644 --- a/Code Practice/src/testSuite/TestRandomSet.java +++ b/src/test/java/TestRandomSet.java @@ -1,6 +1,3 @@ -package testSuite; - - import org.junit.Test; import structures.RandomSet; diff --git a/Code Practice/src/testSuite/TestRecursive.java b/src/test/java/TestRecursive.java similarity index 97% rename from Code Practice/src/testSuite/TestRecursive.java rename to src/test/java/TestRecursive.java index 5dd53b2..098602f 100644 --- a/Code Practice/src/testSuite/TestRecursive.java +++ b/src/test/java/TestRecursive.java @@ -1,6 +1,3 @@ -package testSuite; - - import java.util.HashSet; import java.util.Iterator; import java.util.Set; diff --git a/Code Practice/src/testSuite/TestSortingAndSearching.java b/src/test/java/TestSortingAndSearching.java similarity index 96% rename from Code Practice/src/testSuite/TestSortingAndSearching.java rename to src/test/java/TestSortingAndSearching.java index 602bdfd..cebb16d 100644 --- a/Code Practice/src/testSuite/TestSortingAndSearching.java +++ b/src/test/java/TestSortingAndSearching.java @@ -1,5 +1,3 @@ -package testSuite; - import org.junit.Assert; import org.junit.Test; diff --git a/Code Practice/src/testSuite/TestStacksAndQueues.java b/src/test/java/TestStacksAndQueues.java similarity index 94% rename from Code Practice/src/testSuite/TestStacksAndQueues.java rename to src/test/java/TestStacksAndQueues.java index cdec8d1..53d0d77 100644 --- a/Code Practice/src/testSuite/TestStacksAndQueues.java +++ b/src/test/java/TestStacksAndQueues.java @@ -1,5 +1,3 @@ -package testSuite; - import static org.junit.Assert.*; import org.junit.Test; diff --git a/Code Practice/src/testSuite/TestTreesAndGraphs.java b/src/test/java/TestTreesAndGraphs.java similarity index 97% rename from Code Practice/src/testSuite/TestTreesAndGraphs.java rename to src/test/java/TestTreesAndGraphs.java index a9e092e..200ee4a 100644 --- a/Code Practice/src/testSuite/TestTreesAndGraphs.java +++ b/src/test/java/TestTreesAndGraphs.java @@ -1,5 +1,3 @@ -package testSuite; - import static org.junit.Assert.*; import java.util.ArrayList; @@ -52,16 +50,16 @@ public void testlinkedListPerDepth() { assertNotNull("llpd not null",llpd); assertEquals("llpd must have 3 linked lists", 3, llpd.length); assertNotNull("1st linked list not null",llpd[0]); - assertEquals("1st element in 1st linked list is 5", 5, llpd[0].getData()); + assertEquals("1st element in 1st linked list is 5", 5, llpd[0].data); assertNotNull("2nd linked list not null",llpd[1]); LinkedListNode ll = llpd[1]; boolean isSeven = false; boolean isThree = false; while(ll != null) { - if(ll.getData() == 7) {isSeven = true;} - if(ll.getData() == 3) {isThree = true;} - ll=ll.getNext(); + if(ll.data == 7) {isSeven = true;} + if(ll.data == 3) {isThree = true;} + ll=ll.next; } assertTrue("2nd linked list contains 5 and 7", isSeven && isThree); } From 95527c8e7f4fe92fefc2247b49482559b9583bf1 Mon Sep 17 00:00:00 2001 From: unboagable Date: Sat, 4 Jan 2025 10:52:28 -0500 Subject: [PATCH 12/19] Format spacing --- src/main/java/solutions/ArraysnStrings.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/solutions/ArraysnStrings.java b/src/main/java/solutions/ArraysnStrings.java index 41e3502..4777db0 100644 --- a/src/main/java/solutions/ArraysnStrings.java +++ b/src/main/java/solutions/ArraysnStrings.java @@ -14,7 +14,7 @@ public class ArraysnStrings { public static Boolean isUnique(String input){ if(input == null || input.isEmpty()){ return true;} - Set seenCharacters = new HashSet(); + Set seenCharacters = new HashSet(); for (char ch: input.toCharArray()){ if (seenCharacters.contains(ch)){ return false; From f0cd8c06de70c42c8cf691360e4b28adeb289b65 Mon Sep 17 00:00:00 2001 From: unboagable Date: Sat, 4 Jan 2025 10:54:38 -0500 Subject: [PATCH 13/19] Format spacing --- src/main/java/solutions/ArraysnStrings.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/main/java/solutions/ArraysnStrings.java b/src/main/java/solutions/ArraysnStrings.java index 4777db0..5e9b339 100644 --- a/src/main/java/solutions/ArraysnStrings.java +++ b/src/main/java/solutions/ArraysnStrings.java @@ -29,14 +29,14 @@ public static Boolean isUniqueWOAddStructs(String input){ if(input == null || input.isEmpty()){ return true;} int slen = input.length(); - for (int i=0; i < slen-1; i++ ){ - for (int j=i+1; j < slen; j++){ - if (input.charAt(i) == input.charAt(j)){ - return false; - } - } - } - return true; + for (int i=0; i < slen-1; i++ ){ + for (int j=i+1; j < slen; j++){ + if (input.charAt(i) == input.charAt(j)){ + return false; + } + } + } + return true; } //ctci:P1.2 From ca4e82b2fb1f8bb841209d665108dcfdab796aa6 Mon Sep 17 00:00:00 2001 From: unboagable Date: Sat, 4 Jan 2025 10:55:47 -0500 Subject: [PATCH 14/19] Format spacing --- src/main/java/solutions/ArraysnStrings.java | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/main/java/solutions/ArraysnStrings.java b/src/main/java/solutions/ArraysnStrings.java index 5e9b339..5102ad5 100644 --- a/src/main/java/solutions/ArraysnStrings.java +++ b/src/main/java/solutions/ArraysnStrings.java @@ -15,13 +15,13 @@ public static Boolean isUnique(String input){ if(input == null || input.isEmpty()){ return true;} Set seenCharacters = new HashSet(); - for (char ch: input.toCharArray()){ - if (seenCharacters.contains(ch)){ - return false; - } - seenCharacters.add(ch); - } - return true; + for (char ch: input.toCharArray()){ + if (seenCharacters.contains(ch)){ + return false; + } + seenCharacters.add(ch); + } + return true; } //ctci:P1.1 From 0610d2797a31b849d810df6d7fe106d54506427e Mon Sep 17 00:00:00 2001 From: unboagable Date: Sat, 4 Jan 2025 10:57:45 -0500 Subject: [PATCH 15/19] Format spacing --- src/main/java/solutions/ArraysnStrings.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/solutions/ArraysnStrings.java b/src/main/java/solutions/ArraysnStrings.java index 5102ad5..688b473 100644 --- a/src/main/java/solutions/ArraysnStrings.java +++ b/src/main/java/solutions/ArraysnStrings.java @@ -9,9 +9,9 @@ public class ArraysnStrings { - - //ctci:P1.1 - public static Boolean isUnique(String input){ + + //ctci:P1.1 + public static Boolean isUnique(String input){ if(input == null || input.isEmpty()){ return true;} Set seenCharacters = new HashSet(); @@ -25,7 +25,7 @@ public static Boolean isUnique(String input){ } //ctci:P1.1 - public static Boolean isUniqueWOAddStructs(String input){ + public static Boolean isUniqueWOAddStructs(String input){ if(input == null || input.isEmpty()){ return true;} int slen = input.length(); From 725c0ea130bcbb59b71ed07f50d9f441034de195 Mon Sep 17 00:00:00 2001 From: unboagable Date: Sat, 4 Jan 2025 10:58:45 -0500 Subject: [PATCH 16/19] Format spacing --- src/main/java/solutions/ArraysnStrings.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/solutions/ArraysnStrings.java b/src/main/java/solutions/ArraysnStrings.java index 688b473..73b8516 100644 --- a/src/main/java/solutions/ArraysnStrings.java +++ b/src/main/java/solutions/ArraysnStrings.java @@ -22,7 +22,7 @@ public static Boolean isUnique(String input){ seenCharacters.add(ch); } return true; - } + } //ctci:P1.1 public static Boolean isUniqueWOAddStructs(String input){ From 4c90ab16441e98d083a0d2173fdc428d04806ee2 Mon Sep 17 00:00:00 2001 From: unboagable Date: Sat, 4 Jan 2025 11:00:11 -0500 Subject: [PATCH 17/19] Format spacing --- src/main/java/solutions/ArraysnStrings.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/solutions/ArraysnStrings.java b/src/main/java/solutions/ArraysnStrings.java index 73b8516..d76c2d0 100644 --- a/src/main/java/solutions/ArraysnStrings.java +++ b/src/main/java/solutions/ArraysnStrings.java @@ -37,10 +37,10 @@ public static Boolean isUniqueWOAddStructs(String input){ } } return true; - } - - //ctci:P1.2 - public static String reverseString(String input){ + } + + //ctci:P1.2 + public static String reverseString(String input){ char[] inputCharA = input.toCharArray(); int length = input.length(); char[] outputCharA = new char[length]; @@ -50,7 +50,7 @@ public static String reverseString(String input){ outputCharA[i]=inputCharA[j]; } return String.valueOf(outputCharA); - } + } //helper removeDuplicates static void moveOneBack(char[] str, int i){ From 2917e0567795d6c53acb114d306e19f0679ba953 Mon Sep 17 00:00:00 2001 From: unboagable Date: Sat, 4 Jan 2025 11:02:05 -0500 Subject: [PATCH 18/19] Format spacing --- src/main/java/solutions/ArraysnStrings.java | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/src/main/java/solutions/ArraysnStrings.java b/src/main/java/solutions/ArraysnStrings.java index d76c2d0..e9b9067 100644 --- a/src/main/java/solutions/ArraysnStrings.java +++ b/src/main/java/solutions/ArraysnStrings.java @@ -23,8 +23,8 @@ public static Boolean isUnique(String input){ } return true; } - - //ctci:P1.1 + + //ctci:P1.1 public static Boolean isUniqueWOAddStructs(String input){ if(input == null || input.isEmpty()){ return true;} @@ -51,19 +51,19 @@ public static String reverseString(String input){ } return String.valueOf(outputCharA); } - - //helper removeDuplicates - static void moveOneBack(char[] str, int i){ + + //helper removeDuplicates + static void moveOneBack(char[] str, int i){ char cc=str[i]; while (cc != '\0'){ str[i]=str[i+1]; i=i+1; cc=str[i]; } - } - - //ctci:P1.3 - public static void removeDuplicates(char[] str) { + } + + //ctci:P1.3 + public static void removeDuplicates(char[] str) { int i=0; int j; while(str[i]!= '\0'){ @@ -222,5 +222,4 @@ private LinkedList> allPalindromesForEmpty(String[] words, int myi } return sol; } - } From 6373d0b8f99f5578331297847b1fc1b6bc49d4ab Mon Sep 17 00:00:00 2001 From: unboagable Date: Sat, 4 Jan 2025 11:08:03 -0500 Subject: [PATCH 19/19] Format spacing --- src/main/java/solutions/ArraysnStrings.java | 68 +++++++++++---------- 1 file changed, 35 insertions(+), 33 deletions(-) diff --git a/src/main/java/solutions/ArraysnStrings.java b/src/main/java/solutions/ArraysnStrings.java index e9b9067..e1feff1 100644 --- a/src/main/java/solutions/ArraysnStrings.java +++ b/src/main/java/solutions/ArraysnStrings.java @@ -41,30 +41,30 @@ public static Boolean isUniqueWOAddStructs(String input){ //ctci:P1.2 public static String reverseString(String input){ - char[] inputCharA = input.toCharArray(); - int length = input.length(); - char[] outputCharA = new char[length]; - int j; - for (int i= 0; i < length; i++){ - j=length-1-i; - outputCharA[i]=inputCharA[j]; - } - return String.valueOf(outputCharA); + char[] inputCharA = input.toCharArray(); + int length = input.length(); + char[] outputCharA = new char[length]; + int j; + for (int i= 0; i < length; i++){ + j=length-1-i; + outputCharA[i]=inputCharA[j]; + } + return String.valueOf(outputCharA); } //helper removeDuplicates static void moveOneBack(char[] str, int i){ - char cc=str[i]; - while (cc != '\0'){ - str[i]=str[i+1]; - i=i+1; - cc=str[i]; - } - } + char cc=str[i]; + while (cc != '\0'){ + str[i]=str[i+1]; + i=i+1; + cc=str[i]; + } + } //ctci:P1.3 public static void removeDuplicates(char[] str) { - int i=0; + int i=0; int j; while(str[i]!= '\0'){ j=i+1; @@ -78,32 +78,34 @@ public static void removeDuplicates(char[] str) { i++; } } - - //ctci:P1.4 - public static boolean isAnagram(String str1, String str2){ - Map let2char = new HashMap(); //letter to character - //counts letters in str1 - for (char c: str1.toCharArray()){ + //ctci:P1.4 + public static boolean isAnagram(String str1, String str2){ + Map let2char = new HashMap(); //letter to character + + // counts letters in str1 + for (char c: str1.toCharArray()){ if ( let2char.containsKey(c)){ let2char.put(c, let2char.get(c) + 1); - } - else{ + }else{ let2char.put(c, 1); } } - int ccount; + int ccount; for (char c: str2.toCharArray()){ if ( let2char.containsKey(c)){ ccount=let2char.get(c); - if (ccount -1 == 0){let2char.remove(c);} - else {let2char.put(c, ccount-1);} - } - else{ return false;} - } - if (let2char.size() == 0){ return true;} - return false; + if (ccount -1 == 0){ + let2char.remove(c); + }else { + let2char.put(c, ccount-1); + } + }else{ + return false; + } + } + return let2char.isEmpty(); } //leetcode Palindrome Pairs