suma de pares ordenada
package main
import "fmt"
func main() {
TestPairSum()
}
func PairSum(data []int, target int) []int {
var result []int
for i, v := range data {
if v >= target {
return []int{}
}
if v+data[i+1] == target {
return []int{i, i + 1}
}
if i+1 == len(data) {
return []int{}
}
}
return result
}
func TestPairSum() {
table := map[uint8]struct {
Input []int
Target int
Want []int
}{
1: {Input: []int{5, -2, 3, 4, 6}, Target: 7, Want: []int{2, 3}},
2: {Input: []int{1, 1, 1}, Target: 2, Want: []int{0, 1}},
3: {Input: []int{2, 7, 11, 15}, Target: 9, Want: []int{0, 1}},
4: {Input: []int{2, 7, 11, 15}, Target: 10, Want: []int{}},
5: {Input: []int{}, Target: 5, Want: []int{}},
6: {Input: []int{5}, Target: 5, Want: []int{}},
7: {Input: []int{5, 5}, Target: 10, Want: []int{0, 1}},
8: {Input: []int{-1, 0, 1, 2, -2}, Target: 0, Want: []int{1, 3}},
9: {Input: []int{-3, 3}, Target: 0, Want: []int{0, 1}},
10: {Input: []int{1, 2, 3, 4, 5}, Target: 9, Want: []int{3, 4}},
11: {Input: []int{1, 2, 3, 4, 5}, Target: 3, Want: []int{0, 1}},
12: {Input: []int{-1, -1, -1, -1, -1}, Target: -2, Want: []int{0, 1}},
}
for k, v := range table {
result := PairSum(v.Input, v.Target)
if v.Want[0] != result[0] && v.Want[1] != result[1] {
fmt.Printf("Error test: %v\n Want:%v Result:%v", k, v.Want, result)
}
fmt.Printf("Test %v:Ok %v \n", k, result)
}
}
sugerencia de gemini
package main
import "fmt"
import "sort"
func PairSum(data []int, target int) []int {
sort.Ints(data) // Aseguramos que el array esté ordenado
left := 0
right := len(data) - 1
for left < right {
sum := data[left] + data[right]
if sum == target {
return []int{left, right}
} else if sum < target {
left++
} else {
right--
}
}
return []int{}
}
type TestCase struct {
Input []int
Target int
Want []int
}
func main() {
testCases := []TestCase{
{Input: []int{-5, -2, 3, 4, 6}, Target: 7, Want: []int{2, 3}},
{Input: []int{1, 1, 1}, Target: 2, Want: []int{0, 1}},
{Input: []int{2, 7, 11, 15}, Target: 9, Want: []int{0, 1}},
{Input: []int{2, 7, 11, 15}, Target: 10, Want: []int{}},
{Input: []int{}, Target: 5, Want: []int{}},
{Input: []int{5}, Target: 5, Want: []int{}},
{Input: []int{5, 5}, Target: 10, Want: []int{0, 1}},
{Input: []int{-1, 0, 1, 2, -2}, Target: 0, Want: []int{1, 3}},
{Input: []int{-3, 3}, Target: 0, Want: []int{0, 1}},
{Input: []int{1, 2, 3, 4, 5}, Target: 9, Want: []int{3, 4}},
{Input: []int{1, 2, 3, 4, 5}, Target: 3, Want: []int{0, 1}},
{Input: []int{-1, -1, -1, -1, -1}, Target: -2, Want: []int{0, 1}},
}
for i, tc := range testCases {
got := PairSum(tc.Input, tc.Target)
sort.Ints(got) // Ordenamos el resultado para comparar correctamente
sort.Ints(tc.Want)
if !equal(got, tc.Want) {
fmt.Printf("Caso %d falló: Input: %v, Target: %d, Got: %v, Want: %v\n", i+1, tc.Input, tc.Target, got, tc.Want)
} else {
fmt.Printf("Caso %d pasó: Input: %v, Target: %d, Got: %v, Want: %v\n", i+1, tc.Input, tc.Target, got, tc.Want)
}
}
}
func equal(a, b []int) bool {
if len(a) != len(b) {
return false
}
for i, v := range a {
if v != b[i] {
return false
}
}
return true
}
Pair Sum – Sorted
Easy
Given an array of integers sorted in ascending order and a target value, return the indexes of any pair of numbers in the array that sum to the target. The order of the indexes in the result doesn’t matter. If no pair is found, return an empty array.
Example 1:
Input: nums = [-5, -2, 3, 4, 6], target = 7
Output: [2, 3]
Explanation: nums[2] + nums[3] = 3 + 4 = 7
Example 2:
Input: nums = [1, 1, 1], target = 2
Output: [0, 1]
Explanation: other valid outputs could be [1, 0], [0, 2], [2, 0], [1, 2] or [2, 1].
Triplet Sum
Medium
Given an array of integers, return all triplets [a, b, c] such that a + b + c = 0 . The solution must not contain duplicate triplets (e.g., [1, 2, 3] and [2, 3, 1] are considered duplicates). If no such triplets are found, return an empty array.
Each triplet can be arranged in any order, and the output can be returned in any order.
Example:
Input: nums = [0, -1, 2, -3, 1]
Output: [[-3, 1, 2], [-1, 0, 1]]
Is Palindrome Valid
Easy
A palindrome is a sequence of characters that reads the same forward and backward.
Given a string, determine if it’s a palindrome after removing all non-alphanumeric characters. A character is alphanumeric if it’s either a letter or a number.
Example 1:
Input: s = 'a dog! a panic in a pagoda.'
Output: True
Example 2:
Input: s = 'abc123'
Output: False
Constraints:
- The string may include a combination of lowercase English letters, numbers, spaces, and punctuations.
Largest Container
Medium
You are given an array of numbers, each representing the height of a vertical line on a graph. A container can be formed with any pair of these lines, along with the x-axis of the graph. Return the amount of water which the largest container can hold.
Example:
Input: heights = [2, 7, 8, 3, 7, 6]
Output: 24
Shift Zeros to the End
Easy
Given an array of integers, modify the array in place to move all zeros to the end while maintaining the relative order of non-zero elements.
Example:
Input: nums = [0, 1, 0, 3, 2]
Output: [1, 3, 2, 0, 0]
Next Lexicographical Sequence
Medium
Given a string of lowercase English letters, rearrange the characters to form a new string representing the next immediate sequence in lexicographical (alphabetical) order. If the given string is already last in lexicographical order among all possible arrangements, return the arrangement that’s first in lexicographical order.
Example 1:
Input: s = 'abcd'
Output: 'abdc'
Explanation: "abdc" is the next sequence in lexicographical order after rearranging "abcd".
Example 2:
Input: s = 'dcba'
Output: 'abcd'
Explanation: Since "dcba" is the last sequence in lexicographical order, we return the first sequence: "abcd".
Constraints:
- The string contains at least one character.