c-sharp – Page 3 – My Programming Notes

Tag Archives: c-sharp

C# || Two Sum IV – How To Get Two Numbers In Binary Search Tree Equal To Target Value Using C#

October 09, 2022 admin No comments

The following is a module with functions which demonstrates how to get two numbers in a binary search tree equal to target value using C#.

1. Find Target – Problem Statement

Given the root of a Binary Search Tree and a target number k, return true if there exist two elements in the BST such that their sum is equal to the given target.

Example 1:

Input: root = [5,3,6,2,4,null,7], k = 9 Output: true

Example 2:

Input: root = [5,3,6,2,4,null,7], k = 28 Output: false

2. Find Target – Solution

The following are two solutions which demonstrates how to get two numbers in a binary search tree equal to target value.

Both solutions use a set to keep track of the items already seen.

Each time a new node is encountered, we subtract the target value from the current node value. If the difference amount from subtracting the two numbers exists in the set, a 2 sum combination exists in the tree

1. Recursive

The following solution uses Depth First Search when looking for the target value.





		
		
			2. Find Target - Solution - Recursive
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Oct 9, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to get two numbers equal to target value
// ============================================================================
public class Solution {
    public bool FindTarget(TreeNode root, int k) {
        return Traverse(root, k, new HashSet<int>());
    }

    private bool Traverse(TreeNode node, int k, HashSet<int> seen) {
        if (node == null) {
            return false;
        }
        // Get remaining value
        var remaining = k - node.val;

        // Check if remaining value has been seen
        if (seen.Contains(remaining)) {
            return true;
        }
        // Add current node value to items seen
        seen.Add(node.val);

        // Keep traversing left and right looking for 2 sum
        return Traverse(node.left, k, seen) || Traverse(node.right, k, seen);
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Oct 9, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to get two numbers equal to target value
// ============================================================================
public class Solution {
    public bool FindTarget(TreeNode root, int k) {
        return Traverse(root, k, new HashSet<int>());
    }
 
    private bool Traverse(TreeNode node, int k, HashSet<int> seen) {
        if (node == null) {
            return false;
        }
        // Get remaining value
        var remaining = k - node.val;
 
        // Check if remaining value has been seen
        if (seen.Contains(remaining)) {
            return true;
        }
        // Add current node value to items seen
        seen.Add(node.val);
 
        // Keep traversing left and right looking for 2 sum
        return Traverse(node.left, k, seen) || Traverse(node.right, k, seen);
    }
}// http://programmingnotes.org/

2. Iterative

The following solution uses Breadth First Search when looking for the target value.





		
		
			2. Find Target - Solution - Iterative
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Oct 9, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to get two numbers equal to target value
// ============================================================================
public class Solution {
    public bool FindTarget(TreeNode root, int k) {
        if (root == null) {
            return false;
        }
        // Declare stack
        var stack = new Stack<TreeNode>();

        // Keep track of values seen
        var seen = new HashSet<int>();

        // Add root to stack
        stack.Push(root);

        // Loop through items on the stack
        while (stack.Count > 0) {
            // Get current node
            var node = stack.Pop();

            // Get remaining value
            var remaining = k - node.val;

            // Check if remaining value has been seen
            if (seen.Contains(remaining)) {
                return true;
            } else {
                // Keep traversing left and right looking for 2 sum
                if (node.left != null) {
                    stack.Push(node.left);
                }
                if (node.right != null) {
                    stack.Push(node.right);
                }
            }
            // Add current node value to items seen
            seen.Add(node.val);
        }
        return false;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Oct 9, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to get two numbers equal to target value
// ============================================================================
public class Solution {
    public bool FindTarget(TreeNode root, int k) {
        if (root == null) {
            return false;
        }
        // Declare stack
        var stack = new Stack<TreeNode>();
 
        // Keep track of values seen
        var seen = new HashSet<int>();
 
        // Add root to stack
        stack.Push(root);
 
        // Loop through items on the stack
        while (stack.Count > 0) {
            // Get current node
            var node = stack.Pop();
 
            // Get remaining value
            var remaining = k - node.val;
 
            // Check if remaining value has been seen
            if (seen.Contains(remaining)) {
                return true;
            } else {
                // Keep traversing left and right looking for 2 sum
                if (node.left != null) {
                    stack.Push(node.left);
                }
                if (node.right != null) {
                    stack.Push(node.right);
                }
            }
            // Add current node value to items seen
            seen.Add(node.val);
        }
        return false;
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

true false

C# || Counting Bits – How To Return The Number Of 1’s In Binary Representation Of X Using C#

October 02, 2022 admin No comments

The following is a module with functions which demonstrates how to return the number of 1’s in binary representation of X using C#.

1. Count Bits – Problem Statement

Given an integer n, return an array ans of length n + 1 such that for each i (0 <= i <= n), ans[i] is the number of 1‘s in the binary representation of i.

Example 1:

Input: n = 2 Output: [0,1,1] Explanation: 0 --> 0 1 --> 1 2 --> 10

Example 2:

Input: n = 5 Output: [0,1,1,2,1,2] Explanation: 0 --> 0 1 --> 1 2 --> 10 3 --> 11 4 --> 100 5 --> 101

2. Count Bits – Solution

The following is a solution which demonstrates how return the number of 1’s in binary representation of X.

In this problem, we can see a pattern start to form.

When the current n is even, we can get the answer by dividing by 2 (e.g result[n] = result[n / 2])

When the current n is odd, we can get the answer by getting the result at previous index and adding 1 (e.g result[n] = result[n – 1] + 1)





		
		
			2. Level Order - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Oct 2, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to return binary representation of X
// ============================================================================
public class Solution {
    public int[] CountBits(int n) {
        var result = new int[n + 1];
        result[0] = 0;

        for (int index = 1; index < result.Length; ++index) {
            if (index % 2 == 0) {
                result[index] = result[index / 2];
            } else {
                result[index] = result[index - 1] + 1;
            }
        }
        return result;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Oct 2, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to return binary representation of X
// ============================================================================
public class Solution {
    public int[] CountBits(int n) {
        var result = new int[n + 1];
        result[0] = 0;
 
        for (int index = 1; index < result.Length; ++index) {
            if (index % 2 == 0) {
                result[index] = result[index / 2];
            } else {
                result[index] = result[index - 1] + 1;
            }
        }
        return result;
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

[0,1,1] [0,1,1,2,1,2]

C# || How To Traverse N-ary Tree Level Order Using C#

September 05, 2022 admin No comments

The following is a module with functions which demonstrates how to traverse a N-ary Tree level order using C#.

1. Level Order – Problem Statement

Given an n-ary tree, return the level order traversal of its nodes’ values.

Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value (See examples).

Example 1:

Input: root = [1,null,3,2,4,null,5,6] Output: [[1],[3,2,4],[5,6]]

Example 2:

Input: root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14] Output: [[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

2. Level Order – Solution

The following is a solution which demonstrates how to traverse a N-ary Tree level order.

This solution uses Breadth First Search to explore items at each level.





		
		
			2. Level Order - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Sep 5, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to traverse a N-ary Tree Level Order
// ============================================================================
/*
// Definition for a Node.
public class Node {
    public int val;
    public IList<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, IList<Node> _children) {
        val = _val;
        children = _children;
    }
}
*/
public class Solution {
    public IList<IList<int>> LevelOrder(Node root) {
        var result = new List<IList<int>>();
        if (root == null) {
           return result;
        }

        var queue = new Queue<Node>();
        queue.Enqueue(root);

        while (queue.Count > 0) {
            var currentLevel = new List<int>();
            for (int count = queue.Count - 1; count >= 0 ; --count) {
                var currentNode = queue.Dequeue();
                currentLevel.Add(currentNode.val);
                foreach (var child in currentNode.children) {
                    queue.Enqueue(child);
                }
            }
            result.Add(currentLevel);
        }

        return result;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Sep 5, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to traverse a N-ary Tree Level Order
// ============================================================================
/*
// Definition for a Node.
public class Node {
    public int val;
    public IList<Node> children;
 
    public Node() {}
 
    public Node(int _val) {
        val = _val;
    }
 
    public Node(int _val, IList<Node> _children) {
        val = _val;
        children = _children;
    }
}
*/
public class Solution {
    public IList<IList<int>> LevelOrder(Node root) {
        var result = new List<IList<int>>();
        if (root == null) {
           return result;
        }
 
        var queue = new Queue<Node>();
        queue.Enqueue(root);
 
        while (queue.Count > 0) {
            var currentLevel = new List<int>();
            for (int count = queue.Count - 1; count >= 0 ; --count) {
                var currentNode = queue.Dequeue();
                currentLevel.Add(currentNode.val);
                foreach (var child in currentNode.children) {
                    queue.Enqueue(child);
                }
            }
            result.Add(currentLevel);
        }
 
        return result;
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

[[1],[3,2,4],[5,6]] [[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

C# || How To Validate A Binary Search Tree Using C#

August 12, 2022 admin No comments

The following is a module with functions which demonstrates how to validate a binary search tree using C#.

1. Is Valid BST – Problem Statement

Given the root of a binary tree, determine if it is a valid binary search tree (BST).

A valid BST is defined as follows:

The left subtree of a node contains only nodes with keys less than the node’s key.
The right subtree of a node contains only nodes with keys greater than the node’s key.
Both the left and right subtrees must also be binary search trees.

Example 1:

Input: root = [2,1,3] Output: true

Example 2:

Input: root = [5,1,4,null,null,3,6] Output: false Explanation: The root node's value is 5 but its right child's value is 4.

2. Is Valid BST – Solution

The following is a solution which demonstrates how to validate a binary search tree.





		
		
			2. Is Valid BST - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Aug 12, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to validate a BST
// ============================================================================
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    public bool IsValidBST(TreeNode root) {
        return Traverse(root, null, null);
    }

    private bool Traverse(TreeNode node, TreeNode min, TreeNode max) {
        if (node == null) {
            return true;
        }
        if (max != null && node.val >= max.val) {
            return false;
        }
        if (min != null && node.val <= min.val) {
            return false;
        }
        return Traverse(node.left, min, node)
            && Traverse(node.right, node, max);
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Aug 12, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to validate a BST
// ============================================================================
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    public bool IsValidBST(TreeNode root) {
        return Traverse(root, null, null);
    }
 
    private bool Traverse(TreeNode node, TreeNode min, TreeNode max) {
        if (node == null) {
            return true;
        }
        if (max != null && node.val >= max.val) {
            return false;
        }
        if (min != null && node.val <= min.val) {
            return false;
        }
        return Traverse(node.left, min, node)
            && Traverse(node.right, node, max);
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

true false

C# || Max Area of Island – How To Find The Maximum Area Of An Island In A Grid Using C#

July 28, 2022 admin No comments

The following is a module with functions which demonstrates how to find the maximum area of an island in a grid using C#.

1. Max Area Of Island – Problem Statement

You are given an m x n binary matrix grid. An island is a group of 1‘s (representing land) connected 4-directionally (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water.

The area of an island is the number of cells with a value 1 in the island.

Return the maximum area of an island in grid. If there is no island, return 0.

Example 1:

Input: grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]] Output: 6 Explanation: The answer is not 11, because the island must be connected 4-directionally.

Example 2:

Input: grid = [[0,0,0,0,0,0,0,0]] Output: 0

2. Max Area Of Island – Solution

The following is a solution which demonstrates how to find the maximum area of an island in a grid.

We want to know the area of each connected shape in the grid, then take the maximum of these.

If we are on a land square and explore every square connected to it 4-directionally (and recursively squares connected to those squares, and so on), then the total number of squares explored will be the area of that connected shape.

To ensure we don’t count squares in a shape more than once, we use ‘seen’ to keep track of squares we haven’t visited before. It will also prevent us from counting the same shape more than once.





		
		
			2. Max Area Of Island - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jul 28, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to find the maximum area in a grid
// ============================================================================
public class Solution {
    public int MaxAreaOfIsland(int[][] grid) {
        var seen = new bool[grid.Length][];
        for (int row = 0; row < seen.Length; ++row) {
            seen[row] = new bool[grid[row].Length];
        }
        var result = 0;
        for (int row = 0; row < grid.Length; ++row) {
            for (int col = 0; col < grid[row].Length; ++col) {
                result = Math.Max(result, Area(grid, row, col, seen));
            }
        }
        return result;
    }

    private int Area(int[][] grid, int row, int col, bool[][] seen) {
        if (!IsValidCell(grid, row, col)) {
            return 0;
        }
        if (seen[row][col] || grid[row][col] == 0) {
            return 0;
        }
        seen[row][col] = true;
        return 1 +
            // Search Bottom
            Area(grid, row + 1, col, seen) +
            // Search Top
            Area(grid, row - 1, col, seen) +
            // Search Left
            Area(grid, row, col - 1, seen) +
            // Search Right
            Area(grid, row, col + 1, seen);
    }

    private bool IsValidCell(int[][] grid, int row, int col) {
        return row >= 0 && row < grid.Length && col >= 0 && col < grid[row].Length;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jul 28, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to find the maximum area in a grid
// ============================================================================
public class Solution {
    public int MaxAreaOfIsland(int[][] grid) {
        var seen = new bool[grid.Length][];
        for (int row = 0; row < seen.Length; ++row) {
            seen[row] = new bool[grid[row].Length];
        }
        var result = 0;
        for (int row = 0; row < grid.Length; ++row) {
            for (int col = 0; col < grid[row].Length; ++col) {
                result = Math.Max(result, Area(grid, row, col, seen));
            }
        }
        return result;
    }
 
    private int Area(int[][] grid, int row, int col, bool[][] seen) {
        if (!IsValidCell(grid, row, col)) {
            return 0;
        }
        if (seen[row][col] || grid[row][col] == 0) {
            return 0;
        }
        seen[row][col] = true;
        return 1 +
            // Search Bottom
            Area(grid, row + 1, col, seen) +
            // Search Top
            Area(grid, row - 1, col, seen) +
            // Search Left
            Area(grid, row, col - 1, seen) +
            // Search Right
            Area(grid, row, col + 1, seen);
    }
 
    private bool IsValidCell(int[][] grid, int row, int col) {
        return row >= 0 && row < grid.Length && col >= 0 && col < grid[row].Length;
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

6 0

C# || Binary Tree Right Side View – How To Get Nodes Ordered Top To Bottom C#

July 10, 2022 admin No comments

The following is a module with functions which demonstrates how to get nodes in a binary tree ordered from top to bottom using C#.

1. Right Side View – Problem Statement

Given the root of a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.

Example 1:

Input: root = [1,2,3,null,5,null,4] Output: [1,3,4]

Example 2:

Input: root = [1,null,3] Output: [1,3]

Example 3:

Input: root = [] Output: []

2. Right Side View – Solution

The following is a solution which demonstrates how to get right side nodes ordered from top to bottom.

This solution uses Depth First Search level order traversal to explore items at each level, and then adds the last node on every layer.





		
		
			2. Right Side View - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jul 10, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to get nodes ordered from top to bottom
// ============================================================================
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    public IList<int> RightSideView(TreeNode root) {
        var result = new List<int>();
        Traverse(root, 0, result);
        return result;
    }

    public void Traverse(TreeNode node, int currentDepth, List<int> result) {
        if (node == null) {
            return;
        }
        if (currentDepth == result.Count) {
            result.Add(node.val);
        }
        Traverse(node.right, currentDepth + 1, result);
        Traverse(node.left, currentDepth + 1, result);
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jul 10, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to get nodes ordered from top to bottom
// ============================================================================
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    public IList<int> RightSideView(TreeNode root) {
        var result = new List<int>();
        Traverse(root, 0, result);
        return result;
    }
 
    public void Traverse(TreeNode node, int currentDepth, List<int> result) {
        if (node == null) {
            return;
        }
        if (currentDepth == result.Count) {
            result.Add(node.val);
        }
        Traverse(node.right, currentDepth + 1, result);
        Traverse(node.left, currentDepth + 1, result);
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

[1,3,4] [1,3] []

C# || How To Find The Shortest Clear Path In A Binary Matrix Using C#

June 03, 2022 admin No comments

The following is a module with functions which demonstrates how to find the shortest clear path in a binary matrix using C#.

1. Shortest Path Binary Matrix – Problem Statement

Given an n x n binary matrix grid, return the length of the shortest clear path in the matrix. If there is no clear path, return -1.

A clear path in a binary matrix is a path from the top-left cell (i.e., (0, 0)) to the bottom-right cell (i.e., (n – 1, n – 1)) such that:

All the visited cells of the path are 0.
All the adjacent cells of the path are 8-directionally connected (i.e., they are different and they share an edge or a corner).

The length of a clear path is the number of visited cells of this path.

Example 1:

Input: grid = [[0,1],[1,0]] Output: 2

Example 2:

Input: grid = [[0,0,0],[1,1,0],[1,1,0]] Output: 4

Example 3:

Input: grid = [[1,0,0],[1,1,0],[1,1,0]] Output: -1

2. Shortest Path Binary Matrix – Solution

The following is a solution which demonstrates how find the shortest clear path in a binary matrix.





		
		
			2. Shortest Path Binary Matrix - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jun 3, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to find shortest path binary matrix
// ============================================================================
public class Solution {
    // Search directions
    List<KeyValuePair<int, int>> directions = new List<KeyValuePair<int, int>>() {
        // Direction coordinates: (y, x)
        new KeyValuePair<int, int>(0, -1),
        new KeyValuePair<int, int>(0, 1),
        new KeyValuePair<int, int>(-1, 0),
        new KeyValuePair<int, int>(1, 0),
        new KeyValuePair<int, int>(1, 1),
        new KeyValuePair<int, int>(-1, -1),
        new KeyValuePair<int, int>(-1, 1),
        new KeyValuePair<int, int>(1, -1)
    };

    public int ShortestPathBinaryMatrix(int[][] grid) {
        var NOT_VISITED = 0;
        var VISITED = 1;

        if (grid[0][0] == VISITED) {
            return -1;
        }

        var queue = new Queue<KeyValuePair<int, int>>();
        queue.Enqueue(new KeyValuePair<int, int>(0, 0));
        grid[0][0] = VISITED;

        var result = 0;
        while(queue.Count > 0) {
            ++result;
            for (var itemCount = queue.Count; itemCount > 0; --itemCount) {
                var current = queue.Dequeue();

                // Get the current coordinates
                var row = current.Key;
                var col = current.Value;

                if (row == grid.Length - 1 && col == grid[row].Length - 1) {
                    return result;
                }

                // Search in different directions
                foreach (var direction in directions) {
                    var newRow = row + direction.Key;
                    var newCol = col + direction.Value;

                    if (IsValidCell(grid, newRow, newCol) && grid[newRow][newCol] == NOT_VISITED) {
                        grid[newRow][newCol] = VISITED;
                        queue.Enqueue(new KeyValuePair<int, int>(newRow, newCol));
                    }
                }
            }
        }
        return -1;
    }

    private bool IsValidCell(int[][] grid, int row, int col) {
        return row >= 0 && row < grid.Length && col >= 0 && col < grid[row].Length;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jun 3, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to find shortest path binary matrix
// ============================================================================
public class Solution {
    // Search directions
    List<KeyValuePair<int, int>> directions = new List<KeyValuePair<int, int>>() {
        // Direction coordinates: (y, x)
        new KeyValuePair<int, int>(0, -1),
        new KeyValuePair<int, int>(0, 1),
        new KeyValuePair<int, int>(-1, 0),
        new KeyValuePair<int, int>(1, 0),
        new KeyValuePair<int, int>(1, 1),
        new KeyValuePair<int, int>(-1, -1),
        new KeyValuePair<int, int>(-1, 1),
        new KeyValuePair<int, int>(1, -1)
    };
 
    public int ShortestPathBinaryMatrix(int[][] grid) {
        var NOT_VISITED = 0;
        var VISITED = 1;
 
        if (grid[0][0] == VISITED) {
            return -1;
        }
 
        var queue = new Queue<KeyValuePair<int, int>>();
        queue.Enqueue(new KeyValuePair<int, int>(0, 0));
        grid[0][0] = VISITED;
 
        var result = 0;
        while(queue.Count > 0) {
            ++result;
            for (var itemCount = queue.Count; itemCount > 0; --itemCount) {
                var current = queue.Dequeue();
 
                // Get the current coordinates
                var row = current.Key;
                var col = current.Value;
 
                if (row == grid.Length - 1 && col == grid[row].Length - 1) {
                    return result;
                }
 
                // Search in different directions
                foreach (var direction in directions) {
                    var newRow = row + direction.Key;
                    var newCol = col + direction.Value;
 
                    if (IsValidCell(grid, newRow, newCol) && grid[newRow][newCol] == NOT_VISITED) {
                        grid[newRow][newCol] = VISITED;
                        queue.Enqueue(new KeyValuePair<int, int>(newRow, newCol));
                    }
                }
            }
        }
        return -1;
    }
 
    private bool IsValidCell(int[][] grid, int row, int col) {
        return row >= 0 && row < grid.Length && col >= 0 && col < grid[row].Length;
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

2 4 -1

C# || Palindromic Substrings – How To Find The Number Of Palindromic Substrings Using C#

June 02, 2022 admin No comments

The following is a module with functions which demonstrates how to find the number of palindromic substrings using C#.

1. Count Substrings – Problem Statement

Given a string s, return the number of palindromic substrings in it.

A string is a palindrome when it reads the same backward as forward.

A substring is a contiguous sequence of characters within the string.

Example 1:

Input: s = "abc" Output: 3 Explanation: Three palindromic strings: "a", "b", "c".

Example 2:

Input: s = "aaa" Output: 6 Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".

2. Count Substrings – Solution

The following is a solution which demonstrates how to find the number of palindromic substrings.





		
		
			2. Count Substrings - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jun 2, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to find palindromic substrings
// ============================================================================
public class Solution {
    public int CountSubstrings(string s) {
        var count = 0;
        for (var index = 0; index < s.Length; ++index) {
            count += CountPalindrome(s, index, index);  // Count even sized
            count += CountPalindrome(s, index, index + 1); // Count odd sized
        }
        return count;
    }

    private int CountPalindrome(string s, int start, int end) {
        var count = 0;
        while (start >= 0 && end < s.Length && s[start--] == s[end++]) {
            ++count;
        }
        return count;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jun 2, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to find palindromic substrings
// ============================================================================
public class Solution {
    public int CountSubstrings(string s) {
        var count = 0;
        for (var index = 0; index < s.Length; ++index) {
            count += CountPalindrome(s, index, index);  // Count even sized
            count += CountPalindrome(s, index, index + 1); // Count odd sized
        }
        return count;
    }
 
    private int CountPalindrome(string s, int start, int end) {
        var count = 0;
        while (start >= 0 && end < s.Length && s[start--] == s[end++]) {
            ++count;
        }
        return count;
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

3 6

C# || Longest Valid Parentheses – How To Find The Longest Valid Well Formed Parentheses Using C#

May 24, 2022 admin No comments

The following is a module with functions which demonstrates how to find the longest valid well formed parentheses using C#.

1. Longest Valid Parentheses – Problem Statement

Given a string containing just the characters ‘(‘ and ‘)’, find the length of the longest valid (well-formed) parentheses substring.

Example 1:

Input: s = "(()" Output: 2 Explanation: The longest valid parentheses substring is "()".

Example 2:

Input: s = ")()())" Output: 4 Explanation: The longest valid parentheses substring is "()()".

Example 3:

Input: s = "" Output: 0

2. Longest Valid Parentheses – Solution

The following is a solution which demonstrates how to find the longest valid well formed parentheses.

In this solution we can make use of a stack while scanning the given string to:

Check if the string scanned so far is valid

Find the length of the longest valid string

In order to do so, we start by pushing -1 onto the stack. For every ‘(‘ encountered, we push its index onto the stack.

For every ‘)‘ encountered, we pop the topmost element. Then, the length of the currently encountered valid string of parentheses will be the difference between the current element’s index and the top element of the stack.

If, while popping the element, the stack becomes empty, we will push the current element’s index onto the stack. In this way, we can continue to calculate the length of the valid substrings and return the length of the longest valid string at the end.





		
		
			2. Longest Valid Parentheses - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 24, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to find the longest valid parentheses
// ============================================================================
public class Solution {
    public int LongestValidParentheses(string s) {
        var result = 0;
        var stack = new Stack<int>();
        stack.Push(-1);
        for (var index = 0; index < s.Length; ++index) {
            if (s[index] == '(') {
                stack.Push(index);
            } else {
                stack.Pop();
                if (stack.Count == 0) {
                    stack.Push(index);
                } else {
                    result = Math.Max(result, index - stack.Peek());
                }
            }
        }
        return result;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 24, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to find the longest valid parentheses
// ============================================================================
public class Solution {
    public int LongestValidParentheses(string s) {
        var result = 0;
        var stack = new Stack<int>();
        stack.Push(-1);
        for (var index = 0; index < s.Length; ++index) {
            if (s[index] == '(') {
                stack.Push(index);
            } else {
                stack.Pop();
                if (stack.Count == 0) {
                    stack.Push(index);
                } else {
                    result = Math.Max(result, index - stack.Peek());
                }
            }
        }
        return result;
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

2 4 0

C# || Backspace String Compare – How To Backspace Compare Two Strings Using C#

May 23, 2022 admin No comments

The following is a module with functions which demonstrates how to backspace compare two strings using C#.

1. Backspace Compare – Problem Statement

Given two strings s and t, return true if they are equal when both are typed into empty text editors. ‘#’ means a backspace character.

Note that after backspacing an empty text, the text will continue empty.

Example 1:

Input: s = "ab#c", t = "ad#c" Output: true Explanation: Both s and t become "ac".

Example 2:

Input: s = "ab##", t = "c#d#" Output: true Explanation: Both s and t become "".

Example 3:

Input: s = "a#c", t = "b" Output: false Explanation: s becomes "c" while t becomes "b".

2. Backspace Compare – Solution

The following is a solution which demonstrates how to backspace compare two strings.





		
		
			2. Backspace Compare - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 23, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to backspace compare two strings
// ============================================================================
public class Solution {
    public bool BackspaceCompare(string s, string t) {
        return Clean(s) == Clean(t);
    }

    public string Clean(string source) {
        // Create result buffer
        var buffer = new StringBuilder();
        foreach (var ch in source) {
            if (ch == '#') {
                // Backspace by removing the last character in the buffer
                if (buffer.Length > 0) {
                    buffer.Length -= 1;
                }
            } else {
                // Add the character to the buffer
                buffer.Append(ch);
            }
        }
        return buffer.ToString();
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 23, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to backspace compare two strings
// ============================================================================
public class Solution {
    public bool BackspaceCompare(string s, string t) {
        return Clean(s) == Clean(t);
    }
 
    public string Clean(string source) {
        // Create result buffer
        var buffer = new StringBuilder();
        foreach (var ch in source) {
            if (ch == '#') {
                // Backspace by removing the last character in the buffer
                if (buffer.Length > 0) {
                    buffer.Length -= 1;
                }
            } else {
                // Add the character to the buffer
                buffer.Append(ch);
            }
        }
        return buffer.ToString();
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

true true false

C# || How To Design Underground System To Keep Track Of Customer Travel Times Between Stations Using C#

May 01, 2022 admin No comments

The following is a module with functions which demonstrates how to design an underground system to keep track of customer travel times between different stations using C#.

1. Underground System – Problem Statement

An underground railway system is keeping track of customer travel times between different stations. They are using this data to calculate the average time it takes to travel from one station to another.

Implement the UndergroundSystem class:

void checkIn(int id, string stationName, int t)
- A customer with a card ID equal to id, checks in at the station stationName at time t.
- A customer can only be checked into one place at a time.
void checkOut(int id, string stationName, int t)
- A customer with a card ID equal to id, checks out from the station stationName at time t.
double getAverageTime(string startStation, string endStation)
- Returns the average time it takes to travel from startStation to endStation.
- The average time is computed from all the previous traveling times from startStation to endStation that happened directly, meaning a check in at startStation followed by a check out from endStation.
- The time it takes to travel from startStation to endStation may be different from the time it takes to travel from endStation to startStation.
- There will be at least one customer that has traveled from startStation to endStation before getAverageTime is called.

You may assume all calls to the checkIn and checkOut methods are consistent. If a customer checks in at time t₁ then checks out at time t₂, then t₁ < t₂. All events happen in chronological order.

Example 1:

Input ["UndergroundSystem","checkIn","checkIn","checkIn","checkOut","checkOut","checkOut","getAverageTime","getAverageTime","checkIn","getAverageTime","checkOut","getAverageTime"] [[],[45,"Leyton",3],[32,"Paradise",8],[27,"Leyton",10],[45,"Waterloo",15],[27,"Waterloo",20],[32,"Cambridge",22],["Paradise","Cambridge"],["Leyton","Waterloo"],[10,"Leyton",24],["Leyton","Waterloo"],[10,"Waterloo",38],["Leyton","Waterloo"]]
Output [null,null,null,null,null,null,null,14.00000,11.00000,null,11.00000,null,12.00000]
Explanation UndergroundSystem undergroundSystem = new UndergroundSystem(); undergroundSystem.checkIn(45, "Leyton", 3); undergroundSystem.checkIn(32, "Paradise", 8); undergroundSystem.checkIn(27, "Leyton", 10); undergroundSystem.checkOut(45, "Waterloo", 15); // Customer 45 "Leyton" -> "Waterloo" in 15-3 = 12 undergroundSystem.checkOut(27, "Waterloo", 20); // Customer 27 "Leyton" -> "Waterloo" in 20-10 = 10 undergroundSystem.checkOut(32, "Cambridge", 22); // Customer 32 "Paradise" -> "Cambridge" in 22-8 = 14 undergroundSystem.getAverageTime("Paradise", "Cambridge"); // return 14.00000. One trip "Paradise" -> "Cambridge", (14) / 1 = 14 undergroundSystem.getAverageTime("Leyton", "Waterloo"); // return 11.00000. Two trips "Leyton" -> "Waterloo", (10 + 12) / 2 = 11 undergroundSystem.checkIn(10, "Leyton", 24); undergroundSystem.getAverageTime("Leyton", "Waterloo"); // return 11.00000 undergroundSystem.checkOut(10, "Waterloo", 38); // Customer 10 "Leyton" -> "Waterloo" in 38-24 = 14 undergroundSystem.getAverageTime("Leyton", "Waterloo"); // return 12.00000. Three trips "Leyton" -> "Waterloo", (10 + 12 + 14) / 3 = 12

Example 2:

Input ["UndergroundSystem","checkIn","checkOut","getAverageTime","checkIn","checkOut","getAverageTime","checkIn","checkOut","getAverageTime"] [[],[10,"Leyton",3],[10,"Paradise",8],["Leyton","Paradise"],[5,"Leyton",10],[5,"Paradise",16],["Leyton","Paradise"],[2,"Leyton",21],[2,"Paradise",30],["Leyton","Paradise"]]
Output [null,null,null,5.00000,null,null,5.50000,null,null,6.66667]
Explanation UndergroundSystem undergroundSystem = new UndergroundSystem(); undergroundSystem.checkIn(10, "Leyton", 3); undergroundSystem.checkOut(10, "Paradise", 8); // Customer 10 "Leyton" -> "Paradise" in 8-3 = 5 undergroundSystem.getAverageTime("Leyton", "Paradise"); // return 5.00000, (5) / 1 = 5 undergroundSystem.checkIn(5, "Leyton", 10); undergroundSystem.checkOut(5, "Paradise", 16); // Customer 5 "Leyton" -> "Paradise" in 16-10 = 6 undergroundSystem.getAverageTime("Leyton", "Paradise"); // return 5.50000, (5 + 6) / 2 = 5.5 undergroundSystem.checkIn(2, "Leyton", 21); undergroundSystem.checkOut(2, "Paradise", 30); // Customer 2 "Leyton" -> "Paradise" in 30-21 = 9 undergroundSystem.getAverageTime("Leyton", "Paradise"); // return 6.66667, (5 + 6 + 9) / 3 = 6.66667

2. Underground System – Solution

The following is a solution which demonstrates how to design an underground system to keep track of customer travel times between different stations.





		
		
			2. Underground System - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 1, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to design underground system
// ============================================================================
public class UndergroundSystem {
    Dictionary<string, KeyValuePair<int, int>> checkoutMap;
    Dictionary<int, KeyValuePair<string, int>> checkInMap;

    public UndergroundSystem() {
        checkoutMap = new Dictionary<string, KeyValuePair<int, int>>(); // Route - {TotalTime, Count}
        checkInMap = new Dictionary<int, KeyValuePair<string, int>>();  // Uid - {StationName, Time}
    }

    public void CheckIn(int id, string stationName, int t) {
        checkInMap[id] = new KeyValuePair<string, int>(stationName, t);
    }

    public void CheckOut(int id, string stationName, int t) {
        var checkIn = checkInMap[id];
        var route = checkIn.Key + "_" + stationName;
        var totalTime = t - checkIn.Value;
        var checkout = checkoutMap.ContainsKey(route) ? checkoutMap[route] : new KeyValuePair<int, int>(0, 0);
        checkoutMap[route] = new KeyValuePair<int, int>(checkout.Key + totalTime, checkout.Value + 1);
    }

    public double GetAverageTime(string startStation, string endStation) {
        var route = startStation + "_" + endStation;
        var checkout = checkoutMap[route];
        return (double) checkout.Key / checkout.Value;
    }
}// http://programmingnotes.org/

/**
 * Your UndergroundSystem object will be instantiated and called as such:
 * UndergroundSystem obj = new UndergroundSystem();
 * obj.CheckIn(id,stationName,t);
 * obj.CheckOut(id,stationName,t);
 * double param_3 = obj.GetAverageTime(startStation,endStation);
 */
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 1, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to design underground system
// ============================================================================
public class UndergroundSystem {
    Dictionary<string, KeyValuePair<int, int>> checkoutMap;
    Dictionary<int, KeyValuePair<string, int>> checkInMap;
 
    public UndergroundSystem() {
        checkoutMap = new Dictionary<string, KeyValuePair<int, int>>(); // Route - {TotalTime, Count}
        checkInMap = new Dictionary<int, KeyValuePair<string, int>>();  // Uid - {StationName, Time}
    }
 
    public void CheckIn(int id, string stationName, int t) {
        checkInMap[id] = new KeyValuePair<string, int>(stationName, t);
    }
 
    public void CheckOut(int id, string stationName, int t) {
        var checkIn = checkInMap[id];
        var route = checkIn.Key + "_" + stationName;
        var totalTime = t - checkIn.Value;
        var checkout = checkoutMap.ContainsKey(route) ? checkoutMap[route] : new KeyValuePair<int, int>(0, 0);
        checkoutMap[route] = new KeyValuePair<int, int>(checkout.Key + totalTime, checkout.Value + 1);
    }
 
    public double GetAverageTime(string startStation, string endStation) {
        var route = startStation + "_" + endStation;
        var checkout = checkoutMap[route];
        return (double) checkout.Key / checkout.Value;
    }
}// http://programmingnotes.org/
 
/**
 * Your UndergroundSystem object will be instantiated and called as such:
 * UndergroundSystem obj = new UndergroundSystem();
 * obj.CheckIn(id,stationName,t);
 * obj.CheckOut(id,stationName,t);
 * double param_3 = obj.GetAverageTime(startStation,endStation);
 */

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

[null,null,null,null,null,null,null,14.00000,11.00000,null,11.00000,null,12.00000] [null,null,null,5.00000,null,null,5.50000,null,null,6.66667]

C# || How To Add Simple Object Change Tracking To Track Changes Using C#

April 10, 2022 admin No comments

The following is a module with functions which demonstrates how to add simple object change tracking to track changes made to an object using C#.

Contents

1. Overview 2. Basic Usage 3. Accept Changes 4. Reject Changes 5. Ignore Tracking For Property 6. Notify Property Changed 7. Utils Namespace 8. More Examples

1. Overview

The following is a simple abstract change tracker class which implements INotifyPropertyChanged and IRevertibleChangeTracking which provides functionality to track object changes, and to ‘accept’ or ‘revert’ changes.

To use this class, simply inherit the abstract class, and your all set!

Note: Don’t forget to include the ‘Utils Namespace‘ before running the examples!

2. Basic Usage

The example below demonstrates the use of ChangeTracker.BeginChanges to start tracking object changes, as well as ChangeTracker.GetChanges to get the changes made to an object.

The following example demonstrates the basic usage of adding change tracking to an object, and making and getting changes.





		
		
			2. Basic Usage
			
C#
			
			// Basic Usage

using Utils;

// Declare class and inherit ChangeTracker
public class Person : ChangeTracker {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int? Age { get; set; }
}

// Declare data
var person = new Person {
    FirstName = "Kenneth",
    LastName = "Perkins",
    Age = 31
};

// Required: Changes made to this object will start being
// tracked the moment this function is called
person.BeginChanges();

// Make changes to the object
person.FirstName = "Jennifer";
person.LastName = "Nguyen";
person.Age = 28;

// Get changes made to the object
var changes = person.GetChanges();

// Display the changes
Console.WriteLine($"Changes: {changes.Count}");
foreach (var change in changes) {
    Console.WriteLine($"    PropertyName: {change.PropertyName}, OriginalValue: {change.OriginalValue}, CurrentValue: {change.CurrentValue}");
}

// expected output:
/*
    Changes: 3
        PropertyName: FirstName, OriginalValue: Kenneth, CurrentValue: Jennifer
        PropertyName: LastName, OriginalValue: Perkins, CurrentValue: Nguyen
        PropertyName: Age, OriginalValue: 31, CurrentValue: 28
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
				
						// Basic Usage
 
using Utils;
 
// Declare class and inherit ChangeTracker
public class Person : ChangeTracker {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int? Age { get; set; }
}
 
// Declare data
var person = new Person {
    FirstName = "Kenneth",
    LastName = "Perkins",
    Age = 31
};
 
// Required: Changes made to this object will start being
// tracked the moment this function is called
person.BeginChanges();
 
// Make changes to the object
person.FirstName = "Jennifer";
person.LastName = "Nguyen";
person.Age = 28;
 
// Get changes made to the object
var changes = person.GetChanges();
 
// Display the changes
Console.WriteLine($"Changes: {changes.Count}");
foreach (var change in changes) {
    Console.WriteLine($"    PropertyName: {change.PropertyName}, OriginalValue: {change.OriginalValue}, CurrentValue: {change.CurrentValue}");
}
 
// expected output:
/*
    Changes: 3
        PropertyName: FirstName, OriginalValue: Kenneth, CurrentValue: Jennifer
        PropertyName: LastName, OriginalValue: Perkins, CurrentValue: Nguyen
        PropertyName: Age, OriginalValue: 31, CurrentValue: 28
*/

3. Accept Changes

The example below demonstrates the use of ChangeTracker.AcceptChanges to accept modification changes made to an object.

This function commits all the changes made to the object since either ChangeTracker.BeginChanges was called, or since ChangeTracker.AcceptChanges was last called.

When the accept function is called, all the changes made to the object up to that point will be marked as the current ‘source of truth’ for change tracking.





		
		
			3. Accept Changes
			
C#
			
			// Accept Changes

using Utils;

// Declare class and inherit ChangeTracker
public class Person : ChangeTracker {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int? Age { get; set; }
}

// Declare data
var person = new Person {
    FirstName = "Kenneth",
    LastName = "Perkins",
    Age = 31
};

// Required: Changes made to this object will start being
// tracked the moment this function is called
person.BeginChanges();

// Make changes to the object
person.FirstName = "Lynn";
person.LastName = "P";
person.Age = 10;

// Accept all the changes made to the object up to
// this point as the source of truth for change tracking
person.AcceptChanges();

// Get changes made to the object
var changes = person.GetChanges();

// Display the changes
// Note: No changes will display because the most recent modifications has been accepted
Console.WriteLine($"Changes: {changes.Count}");
foreach (var change in changes) {
    Console.WriteLine($"    PropertyName: {change.PropertyName}, OriginalValue: {change.OriginalValue}, CurrentValue: {change.CurrentValue}");
}

// expected output:
/*
    Changes: 0
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
				
						// Accept Changes
 
using Utils;
 
// Declare class and inherit ChangeTracker
public class Person : ChangeTracker {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int? Age { get; set; }
}
 
// Declare data
var person = new Person {
    FirstName = "Kenneth",
    LastName = "Perkins",
    Age = 31
};
 
// Required: Changes made to this object will start being
// tracked the moment this function is called
person.BeginChanges();
 
// Make changes to the object
person.FirstName = "Lynn";
person.LastName = "P";
person.Age = 10;
 
// Accept all the changes made to the object up to
// this point as the source of truth for change tracking
person.AcceptChanges();
 
// Get changes made to the object
var changes = person.GetChanges();
 
// Display the changes
// Note: No changes will display because the most recent modifications has been accepted
Console.WriteLine($"Changes: {changes.Count}");
foreach (var change in changes) {
    Console.WriteLine($"    PropertyName: {change.PropertyName}, OriginalValue: {change.OriginalValue}, CurrentValue: {change.CurrentValue}");
}
 
// expected output:
/*
    Changes: 0
*/

4. Reject Changes

The example below demonstrates the use of ChangeTracker.RejectChanges to reject modification changes made to an object.

This function rejects all the changes made to the object since either ChangeTracker.BeginChanges was called, or since ChangeTracker.AcceptChanges was last called.

When the reject function is called, all the changes made to the object up to that point reverts back to the objects state before modifications initially began or modifications was last accepted.





		
		
			4. Reject Changes
			
C#
			
			// Reject Changes

using Utils;

// Declare class and inherit ChangeTracker
public class Person : ChangeTracker {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int? Age { get; set; }
}

// Declare data
var person = new Person {
    FirstName = "Kenneth",
    LastName = "Perkins",
    Age = 31
};

// Required: Changes made to this object will start being
// tracked the moment this function is called
person.BeginChanges();

// Make changes to the object
person.FirstName = "Sole";
person.LastName = "P";
person.Age = 19;

// Rejects all the changes made to the object up to
// this point and reverts back to the objects state
// before modifications were made
person.RejectChanges();

// Get changes made to the object
var changes = person.GetChanges();

// Display the changes
// Note: No changes will display because the most recent modifications has been rejected
Console.WriteLine($"Changes: {changes.Count}");
foreach (var change in changes) {
    Console.WriteLine($"    PropertyName: {change.PropertyName}, OriginalValue: {change.OriginalValue}, CurrentValue: {change.CurrentValue}");
}

// expected output:
/*
    Changes: 0
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
				
						// Reject Changes
 
using Utils;
 
// Declare class and inherit ChangeTracker
public class Person : ChangeTracker {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int? Age { get; set; }
}
 
// Declare data
var person = new Person {
    FirstName = "Kenneth",
    LastName = "Perkins",
    Age = 31
};
 
// Required: Changes made to this object will start being
// tracked the moment this function is called
person.BeginChanges();
 
// Make changes to the object
person.FirstName = "Sole";
person.LastName = "P";
person.Age = 19;
 
// Rejects all the changes made to the object up to
// this point and reverts back to the objects state
// before modifications were made
person.RejectChanges();
 
// Get changes made to the object
var changes = person.GetChanges();
 
// Display the changes
// Note: No changes will display because the most recent modifications has been rejected
Console.WriteLine($"Changes: {changes.Count}");
foreach (var change in changes) {
    Console.WriteLine($"    PropertyName: {change.PropertyName}, OriginalValue: {change.OriginalValue}, CurrentValue: {change.CurrentValue}");
}
 
// expected output:
/*
    Changes: 0
*/

5. Ignore Tracking For Property

The example below demonstrates the use of ChangeTracker.ChangeTrackerIgnore attribute to mark a specific property to be ignored from change tracking.





		
		
			5. Ignore Tracking For Property
			
C#
			
			// Ignore Tracking For Property

using Utils;

// Declare class and inherit ChangeTracker
public class Person : ChangeTracker {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    [ChangeTrackerIgnore]
    public int? Age { get; set; }
}

// Declare data
var person = new Person {
    FirstName = "Kenneth",
    LastName = "Perkins",
    Age = 31
};

// Required: Changes made to this object will start being
// tracked the moment this function is called
person.BeginChanges();

// Make changes to the object
person.FirstName = "Jennifer";
person.LastName = "Nguyen";
person.Age = 28;

// Get changes made to the object
var changes = person.GetChanges();

// Display the changes
Console.WriteLine($"Changes: {changes.Count}");
foreach (var change in changes) {
    Console.WriteLine($"    PropertyName: {change.PropertyName}, OriginalValue: {change.OriginalValue}, CurrentValue: {change.CurrentValue}");
}

// expected output:
/*
    Changes: 2
        PropertyName: FirstName, OriginalValue: Kenneth, CurrentValue: Jennifer
        PropertyName: LastName, OriginalValue: Perkins, CurrentValue: Nguyen
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
				
						// Ignore Tracking For Property
 
using Utils;
 
// Declare class and inherit ChangeTracker
public class Person : ChangeTracker {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    [ChangeTrackerIgnore]
    public int? Age { get; set; }
}
 
// Declare data
var person = new Person {
    FirstName = "Kenneth",
    LastName = "Perkins",
    Age = 31
};
 
// Required: Changes made to this object will start being
// tracked the moment this function is called
person.BeginChanges();
 
// Make changes to the object
person.FirstName = "Jennifer";
person.LastName = "Nguyen";
person.Age = 28;
 
// Get changes made to the object
var changes = person.GetChanges();
 
// Display the changes
Console.WriteLine($"Changes: {changes.Count}");
foreach (var change in changes) {
    Console.WriteLine($"    PropertyName: {change.PropertyName}, OriginalValue: {change.OriginalValue}, CurrentValue: {change.CurrentValue}");
}
 
// expected output:
/*
    Changes: 2
        PropertyName: FirstName, OriginalValue: Kenneth, CurrentValue: Jennifer
        PropertyName: LastName, OriginalValue: Perkins, CurrentValue: Nguyen
*/

6. Notify Property Changed

The example below demonstrates the use of ChangeTracker.NotifyPropertyChanged to fire the PropertyChanged event notifying that the specified property value has changed.

In the class declaration, simply add ChangeTracker.NotifyPropertyChanged to the properties you wish to notify changes, and add a PropertyChanged event handler function to receive the notifications.





		
		
			6. Notify Property Changed
			
C#
			
			// Notify Property Changed

using Utils;

// Declare class and inherit ChangeTracker
// Modify the properties you wish to notify changes
public class Person : ChangeTracker {
    string _firstName;
    public string FirstName {
        get { return _firstName; }
        set {
            _firstName = value;
            NotifyPropertyChanged(value);
        }
    }

    string _lastName;
    public string LastName {
        get { return _lastName; }
        set {
            _lastName = value;
            NotifyPropertyChanged(value);
        }
    }

    int? _age;
    public int? Age {
        get { return _age; }
        set {
            _age = value;
            NotifyPropertyChanged(value);
        }
    }
}

// Declare data
var person = new Person {
    FirstName = "Kenneth",
    LastName = "Perkins",
    Age = 31
};

// Set custom event handler function for property changed event
person.PropertyChanged += Person_PropertyChanged;

// Required: Changes made to this object will start being
// tracked the moment this function is called
person.BeginChanges();

// Make changes to the object
person.FirstName = "Jennifer";
person.LastName = "Nguyen";
person.Age = 28;


// Declare Custom event handler function for the PropertyChanged event
public static void Person_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) {
    var eventArgs = (ChangeTracker.PropertyChangedTrackedEventArgs)e;
    Console.WriteLine($"Event Handler Changes:");
    Console.WriteLine($"    PropertyName: {eventArgs.PropertyName}, OriginalValue: {eventArgs.OriginalValue}, CurrentValue: {eventArgs.CurrentValue}");
}

// expected output:
/*
    Event Handler Changes:
        PropertyName: FirstName, OriginalValue: Kenneth, CurrentValue: Jennifer
    Event Handler Changes:
        PropertyName: LastName, OriginalValue: Perkins, CurrentValue: Nguyen
    Event Handler Changes:
        PropertyName: Age, OriginalValue: 31, CurrentValue: 28
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
				
						// Notify Property Changed
 
using Utils;
 
// Declare class and inherit ChangeTracker
// Modify the properties you wish to notify changes
public class Person : ChangeTracker {
    string _firstName;
    public string FirstName {
        get { return _firstName; }
        set {
            _firstName = value;
            NotifyPropertyChanged(value);
        }
    }
 
    string _lastName;
    public string LastName {
        get { return _lastName; }
        set {
            _lastName = value;
            NotifyPropertyChanged(value);
        }
    }
 
    int? _age;
    public int? Age {
        get { return _age; }
        set {
            _age = value;
            NotifyPropertyChanged(value);
        }
    }
}
 
// Declare data
var person = new Person {
    FirstName = "Kenneth",
    LastName = "Perkins",
    Age = 31
};
 
// Set custom event handler function for property changed event
person.PropertyChanged += Person_PropertyChanged;
 
// Required: Changes made to this object will start being
// tracked the moment this function is called
person.BeginChanges();
 
// Make changes to the object
person.FirstName = "Jennifer";
person.LastName = "Nguyen";
person.Age = 28;
 
 
// Declare Custom event handler function for the PropertyChanged event
public static void Person_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) {
    var eventArgs = (ChangeTracker.PropertyChangedTrackedEventArgs)e;
    Console.WriteLine($"Event Handler Changes:");
    Console.WriteLine($"    PropertyName: {eventArgs.PropertyName}, OriginalValue: {eventArgs.OriginalValue}, CurrentValue: {eventArgs.CurrentValue}");
}
 
// expected output:
/*
    Event Handler Changes:
        PropertyName: FirstName, OriginalValue: Kenneth, CurrentValue: Jennifer
    Event Handler Changes:
        PropertyName: LastName, OriginalValue: Perkins, CurrentValue: Nguyen
    Event Handler Changes:
        PropertyName: Age, OriginalValue: 31, CurrentValue: 28
*/

7. Utils Namespace

The following is the Utils Namespace. Include this in your project to start using!





		
		
			Utils Namespace
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Apr 10, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Utils.cs
//    Description: Handles general utility functions
// ============================================================================
using System;
using System.Linq;
using System.Reflection;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

namespace Utils {
    public abstract class ChangeTracker : System.ComponentModel.INotifyPropertyChanged,
            System.ComponentModel.IRevertibleChangeTracking {
        protected Dictionary<string, ITrackedChange> Tracked { get; set; }
        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        public bool IsTracking { get { return Tracked.Count > 0; } }

        /// <summary>
        /// Gets the objects changed status
        /// </summary>
        /// <returns><see langword="true"/> if the objects content has changed since either <see cref="BeginChanges"/>
        /// was called, or since <see cref="AcceptChanges"/> was last called; <see langword="false"/> otherwise</returns>
        public bool IsChanged {
            get {
                if (!_isChanged && IsTracking) {
                    var trackedChanges = GetTrackedChanges();
                    if (trackedChanges.Any(x => x.DetectChange(GetValue(x.Property)))) {
                        _isChanged = true;
                    }
                }
                return _isChanged;
            }
            protected set {
                _isChanged = value;
            }
        }
        private bool _isChanged = false;

        protected ChangeTracker() {
            Tracked = new Dictionary<string, ITrackedChange>();
        }

        /// <summary>
        /// Fires the PropertyChanged event notifying that the specified property value changed
        /// </summary>
        /// <param name="currentValue">The current value</param>
        /// <param name="originalValue">The original value</param>
        /// <param name="propertyName">The corresponding property name</param>
        protected void NotifyPropertyChanged(object currentValue, object originalValue, [CallerMemberName] string propertyName = "") {
            this.PropertyChanged?.Invoke(this, new PropertyChangedTrackedEventArgs(propertyName, originalValue, currentValue));
        }

        /// <summary>
        /// Fires the PropertyChanged event notifying that the specified property value changed
        /// </summary>
        /// <param name="currentValue">The current value</param>
        /// <param name="propertyName">The corresponding property name</param>
        protected virtual void NotifyPropertyChanged(object currentValue, [CallerMemberName] string propertyName = "") {
            NotifyPropertyChanged(currentValue, GetTrackedChange(propertyName)?.OriginalValue, propertyName);
        }

        /// <summary>
        /// Starts the tracking operation on the object. Changes made to the
        /// object will start being tracked the moment this function is called
        /// </summary>
        /// <exception cref="InvalidOperationException">Changes have already begun</exception>
        public virtual void BeginChanges() {
            ThrowIfTrackingStarted();
            Track(GetTrackableProperties());
            IsChanged = false;
        }

        /// <summary>
        /// Ends the tracking operation on the object. Any pending tracked changes made to the
        /// object since either <see cref="BeginChanges"/> was called, or since <see cref="AcceptChanges"/>
        /// was last called will be lost the moment this function is called
        /// </summary>
        /// <exception cref="InvalidOperationException">Change tracking has not started</exception>
        public virtual void EndChanges() {
            ThrowIfTrackingNotStarted();
            Tracked.Clear();
            IsChanged = false;
        }

        /// <summary>
        /// Sets the current object state as its default state by accepting the modifications.
        /// Commits all the changes made to this object since either <see cref="BeginChanges"/>
        /// was called, or since <see cref="AcceptChanges"/> was last called
        /// </summary>
        /// <exception cref="InvalidOperationException">Change tracking has not started</exception>
        public virtual void AcceptChanges() {
            ThrowIfTrackingNotStarted();
            var trackedChanges = UpdateTracked();
            foreach (var change in trackedChanges) {
                change.AcceptChange();
            }
            IsChanged = false;
        }

        /// <summary>
        /// Resets the current objects state by rejecting the modifications. Rejects
        /// all changes made to the object since either <see cref="BeginChanges"/>
        /// was called, or since <see cref="AcceptChanges"/> was last called
        /// </summary>
        /// <exception cref="InvalidOperationException">Change tracking has not started</exception>
        public virtual void RejectChanges() {
            ThrowIfTrackingNotStarted();
            var trackedChanges = GetTrackedChanges();
            foreach (var change in trackedChanges) {
                SetValue(change.Property, change.OriginalValue);
                change.RejectChange();
            }
            IsChanged = false;
        }

        /// <summary>
        /// Returns a list containing information of all the properties with changes
        /// applied to it since either <see cref="BeginChanges"/> was called, or
        /// since <see cref="AcceptChanges"/> was last called
        /// </summary>
        /// <returns>A list containing the changes made to the object</returns>
        /// <exception cref="InvalidOperationException">Change tracking has not started</exception>
        public virtual List<ITrackedChange> GetChanges() {
            ThrowIfTrackingNotStarted();
            var result = new List<ITrackedChange>();
            var trackedChanges = UpdateTracked();
            foreach (var change in trackedChanges) {
                if (change.HasChanges) {
                    result.Add(change);
                }
            }
            return result;
        }

        /// <summary>
        /// Returns a list containing information of all the properties being tracked
        /// </summary>
        /// <returns>A list containing property tracking information</returns>
        /// <exception cref="InvalidOperationException">Change tracking has not started</exception>
        public List<ITrackedChange> GetTracked() {
            ThrowIfTrackingNotStarted();
            return Tracked.Values.ToList();
        }

        /// <summary>
        /// Updates the tracking status of all the properties being tracked
        /// </summary>
        /// <returns>A list containing properties being tracked</returns>
        protected IEnumerable<TrackedChange> UpdateTracked() {
            var trackedChanges = GetTrackedChanges();
            Track(trackedChanges.Select(x => x.Property));
            return trackedChanges;
        }

        /// <summary>
        /// Keeps track of the original and current values of the provided properties
        /// </summary>
        /// <param name="properties">The properties to track</param>
        protected void Track(IEnumerable<PropertyInfo> properties) {
            if (properties != null) {
                foreach (var prop in properties) {
                    Track(prop, GetValue(prop));
                }
            }
        }

        /// <summary>
        /// Keeps track of the original and current value of the provided property
        /// </summary>
        /// <param name="property">The property to track</param>
        /// <param name="currentValue">The current value of the property</param>
        protected void Track(PropertyInfo property, object currentValue) {
            TrackedChange currentChange = null;
            if (!IsTrackedChange(property.Name)) {
                Func<object, object, bool> hasChangedFunc = (original, current) => {
                    return HasValuesChanged(original, current);
                };
                currentChange = new TrackedChange {
                    Property = property,
                    OriginalValue = currentValue,
                    HasChangedFunc = hasChangedFunc
                };
                Tracked.Add(property.Name, currentChange);
            } else {
                currentChange = GetTrackedChange(property.Name);
                currentChange.CurrentValue = currentValue;
                currentChange.Status = TrackedChange.TrackingStatus.Checked;
                currentChange.LastChecked = DateTime.Now;
            }
            if (currentChange.HasChanges) {
                IsChanged = true;
            }
        }

        /// <summary>
        /// Class which contains property tracking information
        /// </summary>
        protected class TrackedChange : ITrackedChange {
            public enum TrackingStatus {
                Unchecked,
                Checked
            }
            public PropertyInfo Property { get; set; }
            public string PropertyName { get { return Property?.Name; } }
            public object OriginalValue { get; set; }
            public object CurrentValue { get; set; }
            public TrackingStatus Status { get; set; } = TrackingStatus.Unchecked;
            public bool HasChanges {
                get {
                    return Status == TrackingStatus.Checked && DetectChange(CurrentValue);
                }
            }
            public DateTime? LastChecked { get; set; } = null;
            public Func<object, object, bool> HasChangedFunc { get; set; }
            public bool DetectChange(object currentValue) {
                return HasChangedFunc(OriginalValue, currentValue);
            }
            public void AcceptChange() {
                OriginalValue = CurrentValue;
                RejectChange();
            }
            public void RejectChange() {
                CurrentValue = null;
                Status = TrackingStatus.Unchecked;
                LastChecked = null;
            }
        }

        /// <summary>
        /// Provides support for object change tracking
        /// </summary>
        public interface ITrackedChange {
            string PropertyName { get; }
            object OriginalValue { get; }
            object CurrentValue { get; }
        }

        /// <summary>
        /// Provides data for the <see cref=" System.ComponentModel.PropertyChangedEventArgs"/> event
        /// </summary>
        public class PropertyChangedTrackedEventArgs : System.ComponentModel.PropertyChangedEventArgs {
            public object OriginalValue{ get; private set; }
            public object CurrentValue { get; private set; }
            public PropertyChangedTrackedEventArgs(string propertyName, object originalValue, object currentValue)
                   : base(propertyName) {
                OriginalValue = originalValue;
                CurrentValue = currentValue;
            }
        }

        /// <summary>
        /// Attribute which allows a property to be ignored from being tracked
        /// </summary>
        public class ChangeTrackerIgnoreAttribute : System.Attribute {}

#region "Helpers"
        protected bool IsTrackedChange(string propertyName) {
            return Tracked.ContainsKey(propertyName);
        }
        protected TrackedChange GetTrackedChange(string propertyName) {
            return IsTrackedChange(propertyName) ? (TrackedChange)Tracked[propertyName] : null;
        }
        protected IEnumerable<TrackedChange> GetTrackedChanges() {
            return Tracked.Select(pair => (TrackedChange)pair.Value);
        }
        protected virtual IEnumerable<PropertyInfo> GetTrackableProperties() {
            return this.GetType().GetProperties()
                    .Where(p =>
                        !p.DeclaringType.Equals(typeof(ChangeTracker))
                        && p.CanRead
                        && p.CanWrite
                        && !p.GetCustomAttributes<ChangeTrackerIgnoreAttribute>(false).Any()
                    );
        }
        protected virtual object GetValue(PropertyInfo property) {
            return property?.GetValue(this, property.GetIndexParameters()
                .Count() == 1 ? new object[] { null } : null);
        }
        protected virtual void SetValue(PropertyInfo property, object value) {
            if (property != null && property.CanWrite) {
                property.SetValue(this, value);
            }
        }
        protected virtual bool HasValuesChanged<T>(T originalValue, T currentValue) {
            return !EqualityComparer<T>.Default.Equals(originalValue, currentValue);
        }
        protected void ThrowIfTrackingNotStarted() {
            if (!IsTracking) {
                throw new InvalidOperationException("Change tracking has not started. Call 'BeginChanges' to start change tracking");
            }
        }
        protected void ThrowIfTrackingStarted() {
            if (IsTracking) {
                throw new InvalidOperationException("Change tracking has already started");
            }
        }
#endregion
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Apr 10, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Utils.cs
//    Description: Handles general utility functions
// ============================================================================
using System;
using System.Linq;
using System.Reflection;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
 
namespace Utils {
    public abstract class ChangeTracker : System.ComponentModel.INotifyPropertyChanged,
            System.ComponentModel.IRevertibleChangeTracking {
        protected Dictionary<string, ITrackedChange> Tracked { get; set; }
        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        public bool IsTracking { get { return Tracked.Count > 0; } }
 
        /// <summary>
        /// Gets the objects changed status
        /// </summary>
        /// <returns><see langword="true"/> if the objects content has changed since either <see cref="BeginChanges"/>
        /// was called, or since <see cref="AcceptChanges"/> was last called; <see langword="false"/> otherwise</returns>
        public bool IsChanged {
            get {
                if (!_isChanged && IsTracking) {
                    var trackedChanges = GetTrackedChanges();
                    if (trackedChanges.Any(x => x.DetectChange(GetValue(x.Property)))) {
                        _isChanged = true;
                    }
                }
                return _isChanged;
            }
            protected set {
                _isChanged = value;
            }
        }
        private bool _isChanged = false;
 
        protected ChangeTracker() {
            Tracked = new Dictionary<string, ITrackedChange>();
        }
 
        /// <summary>
        /// Fires the PropertyChanged event notifying that the specified property value changed
        /// </summary>
        /// <param name="currentValue">The current value</param>
        /// <param name="originalValue">The original value</param>
        /// <param name="propertyName">The corresponding property name</param>
        protected void NotifyPropertyChanged(object currentValue, object originalValue, [CallerMemberName] string propertyName = "") {
            this.PropertyChanged?.Invoke(this, new PropertyChangedTrackedEventArgs(propertyName, originalValue, currentValue));
        }
 
        /// <summary>
        /// Fires the PropertyChanged event notifying that the specified property value changed
        /// </summary>
        /// <param name="currentValue">The current value</param>
        /// <param name="propertyName">The corresponding property name</param>
        protected virtual void NotifyPropertyChanged(object currentValue, [CallerMemberName] string propertyName = "") {
            NotifyPropertyChanged(currentValue, GetTrackedChange(propertyName)?.OriginalValue, propertyName);
        }
 
        /// <summary>
        /// Starts the tracking operation on the object. Changes made to the
        /// object will start being tracked the moment this function is called
        /// </summary>
        /// <exception cref="InvalidOperationException">Changes have already begun</exception>
        public virtual void BeginChanges() {
            ThrowIfTrackingStarted();
            Track(GetTrackableProperties());
            IsChanged = false;
        }
 
        /// <summary>
        /// Ends the tracking operation on the object. Any pending tracked changes made to the
        /// object since either <see cref="BeginChanges"/> was called, or since <see cref="AcceptChanges"/>
        /// was last called will be lost the moment this function is called
        /// </summary>
        /// <exception cref="InvalidOperationException">Change tracking has not started</exception>
        public virtual void EndChanges() {
            ThrowIfTrackingNotStarted();
            Tracked.Clear();
            IsChanged = false;
        }
 
        /// <summary>
        /// Sets the current object state as its default state by accepting the modifications.
        /// Commits all the changes made to this object since either <see cref="BeginChanges"/>
        /// was called, or since <see cref="AcceptChanges"/> was last called
        /// </summary>
        /// <exception cref="InvalidOperationException">Change tracking has not started</exception>
        public virtual void AcceptChanges() {
            ThrowIfTrackingNotStarted();
            var trackedChanges = UpdateTracked();
            foreach (var change in trackedChanges) {
                change.AcceptChange();
            }
            IsChanged = false;
        }
 
        /// <summary>
        /// Resets the current objects state by rejecting the modifications. Rejects
        /// all changes made to the object since either <see cref="BeginChanges"/>
        /// was called, or since <see cref="AcceptChanges"/> was last called
        /// </summary>
        /// <exception cref="InvalidOperationException">Change tracking has not started</exception>
        public virtual void RejectChanges() {
            ThrowIfTrackingNotStarted();
            var trackedChanges = GetTrackedChanges();
            foreach (var change in trackedChanges) {
                SetValue(change.Property, change.OriginalValue);
                change.RejectChange();
            }
            IsChanged = false;
        }
 
        /// <summary>
        /// Returns a list containing information of all the properties with changes
        /// applied to it since either <see cref="BeginChanges"/> was called, or
        /// since <see cref="AcceptChanges"/> was last called
        /// </summary>
        /// <returns>A list containing the changes made to the object</returns>
        /// <exception cref="InvalidOperationException">Change tracking has not started</exception>
        public virtual List<ITrackedChange> GetChanges() {
            ThrowIfTrackingNotStarted();
            var result = new List<ITrackedChange>();
            var trackedChanges = UpdateTracked();
            foreach (var change in trackedChanges) {
                if (change.HasChanges) {
                    result.Add(change);
                }
            }
            return result;
        }
 
        /// <summary>
        /// Returns a list containing information of all the properties being tracked
        /// </summary>
        /// <returns>A list containing property tracking information</returns>
        /// <exception cref="InvalidOperationException">Change tracking has not started</exception>
        public List<ITrackedChange> GetTracked() {
            ThrowIfTrackingNotStarted();
            return Tracked.Values.ToList();
        }
 
        /// <summary>
        /// Updates the tracking status of all the properties being tracked
        /// </summary>
        /// <returns>A list containing properties being tracked</returns>
        protected IEnumerable<TrackedChange> UpdateTracked() {
            var trackedChanges = GetTrackedChanges();
            Track(trackedChanges.Select(x => x.Property));
            return trackedChanges;
        }
 
        /// <summary>
        /// Keeps track of the original and current values of the provided properties
        /// </summary>
        /// <param name="properties">The properties to track</param>
        protected void Track(IEnumerable<PropertyInfo> properties) {
            if (properties != null) {
                foreach (var prop in properties) {
                    Track(prop, GetValue(prop));
                }
            }
        }
 
        /// <summary>
        /// Keeps track of the original and current value of the provided property
        /// </summary>
        /// <param name="property">The property to track</param>
        /// <param name="currentValue">The current value of the property</param>
        protected void Track(PropertyInfo property, object currentValue) {
            TrackedChange currentChange = null;
            if (!IsTrackedChange(property.Name)) {
                Func<object, object, bool> hasChangedFunc = (original, current) => {
                    return HasValuesChanged(original, current);
                };
                currentChange = new TrackedChange {
                    Property = property,
                    OriginalValue = currentValue,
                    HasChangedFunc = hasChangedFunc
                };
                Tracked.Add(property.Name, currentChange);
            } else {
                currentChange = GetTrackedChange(property.Name);
                currentChange.CurrentValue = currentValue;
                currentChange.Status = TrackedChange.TrackingStatus.Checked;
                currentChange.LastChecked = DateTime.Now;
            }
            if (currentChange.HasChanges) {
                IsChanged = true;
            }
        }
 
        /// <summary>
        /// Class which contains property tracking information
        /// </summary>
        protected class TrackedChange : ITrackedChange {
            public enum TrackingStatus {
                Unchecked,
                Checked
            }
            public PropertyInfo Property { get; set; }
            public string PropertyName { get { return Property?.Name; } }
            public object OriginalValue { get; set; }
            public object CurrentValue { get; set; }
            public TrackingStatus Status { get; set; } = TrackingStatus.Unchecked;
            public bool HasChanges {
                get {
                    return Status == TrackingStatus.Checked && DetectChange(CurrentValue);
                }
            }
            public DateTime? LastChecked { get; set; } = null;
            public Func<object, object, bool> HasChangedFunc { get; set; }
            public bool DetectChange(object currentValue) {
                return HasChangedFunc(OriginalValue, currentValue);
            }
            public void AcceptChange() {
                OriginalValue = CurrentValue;
                RejectChange();
            }
            public void RejectChange() {
                CurrentValue = null;
                Status = TrackingStatus.Unchecked;
                LastChecked = null;
            }
        }
 
        /// <summary>
        /// Provides support for object change tracking
        /// </summary>
        public interface ITrackedChange {
            string PropertyName { get; }
            object OriginalValue { get; }
            object CurrentValue { get; }
        }
 
        /// <summary>
        /// Provides data for the <see cref=" System.ComponentModel.PropertyChangedEventArgs"/> event
        /// </summary>
        public class PropertyChangedTrackedEventArgs : System.ComponentModel.PropertyChangedEventArgs {
            public object OriginalValue{ get; private set; }
            public object CurrentValue { get; private set; }
            public PropertyChangedTrackedEventArgs(string propertyName, object originalValue, object currentValue)
                   : base(propertyName) {
                OriginalValue = originalValue;
                CurrentValue = currentValue;
            }
        }
 
        /// <summary>
        /// Attribute which allows a property to be ignored from being tracked
        /// </summary>
        public class ChangeTrackerIgnoreAttribute : System.Attribute {}
 
#region "Helpers"
        protected bool IsTrackedChange(string propertyName) {
            return Tracked.ContainsKey(propertyName);
        }
        protected TrackedChange GetTrackedChange(string propertyName) {
            return IsTrackedChange(propertyName) ? (TrackedChange)Tracked[propertyName] : null;
        }
        protected IEnumerable<TrackedChange> GetTrackedChanges() {
            return Tracked.Select(pair => (TrackedChange)pair.Value);
        }
        protected virtual IEnumerable<PropertyInfo> GetTrackableProperties() {
            return this.GetType().GetProperties()
                    .Where(p =>
                        !p.DeclaringType.Equals(typeof(ChangeTracker))
                        && p.CanRead
                        && p.CanWrite
                        && !p.GetCustomAttributes<ChangeTrackerIgnoreAttribute>(false).Any()
                    );
        }
        protected virtual object GetValue(PropertyInfo property) {
            return property?.GetValue(this, property.GetIndexParameters()
                .Count() == 1 ? new object[] { null } : null);
        }
        protected virtual void SetValue(PropertyInfo property, object value) {
            if (property != null && property.CanWrite) {
                property.SetValue(this, value);
            }
        }
        protected virtual bool HasValuesChanged<T>(T originalValue, T currentValue) {
            return !EqualityComparer<T>.Default.Equals(originalValue, currentValue);
        }
        protected void ThrowIfTrackingNotStarted() {
            if (!IsTracking) {
                throw new InvalidOperationException("Change tracking has not started. Call 'BeginChanges' to start change tracking");
            }
        }
        protected void ThrowIfTrackingStarted() {
            if (IsTracking) {
                throw new InvalidOperationException("Change tracking has already started");
            }
        }
#endregion
    }
}// http://programmingnotes.org/

8. More Examples

Below are more examples demonstrating the use of the ‘Utils‘ Namespace. Don’t forget to include the module when running the examples!





		
		
			More Examples
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Apr 10, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Program.cs
//    Description: The following demonstrates the use of the Utils Namespace
// ============================================================================
using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.Threading.Tasks;
using Utils;

public class Program {
    // Declare class and inherit ChangeTracker
    // Modify the properties you wish to notify changes
    public class Person : ChangeTracker {
        string _firstName;       
        public string FirstName {
            get { return _firstName; }
            set {
                _firstName = value;
                NotifyPropertyChanged(value);
            }
        }

        string _lastName;
        public string LastName {
            get { return _lastName; }
            set {
                _lastName = value;
                NotifyPropertyChanged(value);
            }
        }

        int? _age;
        //[ChangeTrackerIgnore]
        public int? Age {
            get { return _age; }
            set {
                _age = value;
                NotifyPropertyChanged(value);
            }
        }
    }

    static void Main(string[] args) {
        try {
            // Declare data
            var person = new Person {
                FirstName = "Kenneth",
                LastName = "Perkins",
                Age = 31
            };

            // Set custom event handler function for property changed event
            person.PropertyChanged += Person_PropertyChanged;

            // Required: Changes made to this object will start being
            // tracked the moment this function is called
            person.BeginChanges();

            var changes1 = person.GetChanges();

            // Make changes to the object
            person.FirstName = "Jennifer";
            person.LastName = "Nguyen";
            person.Age = 28;

            // Get changes made to the object
            var changes2 = person.GetChanges();

            // Display the changes
            DisplayChanges(changes2);


            // --- Accept changes ---

            // Make changes to the object
            person.FirstName = "Lynn";
            person.LastName = "P";
            person.Age = 10;

            var changes3 = person.GetChanges();        

            // Accept all the changes made to the object up to
            // this point as the source of truth for change tracking
            person.AcceptChanges();
        
            // Get changes made to the object
            var changes4 = person.GetChanges();

            // Display the changes
            // Note: No changes will display because the most recent modifications has been accepted
            DisplayChanges(changes4);

            // --- Reject changes ---

            // Make changes to the object
            person.FirstName = "Sole";
            person.LastName = "P";
            person.Age = 19;

            // Rejects all the changes made to the object up to
            // this point and reverts back to the objects state
            // before modifications were made
            person.RejectChanges();

            // Get changes made to the object
            var changes5 = person.GetChanges();

            // Display the changes
            // Note: No changes will display because the most recent modifications has been rejected
            DisplayChanges(changes5);
        } catch (Exception ex) {
            Display(ex.ToString());
        } finally {
            Console.ReadLine();
        }
    }

    // Declare Custom event handler function for the PropertyChanged event
    public static void Person_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) {
        var eventArgs = (ChangeTracker.PropertyChangedTrackedEventArgs)e;
        Display($"Event Handler Changes:");
        Display($"    PropertyName: {eventArgs.PropertyName}, OriginalValue: {eventArgs.OriginalValue}, CurrentValue: {eventArgs.CurrentValue}");
    }

    public static void DisplayChanges(List<ChangeTracker.ITrackedChange> changes) {
        Display($"Changes: {changes.Count}");
        foreach (var change in changes) { 
            Display($"    PropertyName: {change.PropertyName}, OriginalValue: {change.OriginalValue}, CurrentValue: {change.CurrentValue}");            
        }
        Display("============");
    }

    static void Display(string message) {
        Console.WriteLine(message);
        Debug.Print(message);
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Apr 10, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Program.cs
//    Description: The following demonstrates the use of the Utils Namespace
// ============================================================================
using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.Threading.Tasks;
using Utils;
 
public class Program {
    // Declare class and inherit ChangeTracker
    // Modify the properties you wish to notify changes
    public class Person : ChangeTracker {
        string _firstName;       
        public string FirstName {
            get { return _firstName; }
            set {
                _firstName = value;
                NotifyPropertyChanged(value);
            }
        }
 
        string _lastName;
        public string LastName {
            get { return _lastName; }
            set {
                _lastName = value;
                NotifyPropertyChanged(value);
            }
        }
 
        int? _age;
        //[ChangeTrackerIgnore]
        public int? Age {
            get { return _age; }
            set {
                _age = value;
                NotifyPropertyChanged(value);
            }
        }
    }
 
    static void Main(string[] args) {
        try {
            // Declare data
            var person = new Person {
                FirstName = "Kenneth",
                LastName = "Perkins",
                Age = 31
            };
 
            // Set custom event handler function for property changed event
            person.PropertyChanged += Person_PropertyChanged;
 
            // Required: Changes made to this object will start being
            // tracked the moment this function is called
            person.BeginChanges();
 
            var changes1 = person.GetChanges();
 
            // Make changes to the object
            person.FirstName = "Jennifer";
            person.LastName = "Nguyen";
            person.Age = 28;
 
            // Get changes made to the object
            var changes2 = person.GetChanges();
 
            // Display the changes
            DisplayChanges(changes2);
 
 
            // --- Accept changes ---
 
            // Make changes to the object
            person.FirstName = "Lynn";
            person.LastName = "P";
            person.Age = 10;
 
            var changes3 = person.GetChanges();        
 
            // Accept all the changes made to the object up to
            // this point as the source of truth for change tracking
            person.AcceptChanges();
        
            // Get changes made to the object
            var changes4 = person.GetChanges();
 
            // Display the changes
            // Note: No changes will display because the most recent modifications has been accepted
            DisplayChanges(changes4);
 
            // --- Reject changes ---
 
            // Make changes to the object
            person.FirstName = "Sole";
            person.LastName = "P";
            person.Age = 19;
 
            // Rejects all the changes made to the object up to
            // this point and reverts back to the objects state
            // before modifications were made
            person.RejectChanges();
 
            // Get changes made to the object
            var changes5 = person.GetChanges();
 
            // Display the changes
            // Note: No changes will display because the most recent modifications has been rejected
            DisplayChanges(changes5);
        } catch (Exception ex) {
            Display(ex.ToString());
        } finally {
            Console.ReadLine();
        }
    }
 
    // Declare Custom event handler function for the PropertyChanged event
    public static void Person_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) {
        var eventArgs = (ChangeTracker.PropertyChangedTrackedEventArgs)e;
        Display($"Event Handler Changes:");
        Display($"    PropertyName: {eventArgs.PropertyName}, OriginalValue: {eventArgs.OriginalValue}, CurrentValue: {eventArgs.CurrentValue}");
    }
 
    public static void DisplayChanges(List<ChangeTracker.ITrackedChange> changes) {
        Display($"Changes: {changes.Count}");
        foreach (var change in changes) { 
            Display($"    PropertyName: {change.PropertyName}, OriginalValue: {change.OriginalValue}, CurrentValue: {change.CurrentValue}");            
        }
        Display("============");
    }
 
    static void Display(string message) {
        Console.WriteLine(message);
        Debug.Print(message);
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

C# || Remove Linked List Elements – How To Remove All Target Linked List Elements Using C#

April 02, 2022 admin No comments

The following is a module with functions which demonstrates how to remove all target linked list elements using C#.

1. Remove Elements – Problem Statement

Given the head of a linked list and an integer val, remove all the nodes of the linked list that has Node.val == val, and return the new head.

Example 1:

Input: head = [1,2,6,3,4,5,6], val = 6 Output: [1,2,3,4,5]

Example 2:

Input: head = [], val = 1 Output: []

Example 3:

Input: head = [7,7,7,7], val = 7 Output: []

2. Remove Elements – Solution

The following is a solution which demonstrates how to remove all target linked list elements.





		
		
			2. Remove Elements - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Apr 2, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to remove all target linked list elements
// ============================================================================
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int val=0, ListNode next=null) {
 *         this.val = val;
 *         this.next = next;
 *     }
 * }
 */
public class Solution {
    public ListNode RemoveElements(ListNode head, int val) {
        var ptr = head;

        // Loop through data checking to see if the next node equals the target value
        while (ptr != null && ptr.next != null) {

            // If the next node value is the target value, set the next node
            // to point to the one after it
            if (ptr.next.val == val) {
                ptr.next = ptr.next.next;
            } else {
                // Advance to the next node
                ptr = ptr.next;
            }
        }

        // If the head equals the target value, advance to the next
        if (head != null && head.val == val) {
            head = head.next;
        }

        return head;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Apr 2, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to remove all target linked list elements
// ============================================================================
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int val=0, ListNode next=null) {
 *         this.val = val;
 *         this.next = next;
 *     }
 * }
 */
public class Solution {
    public ListNode RemoveElements(ListNode head, int val) {
        var ptr = head;
 
        // Loop through data checking to see if the next node equals the target value
        while (ptr != null && ptr.next != null) {
 
            // If the next node value is the target value, set the next node
            // to point to the one after it
            if (ptr.next.val == val) {
                ptr.next = ptr.next.next;
            } else {
                // Advance to the next node
                ptr = ptr.next;
            }
        }
 
        // If the head equals the target value, advance to the next
        if (head != null && head.val == val) {
            head = head.next;
        }
 
        return head;
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

[1,2,3,4,5] [] []

C# || How To Compare Version Numbers Using C#

March 01, 2022 admin No comments

The following is a module with functions which demonstrates how to compare version numbers using C#.

1. Compare Version – Problem Statement

Given two version numbers, version1 and version2, compare them.

Version numbers consist of one or more revisions joined by a dot ‘.’. Each revision consists of digits and may contain leading zeros. Every revision contains at least one character. Revisions are 0-indexed from left to right, with the leftmost revision being revision 0, the next revision being revision 1, and so on. For example 2.5.33 and 0.1 are valid version numbers.

To compare version numbers, compare their revisions in left-to-right order. Revisions are compared using their integer value ignoring any leading zeros. This means that revisions 1 and 001 are considered equal. If a version number does not specify a revision at an index, then treat the revision as 0. For example, version 1.0 is less than version 1.1 because their revision 0s are the same, but their revision 1s are 0 and 1 respectively, and 0 < 1.

Return the following:

If version1 < version2, return -1.
If version1 > version2, return 1.
Otherwise, return 0.

Example 1:

Input: version1 = "1.01", version2 = "1.001" Output: 0 Explanation: Ignoring leading zeroes, both "01" and "001" represent the same integer "1".

Example 2:

Input: version1 = "1.0", version2 = "1.0.0" Output: 0 Explanation: version1 does not specify revision 2, which means it is treated as "0".

Example 3:

Input: version1 = "0.1", version2 = "1.1" Output: -1 Explanation: version1's revision 0 is "0", while version2's revision 0 is "1". 0 < 1, so version1 < version2.

2. Compare Version – Solution

The following is a solution which demonstrates how to compare version numbers.





		
		
			2. Compare Version - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Mar 1, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to compare version numbers
// ============================================================================
public class Solution {
    public int CompareVersion(string version1, string version2) {
        var revisions1 = version1.Split(".");
        var revisions2 = version2.Split(".");

        var length = Math.Max(revisions1.Length, revisions2.Length);
        for (int index = 0; index < length; ++index) {
            var v1 = index < revisions1.Length ? int.Parse(revisions1[index]) : 0;
            var v2 = index < revisions2.Length ? int.Parse(revisions2[index]) : 0;
            if (v1 < v2) {
                return -1;
            } else if (v1 > v2) {
                return 1;
            }
        }
        return 0;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Mar 1, 2022
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to compare version numbers
// ============================================================================
public class Solution {
    public int CompareVersion(string version1, string version2) {
        var revisions1 = version1.Split(".");
        var revisions2 = version2.Split(".");
 
        var length = Math.Max(revisions1.Length, revisions2.Length);
        for (int index = 0; index < length; ++index) {
            var v1 = index < revisions1.Length ? int.Parse(revisions1[index]) : 0;
            var v2 = index < revisions2.Length ? int.Parse(revisions2[index]) : 0;
            if (v1 < v2) {
                return -1;
            } else if (v1 > v2) {
                return 1;
            }
        }
        return 0;
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

0 0 -1

Tag Archives: c-sharp

C# || Two Sum IV – How To Get Two Numbers In Binary Search Tree Equal To Target Value Using C#

C# || Counting Bits – How To Return The Number Of 1’s In Binary Representation Of X Using C#

C# || How To Traverse N-ary Tree Level Order Using C#

C# || How To Validate A Binary Search Tree Using C#

C# || Max Area of Island – How To Find The Maximum Area Of An Island In A Grid Using C#

C# || Binary Tree Right Side View – How To Get Nodes Ordered Top To Bottom C#

C# || How To Find The Shortest Clear Path In A Binary Matrix Using C#

C# || Palindromic Substrings – How To Find The Number Of Palindromic Substrings Using C#

C# || Longest Valid Parentheses – How To Find The Longest Valid Well Formed Parentheses Using C#

C# || Backspace String Compare – How To Backspace Compare Two Strings Using C#

C# || How To Design Underground System To Keep Track Of Customer Travel Times Between Stations Using C#

C# || How To Add Simple Object Change Tracking To Track Changes Using C#

C# || Remove Linked List Elements – How To Remove All Target Linked List Elements Using C#

C# || How To Compare Version Numbers Using C#

Search

Compile Your Code Now

Translate Page

Popular Pages

Recent

Archives

Categories