Add: programs

Author: openset

problems/binary-string-with-substrings-representing-1-to-n/binary_string_with_substrings_representing_1_to_n.go

@@ -0,0 +1,33 @@
+package binary_string_with_substrings_representing_1_to_n
+
+import "strings"
+
+func queryString(S string, N int) bool {
+	end := N >> 1
+	for N >= end {
+		if !strings.Contains(S, binaryString(N)) {
+			return false
+		}
+		N--
+	}
+	return true
+}
+
+func binaryString(n int) string {
+	B := make([]byte, 0, 30)
+	for n > 0 {
+		B = append(B, byte(n&1)+'0')
+		n >>= 1
+	}
+	swap(B)
+	return string(B)
+}
+
+func swap(B []byte) {
+	i, j := 0, len(B)-1
+	for i < j {
+		B[i], B[j] = B[j], B[i]
+		i++
+		j--
+	}
+}

problems/defanging-an-ip-address/defanging_an_ip_address.go

@@ -0,0 +1,7 @@
+package defanging_an_ip_address
+
+import "strings"
+
+func defangIPaddr(address string) string {
+	return strings.Replace(address, ".", "[.]", -1)
+}

problems/distant-barcodes/distant_barcodes.go

@@ -0,0 +1,31 @@
+package distant_barcodes
+
+import "sort"
+
+func rearrangeBarcodes(A []int) []int {
+	n := len(A)
+
+	count := [10001]int{}
+	for _, a := range A {
+		count[a]++
+	}
+
+	sort.Slice(A, func(i int, j int) bool {
+		if count[A[i]] == count[A[j]] {
+			return A[i] < A[j]
+		}
+		return count[A[i]] > count[A[j]]
+	})
+
+	res := make([]int, n)
+	i := 0
+	for _, a := range A {
+		res[i] = a
+		i += 2
+		if i >= n {
+			i = 1
+		}
+	}
+
+	return res
+}

problems/flip-columns-for-maximum-number-of-equal-rows/flip_columns_for_maximum_number_of_equal_rows.go

@@ -0,0 +1,31 @@
+package flip_columns_for_maximum_number_of_equal_rows
+
+import "strings"
+
+func maxEqualRowsAfterFlips(A [][]int) int {
+	count := make(map[string]int, 300)
+	var sb strings.Builder
+	for _, r := range A {
+		r0 := r[0]
+		for _, x := range r {
+			sb.WriteByte(byte(x ^ r0 + '0'))
+		}
+		count[sb.String()]++
+		sb.Reset()
+	}
+
+	res := 0
+
+	for _, c := range count {
+		res = max(res, c)
+	}
+
+	return res
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

problems/greatest-common-divisor-of-strings/greatest_common_divisor_of_strings.go

@@ -0,0 +1,36 @@
+package greatest_common_divisor_of_strings
+
+import "strings"
+
+func gcdOfStrings(s1, s2 string) string {
+	l1, l2 := len(s1), len(s2)
+	d := gcd(max(l1, l2), min(l1, l2))
+	p := s2[:d]
+	if s1 == strings.Repeat(p, l1/d) &&
+		s2 == strings.Repeat(p, l2/d) {
+		return p
+	}
+	return ""
+}
+
+// a >= b
+func gcd(a, b int) int {
+	if b == 0 {
+		return a
+	}
+	return gcd(b, a%b)
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

problems/largest-values-from-labels/largest_values_from_labels.go

@@ -0,0 +1,29 @@
+package largest_values_from_labels
+
+import "sort"
+
+func largestValsFromLabels(values []int, labels []int, num_wanted int, use_limit int) int {
+	for i, v := range values {
+		values[i] = v<<16 + labels[i]
+	}
+
+	sort.Slice(values, func(i int, j int) bool {
+		return values[i] > values[j]
+	})
+
+	count := [20001]int{}
+	res := 0
+	for _, v := range values {
+		if count[v&0xFFFF] == use_limit {
+			continue
+		}
+		res += v >> 16
+		count[v&0xFFFF]++
+		num_wanted--
+		if num_wanted == 0 {
+			break
+		}
+	}
+
+	return res
+}

problems/max-consecutive-ones-iii/max_consecutive_ones_iii.go

@@ -1,6 +1,5 @@
 package max_consecutive_ones_iii
 
-// ref: https://leetcode.com/problems/max-consecutive-ones-iii/discuss/247564/JavaC%2B%2BPython-Sliding-Window
 func longestOnes(A []int, K int) int {
 	left, right := 0, 0
 	for right = range A {

problems/moving-stones-until-consecutive-ii/moving_stones_until_consecutive_ii.go

@@ -0,0 +1,42 @@
+package moving_stones_until_consecutive_ii
+
+import "sort"
+
+func numMovesStonesII(stones []int) []int {
+	sort.Ints(stones)
+	return []int{low(stones), high(stones)}
+}
+
+func high(s []int) int {
+	n := len(s)
+	return max(s[n-1]-s[1], s[n-2]-s[0]) - n + 2
+}
+
+func low(s []int) int {
+	n := len(s)
+	// corner case
+	if (s[n-2]-s[0] == n-2 && s[n-1]-s[n-2] > 2) ||
+		(s[n-1]-s[1] == n-2 && s[1]-s[0] > 2) {
+		return 2
+	}
+	// sliding window is s[i:j]
+	width, i, j := 0, 0, 1
+	for ; j < n; j++ {
+		if s[j]-s[i] < n {
+			continue
+		}
+		width = max(width, j-i)
+		i = j
+	}
+	width = max(width, j-i)
+	// finally, all stone move into maxWidth windows
+	// so need move n-width stones
+	return n - width
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

problems/occurrences-after-bigram/occurrences_after_bigram.go

@@ -0,0 +1,16 @@
+package occurrences_after_bigram
+
+import "strings"
+
+func findOcurrences(text string, first string, second string) []string {
+	words := strings.Split(text, " ")
+	n := len(words)
+	res := make([]string, 0, n)
+	for i := 0; i+2 < n; i++ {
+		if words[i] == first &&
+			words[i+1] == second {
+			res = append(res, words[i+2])
+		}
+	}
+	return res
+}

problems/shortest-common-supersequence/shortest_common_supersequence.go

@@ -0,0 +1,64 @@
+package shortest_common_supersequence
+
+import "strings"
+
+func shortestCommonSupersequence(A, B string) string {
+	m, n := len(A), len(B)
+	// 解题思路，
+	//   先求出 A 和 B 的 LCS，
+	//   然后，在 LCS 上添加缺少的字母
+	// 利用 dp 求解 LCS ,
+	// dp[i][j]=k 表示 A[:i] 与 B[:j] 的 LCS 的长度为 k
+	// 在递归过程中，会出现三种情况:
+	//   1. A[i]=B[j]， 则 dp[i][j]= dp[i-1][j-1]+1
+	//   2. A[i]!=B[j] 且 dp[i-1][j] >= dp[i][j-1]，则 dp[i][j]=dp[i-1][j]
+	//   3. A[i]!=B[j] 且 dp[i-1][j] < dp[i][j-1]，则 dp[i][j]=dp[i][j+1]
+
+	dp := [1001][1001]int{}
+	b := [1001][1001]int{} // 记录哪种情况发生了，以便添加字母
+
+	for i := 1; i <= m; i++ {
+		for j := 1; j <= n; j++ {
+			if A[i-1] == B[j-1] {
+				dp[i][j] = dp[i-1][j-1] + 1
+				b[i][j] = 1
+			} else if dp[i-1][j] >= dp[i][j-1] {
+				dp[i][j] = dp[i-1][j]
+				b[i][j] = 2
+			} else {
+				dp[i][j] = dp[i][j-1]
+				b[i][j] = 3
+			}
+		}
+	}
+
+	var sb strings.Builder
+	var dfs func(int, int)
+	dfs = func(i, j int) {
+		if i == 0 {
+			sb.WriteString(B[:j])
+			return
+		}
+
+		if j == 0 {
+			sb.WriteString(A[:i])
+			return
+		}
+
+		switch b[i][j] {
+		case 1:
+			dfs(i-1, j-1)
+			sb.WriteByte(A[i-1])
+		case 2:
+			dfs(i-1, j)
+			sb.WriteByte(A[i-1])
+		case 3:
+			dfs(i, j-1)
+			sb.WriteByte(B[j-1])
+		}
+	}
+
+	dfs(m, n)
+
+	return sb.String()
+}