Merge pull request neetcode-gh#1008 from Ykhan799/main

Create: 78-Subsets.swift, 287-Find-The-Duplicate-Number.swift, 53-Maximum-Subarray.swift, 134-Gas-Station.swift, 287-Find-The-Duplicate-Number.c, 268-Missing-Number.c, 190-Reverse-Bits.c, 191-Number-of-1-Bits.c, 136-Single-Number.c, 213-House-Robber-II.c, 153-Find-Minimum-in-Rotated-Sorted-Array.c, 202-Happy-Number.c, 55-Jump-Game.c

c/136-Single-Number.c

@@ -0,0 +1,7 @@
+int singleNumber(int* nums, int numsSize){
+ int res = 0;
+ for (int i = 0; i < numsSize; i++) {
+ res = nums[i] ^ res;
+ }
+ return res;
+}

c/153-Find-Minimum-in-Rotated-Sorted-Array.c

@@ -0,0 +1,19 @@
+int findMin(int* nums, int numsSize){
+ // set the starting indicies to find minimum pivot
+ int left = 0;
+ int right = numsSize - 1;
+
+ while (left < right) {
+ // calculate middle index
+ int middle = (left + right) / 2;
+
+ // set the left or right index accordingly
+ if (nums[middle] > nums[right]) {
+ left = middle + 1;
+ }
+ else {
+ right = middle;
+ }
+ }
+ return nums[left];
+}

c/190-Reverse-Bits.c

@@ -0,0 +1,10 @@
+uint32_t reverseBits(uint32_t n) {
+ uint32_t res = 0;
+
+ for (int i = 0; i < 32; i++) {
+ res <<= 1;
+ res |= n & 1;
+ n >>= 1;
+ }
+ return res;
+}

c/191-Number-of-1-Bits.c

@@ -0,0 +1,12 @@
+int hammingWeight(uint32_t n) {
+ int res = 0;
+ int bit = 0;
+ while (n != 0) {
+ bit = n & 1;
+ if (bit == 1) {
+ res++;
+ }
+ n = n >> 1;
+ }
+ return res;
+}

c/202-Happy-Number.c

@@ -0,0 +1,20 @@
+bool isHappy(int n) {
+ int slow = n;
+ int fast = sumSquareDigits(n);
+
+ while (slow != fast) {
+ fast = sumSquareDigits(sumSquareDigits(fast));
+ slow = sumSquareDigits(slow);
+ }
+ return fast == 1;
+}
+
+int sumSquareDigits(n) {
+ int result = 0;
+ while (n != 0) {
+ int digit = n % 10;
+ result += digit * digit;
+ n /= 10;
+ }
+ return result;
+}

c/213-House-Robber-II.c

@@ -0,0 +1,25 @@
+int rob(int* nums, int numsSize){
+ int n = numsSize;
+
+ if (n == 1) {
+ return nums[0];
+ }
+
+ int range1 = robber(nums, 0, n - 2);
+ int range2 = robber(nums, 1, n - 1);
+
+ return (range1 > range2) ? range1 : range2;
+}
+
+int robber(int* nums, int start, int end) {
+ int prev = 0;
+ int curr = 0;
+ int next = 0;
+
+ for (int i = start; i <= end; i++) {
+ next = (curr > prev + nums[i]) ? curr : prev + nums[i];
+ prev = curr;
+ curr = next;
+ }
+ return curr;
+}

c/268-Missing-Number.c

@@ -0,0 +1,8 @@
+int missingNumber(int* nums, int numsSize){
+ int res = numsSize;
+
+ for (int i = 0; i < numsSize; i++) {
+ res += i - nums[i];
+ }
+ return res;
+}

c/287-Find-The-Duplicate-Number.c

@@ -0,0 +1,16 @@
+int findDuplicate(int* nums, int numsSize){
+ int slow = nums[0];
+ int fast = nums[nums[0]];
+
+ while (slow != fast) {
+ slow = nums[slow];
+ fast = nums[nums[fast]];
+ }
+
+ slow = 0;
+ while (slow != fast) {
+ slow = nums[slow];
+ fast = nums[fast];
+ }
+ return slow;
+}

c/55-Jump-Game.c

@@ -0,0 +1,10 @@
+bool canJump(int* nums, int numsSize){
+ int goal = numsSize - 1;
+
+ for (int i = numsSize - 2; i >= 0; i--) {
+ if (i + nums[i] >= goal) {
+ goal = i;
+ }
+ }
+ return goal == 0;
+}

swift/134-Gas-Station.swift

@@ -0,0 +1,22 @@
+class Solution {
+ func canCompleteCircuit(_ gas: [Int], _ cost: [Int]) -> Int {
+ if gas.reduce(0, +) < cost.reduce(0, +) {
+ return -1
+ }
+ var start = gas.count - 1, end = 0
+ var total = gas[start] - cost[start]
+
+ while start >= end {
+ while total < 0 && start >= end {
+ start -= 1
+ total += gas[start] - cost[start]
+ }
+ if start == end {
+ return start
+ }
+ total += gas[end] - cost[end]
+ end += 1
+ }
+ return -1
+ }
+}

swift/287-Find-The-Duplicate-Number.swift

@@ -0,0 +1,21 @@
+class Solution {
+ func findDuplicate(_ nums: [Int]) -> Int {
+ var slow = 0, fast = 0
+ while true {
+ slow = nums[slow]
+ fast = nums[nums[fast]]
+ if slow == fast {
+ break
+ }
+ }
+
+ var slow2 = 0
+ while true {
+ slow = nums[slow]
+ slow2 = nums[slow2] 
+ if slow == slow2 {
+ return slow
+ }
+ }
+ }
+}

swift/53-Maximum-Subarray.swift

@@ -0,0 +1,15 @@
+class Solution {
+ func maxSubArray(_ nums: [Int]) -> Int {
+ var res = nums[0]
+ var total = 0
+
+ for n in nums {
+ total += n
+ res = max(res, total)
+ if total < 0 {
+ total = 0
+ }
+ }
+ return res
+ }
+}

swift/78-Subsets.swift

@@ -0,0 +1,22 @@
+class Solution {
+ func subsets(_ nums: [Int]) -> [[Int]] {
+ var res : [[Int]] = []
+ var subset : [Int] = []
+
+ func dfs(_ i: Int) {
+ if i >= nums.count {
+ res.append(subset)
+ return
+ }
+ // decision to include nums[i]
+ subset.append(nums[i])
+ dfs(i + 1)
+ // decision NOT to include nums[i]
+ subset.removeLast()
+ dfs(i + 1)
+ }
+
+ dfs(0)
+ return res
+ }
+}