public void PermutationsWithDuplicatesResultsInSucess()
{
int[] nums = new int[] { 1, 1, 2 };
var expectedResult = new List <IList <int> >()
{
new List <int>()
{
1, 1, 2
},
new List <int>()
{
1, 2, 1
},
new List <int>()
{
2, 1, 1
}
};
var result = new PermutationsWithDuplicates().PermuteUnique(nums);
var areEqual = CollectionsAreEqual.AreEqualListOfLists <int>(result, (IList <IList <int> >)expectedResult);
Assert.IsTrue(areEqual);
}
public void GroupAnagramSuccess()
{
string[] input = new string[] { "eat", "tea", "tan", "ate", "nat", "bat" };
var expectedResult = new List <IList <string> >()
{
new List <string>()
{
"eat", "tea", "ate"
},
new List <string>()
{
"tan", "nat"
},
new List <string>()
{
"bat"
}
};
var result = new GroupAnagramsSolution().GroupAnagrams(input);
var isEqual = CollectionsAreEqual.AreEqualListOfLists(result, expectedResult);
Assert.IsTrue(isEqual);
}
public void BinaryTreePathResultsInSucessForIterativeImplementation()
{
var treeNode1 = new TreeNode(1);
var treeNode2 = new TreeNode(2);
var treeNode3 = new TreeNode(3);
var treeNode5 = new TreeNode(5);
treeNode1.Left = treeNode2;
treeNode1.Right = treeNode3;
treeNode2.Right = treeNode5;
var expectedResult = new List <string>()
{
"1->2->5",
"1->3"
};
var result = new BinaryTreePaths().BinaryTreePathsIterative(treeNode1);
var areEqual = CollectionsAreEqual.AreEqual <string>(result, expectedResult);
Assert.IsTrue(areEqual);
}
public void CloneGraphSolutionResultsInSuccess()
{
var node1 = new Node(1, new List <Node>());
var node2 = new Node(2, new List <Node>());
var node3 = new Node(3, new List <Node>());
var node4 = new Node(4, new List <Node>());
node1.neighbors.Add(node2);
node1.neighbors.Add(node4);
node2.neighbors.Add(node1);
node2.neighbors.Add(node3);
node3.neighbors.Add(node2);
node3.neighbors.Add(node4);
node4.neighbors.Add(node1);
node4.neighbors.Add(node3);
var expectedResult = DFS(node1);
var result = new CloneGraph().CloneGraphSolution(node1);
var actualResult = DFS(result);
var areEqual = CollectionsAreEqual.AreEqual(actualResult, expectedResult, new GraphComparer());
Assert.IsTrue(areEqual);
}
public void BFSTraversalIterativeSuccess()
{
TreeNode root = new TreeNode(3);
var node9 = root.Left = new TreeNode(9);
var node20 = root.Right = new TreeNode(20);
node20.Left = new TreeNode(15);
node20.Right = new TreeNode(7);
var expectedResult = new List <List <int> >()
{
new List <int>()
{
3
},
new List <int>()
{
9, 20
},
new List <int>()
{
15, 7
},
};
var result = (List <List <int> >) new BFSTraversal().LevelOrder(root);
var areEqual = CollectionsAreEqual.AreEqualListOfLists(result, expectedResult);
}
public void LetterCombinationResultsInSuccess()
{
var expectedResult = new List <string>
{
"ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"
};
var result = new LetterCombinations().LetterCombinationsSolution("23");
var areEqual = CollectionsAreEqual.AreEqual <string>(result, expectedResult);
Assert.IsTrue(areEqual);
}
public void PreOrderInOrderTraversalRecursive_Success()
{
var preorder = new int[] { 3, 9, 20, 15, 7 };
var inorder = new int[] { 9, 3, 15, 20, 7 };
var result = new ConstructBinaryTreefromPreorderInorderTraversal().BuildTreeRecursive(preorder, inorder);
var preOrderTraversalResult = PreOrderTraversal(result);
var areEqual = CollectionsAreEqual.AreEqual <int>(preorder, preOrderTraversalResult);
Assert.IsNotNull(result);
Assert.IsTrue(areEqual);
}
public void PreOrderPostOrderTraversal_Success()
{
var preorder = new int[] { 1, 2, 4, 8, 9, 5, 3, 6, 7 };
var postorder = new int[] { 8, 9, 4, 5, 2, 6, 7, 3, 1 };
var result = new ConstructBinaryTreefromPreorderPostorderTraversal().BuildTree(preorder, postorder);
var preOrderTraversalResult = PreOrderTraversal(result);
var areEqual = CollectionsAreEqual.AreEqual <int>(preorder, preOrderTraversalResult);
Assert.IsNotNull(result);
Assert.IsTrue(areEqual);
}
public void ConstructBinaryTreeFromInorderPostorderTraversalSuccess()
{
var postorder = new int[] { 9, 15, 7, 20, 3 };
var inorder = new int[] { 9, 3, 15, 20, 7 };
var result = new ConstructBinaryTreeFromInorderPostorderTraversal().BuildTree(inorder, postorder);
var inOrderTraversalResult = new InOrderTraversalIterative().InOrderTraversal(result);
var areEqual = CollectionsAreEqual.AreEqual <int>(inorder, inOrderTraversalResult);
Assert.IsNotNull(result);
Assert.IsTrue(areEqual);
}
public void RemoveParenThesisResultsInSuccess()
{
string input = "()())()";
List <string> expectedResult = new List <string>()
{
"(())()",
"()()()",
};
var result = new RemoveInvalidParenthesesSolution().RemoveInvalidParentheses(input);
var areEqual = CollectionsAreEqual.AreEqual(result, expectedResult);
Assert.IsTrue(areEqual);
}
public void VerticalOrderTraversalWhenSingleNodeResultsInSuccess()
{
TreeNode node = new TreeNode(1);
var result = new BinaryTreeVerticalOrderTraversal().VerticalOrder(node);
var expectedResult = new List <List <int> >()
{
new List <int> {
1
}
};
var areEqual = CollectionsAreEqual.AreEqualListOfLists(result, expectedResult);
Assert.IsTrue(areEqual);
}
public void SubsSetTestsResultsInSucess()
{
int[] nums = new int[] { 1, 2, 3 };
var expectedResult = new List <IList <int> >()
{
new List <int>(),
new List <int>()
{
1
},
new List <int>()
{
2
},
new List <int>()
{
3
},
new List <int>()
{
1, 2
},
new List <int>()
{
1, 3
},
new List <int>()
{
2, 3
},
new List <int>()
{
1, 2, 3
}
};
var result = new SubSet().Subsets(nums);
var areEqual = CollectionsAreEqual.AreEqualListOfLists <int>(result, (IList <IList <int> >)expectedResult);
Assert.IsTrue(areEqual);
}
public void TravesalSuccess()
{
TreeNode node3 = new TreeNode(3);
TreeNode node9 = new TreeNode(9);
TreeNode node20 = new TreeNode(20);
TreeNode node15 = new TreeNode(15);
TreeNode node7 = new TreeNode(7);
node3.left = node9;
node3.right = node20;
node20.left = node15;
node20.right = node7;
List <IList <int> > expectedResult = new List <IList <int> >()
{
new List <int>()
{
3
},
new List <int>()
{
20, 9
},
new List <int>()
{
15, 7
}
};
var result = new ZigzagTraversal().ZigzagLevelOrder(node3);
var areEqual = CollectionsAreEqual.AreEqualListOfLists(result, expectedResult);
Assert.IsTrue(areEqual);
}
public void VerticalOrderTraversalResultsInSuccess()
{
var treeNode3 = new TreeNode(3);
var treeNode9 = new TreeNode(9);
var treeNode20 = new TreeNode(20);
var treeNode15 = new TreeNode(15);
var treeNode7 = new TreeNode(7);
treeNode3.Left = treeNode9;
treeNode3.Right = treeNode20;
treeNode20.Left = treeNode15;
treeNode20.Right = treeNode7;
var expectedResult = new List <List <int> >()
{
new List <int> {
9
},
new List <int> {
3, 15
},
new List <int> {
20
},
new List <int> {
7
}
};
var result = new BinaryTreeVerticalOrderTraversal().VerticalOrder(treeNode3);
var areEqual = CollectionsAreEqual.AreEqualListOfLists(result, expectedResult);
Assert.IsTrue(areEqual);
}
public void MissingRangeTests_Success()
{
int[] nums = new int[] { 0, 1, 3, 50, 75 };
List <string> expectedResult = new List <string>()
{
"2", "4->49", "51->74", "76->99"
};
var result = new MissingRanges().FindMissingRanges(nums, 0, 99);
var areEqual = CollectionsAreEqual.AreEqual(result, expectedResult);
Assert.IsTrue(areEqual);
nums = new int[] { -1 };
expectedResult = new List <string>()
{
"-2"
};
result = new MissingRanges().FindMissingRanges(nums, -2, -1);
areEqual = CollectionsAreEqual.AreEqual(result, expectedResult);
Assert.IsTrue(areEqual);
}
