1. Two Sum

C

typedef struct Pair{
	int val;
	int index;
}Pair;

int compair(const void * a, const void * b){
	const Pair * _a = (Pair *) a;
	const Pair * _b = (Pair *) b;
	return _a->val > _b->val;
}

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
	int *ans = (int *)malloc(sizeof(int) * 2);
	Pair arr[numsSize];
	for (int i=0; i<numsSize; ++i){
		arr[i].val = *(nums+i);
		arr[i].index = i;
	}

	qsort(arr, numsSize, sizeof(Pair), compair);

	int start = 0, end = numsSize-1;
	while(start < end){
		if (arr[start].val + arr[end].val > target)
			--end;
		else if (arr[start].val + arr[end].val < target)
			++start;
		else{
			ans[0] = arr[start].index;
			ans[1] = arr[end].index;
			break;
		}
	}
	*returnSize = 2;
	return ans;
}

Go

func twoSum(nums []int, target int) []int {
    sorted := make([][2]int, len(nums))

    for i, num := range nums {
		sorted[i] = [2]int{i, num}
	}

    sort.Slice(sorted, func(i, j int) bool {
        return sorted[i][1] < sorted[j][1]
    })

    left, right := 0, len(nums) - 1

    for left < right {
        sum := sorted[left][1] + sorted[right][1]

        switch {
            case sum == target:
                return []int{sorted[left][0], sorted[right][0]}
            case sum < target:
                left++
                break
            case sum > target:
                right--
                break
        }
    }

    return []int{}
}

Python

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        newlist = nums.copy()
        newlist.sort()
        front = 0
        end = len(newlist) - 1
        while True:
            if newlist[front] + newlist[end] < target:
                front += 1
            if newlist[front] + newlist[end] > target:
                end -= 1
            if newlist[front] + newlist[end] == target:
                break
        ans = []
        for i in range(0, len(nums)):
            if nums[i] == newlist[front]:
                ans.append(i)
            elif nums[i] == newlist[end]:
                ans.append(i)
        return ans

Rust

impl Solution {
    pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
        let mut v = Vec::<i32>::new();
        for i in &nums {
            v.push(*i);
        }
        v.sort();
        let (mut front, mut end): (usize, usize) = (0, v.len() - 1);
        loop {
            if (front > end || v[front] + v[end] == target) {
                break;
            } else if v[front] + v[end] > target {
                end -= 1;
            } else if v[front] + v[end] < target {
                front += 1;
            }
        }
        let (front, end) = (v[front], v[end]);
        let mut r = Vec::<i32>::new();
        for i in 0..nums.len() {
            if &nums[i] == &front {
                r.push(i as i32);
            } else if &nums[i] == &end {
                r.push(i as i32);
            }
        }
        r
    }
}

Typescript

function twoSum(nums: number[], target: number): number[] {
  let original: number[] = [...nums] // Clone nums
  nums.sort((a, b) => a - b) // Sort nums for searching
  let idx_down: number = 0,
    idx_up: number = nums.length - 1

  while (idx_down < idx_up) {
    // Assume exactly one solution
    let sum = nums[idx_down] + nums[idx_up]
    if (sum < target) ++idx_down
    else if (sum > target) --idx_up
    else break
  }

  let ans: number[] = []
  original.map((value, index) => {
    if (value == nums[idx_down]) ans.push(index)
    else if (value == nums[idx_up]) ans.push(index)
  })

  return ans
}