Added Go

Author: javadev

README.md

@@ -0,0 +1,38 @@
+1\. Two Sum
+
+Easy
+
+Given an array of integers `nums` and an integer `target`, return _indices of the two numbers such that they add up to `target`_.
+
+You may assume that each input would have **_exactly_ one solution**, and you may not use the _same_ element twice.
+
+You can return the answer in any order.
+
+**Example 1:**
+
+**Input:** nums = [2,7,11,15], target = 9
+
+**Output:** [0,1]
+
+**Explanation:** Because nums[0] + nums[1] == 9, we return [0, 1]. 
+
+**Example 2:**
+
+**Input:** nums = [3,2,4], target = 6
+
+**Output:** [1,2] 
+
+**Example 3:**
+
+**Input:** nums = [3,3], target = 6
+
+**Output:** [0,1] 
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>
+*   **Only one valid answer exists.**
+
+**Follow-up:** Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>)</code> time complexity?

src/main/go/g0001_0100/s0001_two_sum/readme.md

@@ -0,0 +1,17 @@
+package s0001_two_sum
+
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table
+// #Data_Structure_I_Day_2_Array #Level_1_Day_13_Hashmap #Udemy_Arrays #Big_O_Time_O(n)_Space_O(n)
+// #2024_01_28_Time_3_ms_(93.85%)_Space_4.2_MB_(58.64%)
+
+func twoSum(nums []int, target int) []int {
+	indexMap := make(map[int]int)
+	for i, num := range nums {
+		requiredNum := target - num
+		if j, ok := indexMap[requiredNum]; ok {
+			return []int{j, i}
+		}
+		indexMap[num] = i
+	}
+	return []int{-1, -1}
+}

src/main/go/g0001_0100/s0001_two_sum/solution.go

@@ -0,0 +1,35 @@
+2\. Add Two Numbers
+
+Medium
+
+You are given two **non-empty** linked lists representing two non-negative integers. The digits are stored in **reverse order**, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.
+
+You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/02/addtwonumber1.jpg)
+
+**Input:** l1 = [2,4,3], l2 = [5,6,4]
+
+**Output:** [7,0,8]
+
+**Explanation:** 342 + 465 = 807. 
+
+**Example 2:**
+
+**Input:** l1 = [0], l2 = [0]
+
+**Output:** [0] 
+
+**Example 3:**
+
+**Input:** l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+
+**Output:** [8,9,9,9,0,0,0,1] 
+
+**Constraints:**
+
+*   The number of nodes in each linked list is in the range `[1, 100]`.
+*   `0 <= Node.val <= 9`
+*   It is guaranteed that the list represents a number that does not have leading zeros.

src/main/go/g0001_0100/s0002_add_two_numbers/readme.md

@@ -0,0 +1,47 @@
+package s0002_add_two_numbers
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Math #Linked_List #Recursion
+// #Data_Structure_II_Day_10_Linked_List #Programming_Skills_II_Day_15
+// #Big_O_Time_O(max(N,M))_Space_O(max(N,M)) #2024_03_05_Time_4_ms_(84.60%)_Space_4.4_MB_(47.97%)
+
+/*
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+	dummyHead := &ListNode{}
+	p, q, curr := l1, l2, dummyHead
+	carry := 0
+
+	for p != nil || q != nil {
+		x, y := 0, 0
+		if p != nil {
+			x = p.Val
+			p = p.Next
+		}
+		if q != nil {
+			y = q.Val
+			q = q.Next
+		}
+
+		sum := carry + x + y
+		carry = sum / 10
+		curr.Next = &ListNode{Val: sum % 10}
+		curr = curr.Next
+	}
+
+	if carry > 0 {
+		curr.Next = &ListNode{Val: carry}
+	}
+
+	return dummyHead.Next
+}

src/main/go/g0001_0100/s0002_add_two_numbers/solution.go

@@ -0,0 +1,34 @@
+3\. Longest Substring Without Repeating Characters
+
+Medium
+
+Given a string `s`, find the length of the **longest** **substring** without repeating characters.
+
+**Example 1:**
+
+**Input:** s = "abcabcbb"
+
+**Output:** 3
+
+**Explanation:** The answer is "abc", with the length of 3. 
+
+**Example 2:**
+
+**Input:** s = "bbbbb"
+
+**Output:** 1
+
+**Explanation:** The answer is "b", with the length of 1. 
+
+**Example 3:**
+
+**Input:** s = "pwwkew"
+
+**Output:** 3
+
+**Explanation:** The answer is "wke", with the length of 3. Notice that the answer must be a substring, "pwke" is a subsequence and not a substring. 
+
+**Constraints:**
+
+*   <code>0 <= s.length <= 5 * 10<sup>4</sup></code>
+*   `s` consists of English letters, digits, symbols and spaces.

src/main/go/g0001_0100/s0003_longest_substring_without_repeating_characters/readme.md

@@ -0,0 +1,32 @@
+package s0003_longest_substring_without_repeating_characters
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table #Sliding_Window
+// #Algorithm_I_Day_6_Sliding_Window #Level_2_Day_14_Sliding_Window/Two_Pointer #Udemy_Strings
+// #Big_O_Time_O(n)_Space_O(1) #2024_03_05_Time_0_ms_(100.00%)_Space_2.5_MB_(98.66%)
+
+func lengthOfLongestSubstring(s string) int {
+	lastIndices := make([]int, 256)
+	for i := 0; i < 256; i++ {
+		lastIndices[i] = -1
+	}
+	maxLen := 0
+	curLen := 0
+	start := 0
+
+	for i := 0; i < len(s); i++ {
+		cur := s[i]
+		if lastIndices[cur] < start {
+			lastIndices[cur] = i
+			curLen++
+		} else {
+			lastIndex := lastIndices[cur]
+			start = lastIndex + 1
+			curLen = i - start + 1
+			lastIndices[cur] = i
+		}
+		if curLen > maxLen {
+			maxLen = curLen
+		}
+	}
+	return maxLen
+}

src/main/go/g0001_0100/s0003_longest_substring_without_repeating_characters/solution.go

@@ -0,0 +1,32 @@
+4\. Median of Two Sorted Arrays
+
+Hard
+
+Given two sorted arrays `nums1` and `nums2` of size `m` and `n` respectively, return **the median** of the two sorted arrays.
+
+The overall run time complexity should be `O(log (m+n))`.
+
+**Example 1:**
+
+**Input:** nums1 = [1,3], nums2 = [2]
+
+**Output:** 2.00000
+
+**Explanation:** merged array = [1,2,3] and median is 2. 
+
+**Example 2:**
+
+**Input:** nums1 = [1,2], nums2 = [3,4]
+
+**Output:** 2.50000
+
+**Explanation:** merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5. 
+
+**Constraints:**
+
+*   `nums1.length == m`
+*   `nums2.length == n`
+*   `0 <= m <= 1000`
+*   `0 <= n <= 1000`
+*   `1 <= m + n <= 2000`
+*   <code>-10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup></code>

src/main/go/g0001_0100/s0004_median_of_two_sorted_arrays/readme.md

@@ -0,0 +1,48 @@
+package s0004_median_of_two_sorted_arrays
+
+// #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Binary_Search #Divide_and_Conquer
+// #Big_O_Time_O(log(min(N,M)))_Space_O(1) #2024_03_05_Time_9_ms_(72.04%)_Space_4.8_MB_(67.69%)
+
+func findMedianSortedArrays(nums1 []int, nums2 []int) float64 {
+	if len(nums1) > len(nums2) {
+		nums1, nums2 = nums2, nums1
+	}
+
+	x, y := len(nums1), len(nums2)
+	low, high := 0, x
+
+	for low <= high {
+		partitionX := (low + high) / 2
+		partitionY := (x+y+1)/2 - partitionX
+
+		maxLeftX := getIntValue(nums1, partitionX-1)
+		minRightX := getIntValue(nums1, partitionX)
+
+		maxLeftY := getIntValue(nums2, partitionY-1)
+		minRightY := getIntValue(nums2, partitionY)
+
+		if maxLeftX <= minRightY && maxLeftY <= minRightX {
+			if (x+y)%2 == 0 {
+				return float64(max(maxLeftX, maxLeftY)+min(minRightX, minRightY)) / 2
+			} else {
+				return float64(max(maxLeftX, maxLeftY))
+			}
+		} else if maxLeftX > minRightY {
+			high = partitionX - 1
+		} else {
+			low = partitionX + 1
+		}
+	}
+
+	return 0.0
+}
+
+func getIntValue(nums []int, index int) int {
+	if index < 0 {
+		return -1000000
+	}
+	if index >= len(nums) {
+		return 1000000
+	}
+	return nums[index]
+}

src/main/go/g0001_0100/s0004_median_of_two_sorted_arrays/solution.go

@@ -0,0 +1,24 @@
+5\. Longest Palindromic Substring
+
+Medium
+
+Given a string `s`, return _the longest_ _palindromic_ _substring_ in `s`.
+
+**Example 1:**
+
+**Input:** s = "babad"
+
+**Output:** "bab"
+
+**Explanation:** "aba" is also a valid answer. 
+
+**Example 2:**
+
+**Input:** s = "cbbd"
+
+**Output:** "bb" 
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s` consist of only digits and English letters.

src/main/go/g0001_0100/s0005_longest_palindromic_substring/readme.md

@@ -0,0 +1,43 @@
+package s0005_longest_palindromic_substring
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Dynamic_Programming
+// #Data_Structure_II_Day_9_String #Algorithm_II_Day_14_Dynamic_Programming
+// #Dynamic_Programming_I_Day_17 #Udemy_Strings #Big_O_Time_O(n)_Space_O(n)
+// #2024_03_05_Time_0_ms_(100.00%)_Space_3.8_MB_(32.56%)
+
+func longestPalindrome(s string) string {
+	newStr := make([]byte, len(s)*2+1)
+	newStr[0] = '#'
+	for i := 0; i < len(s); i++ {
+		newStr[2*i+1] = s[i]
+		newStr[2*i+2] = '#'
+	}
+	dp := make([]int, len(newStr))
+	friendCenter, friendRadius := 0, 0
+	lpsCenter, lpsRadius := 0, 0
+
+	for i := 0; i < len(newStr); i++ {
+		if friendCenter+friendRadius > i {
+			dp[i] = min(dp[2*friendCenter-i], (friendCenter+friendRadius)-i)
+		} else {
+			dp[i] = 1
+		}
+		for i+dp[i] < len(newStr) && i-dp[i] >= 0 && newStr[i+dp[i]] == newStr[i-dp[i]] {
+			dp[i]++
+		}
+		if friendCenter+friendRadius < i+dp[i] {
+			friendCenter, friendRadius = i, dp[i]
+		}
+		if lpsRadius < dp[i] {
+			lpsCenter, lpsRadius = i, dp[i]
+		}
+	}
+	return s[(lpsCenter-lpsRadius+1)/2 : (lpsCenter+lpsRadius-1)/2]
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}