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.

164.MaximumGap.cs

@@ -1,16 +1,15 @@
 // 164. Maximum Gap
 
-// Given an integer array nums, return the maximum difference between two successive elements in its sorted form. If the array contains less than two elements, return 0.
+// Given an integer array nums, return the maximum difference between two successive elements in its sorted form.
+// If the array contains less than two elements, return 0.
 
 // You must write an algorithm that runs in linear time and uses linear extra space.
 
 // Example 1:
-
 // Input: nums = [3,6,9,1]
 // Output: 3
 // Explanation: The sorted form of the array is [1,3,6,9], either (3,6) or (6,9) has the maximum difference 3.
 // Example 2:
-
 // Input: nums = [10]
 // Output: 0
 // Explanation: The array contains less than 2 elements, therefore return 0.

169.MajorityElement.cs

@@ -1,7 +1,8 @@
 //169. Majority Element
 // Given an array nums of size n, return the majority element.
 
-// The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array.
+// The majority element is the element that appears more than ⌊n / 2⌋ times.
+// You may assume that the majority element always exists in the array.
 
 public class Solution {
     public int MajorityElement(int[] nums) {

191.HammingWeight.cs

@@ -4,12 +4,12 @@
 
 // Note:
 
-// Note that in some languages, such as Java, there is no unsigned integer type. In this case, the input will be given as a signed integer type. It should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.
-// In Java, the compiler represents the signed integers using 2's complement notation. Therefore, in Example 3, the input represents the signed integer. -3.
- 
-
+// Note that in some languages, such as Java, there is no unsigned integer type. In this case, the input will be given as
+// a signed integer type. It should not affect your implementation, as the integer's internal binary representation is the same,
+// whether it is signed or unsigned.
+// In Java, the compiler represents the signed integers using 2's complement notation.
+// Therefore, in Example 3, the input represents the signed integer. -3.
 // Example 1:
-
 // Input: n = 00000000000000000000000000001011
 // Output: 3
 // Explanation: The input binary string 00000000000000000000000000001011 has a total of three '1' bits.

198.Rob.cs

@@ -1,8 +1,11 @@
 // 198. House Robber
 
-// You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and it will automatically contact the police if two adjacent houses were broken into on the same night.
+// You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed,
+// the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and
+// it will automatically contact the police if two adjacent houses were broken into on the same night.
 
-// Given an integer array nums representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.
+// Given an integer array nums representing the amount of money of each house, return the maximum amount of money you
+//   can rob tonight without alerting the police.
 
 // Example 1:
 

200.NumIslands.cs

@@ -2,12 +2,9 @@
 
 // Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0's (water), return the number of islands.
 
-// An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
-
- 
-
+// An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically.
+// You may assume all four edges of the grid are all surrounded by water.
 // Example 1:
-
 // Input: grid = [
 //   ["1","1","1","1","0"],
 //   ["1","1","0","1","0"],
@@ -16,7 +13,6 @@
 // ]
 // Output: 1
 // Example 2:
-
 // Input: grid = [
 //   ["1","1","0","0","0"],
 //   ["1","1","0","0","0"],
@@ -28,8 +24,7 @@
 public class Solution {
     bool[,] visited = new bool[300,300];
     public int NumIslands(char[][] grid)
-    {
-        
+    {   
         int count=0;
         for(int i = 0; i < grid.Length; i++)
         {

203.RemoveElements.cs

@@ -1,5 +1,6 @@
 //203. Remove Linked List Elements
-//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.
+//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.
 //definition for singly-linked list.
 public class listnode
 {

204.CountPrimes.cs

@@ -30,4 +30,23 @@ public int CountPrimes(int n) {
         }
         return count;
     }
+}
+
+public class Solution {
+    public int CountPrimes(int n) {
+        if (n < 3) return n-1;
+        int[] isNotPrime = new int[n];
+        int count = 1; // count 2 as a prime
+        for (int i = 3; i < n; i += 2) {
+            if (isNotPrime[i] == 0) {
+                count++;
+                if ((long)i * i < n) {
+                    for (int j = i * i; j < n; j += 2 * i) {
+                        isNotPrime[j] = 1;
+                    }
+                }
+            }
+        }
+        return count;
+    }
 }

206.ReverseList.cs

@@ -2,24 +2,16 @@
 
 // Given the head of a singly linked list, reverse the list, and return the reversed list.
 
- 
-
 // Example 1:
-
-
 // Input: head = [1,2,3,4,5]
 // Output: [5,4,3,2,1]
 // Example 2:
-
-
 // Input: head = [1,2]
 // Output: [2,1]
 // Example 3:
-
 // Input: head = []
 // Output: []
 
-
 /**
  * Definition for singly-linked list.
  * public class ListNode {
@@ -43,4 +35,16 @@ public ListNode ReverseList(ListNode head) {
         }
         return prev;
     }
+}
+
+public class Solution {
+    public ListNode ReverseList(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode newHead = ReverseList(head.next);
+        head.next.next = head;
+        head.next = null;
+        return newHead;
+    }
 }

207.CanFinish.cs

@@ -1,6 +1,7 @@
 // 207. Course Schedule
-// There are a total of numCourses courses you have to take, labeled from 0 to numCourses - 1. You are given an array prerequisites where prerequisites[i] = [ai, bi] indicates that you must take course bi first if you want to take course ai.
-
+// There are a total of numCourses courses you have to take, labeled from 0 to numCourses - 1.
+// You are given an array prerequisites where prerequisites[i] = [ai, bi] indicates that you must take course bi first
+// if you want to take course ai.
 // For example, the pair [0, 1], indicates that to take course 0 you have to first take course 1.
 // Return true if you can finish all courses. Otherwise, return false.
 
@@ -13,7 +14,8 @@
 // Input: numCourses = 2, prerequisites = [[1,0],[0,1]]
 // Output: false
 // Explanation: There are a total of 2 courses to take. 
-// To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.
+// To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1.
+// So it is impossible.
 
 
 //Detect Cycle | Deadlock
@@ -26,11 +28,12 @@ public class Solution {
     public bool CanFinish(int numCourses, int[][] prerequisites)
     {
         List<int>[] path = new List<int>[numCourses];
-
+        //initialise List
         for(int i = 0; i < numCourses; i++)
         {
             path[i] = new List<int>();
         }
+        //Add nbr
         foreach(var item in prerequisites)
         {
             path[item[0]].Add(item[1]);

210.FindOrder.cs

@@ -1,23 +1,23 @@
 // 210. Course Schedule II
-// M
-// There are a total of numCourses courses you have to take, labeled from 0 to numCourses - 1. You are given an array prerequisites where prerequisites[i] = [ai, bi] indicates that you must take course bi first if you want to take course ai.
+
+// There are a total of numCourses courses you have to take, labeled from 0 to numCourses - 1.
+// You are given an array prerequisites where prerequisites[i] = [ai, bi] indicates that you must take course bi first if
+// you want to take course ai.
 
 // For example, the pair [0, 1], indicates that to take course 0 you have to first take course 1.
-// Return the ordering of courses you should take to finish all courses. If there are many valid answers, return any of them. If it is impossible to finish all courses, return an empty array.
+// Return the ordering of courses you should take to finish all courses. If there are many valid answers, return any of them.
+// If it is impossible to finish all courses, return an empty array.
 
 // Example 1:
-
 // Input: numCourses = 2, prerequisites = [[1,0]]
 // Output: [0,1]
 // Explanation: There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1].
 // Example 2:
-
 // Input: numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
 // Output: [0,2,1,3]
 // Explanation: There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0.
 // So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].
 // Example 3:
-
 // Input: numCourses = 1, prerequisites = []
 // Output: [0]
 

212.FindWords.cs

@@ -4,13 +4,9 @@
 // Each word must be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.
 
 // Example 1:
-
-
 // Input: board = [["o","a","a","n"],["e","t","a","e"],["i","h","k","r"],["i","f","l","v"]], words = ["oath","pea","eat","rain"]
 // Output: ["eat","oath"]
 // Example 2:
-
-
 // Input: board = [["a","b"],["c","d"]], words = ["abcb"]
 // Output: []