clean

shreymehul · shreymehul · commit 42378ba66111 · 2023-04-05T18:47:51.000+05:30
diff --git a/100.IsSameTree.cs b/100.IsSameTree.cs
@@ -1,19 +1,12 @@
 // 100. Same Tree
 
 // Given the roots of two binary trees p and q, write a function to check if they are the same or not.
-
 // Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.
 
- 
-
 // Example 1:
-
-
 // Input: p = [1,2,3], q = [1,2,3]
 // Output: true
 // Example 2:
-
-
 // Input: p = [1,2], q = [1,null,2]
 // Output: false
 
diff --git a/101.IsSymmetric.cs b/101.IsSymmetric.cs
@@ -2,16 +2,10 @@
 
 // Given the root of a binary tree, check whether it is a mirror of itself (i.e., symmetric around its center).
 
- 
-
 // Example 1:
-
-
 // Input: root = [1,2,2,3,4,4,3]
 // Output: true
 // Example 2:
-
-
 // Input: root = [1,2,2,null,3,null,3]
 // Output: false
 
diff --git a/102.LevelOrder.cs b/102.LevelOrder.cs
@@ -2,19 +2,14 @@
 
 // Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).
 
- 
-
 // Example 1:
-
-
 // Input: root = [3,9,20,null,null,15,7]
 // Output: [[3],[9,20],[15,7]]
 // Example 2:
 
 // Input: root = [1]
 // Output: [[1]]
 // Example 3:
-
 // Input: root = []
 // Output: []
 
diff --git a/103.ZigzagLevelOrder.cs b/103.ZigzagLevelOrder.cs
@@ -1,19 +1,13 @@
 // 103. Binary Tree Zigzag Level Order Traversal
 // Given the root of a binary tree, return the zigzag level order traversal of its nodes' values. (i.e., from left to right, then right to left for the next level and alternate between).
 
- 
-
-// Example 1:
-
-
+ // Example 1:
 // Input: root = [3,9,20,null,null,15,7]
 // Output: [[3],[20,9],[15,7]]
 // Example 2:
-
 // Input: root = [1]
 // Output: [[1]]
 // Example 3:
-
 // Input: root = []
 // Output: []
 
diff --git a/104.MaxDepth.cs b/104.MaxDepth.cs
@@ -4,15 +4,10 @@
 
 // A binary tree's maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
 
- 
-
 // Example 1:
-
-
 // Input: root = [3,9,20,null,null,15,7]
 // Output: 3
 // Example 2:
-
 // Input: root = [1,null,2]
 // Output: 2
 
diff --git a/107.LevelOrderBottom.cs b/107.LevelOrderBottom.cs
@@ -1,20 +1,15 @@
 // 107. Binary Tree Level Order Traversal II
 
-// Given the root of a binary tree, return the bottom-up level order traversal of its nodes' values. (i.e., from left to right, level by level from leaf to root).
-
- 
+// Given the root of a binary tree, return the bottom-up level order traversal of its nodes' values.
+// (i.e., from left to right, level by level from leaf to root).
 
 // Example 1:
-
-
 // Input: root = [3,9,20,null,null,15,7]
 // Output: [[15,7],[9,20],[3]]
 // Example 2:
-
 // Input: root = [1]
 // Output: [[1]]
 // Example 3:
-
 // Input: root = []
 // Output: []
 
diff --git a/108.SortedArrayToBST.cs b/108.SortedArrayToBST.cs
@@ -1,18 +1,12 @@
 // 108. Convert Sorted Array to Binary Search Tree
-// Given an integer array nums where the elements are sorted in ascending order, convert it to a height-balanced binary search tree.
-
- 
+// Given an integer array nums where the elements are sorted in ascending order, convert it to a height-balanced
+// binary search tree.
 
 // Example 1:
-
-
 // Input: nums = [-10,-3,0,5,9]
 // Output: [0,-3,9,-10,null,5]
 // Explanation: [0,-10,5,null,-3,null,9] is also accepted:
-
 // Example 2:
-
-
 // Input: nums = [1,3]
 // Output: [3,1]
 // Explanation: [1,null,3] and [3,1] are both height-balanced BSTs.
diff --git a/109.SortedListToBST.cs b/109.SortedListToBST.cs
@@ -1,17 +1,11 @@
 // 109. Convert Sorted List to Binary Search Tree
 
 // Given the head of a singly linked list where elements are sorted in ascending order, convert it to a height-balanced binary search tree.
-
- 
-
 // Example 1:
-
-
 // Input: head = [-10,-3,0,5,9]
 // Output: [0,-3,9,-10,null,5]
 // Explanation: One possible answer is [0,-3,9,-10,null,5], which represents the shown height balanced BST.
 // Example 2:
-
 // Input: head = []
 // Output: []
 
diff --git a/110.IsBalanced.cs b/110.IsBalanced.cs
@@ -1,25 +1,15 @@
 // 110. Balanced Binary Tree
 
 // Given a binary tree, determine if it is height-balanced.
-
 // For this problem, a height-balanced binary tree is defined as:
-
 // a binary tree in which the left and right subtrees of every node differ in height by no more than 1.
-
- 
-
 // Example 1:
-
-
 // Input: root = [3,9,20,null,null,15,7]
 // Output: true
 // Example 2:
-
-
 // Input: root = [1,2,2,3,3,null,null,4,4]
 // Output: false
 // Example 3:
-
 // Input: root = []
 // Output: true
 
diff --git a/111.MinDepth.cs b/111.MinDepth.cs
@@ -1,19 +1,11 @@
 // 111. Minimum Depth of Binary Tree
 // Given a binary tree, find its minimum depth.
-
 // The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.
-
 // Note: A leaf is a node with no children.
-
- 
-
 // Example 1:
-
-
 // Input: root = [3,9,20,null,null,15,7]
 // Output: 2
 // Example 2:
-
 // Input: root = [2,null,3,null,4,null,5,null,6]
 // Output: 5
 
diff --git a/112.HasPathSum.cs b/112.HasPathSum.cs
@@ -1,5 +1,6 @@
 // 112. Path Sum
-// Given the root of a binary tree and an integer targetSum, return true if the tree has a root-to-leaf path such that adding up all the values along the path equals targetSum.
+// Given the root of a binary tree and an integer targetSum, return true if the tree has a root-to-leaf path such that
+// adding up all the values along the path equals targetSum.
 // A leaf is a node with no children.
 // Example 1:
 // Input: root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
diff --git a/113.PathSum.cs b/113.PathSum.cs
@@ -1,5 +1,6 @@
 // 113. Path Sum II
-// Given the root of a binary tree and an integer targetSum, return all root-to-leaf paths where the sum of the node values in the path equals targetSum. Each path should be returned as a list of the node values, not node references.
+// Given the root of a binary tree and an integer targetSum, return all root-to-leaf paths where the sum of the node values
+// in the path equals targetSum. Each path should be returned as a list of the node values, not node references.
 // A root-to-leaf path is a path starting from the root and ending at any leaf node. A leaf is a node with no children.
 // Example 1:
 // Input: root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
diff --git a/116.Connect.cs b/116.Connect.cs
@@ -13,13 +13,10 @@
 // Initially, all next pointers are set to NULL.
 
 // Example 1:
-
-
 // Input: root = [1,2,3,4,5,6,7]
 // Output: [1,#,2,3,#,4,5,6,7,#]
 // Explanation: Given the above perfect binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.
 // Example 2:
-
 // Input: root = []
 // Output: []
 
diff --git a/118.Generate.cs b/118.Generate.cs
@@ -5,11 +5,9 @@
 // In Pascal's triangle, each number is the sum of the two numbers directly above it as shown:
 
 // Example 1:
-
 // Input: numRows = 5
 // Output: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
 // Example 2:
-
 // Input: numRows = 1
 // Output: [[1]]
 
diff --git a/120.MinimumTotal.cs b/120.MinimumTotal.cs
@@ -1,6 +1,7 @@
 // 120. Triangle
 // Given a triangle array, return the minimum path sum from top to bottom.
-// For each step, you may move to an adjacent number of the row below. More formally, if you are on index i on the current row, you may move to either index i or index i + 1 on the next row.
+// For each step, you may move to an adjacent number of the row below. More formally, if you are on index i on the current row,
+// you may move to either index i or index i + 1 on the next row.
 // Example 1:
 // Input: triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
 // Output: 11
diff --git a/121.MaxProfit.cs b/121.MaxProfit.cs
@@ -2,20 +2,16 @@
 
 // You are given an array prices where prices[i] is the price of a given stock on the ith day.
 
-// You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.
+// You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to
+// sell that stock.
 
 // Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.
-
- 
-
 // Example 1:
-
 // Input: prices = [7,1,5,3,6,4]
 // Output: 5
 // Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
 // Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
 // Example 2:
-
 // Input: prices = [7,6,4,3,1]
 // Output: 0
 // Explanation: In this case, no transactions are done and the max profit = 0.
diff --git a/122.MaxProfit.cs b/122.MaxProfit.cs
@@ -7,23 +7,18 @@
 
 // Find and return the maximum profit you can achieve.
 
- 
-
 // Example 1:
-
 // Input: prices = [7,1,5,3,6,4]
 // Output: 7
 // Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
 // Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
 // Total profit is 4 + 3 = 7.
 // Example 2:
-
 // Input: prices = [1,2,3,4,5]
 // Output: 4
 // Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
 // Total profit is 4.
 // Example 3:
-
 // Input: prices = [7,6,4,3,1]
 // Output: 0
 // Explanation: There is no way to make a positive profit, so we never buy the stock to achieve the maximum profit of 0.
diff --git a/123.MaxProfit.cs b/123.MaxProfit.cs
@@ -9,13 +9,11 @@
 // Explanation: Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
 // Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.
 // Example 2:
-
 // Input: prices = [1,2,3,4,5]
 // Output: 4
 // Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
 // Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again.
 // Example 3:
-
 // Input: prices = [7,6,4,3,1]
 // Output: 0
 // Explanation: In this case, no transaction is done, i.e. max profit = 0.
diff --git a/125.IsPalindrome.cs b/125.IsPalindrome.cs
@@ -1,6 +1,9 @@
 // 125. Valid Palindrome
-// A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.
+// A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric
+// characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.
 // Given a string s, return true if it is a palindrome, or false otherwise.
+
+//Approch 1
 public class Solution
 {
     public bool IsPalindrome(string s)
@@ -13,6 +16,7 @@ public bool IsPalindrome(string s)
     }
 }
 
+//Approch 2
 public class Solution
 {
     public bool IsPalindrome(string s)
diff --git a/90.SubsetsWithDup.cs b/90.SubsetsWithDup.cs
@@ -5,11 +5,9 @@
 // The solution set must not contain duplicate subsets. Return the solution in any order.
 
 // Example 1:
-
 // Input: nums = [1,2,2]
 // Output: [[],[1],[1,2],[1,2,2],[2],[2,2]]
 // Example 2:
-
 // Input: nums = [0]
 // Output: [[],[0]]
 
diff --git a/92.ReverseBetween.cs b/92.ReverseBetween.cs
@@ -1,16 +1,12 @@
 // 92. Reverse Linked List II
 
-// Given the head of a singly linked list and two integers left and right where left <= right, reverse the nodes of the list from position left to position right, and return the reversed list.
-
- 
+// Given the head of a singly linked list and two integers left and right where left <= right, reverse the nodes of the
+// list from position left to position right, and return the reversed list.
 
 // Example 1:
-
-
 // Input: head = [1,2,3,4,5], left = 2, right = 4
 // Output: [1,4,3,2,5]
 // Example 2:
-
 // Input: head = [5], left = 1, right = 1
 // Output: [5]
 
diff --git a/93.RestoreIpAddresses.cs b/93.RestoreIpAddresses.cs
@@ -1,7 +1,10 @@
 // 93. Restore IP Addresses
-// A valid IP address consists of exactly four integers separated by single dots. Each integer is between 0 and 255 (inclusive) and cannot have leading zeros.
-// For example, "0.1.2.201" and "192.168.1.1" are valid IP addresses, but "0.011.255.245", "192.168.1.312" and "192.168@1.1" are invalid IP addresses.
-// Given a string s containing only digits, return all possible valid IP addresses that can be formed by inserting dots into s. You are not allowed to reorder or remove any digits in s. You may return the valid IP addresses in any order.
+// A valid IP address consists of exactly four integers separated by single dots. Each integer is between 0 and 255
+// (inclusive) and cannot have leading zeros.
+// For example, "0.1.2.201" and "192.168.1.1" are valid IP addresses, but "0.011.255.245", "192.168.1.312" and "192.168@1.1"
+// are invalid IP addresses.
+// Given a string s containing only digits, return all possible valid IP addresses that can be formed by inserting dots into s.
+// You are not allowed to reorder or remove any digits in s. You may return the valid IP addresses in any order.
 // Example 1:
 // Input: s = "25525511135"
 // Output: ["255.255.11.135","255.255.111.35"]
diff --git a/94.InorderTraversal.cs b/94.InorderTraversal.cs
@@ -1,20 +1,13 @@
 // 94. Binary Tree Inorder Traversal
 
 // Given the root of a binary tree, return the inorder traversal of its nodes' values.
-
- 
-
 // Example 1:
-
-
 // Input: root = [1,null,2,3]
 // Output: [1,3,2]
 // Example 2:
-
 // Input: root = []
 // Output: []
 // Example 3:
-
 // Input: root = [1]
 // Output: [1]
 
diff --git a/96.NumTrees.cs b/96.NumTrees.cs
diff --git a/98.IsValidBST.cs b/98.IsValidBST.cs
