167. Two sum sorted array

167_solution1_binarysearch.c

#include <stdlib.h>

int *twoSum(int *numbers, int numbersSize, int target, int *returnSize) {
    int *result = malloc(2 * sizeof(int));
    *returnSize = 2;

    for (int idx = 0; idx < numbersSize; idx++) {
        int diff = target - numbers[idx];
        int i = idx + 1, j = numbersSize - 1;

        while (i <= j) {
            int mid = i + (j - i) / 2;

            if (numbers[mid] == diff) {
                result[0] = idx + 1;
                result[1] = mid + 1;
                return result;
            }

            if (numbers[mid] > diff) {
                j = mid - 1;
            } else {
                i = mid + 1;
            }
        }
    }

    *returnSize = 0;
    return result;
}

167_solution2_just_twopointers.c

#include <stdlib.h>

int *twoSum(int *numbers, int numbersSize, int target, int *returnSize) {
    int left = 0, right = numbersSize - 1;
    int *result = malloc(2 * sizeof(int));
    *returnSize = 2;

    while (left < right) {
        int total = numbers[left] + numbers[right];

        if (total == target) {
            result[0] = left + 1;
            result[1] = right + 1;
            return result;
        } else if (total < target) {
            left++;
        } else {
            right--;
        }
    }

    *returnSize = 0;
    return result;
}

167_solution1_binarysearch.cpp

#include <vector>
using namespace std;
class Solution {
public:
  vector<int> twoSum(vector<int> &numbers, int target) {
    int i, j;

    for (int idx = 0; idx < numbers.size(); idx++) {
      int diff = target - numbers[idx];
      i = idx + 1;
      j = numbers.size() - 1;

      while (i <= j) {
        int mid = (i + j) / 2;

        if (numbers[mid] == diff)
          return {idx + 1, mid + 1};

        if (numbers[mid] > diff)
          j = mid - 1;
        else
          i = mid + 1;
      }
    }

    return {};
  }
};

167_solution2_just_twopointers.cpp

#include <vector>
using namespace std;

class Solution {
public:
  vector<int> twoSum(vector<int> &numbers, int target) {
    int left = 0, right = numbers.size() - 1;

    while (left < right) {
      if (numbers[left] + numbers[right] == target) {
        return {left + 1, right + 1};
      } else if (numbers[left] + numbers[right] > target) {
        right--;
      } else {
        left++;
      }
    }

    return {};
  }
};

167_solution1_binarysearch.go

package solution

func twoSum(numbers []int, target int) []int {
    for idx := 0; idx < len(numbers); idx++ {
        diff := target - numbers[idx]
        i, j := idx+1, len(numbers)-1

        for i <= j {
            mid := i + (j-i)/2

            if numbers[mid] == diff {
                return []int{idx + 1, mid + 1}
            }

            if numbers[mid] > diff {
                j = mid - 1
            } else {
                i = mid + 1
            }
        }
    }

    return []int{}
}

167_solution2_just_twopointers.go

package solution

func twoSum(numbers []int, target int) []int {
    left, right := 0, len(numbers)-1

    for left < right {
        total := numbers[left] + numbers[right]

        if total == target {
            return []int{left + 1, right + 1}
        } else if total < target {
            left++
        } else {
            right--
        }
    }

    return []int{}
}

167_solution1_binarysearch.java

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        for (int idx = 0; idx < numbers.length; idx++) {
            int diff = target - numbers[idx];
            int i = idx + 1, j = numbers.length - 1;

            while (i <= j) {
                int mid = i + (j - i) / 2;

                if (numbers[mid] == diff) {
                    return new int[] {idx + 1, mid + 1};
                }

                if (numbers[mid] > diff) {
                    j = mid - 1;
                } else {
                    i = mid + 1;
                }
            }
        }

        return new int[] {};
    }
}

167_solution2_just_twopointers.java

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int left = 0, right = numbers.length - 1;

        while (left < right) {
            int total = numbers[left] + numbers[right];

            if (total == target) {
                return new int[] {left + 1, right + 1};
            } else if (total < target) {
                left++;
            } else {
                right--;
            }
        }

        return new int[] {};
    }
}

167_solution1_binarysearch.js

class Solution {
  twoSum(numbers, target) {
    for (let idx = 0; idx < numbers.length; idx++) {
      const diff = target - numbers[idx];
      let i = idx + 1;
      let j = numbers.length - 1;

      while (i <= j) {
        const mid = Math.floor((i + j) / 2);

        if (numbers[mid] === diff) return [idx + 1, mid + 1];

        if (numbers[mid] > diff) j = mid - 1;
        else i = mid + 1;
      }
    }

    return [];
  }
}

167_solution2_just_twopointers.js

class Solution {
  twoSum(numbers, target) {
    let left = 0;
    let right = numbers.length - 1;

    while (left < right) {
      const total = numbers[left] + numbers[right];

      if (total === target) return [left + 1, right + 1];
      else if (total < target) left++;
      else right--;
    }

    return [];
  }
}

167_solution1_binarysearch.py

class Solution:
    def twoSum(self, numbers: list[int], target: int) -> list[int]:
        for idx in range(len(numbers)):
            diff = target - numbers[idx]
            i, j = idx + 1, len(numbers) - 1

            while i <= j:
                mid = (i + j) // 2

                if numbers[mid] == diff:
                    return [idx + 1, mid + 1]

                if numbers[mid] > diff:
                    j = mid - 1
                else:
                    i = mid + 1

        return []

167_solution2_just_twopointers.py

class Solution:
    def twoSum(self, numbers: list[int], target: int) -> list[int]:
        left, right = 0, len(numbers) - 1

        while left < right:
            total = numbers[left] + numbers[right]

            if total == target:
                return [left + 1, right + 1]
            elif total < target:
                left += 1
            else:
                right -= 1

        return []

167_solution1_binarysearch.rs

struct Solution;

impl Solution {
    fn two_sum(numbers: Vec<i32>, target: i32) -> Vec<i32> {
        for idx in 0..numbers.len() {
            let diff = target - numbers[idx];
            let mut i = idx as i32 + 1;
            let mut j = numbers.len() as i32 - 1;

            while i <= j {
                let mid = i + (j - i) / 2;

                if numbers[mid as usize] == diff {
                    return vec![idx as i32 + 1, mid + 1];
                }

                if numbers[mid as usize] > diff {
                    j = mid - 1;
                } else {
                    i = mid + 1;
                }
            }
        }

        vec![]
    }
}

167_solution2_just_twopointers.rs

struct Solution;

impl Solution {
    fn two_sum(numbers: Vec<i32>, target: i32) -> Vec<i32> {
        let mut left = 0i32;
        let mut right = numbers.len() as i32 - 1;

        while left < right {
            let total = numbers[left as usize] + numbers[right as usize];

            if total == target {
                return vec![left + 1, right + 1];
            } else if total < target {
                left += 1;
            } else {
                right -= 1;
            }
        }

        vec![]
    }
}