clean

Author: shreymehul

134.CanCompleteCircuit.cs

@@ -1,7 +1,9 @@
 // 134. Gas Station
 // There are n gas stations along a circular route, where the amount of gas at the ith station is gas[i].
-// You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from the ith station to its next (i + 1)th station. You begin the journey with an empty tank at one of the gas stations.
-// Given two integer arrays gas and cost, return the starting gas station's index if you can travel around the circuit once in the clockwise direction, otherwise return -1. If there exists a solution, it is guaranteed to be unique
+// You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from the ith station to its next
+// (i + 1)th station. You begin the journey with an empty tank at one of the gas stations.
+// Given two integer arrays gas and cost, return the starting gas station's index if you can travel around the circuit
+// once in the clockwise direction, otherwise return -1. If there exists a solution, it is guaranteed to be unique
 // Example 1:
 // Input: gas = [1,2,3,4,5], cost = [3,4,5,1,2]
 // Output: 3

138.CopyRandomList.cs

@@ -1,10 +1,16 @@
 // 138. Copy List with Random Pointer
 
-// A linked list of length n is given such that each node contains an additional random pointer, which could point to any node in the list, or null.
-// Construct a deep copy of the list. The deep copy should consist of exactly n brand new nodes, where each new node has its value set to the value of its corresponding original node. Both the next and random pointer of the new nodes should point to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state. None of the pointers in the new list should point to nodes in the original list.
-// For example, if there are two nodes X and Y in the original list, where X.random --> Y, then for the corresponding two nodes x and y in the copied list, x.random --> y.
+// A linked list of length n is given such that each node contains an additional random pointer, which could point to any node
+// in the list, or null.
+// Construct a deep copy of the list. The deep copy should consist of exactly n brand new nodes, where each new node has its
+// value set to the value of its corresponding original node. Both the next and random pointer of the new nodes should point
+// to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state.
+// None of the pointers in the new list should point to nodes in the original list.
+// For example, if there are two nodes X and Y in the original list, where X.random --> Y, then for the corresponding two nodes
+// x and y in the copied list, x.random --> y.
 // Return the head of the copied linked list.
-// The linked list is represented in the input/output as a list of n nodes. Each node is represented as a pair of [val, random_index] where:
+// The linked list is represented in the input/output as a list of n nodes. Each node is represented as a pair of
+// [val, random_index] where:
 // val: an integer representing Node.val
 // random_index: the index of the node (range from 0 to n-1) that the random pointer points to, or null if it does not point to any node.
 // Your code will only be given the head of the original linked list.

142.DetectCycle.cs

@@ -1,28 +1,19 @@
 // 142. Linked List Cycle II
-
 // Given the head of a linked list, return the node where the cycle begins. If there is no cycle, return null.
-
-// There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the next pointer. Internally, pos is used to denote the index of the node that tail's next pointer is connected to (0-indexed). It is -1 if there is no cycle. Note that pos is not passed as a parameter.
-
+// There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following
+// the next pointer. Internally, pos is used to denote the index of the node that tail's next pointer is connected to
+// (0-indexed). It is -1 if there is no cycle. Note that pos is not passed as a parameter.
 // Do not modify the linked list.
 
- 
-
 // Example 1:
-
-
 // Input: head = [3,2,0,-4], pos = 1
 // Output: tail connects to node index 1
 // Explanation: There is a cycle in the linked list, where tail connects to the second node.
 // Example 2:
-
-
 // Input: head = [1,2], pos = 0
 // Output: tail connects to node index 0
 // Explanation: There is a cycle in the linked list, where tail connects to the first node.
 // Example 3:
-
-
 // Input: head = [1], pos = -1
 // Output: no cycle
 // Explanation: There is no cycle in the linked list.

146.LRUCache.cs

@@ -9,16 +9,12 @@
 // void put(int key, int value) Update the value of the key if the key exists. Otherwise, add the key-value pair to the cache. If the number of keys exceeds the capacity from this operation, evict the least recently used key.
 // The functions get and put must each run in O(1) average time complexity.
 
- 
-
 // Example 1:
-
 // Input
 // ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
 // [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
 // Output
 // [null, null, null, 1, null, -1, null, -1, 3, 4]
-
 // Explanation
 // LRUCache lRUCache = new LRUCache(2);
 // lRUCache.put(1, 1); // cache is {1=1}

149.MaxPoints.cs

@@ -1,5 +1,6 @@
 // 149. Max Points on a Line
-// Given an array of points where points[i] = [xi, yi] represents a point on the X-Y plane, return the maximum number of points that lie on the same straight line.
+// Given an array of points where points[i] = [xi, yi] represents a point on the X-Y plane, return the maximum number of
+// points that lie on the same straight line.
 // Example 1:
 // Input: points = [[1,1],[2,2],[3,3]]
 // Output: 3

150.EvalRPN.cs

@@ -2,7 +2,8 @@
 // Evaluate the value of an arithmetic expression in Reverse Polish Notation.
 // Valid operators are +, -, *, and /. Each operand may be an integer or another expression.
 // Note that division between two integers should truncate toward zero.
-// It is guaranteed that the given RPN expression is always valid. That means the expression would always evaluate to a result, and there will not be any division by zero operation.
+// It is guaranteed that the given RPN expression is always valid. That means the expression would always evaluate to a result,
+// and there will not be any division by zero operation.
 // Example 1:
 // Input: tokens = ["2","1","+","3","*"]
 // Output: 9

153.FindMin.cs

@@ -1,8 +1,10 @@
 // 153. Find Minimum in Rotated Sorted Array
-// Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array nums = [0,1,2,4,5,6,7] might become:
+// Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array
+// nums = [0,1,2,4,5,6,7] might become:
 // [4,5,6,7,0,1,2] if it was rotated 4 times.
 // [0,1,2,4,5,6,7] if it was rotated 7 times.
-// Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in the array [a[n-1], a[0], a[1], a[2], ..., a[n-2]].
+// Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in the array
+// [a[n-1], a[0], a[1], a[2], ..., a[n-2]].
 // Given the sorted rotated array nums of unique elements, return the minimum element of this array.
 // You must write an algorithm that runs in O(log n) time.
 // Example 1:

154.FindMin.cs

@@ -1,8 +1,10 @@
 // 154. Find Minimum in Rotated Sorted Array II
-// Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array nums = [0,1,4,4,5,6,7] might become:
+// Suppose an array of length n sorted in ascending order is rotated between 1 and n times.
+// For example, the array nums = [0,1,4,4,5,6,7] might become:
 // [4,5,6,7,0,1,4] if it was rotated 4 times.
 // [0,1,4,4,5,6,7] if it was rotated 7 times.
-// Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in the array [a[n-1], a[0], a[1], a[2], ..., a[n-2]].
+// Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in the array
+// [a[n-1], a[0], a[1], a[2], ..., a[n-2]].
 // Given the sorted rotated array nums that may contain duplicates, return the minimum element of this array.
 // You must decrease the overall operation steps as much as possible.
 // Example 1:

155.MinStack.cs

@@ -11,10 +11,7 @@
 // int getMin() retrieves the minimum element in the stack.
 // You must implement a solution with O(1) time complexity for each function.
 
- 
-
 // Example 1:
-
 // Input
 // ["MinStack","push","push","push","getMin","pop","top","getMin"]
 // [[],[-2],[0],[-3],[],[],[],[]]

160.GetIntersectionNode.cs

@@ -1,6 +1,7 @@
 // 160. Intersection of Two Linked Lists
 
-// Given the heads of two singly linked-lists headA and headB, return the node at which the two lists intersect. If the two linked lists have no intersection at all, return null.
+// Given the heads of two singly linked-lists headA and headB, return the node at which the two lists intersect.
+// If the two linked lists have no intersection at all, return null.
 // For example, the following two linked lists begin to intersect at node c1:
 
 // The test cases are generated such that there are no cycles anywhere in the entire linked structure.