Median of Two Sorted Arrays:

Author: Luke-zhang-04

Easy/Two_Sum/Two_Sum.go

@@ -1,58 +1,60 @@
+package Two_Sum
+
 // Runtime: 76 ms, faster than 8.22% of Go online submissions for Two Sum.
 // Memory Usage: 2.9 MB, less than 100.00% of Go online submissions for Two Sum.
 // 16/12/2019
 // DD/MM/YY
 
 func in(target int, list []int) bool {
-    for _, i := range list {
-        if target == i {
-            return true
-        }
-    }
-  return false
+	for _, i := range list {
+		if target == i {
+			return true
+		}
+	}
+	return false
 }
 
 func count(target int, list []int) int {
-  total := 0
-  for _, i := range list {
-    if i == target {
-      total ++
-    }
-  }
-  return total
+	total := 0
+	for _, i := range list {
+		if i == target {
+			total++
+		}
+	}
+	return total
 }
 
 func indice(target int, list []int) []int {
-  indices := make([]int, 0, 0)
-  for i := 0; i < len(list); i++ {
-    if list[i] == target {
-      indices = append(indices, i)
-    }
-  }
-  return indices
+	indices := make([]int, 0, 0)
+	for i := 0; i < len(list); i++ {
+		if list[i] == target {
+			indices = append(indices, i)
+		}
+	}
+	return indices
 }
 
 func indexOf(target int, list []int) int {
-    for k, v := range list {
-        if target == v {
-            return k
-        }
-    }
-    return -1
+	for k, v := range list {
+		if target == v {
+			return k
+		}
+	}
+	return -1
 }
 
 func twoSum(nums []int, target int) []int {
-  for _, i := range nums {
-    if in(target-i, nums) {
-      if count(target-i, nums) >= 2 {
-        indices := indice(target-i, nums)
-        return []int {indices[0], indices[1]}
-      } else if indexOf(i, nums) == indexOf(target-i, nums) {
-        continue
-      } else {
-        return []int {indexOf(i, nums), indexOf(target-i, nums)}
-      }
-    }
-  }
-  return nil
-}
+	for _, i := range nums {
+		if in(target-i, nums) {
+			if count(target-i, nums) >= 2 {
+				indices := indice(target-i, nums)
+				return []int{indices[0], indices[1]}
+			} else if indexOf(i, nums) == indexOf(target-i, nums) {
+				continue
+			} else {
+				return []int{indexOf(i, nums), indexOf(target-i, nums)}
+			}
+		}
+	}
+	return nil
+}

Easy/Two_Sum/Two_Sum.py

@@ -3,11 +3,12 @@
 #16/12/2019
 #DD/MM/YY
 
-def twoSum(nums, target):
-  for i in nums:
-    if target-i in nums:
-      if nums.count(target-i) >= 2:
-        indices = [index for index, x in enumerate(nums) if x == target-i]
-        return [indices[0], indices[1]]
-      elif nums.index(i) == nums.index(target-i): continue
-      else: return [nums.index(i), nums.index(target-i)]
+class Solution:
+  def twoSum(self, nums, target):
+    for i in nums:
+      if target-i in nums:
+        if nums.count(target-i) >= 2:
+          indices = [index for index, x in enumerate(nums) if x == target-i]
+          return [indices[0], indices[1]]
+        elif nums.index(i) == nums.index(target-i): continue
+        else: return [nums.index(i), nums.index(target-i)]

Hard/Median_of_Two_Sorted_Arrays/Median_of_Two_Sorted_Arrays.go

@@ -0,0 +1,47 @@
+package Median_of_Two_Sorted_arrays
+
+// Runtime: 12 ms, faster than 89.45% of Go online submissions for Median of Two Sorted Arrays.
+// Memory Usage: 5.9 MB, less than 10.00% of Go online submissions for Median of Two Sorted Arrays.
+// 02/14/2020
+// MM/DD/YY
+// Suprisingly, shell sort has the fastest runtime for this method out of other sorting algorithms, such as
+// quicksort, merge sort, and merging (from merge sort)
+
+func shell_sort(array []int) []int {
+	gap := len(array) / 2
+	for gap >= 1 {
+		for i := gap; i < len(array); i++ { //iterate through array, starting from gap
+			comparator := array[i] //make comparisons with this
+			var output int         //for accessing x outside the array
+			var index int          //for negative indexes
+
+			for x := i; x > gap-2; x -= gap { //iterate throguh array with gap as the step
+				output = x     //to access x outside the loop
+				if x-gap < 0 { //in case of negative index
+					index = len(array) - x - gap
+				} else {
+					index = x - gap
+				}
+
+				if array[index] <= comparator { //break when correct spot is found
+					break
+				} else { //otherwise, move elements forward to make space
+					array[x] = array[index]
+				}
+			}
+			array[output] = comparator //insert comparator in the correct spot
+		}
+		gap /= 2 //increment the gap
+	}
+	return array
+}
+
+func findMedianSortedArrays(nums1 []int, nums2 []int) float64 {
+	array := append(nums1, nums2...)
+	array = shell_sort(array)
+	if len(array)%2 == 1 {
+		return float64(array[len(array)/2])
+	} else {
+		return float64(array[len(array)/2]+array[len(array)/2-1]) / 2
+	}
+}

Hard/Median_of_Two_Sorted_Arrays/Median_of_Two_Sorted_Arrays.js

@@ -0,0 +1,52 @@
+// Runtime: 104 ms, faster than 92.06% of JavaScript online submissions for Median of Two Sorted Arrays.
+// Memory Usage: 39.2 MB, less than 72.34% of JavaScript online submissions for Median of Two Sorted Arrays.
+// 02/14/2020
+// MM/DD/YY
+
+/*
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+*/
+
+function merge(array1, array2) {
+    let array = []
+    let first = 0
+    let second = 0
+
+    while (first < array1.length && second < array2.length) {
+        if (array1[first] > array2[second]) {
+            array.push(array2[second])
+			second++
+		} else if (array1[first] < array2[second]) {
+            array.push(array1[first])
+			first++
+		} else {
+            array.push(array2[second])
+            array.push(array1[first])
+			second++
+			first++
+        }
+    }
+
+    while (first < array1.length) {
+        array.push(array1[first])
+        first++
+    }
+
+    while (second < array2.length) {
+        array.push(array2[second])
+        second++
+    }
+
+    return array
+}
+
+var findMedianSortedArrays = function(nums1, nums2) {
+    let array = merge(nums1, nums2)
+    if (array.length % 2 === 1) {
+        return array[Math.floor(array.length/2)]
+    } else {
+        return (array[Math.floor(array.length/2)] + array[Math.floor(array.length/2)-1]) / 2
+    }
+}

Hard/Median_of_Two_Sorted_Arrays/Median_of_Two_Sorted_Arrays.py

@@ -0,0 +1,41 @@
+#Runtime: 92 ms, faster than 84.09% of Python3 online submissions for Median of Two Sorted Arrays.
+#Memory Usage: 12.7 MB, less than 100.00% of Python3 online submissions for Median of Two Sorted Arrays.
+#02/14/2020
+#MM/DD/YY
+
+class Solution:
+    #from merge sort
+    @staticmethod
+    def merge(array1, array2): #merge two arrays
+        array = [] #merged array
+        first = second = 0 #starting points
+
+        while first < len(array1) and second < len(array2):
+            if array1[first] > array2[second]:
+                array.append(array2[second])
+                second += 1
+            elif array1[first] < array2[second]:
+                array.append(array1[first])
+                first += 1
+            else:
+                array.append(array1[first])
+                array.append(array2[second])
+                first += 1
+                second += 1
+        
+        while first < len(array1):
+            array.append(array1[first])
+            first += 1
+
+        while second < len(array2):
+            array.append(array2[second])
+            second += 1
+
+        return array
+    
+    def findMedianSortedArrays(self, nums1, nums2):
+        array = self.merge(nums1, nums2)
+        if len(array) % 2 == 1:
+            return float(array[len(array)//2])
+        else:
+            return (array[len(array)//2] + array[len(array)//2-1]) / 2

Medium/Add_Two_Numbers/Add_Two_Numbers.go

@@ -1,3 +1,5 @@
+package Add_Two_Numbers
+
 // Runtime: 12 ms, faster than 65.70% of Go online submissions for Add Two Numbers.
 // Memory Usage: 5.9 MB, less than 7.32% of Go online submissions for Add Two Numbers.
 // 17/12/2019
@@ -11,8 +13,6 @@
  * }
  */
 
-package Add_Two_Numbers
-
 import (
     "strconv"
     "math/big"

Medium/Longest_Substring_Without_Repeating_Characters/Longest_Substring_Without_Repeating_Characters.go

@@ -1,54 +1,53 @@
+package lengthOfLongestSubstring
+
 // Runtime: 20 ms, faster than 31.05% of Go online submissions for Longest Substring Without Repeating Characters.
 // Memory Usage: 6.4 MB, less than 20.00% of Go online submissions for Longest Substring Without Repeating Characters.
 // 13/02/2020
 // DD/MM/YY
 
-package lengthOfLongestSubstring
-
 import "strings"
 
 func contains(target string, list []string) bool {
-    for _, i := range list {
-        if target == i {
-            return true
-        }
-    }
-  return false
+	for _, i := range list {
+		if target == i {
+			return true
+		}
+	}
+	return false
 }
 
 func set(arr []string) []string {
-    all := make([]string, 0, 0)
-    for _, elem := range arr {
-        if !contains(elem, all) {
-            all = append(all, elem)
-        }
-    }
-    return all
+	all := make([]string, 0, 0)
+	for _, elem := range arr {
+		if !contains(elem, all) {
+			all = append(all, elem)
+		}
+	}
+	return all
 }
 
-
 func lengthOfLongestSubstring(s string) int {
-    letters := set(strings.Split(s, ""))
-    longest := 0
-    if len(letters) <= 2 {
-        return len(letters)
-    } else {
-        for index, letter := range s {
-            subString := append(make([]string, 0, 0), string(letter))
-            for _, subLetter := range s[index+1:]{
-                if !contains(string(subLetter), subString) {
-                    subString = append(subString, string(subLetter))
-                } else {
-                    break
-                }
-            }
-            if len(subString) > longest {
-                longest = len(subString)
-            }
-            if longest == len(letters) || index >= len(s)-longest {
-                break
-            }
-        }
-    }
-    return longest
-}
+	letters := set(strings.Split(s, ""))
+	longest := 0
+	if len(letters) <= 2 {
+		return len(letters)
+	} else {
+		for index, letter := range s {
+			subString := append(make([]string, 0, 0), string(letter))
+			for _, subLetter := range s[index+1:] {
+				if !contains(string(subLetter), subString) {
+					subString = append(subString, string(subLetter))
+				} else {
+					break
+				}
+			}
+			if len(subString) > longest {
+				longest = len(subString)
+			}
+			if longest == len(letters) || index >= len(s)-longest {
+				break
+			}
+		}
+	}
+	return longest
+}