add some questions

Author: shani1998

array/backtracking/kth_lexico_string.go

@@ -0,0 +1,75 @@
+package backtracking
+
+import "sort"
+
+/*
+A happy string is a string that:
+
+consists only of letters of the set ['a', 'b', 'c'].
+s[i] != s[i + 1] for all values of i from 1 to s.length - 1 (string is 1-indexed).
+For example, strings "abc", "ac", "b" and "abcbabcbcb" are all happy strings and strings "aa", "baa" and "ababbc" are not happy strings.
+
+Given two integers n and k, consider a list of all happy strings of length n sorted in lexicographical order.
+
+Return the kth string of this list or return an empty string if there are less than k happy strings of length n.
+
+
+
+Example 1:
+
+Input: n = 1, k = 3
+Output: "c"
+Explanation: The list ["a", "b", "c"] contains all happy strings of length 1. The third string is "c".
+*/
+
+func getHappyString(n int, k int) string {
+	happyStrings := getHappyStringUtil(0, n, "", []string{})
+	if len(happyStrings) < k {
+		return ""
+	}
+	sort.Strings(happyStrings)
+	return happyStrings[k-1]
+}
+
+func getHappyStringUtil(start, n int, result string, combinations []string) []string {
+	if len(result) == n {
+		combinations = append(combinations, result)
+		return combinations
+	}
+
+	for _, ch := range []string{"a", "b", "c"} {
+		if start > 0 && string(result[start-1]) == ch {
+			continue
+		}
+		combinations = getHappyStringUtil(start+1, n, result+ch, combinations)
+	}
+
+	return combinations
+}
+
+func getHappyString1(n int, k int) string {
+	count := 0
+	result := ""
+	generateHappyString(0, n, "", k, &count, &result)
+	return result
+}
+
+func generateHappyString(start, n int, current string, k int, count *int, result *string) {
+	if len(current) == n {
+		*count++
+		if *count == k {
+			*result = current
+		}
+		return
+	}
+
+	for _, ch := range []byte{'a', 'b', 'c'} {
+		if start > 0 && current[start-1] == ch {
+			continue
+		}
+		generateHappyString(start+1, n, current+string(ch), k, count, result)
+		if *result != "" { // Stop early when k-th happy string is found
+			return
+		}
+	}
+}

array/recursion/print_all_subsets.go …ktracking/recursion/print_all_subsets.goarray/recursion/print_all_subsets.go renamed to array/backtracking/recursion/print_all_subsets.go array/recursion/print_all_subsets.go renamed to array/backtracking/recursion/print_all_subsets.go

@@ -25,6 +25,26 @@ func subsets(nums []int) [][]int {
 	return res
 }
 
+// time to generate all subsets would be O(2^n) but copy operation will take O(n) time so total time complexity would be O(n*2^n)
+func generateAllSubsets(start int, nums, subset []int, subsets [][]int) [][]int {
+	if start == len(nums) {
+		tmpArr := make([]int, len(subset))
+		copy(tmpArr, subset)
+		subsets = append(subsets, tmpArr)
+		return subsets
+	}
+
+	// include the current element
+	subset = append(subset, nums[start])
+	subsets = generateAllSubsets(start+1, nums, subset, subsets)
+
+	// exclude the current element
+	subset = subset[:len(subset)-1]
+	subsets = generateAllSubsets(start+1, nums, subset, subsets)
+
+	return subsets
+}
+
 /*
                 []
                /   \

array/recursion/print_all_subsets_test.go …king/recursion/print_all_subsets_test.goarray/recursion/print_all_subsets_test.go renamed to array/backtracking/recursion/print_all_subsets_test.go array/recursion/print_all_subsets_test.go renamed to array/backtracking/recursion/print_all_subsets_test.go

@@ -0,0 +1,60 @@
+package backtracking
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+)
+
+/*
+Given a pattern containing I for increasing and D for decreasing, you need to find the smallest number following that pattern.
+You are given a 0-indexed string pattern of length n consisting of the characters 'I' meaning increasing and 'D' meaning decreasing.
+
+A 0-indexed string num of length n + 1 is created using the following conditions:
+
+num consists of the digits '1' to '9', where each digit is used at most once.
+If pattern[i] == 'I', then num[i] < num[i + 1].
+If pattern[i] == 'D', then num[i] > num[i + 1].
+Return the lexicographically smallest possible string num that meets the conditions.
+
+Example 1:
+
+Input: pattern = "IIIDIDDD"
+Output: "123549876"
+Explanation:
+At indices 0, 1, 2, and 4 we must have that num[i] < num[i+1].
+At indices 3, 5, 6, and 7 we must have that num[i] > num[i+1].
+Some possible values of num are "245639871", "135749862", and "123849765".
+It can be proven that "123549876" is the smallest possible num that meets the conditions.
+Note that "123414321" is not possible because the digit '1' is used more than once.
+*/
+func smallestNumber(pattern string) string {
+	comb := smallestNumberUtil(0, pattern, "", math.MaxInt)
+	return fmt.Sprintf("%d", comb)
+}
+
+func smallestNumberUtil(start int, pattern, result string, minNum int) int {
+	fmt.Println(start, result, pattern, len(pattern), minNum)
+
+	if start == len(pattern)+1 {
+		num, _ := strconv.Atoi(result) // Convert string to int
+		minNum = min(minNum, num)
+		return minNum
+	}
+
+	for i := 1; i <= 9; i++ {
+		if strings.Contains(result, fmt.Sprintf("%d", i)) {
+			continue
+		}
+		if start > 0 && pattern[start-1] == 'I' && int(result[start-1]-'0') > i {
+			continue
+		}
+		if start > 0 && pattern[start-1] == 'D' && int(result[start-1]-'0') < i {
+			continue
+		}
+		minNum = smallestNumberUtil(start+1, pattern, result+fmt.Sprintf("%d", i), minNum)
+	}
+
+	return minNum
+}

array/recursion/sum_arr.go array/backtracking/recursion/sum_arr.goarray/recursion/sum_arr.go renamed to array/backtracking/recursion/sum_arr.go

@@ -62,3 +62,53 @@ func maxSubArrayIndices(nums []int) (maxLeft int, maxRight int) {
 
 	return maxLeft, maxRight
 }
+
+// maximum-absolute-sum-of-any-subarray Ex: nums = [2,-5,1,-4,3,-2] -> 8
+// time complexity: O(2n), space complexity: O(1)
+func maxAbsoluteSum1(nums []int) int {
+	maxSum, minSum, currSum := 0, 0, 0
+
+	// maximum positive sum
+	for _, num := range nums {
+		currSum += num
+		maxSum = max(maxSum, currSum)
+		if currSum < 0 {
+			currSum = 0
+		}
+	}
+
+	// maximum negative sum
+	currSum = 0
+	for _, num := range nums {
+		currSum += num
+		minSum = min(minSum, currSum)
+		if currSum > 0 {
+			currSum = 0
+		}
+	}
+
+	return max(maxSum, -minSum)
+}
+
+// Time complexity: O(n), Space complexity: O(1)
+func maxAbsoluteSum2(nums []int) int {
+	maxSum, minSum := 0, 0
+	currMax, currMin := 0, 0
+
+	for _, num := range nums {
+		currMax += num
+		currMin += num
+
+		maxSum = max(maxSum, currMax)
+		minSum = min(minSum, currMin)
+
+		if currMax < 0 {
+			currMax = 0
+		}
+		if currMin > 0 {
+			currMin = 0
+		}
+	}
+
+	return max(maxSum, -minSum)
+}

array/recursion/sum_arr_test.go …y/backtracking/recursion/sum_arr_test.goarray/recursion/sum_arr_test.go renamed to array/backtracking/recursion/sum_arr_test.go array/recursion/sum_arr_test.go renamed to array/backtracking/recursion/sum_arr_test.go

@@ -0,0 +1,35 @@
+package searching
+
+import "math"
+
+func findMin(nums []int) int {
+	n := len(nums)
+	if n == 0 {
+		return -1 // Handle empty array case
+	}
+
+	low, high := 0, n-1
+	minNum := math.MaxInt
+
+	for low <= high {
+		mid := (low + high) / 2
+
+		// Always update the minimum value found
+		minNum = min(minNum, nums[mid])
+
+		// If the left half is sorted
+		if nums[low] <= nums[mid] {
+			// The minimum could be nums[low], so update minNum
+			minNum = min(minNum, nums[low])
+			// Discard the left half
+			low = mid + 1
+		} else { // Otherwise, right half is sorted
+			// The minimum could be nums[mid + 1], so update minNum
+			minNum = min(minNum, nums[mid+1])
+			// Discard the right half
+			high = mid - 1
+		}
+	}
+
+	return minNum
+}