CareerCup

You can do it in o(n) time complexity by using additional space.
Store all the elements in a hashmap as key-value pair, where key is number and value is index.(this will take O(n) time.)
traverse through the list and for each number see whether (sum-num) is present or not in hashmap.(searching in hashmap will take O(1) time)
if(num is present in hashmap){
print both number with indexes
}else{
do nothing.
}

Use Hash
for int i=0; i < arr.length; i++
hash.add(arr[i] as key,i as value);

foreach(Key k in hash.keys)
if there exists hash[8-k] then print hash[k] and has[8-k]
overall complexity 2 o(n)

hash table is best one, but if no additional memory used then
1. we should sort an array in inplace with Quick sort..
2. then keep track of start and end index in array , sum of start + end > given sum then....start++, else end--.

this way, we can get two number without using extra memory

I think using hashmap duplicates cannot be allowed. This works on log(n).When you add a duplicate it updates the value to later one. here is java code
public class SumInArr3 {
public static void findSumHashMap(int[] arr, int key) {
Map<Integer, Integer> valMap = new HashMap<Integer, Integer>();
for (int i = 0; i < arr.length; i++) {
valMap.put(arr[i], i); }
for (int i = 0; i < arr.length; i++) {
if (valMap.containsKey(key - arr[i])
&& valMap.get(key - arr[i]) != i) {
if (valMap.get(key - arr[i]) < i) {
int diff = key - arr[i];
System.out.println(arr[i] + " " + diff);}}}}
public static void main(String[] args) {
int[] arr = { 32, 40, 28, 37, 4, 12, 2, 51, 23, 50, 20, 56, 32,-50,110 };
int sum = 60;
findSumHashMap(arr, sum); }}

This one works on (N^2)/2
public class SumInArr2 {
public static void findSumHashMap(int[] arr, int key) {
for(int i=0;i<=arr.length-2;i++){
for(int j=i+1;j<=arr.length-1;j++){
if (key-arr[i]==arr[j]){
System.out.println(arr[i]+ "index:"+i+" "+arr[j]+ "index:"+j);}}} }
public static void main(String[] args) {
int[] arr={32,40,28,37,4,12,2,51,23,50,20,56};
int sum = 60;
findSumHashMap(arr,sum); }}

public class PairIndexSum {
	public static void printIndexPair(int[] array, int sum) {
		Map<Integer, LinkedList<Integer>> map = new HashMap<Integer, LinkedList<Integer>>();
		for (int i = 0; i < array.length; i++) {
			if (map.containsKey(array[i])) {
				map.get(array[i]).add(i);
			} else {
				LinkedList<Integer> list = new LinkedList<Integer>();
				list.add(i);
				map.put(array[i], list);
			}
		}
		for (int i = 0; i < array.length; i++) {
			if (map.containsKey(sum - array[i])) {
				LinkedList<Integer> list = map.get(sum - array[i]);
				for (Integer n : list) {
					if(i != n){
						System.out.println("Index:" + i + " " + n);
					}
				}
				map.remove(array[i]);
				map.remove(sum - array[i]);
			}
		}
	}

	public static void main(String[] args) {
		int[] array = { 1, 4, 4, 3, 7, 5, 8 };
		printIndexPair(array, 8);
	}

}

in python:

#!/usr/bin/python

a=[1,4,4,3,5,7,8]
sum=10
i=0
l=len(a)
while(i<l-1) :
    j=i+1
    while(j<l) :
        s1=int(a[i])+int(a[j])
        if (s1==sum) :
            print("position of i and j:%d, %d" % (i,j))
        j=j+1
    i=i+1

In Ruby

# O(n)
def sum_of_index_values sum_arr = [], sum
  sum_hash, i = {}, 0
  sum_arr.each do |x|
    sum_hash.store(i, x)
    i+=1
  end
  0.upto(sum_arr.size-1) do |i|
    remainder = sum - sum_arr[i]
    puts "#{remainder} " + '(index '"#{sum_arr[i]}"')' if sum_hash.include?(remainder)
  end
end

#include<stdio.h>
#include<conio.h>
void main()
{
int a[10];
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
(
if(a[i]+a[j]=k)
{
printgf("position of indexes %d %d",i,j)
}
}
}