public void LevelOrderTest(int treeIndex, string expected) { var tree = _trees[treeIndex]; string result = string.Join(",", Traversals.LevelOrder(tree[0], tree.GetChildren).Select(node => node.ToString())); Assert.AreEqual(expected, result); }
//static void Main(string[] args) // { // var root = new TreeNode<int>(4); // root.left = new TreeNode<int>(2); // root.right = new TreeNode<int>(7); // root.left.left = new TreeNode<int>(1); // root.left.right = new TreeNode<int>(3); // root.right.left = new TreeNode<int>(6); // root.right.right = new TreeNode<int>(9); //DFSTraverse(root, Traversals.PreOrder); //} public static void DFSTraverse(TreeNode <int> node, Traversals type) { if (node == null) { return; } switch (type) { case Traversals.PreOrder: Console.WriteLine(node.data); DFSTraverse(node.left, Traversals.PreOrder); DFSTraverse(node.right, Traversals.PreOrder); Console.WriteLine(node.data.ToString() + " Done"); break; case Traversals.InOrder: DFSTraverse(node.left, Traversals.InOrder); Console.WriteLine(node.data); DFSTraverse(node.right, Traversals.InOrder); break; case Traversals.PostOrder: DFSTraverse(node.left, Traversals.PostOrder); DFSTraverse(node.right, Traversals.PostOrder); Console.WriteLine(node.data); break; default: break; } }
public void StatelessInOrderTest(int treeIndex, string expected) { BinaryNode[] tree = _trees[treeIndex]; string result = string.Join(",", Traversals.StatelessInOrder(tree[0], tree.GetLeft, tree.GetRight, tree.GetParent).Select(node => node.ToString())); Assert.AreEqual(expected, result); }
internal static PredictedMove CalculateMove(int size, PredictedMove previousMove, Direction direction) { int score = (int)previousMove.NewScore; Grid2048 previousGrid = new Grid2048(previousMove.Grid); bool moved = false; Coord cell; DigTile tile; Coord vector = GetDirectionalOffset(direction); Traversals traversals = Traversals.BuildTraversals(size, vector); foreach (int x in traversals.x) { foreach (int y in traversals.y) { cell = new Coord(x, y); tile = previousGrid.CellContent(cell); if (tile != null) { FarthestPosition positions = FindFarthestPosition(previousGrid, cell, vector); DigTile next = previousGrid.CellContent(positions.Next); if (next != null && next.Value == tile.Value && next.MergedFrom == null) { DigTile merged = new DigTile(positions.Next, tile.Value * 2) { MergedFrom = new List <DigTile> { tile, next } }; previousGrid.InsertTile(merged); previousGrid.RemoveTile(tile); tile.UpdatePosition(positions.Next); score += merged.Value; } else { MoveTile(previousGrid, tile, positions.Farthest); } if (!PositionsEqual(cell, tile)) { moved = true; } } } } return(new PredictedMove(moved ? score : -1, previousGrid, direction)); }
char GetRandomNode(Node root) { string traversalString = string.Empty; traversalString = Traversals.InOrder(root, traversalString); Random rnd = new Random(); int randomNumber = rnd.Next(0, traversalString.Length); return(traversalString[randomNumber]); }
public TransactionContextState GetExpectedCommitState() { if (Traversals.LevelOrder(this.GetController(), node => node.Children.Where(child => !child.IsController)).All(node => node.VoteAction == VoteAction.VoteCommit)) { return(TransactionContextState.ToBeCommitted); } else { return(TransactionContextState.ToBeRollbacked); } }
public void GetNameOfGrandchildOfSaturn() { //saturn.in('father').in('father').name var v = new WeaverVarAlias <Character>("saturn"); IWeaverQuery q = Traversals.GetGrandchildOfCharacter(v) .Property(x => x.Name) .ToQuery(); string expectScript = "saturn.inE('father').outV.inE('father').outV.property('name');"; Assert.AreEqual(expectScript, q.Script, "Incorrect script."); }
public void GetSaturn() { //saturn = g.V('name','saturn').next() IWeaverVarAlias <Examples.Core.Vertices.Titan> v; IWeaverQuery q = Traversals.GetCharacterByName <Examples.Core.Vertices.Titan>( "saturn", "saturn", out v); string expectScript = "saturn=g.V('name',_P0).next();"; Assert.AreEqual(expectScript, q.Script, "Incorrect script."); Assert.AreEqual("saturn", v.Name, "Incorrect Alias.Name."); var expectParams = new Dictionary <string, IWeaverQueryVal>(); expectParams.Add("_P0", new WeaverQueryVal("saturn")); WeaverTestUtil.CheckQueryParamsOriginalVal(q, expectParams); }
static void Main(string[] args) { Graph g = new Graph(); g.AddVertex("0"); g.AddVertex("1"); g.AddVertex("2"); g.AddVertex("3"); g.AddEdge("0", "1"); g.AddEdge("0", "2"); g.AddEdge("1", "2"); g.AddEdge("2", "3"); g.AddEdge("3", "3"); //Traversals.DFS(g,"2"); Traversals.BFS(g, "2"); }
public List <T> ToList(Traversals traver) { List <T> result = new List <T>(); switch (traver) { case Traversals.PreOrderTraversal: PreOrderTraversal(result.Add); break; case Traversals.InOrderTraversal: InOrderTraversal(result.Add); break; case Traversals.PostOrderTraversal: PostOrderTraversal(result.Add); break; } return(result); }
bool isSubTreeUsingStringComparison(Node bigTree, Node smallTree) { string bigTreePreOrderString = string.Empty; bigTreePreOrderString = Traversals.PreOrderWithNulls(bigTree, bigTreePreOrderString); string bigTreeInOrderString = string.Empty; bigTreeInOrderString = Traversals.InOrderWithNulls(bigTree, bigTreeInOrderString); string smallTreePreOrderString = string.Empty; smallTreePreOrderString = Traversals.PreOrderWithNulls(smallTree, smallTreePreOrderString); string smallTreeInOrderString = string.Empty; smallTreeInOrderString = Traversals.InOrderWithNulls(smallTree, smallTreeInOrderString); return(bigTreeInOrderString.Contains(smallTreeInOrderString) && bigTreePreOrderString.Contains(smallTreePreOrderString)); }
public static Traversals BuildTraversals(int size, Coord vector) { Traversals traversals = new Traversals(); for (int pos = 0; pos < size; pos++) { traversals.x.Add(pos); traversals.y.Add(pos); } if (vector.x > 0) { traversals.x.Reverse(); } if (vector.y > 0) { traversals.y.Reverse(); } return(traversals); }
public static IEnumerable <string> EnumerateDirectories(string path, string searchPattern = "*.*", SearchOption searchOption = SearchOption.TopDirectoryOnly) { if (string.IsNullOrEmpty(path)) { throw new ArgumentNullException(nameof(path)); } if (string.IsNullOrEmpty(searchPattern)) { throw new ArgumentNullException(nameof(searchPattern)); } Func <string, IEnumerable <string> > getChildren = child => SafeGetFileSystemEnumerable(() => Directory.EnumerateDirectories(child, searchPattern, SearchOption.TopDirectoryOnly)); if (searchOption == SearchOption.TopDirectoryOnly) { return(getChildren(path)); } else { return(Traversals.LevelOrder(path, getChildren)); } }
public static void Main(string[] args) { System.Console.WriteLine("LinkList Sample"); SinglyLinkedList <int> primeNumbers = new SinglyLinkedList <int>(); // first we'll add the middle element. Then try the AddToFront with 3 and then try the AddToBack with 7 // generating the final sequence as 3, 5, 7 primeNumbers.AddToFront(5); primeNumbers.AddToFront(3); primeNumbers.AddToBack(7); primeNumbers.AddToBack(9); primeNumbers.AddToBack(8); primeNumbers.AddToBack(7); primeNumbers.Remove(8); primeNumbers.RemoveLast(); PrintHelpers.PrintFromNode(primeNumbers.Head); System.Console.WriteLine("Stack Sample: "); PostfixCalculator postfixCalculator = new PostfixCalculator(); int result = postfixCalculator.calculate("5 6 7 * + 1 -"); System.Console.WriteLine($"The postfix expression result is: {result}"); System.Console.WriteLine("Binary Search Tree Sample:"); BinaryTree <int> binaryTree = new BinaryTree <int>(); binaryTree.Add(3); binaryTree.Add(7); binaryTree.Add(5); binaryTree.Add(4); binaryTree.Add(6); binaryTree.Add(8); binaryTree.Add(11); binaryTree.Add(1); System.Console.WriteLine($"Contains 5: {binaryTree.Contains(5)}"); System.Console.WriteLine($"Contains 6: {binaryTree.Contains(6)}"); System.Console.WriteLine($"Contains 1: {binaryTree.Contains(1)}"); System.Console.WriteLine($"Remove 9 op result: {binaryTree.Remove(9)}"); System.Console.WriteLine($"Remove 7 op result: {binaryTree.Remove(7)}"); System.Console.WriteLine("Traversal Outputs:"); Traversals <int> traversals = new Traversals <int>(); IReadOnlyCollection <int> preOrder = traversals.PreorderTraversal(binaryTree); IReadOnlyCollection <int> inOrder = traversals.InorderTraversal(binaryTree); IReadOnlyCollection <int> postOrder = traversals.PostorderTraversal(binaryTree); System.Console.WriteLine($"Postorder: {string.Join(", ", preOrder)}"); System.Console.WriteLine($"Inorder: {string.Join(", ", inOrder)}"); System.Console.WriteLine($"Postorder: {string.Join(", ", postOrder)}"); }
public BinaryTree() { this.Root = null; this.Traversal = Traversals.PreOrderTraversal; }
// Move tiles on the grid in the specified direction private void InternalMove(MoveDirection direction) { if (IsGameTerminated()) { return; // Don't do anything if the game's over } GameTile tile = null; var vector = GetVector(direction); var traversals = new Traversals(_size, vector); var moved = false; // Save the current tile positions and remove merger information PrepareTiles(); // Traverse the grid in the right direction and move tiles foreach (var x in traversals.Xs) { foreach (var y in traversals.Ys) { var cell = new CellPosition(x, y); tile = _grid.CellContent(cell); if (null != tile) { var positions = FindFarthestPosition(cell, vector); var next = _grid.CellContent(positions.Next); // Only one merger per row traversal? if (null != next && next.Value == tile.Value && (null == next.MergedFrom)) { var merged = new GameTile(positions.Next, tile.Value * 2); merged.MergedFrom = new MergeTile(tile.Position, next.Position); _grid.InsertTile(merged); _grid.RemoveTile(tile); // Converge the two tiles' positions tile.UpdatePosition(positions.Next); // Update the score Score += merged.Value; // The mighty 2048 tile if (merged.Value == _winingTileValue) { Won = true; } } else { MoveTile(tile, positions.Farthest); } if (!cell.IsEqual(tile.Position)) { moved = true; // The tile moved from its original cell! } } } } if (moved) { AddRandomTile(); if (!MovesAvailable()) { Over = true; // Game over! } Actuate(); } }
static void Main(string[] args) { Mine mine = new Mine(); int[][] twoD = new int[2][]; twoD[0] = new int[] { 0, 0 }; twoD[1] = new int[] { 0, 1 }; int[,] field = mine.Minesweeper(twoD, 3, 4); int mRow = field.GetUpperBound(0); int mCol = field.GetUpperBound(1); for (int r = 0; r <= mRow; r++) { for (int c = 0; c <= mCol; c++) { Console.Write(field[r, c] + " "); } Console.WriteLine(""); } int[] bst = { 2, 3, 4, 10, 40 }; BinarySearch binarySearch = new BinarySearch(); int n = bst.Length; int x = 10; Console.WriteLine("Recurcive: The index is " + binarySearch.BinarySearchRecursive(bst, 0, n - 1, x)); Console.WriteLine("Itirative: The index is " + binarySearch.BinarySearchItirative(bst, x)); var path = new List <int>(); var Prev = new Dictionary <int, int>(); Console.WriteLine(string.Join(", ", search.DFS(unDirectedgraph, 1))); Console.WriteLine(string.Join(", ", search.BFS(unDirectedgraph, 1, ref Prev, v => path.Add(v)))); Console.WriteLine("Trace Path..."); Console.WriteLine(string.Join(", ", path)); foreach (var vertex in vertices) { Console.WriteLine("shortest path to {0,2}: {1}", vertex, string.Join(", ", search.ShortestPathFromPrev(Prev, 1, vertex))); } Console.WriteLine("Topological Sort...."); Console.WriteLine(string.Join(", ", TopSort())); Console.WriteLine("Is 'create' anagram of 'eaterc'? : " + anagram.isAnagram("create", "eaterc")); void checkPalindrome(string str) { Palindrome p = new Palindrome(); Console.WriteLine("Is this word a palindrome? " + str); Console.WriteLine(p.isPalidrome(str, false)); }; checkPalindrome("hello"); checkPalindrome("motor"); checkPalindrome("rotor"); Misc misc = new Misc(); int[] arr1 = { 5, 6, 1, 2, 3, 4 }; int n1 = arr1.Length; Console.WriteLine("The minimum element is " + misc.FindMinInSortedRotated(arr1, 0, n1 - 1)); int[] arr2 = { 1, 2, 3, 4 }; int n2 = arr2.Length; Console.WriteLine("The minimum element is " + misc.FindMinInSortedRotated(arr2, 0, n2 - 1)); int[] arr3 = { 1 }; int n3 = arr3.Length; Console.WriteLine("The minimum element is " + misc.FindMinInSortedRotated(arr3, 0, n3 - 1)); int[] arr4 = { 1, 2 }; int n4 = arr4.Length; Console.WriteLine("The minimum element is " + misc.FindMinInSortedRotated(arr4, 0, n4 - 1)); int[] arr5 = { 2, 1 }; int n5 = arr5.Length; Console.WriteLine("The minimum element is " + misc.FindMinInSortedRotated(arr5, 0, n5 - 1)); int[] arr6 = { 5, 6, 7, 1, 2, 3, 4 }; int n6 = arr6.Length; Console.WriteLine("The minimum element is " + misc.FindMinInSortedRotated(arr6, 0, n1 - 1)); int[] arr7 = { 1, 2, 3, 4, 5, 6, 7 }; int n7 = arr7.Length; Console.WriteLine("The minimum element is " + misc.FindMinInSortedRotated(arr7, 0, n7 - 1)); int[] arr8 = { 2, 3, 4, 5, 6, 7, 8, 1 }; int n8 = arr8.Length; Console.WriteLine("The minimum element is " + misc.FindMinInSortedRotated(arr8, 0, n8 - 1)); int[] arr9 = { 3, 4, 5, 1, 2 }; int n9 = arr9.Length; Console.WriteLine("The minimum element is " + misc.FindMinInSortedRotated(arr9, 0, n9 - 1)); int[] arr = { 64, 34, 25, 12, 22, 11, 90 }; BubbleSort bSort = new BubbleSort(); bSort.Sort(arr); Console.Write("arr = { 64, 34, 25, 12, 22, 11, 90 } => Sorted array = "); printArray(arr); int[] ar = { 99, 44, 6, 2, 1, 5, 63, 87, 283, 4, 0 }; QuickSort qs = new QuickSort(); qs.Quick_Sort(ar); Console.Write("arr = { 99, 44, 6, 2, 1, 5, 63, 87, 283, 4, 0} => Insertion Sorted array = "); printArray(ar); int[] arr_1 = { 64, 34, 25, 12, 22, 11, 90 }; SelectionSort sSort = new SelectionSort(); sSort.Sort(arr_1); Console.Write("arr_1 = { 64, 34, 25, 12, 22, 11, 90 } => Sorted array = "); printArray(arr_1); WordLadder wordLadder = new WordLadder(); string strpath = ""; int i = wordLadder.LadderLength("hit", "cog", ref strpath); Console.WriteLine(strpath); HammingWeight hw = new HammingWeight(); int[] hw_1 = { 31, 51 }; Console.WriteLine("Hamming Weight of hw_1 = { 31,51} = " + hw.GetHammingWeightbyPreprocessing(hw_1)); Fibonacci fib = new Fibonacci(); Console.WriteLine("6th Fibonacci number by rec is : " + fib.FibRecursive(6)); Console.WriteLine("6th Fibonacci number by DP is : " + fib.FibDP(6)); Console.WriteLine("6th Fibonacci number by Bottomup is : " + fib.FibBottomUp(6)); Subsets subsets = new Subsets(); int[] arrSS = new int[] { 2, 4, 6, 10 }; Console.WriteLine("No. of subsets whose sum is 16 in { 2, 4, 6, 10 } : " + subsets.CountSubsetsDP(arrSS, 16)); HasPairWithSum obj = new HasPairWithSum(); Console.WriteLine("Does the array { 2, 4, 6, 10 } has a pair whose sum is 12: " + obj.isPairWithSumExists(arrSS, 12)); MergeArrays ma = new MergeArrays(); int[] arrSorted2 = new int[] { 0, 3, 4 }; int[] arrSorted1 = new int[] { 2, 4, 6, 10 }; Console.WriteLine("Merged Sorted array for the sorted arrays { 0, 3, 4} and { 2, 4, 6, 10 } : "); printArray(ma.MergeSortedArrays(arrSorted1, arrSorted2)); MoveZeros mz = new MoveZeros(); Console.WriteLine("Move Zeros from {0,0,1} "); int[] mzA = new int[] { 0, 0, 1 }; mz.MoveZeroes(mzA); printArray(mzA); FirstRecurring fr = new FirstRecurring(); int[] fra = new int[] { 2, 5, 1, 2, 3, 5, 1, 2, 4 }; Console.WriteLine("First recurring element in { 2, 5, 1, 2, 3, 5, 1, 2, 4 } is: " + fr.GetFirstRecurringElement <int>(fra)); Islands il = new Islands(); int[,] M = new int[, ] { { 1, 1, 0, 0, 0 }, { 0, 1, 0, 0, 1 }, { 1, 0, 0, 1, 1 }, { 0, 0, 0, 0, 0 }, { 1, 0, 1, 0, 1 } }; Console.Write("Number of islands is: " + il.countIslands(M)); LongestPalindromicSubstring lss = new LongestPalindromicSubstring(); Console.Write("LongestPalindrome in 'babad' : " + lss.LongestPalindrome("cbbd")); BinaryTree tree = new BinaryTree(); tree.root = new TreeNode(1); tree.root.left = new TreeNode(2); tree.root.right = new TreeNode(3); tree.root.left.left = new TreeNode(4); tree.root.left.right = new TreeNode(5); Console.WriteLine(""); Traversals trav = new Traversals(); trav.printInorder(tree.root); Console.WriteLine(""); trav.printPreorder(tree.root); Console.WriteLine(""); trav.printPostOrder(tree.root); Console.WriteLine(""); Console.Write("The height of the tree is : " + trav.GetTreeHeight(tree.root)); Console.WriteLine("Level Order:"); trav.LevelOrderTraversal(tree.root); }
private void Move(Direction direction) { Coord cell; DigTile tile; Coord vector = GetDirectionalOffset(direction); Traversals traversals = Traversals.BuildTraversals(Size, vector); bool moved = false; PrepareTiles(); foreach (int x in traversals.x) { foreach (int y in traversals.y) { cell = new Coord(x, y); tile = grid.CellContent(cell); if (tile != null) { FarthestPosition positions = FindFarthestPosition(cell, vector); DigTile next = grid.CellContent(positions.Next); if (next != null && next.Value == tile.Value && next.MergedFrom == null) { DigTile merged = new DigTile(positions.Next, tile.Value * 2) { MergedFrom = new List <DigTile> { tile, next } }; grid.InsertTile(merged); grid.RemoveTile(tile); tile.UpdatePosition(positions.Next); CurrentScore += merged.Value; if (merged.Value == Goal) { Solve(); } if (merged.Value == 2048 && !hasWon2048) { Win2048.SetActive(true); hasWon2048 = justWon2048 = true; HideDirectionHighlights(true); } } else { MoveTile(tile, positions.Farthest); } if (!PositionsEqual(cell, tile)) { moved = true; } } } } if (moved) { AddRandomTile(); Actuate(); LogGrid(direction); if (!MovesAvailable()) { GameOver(); } } }
public override string ToString() { return(string.Join(" | ", Traversals.PreOrder(this, node => node.Children).Select(node => $"{{Id={node.Id},Affinity={node.Affinity},VoteAction={node.VoteAction}}}"))); }