C＃中两个整数元组的总和

Question

I am trying to solve this question just as a preparation for a jobb interview: Write a function that, given a list and a target sum, returns zero-based indices of any two distinct elements whose sum is equal to the target sum. If there are no such elements, the function should return null.

For example, FindTwoSum(new List() { 1, 3, 5, 7, 9 }, 12) should return any of the following tuples of indices:

1, 4 (3 + 9 = 12)

2, 3 (5 + 7 = 12)

3, 2 (7 + 5 = 12)

4, 1 (9 + 3 = 12)

Here is what i have done so far

public static Tuple<int, int> FindTwoSum(List<int> list, int sum)
    {
        List<Tuple<int, int>> ListOfInt = new List<Tuple<int, int>>();
        for (int i=0; i<list.Count; i++)
        {
            for(int j=0; j<list.Count; j++)
            {
                if (list[i] + list[j] == sum)
                {
                    ListOfInt.Add(new Tuple<int, int>(i,j));
                }
            }
        }

        foreach ( var elemt in ListOfInt)
        {
            return elemt;
        }
        return null;

    }

The problem is that all results are found and saved in the Tuple: but i still cannot print out the result to the console. I think there is somthing wrong at the foreach statement. In the main method i am writing following to print the result to the console:

Console.WriteLine(FindTwoSum(new List<int>() { 1, 3, 5, 7, 9 }, 12));

Any recommendations please :)?

Answer 1

Well, if a + b = sum then b + a = sum , so you can cut the inner loop and return two pairs at once ; another issue and counter example for your current implementation is that a + a = sum doesn't count, eg

  {3, 6, 9}, 12

should return only

  0, 2 // 3 + 9
  2, 0 // 9 + 3

and not

  1, 1 // 6 + 6 is wrong

I'd rather implement the solution returning IEnumerable<Tuple<int, int>> :

  // Are you given List<int>? What about int[]? IEnumerable<int> is a much better choice 
  public static IEnumerable<Tuple<int, int>> FindTwoSum(IEnumerable<int> items, int sum) {
    // Validate Arguments (the method is public one!)
    if (null == items)
      throw new ArgumentNullException("items");

    var list = items.ToList();

    for (int i = 0; i < list.Count - 1; ++i)   // last line doesn't count
      for (int j = i + 1; j < list.Count; ++j) // note j = i + 1
        // if ((list[i] + list[j] == sum) && (list[i] != list[j])) { // distinct values and indexes
        if (list[i] + list[j] == sum) { // distinct indexes only
          yield return new Tuple<int, int>(i, j);
          yield return new Tuple<int, int>(j, i);                
        }
  }

In case of you want distinct values as well as distinct indexes the condition instead of

  if (list[i] + list[j] == sum)

should be

  if ((list[i] + list[j] == sum) && (list[i] != list[j]))

Distinct values , but not indexes is not a case, since a[i] == a[i] so whenever indexes are not distinct neither the values. And we have the condition

  if ((list[i] + list[j] == sum) && (list[i] != list[j]))

Test:

  // note that I can pass an array (int[]) or list (List<int>) whatever collection
  String report = String.Join(Environment.NewLine, 
    FindTwoSum(new int[] { 1, 3, 5, 7, 9 }, 12));

  // (1, 4)
  // (4, 1)
  // (2, 3)
  // (3, 2)
  Console.Write(report);

Answer 2

Change the return value of your method to IEnumerable<Tuple<int, int>> , then use yield return to return the value. You'll get the value when you enumerate the result in a loop (in your Main() method).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication13
{
    class Program
    {
        static void Main(string[] args)
        {
            var output = FindTwoSum(new List<int>() { 1, 3, 5, 7, 9 }, 12);
            foreach (var x in output)
                Console.WriteLine(x.Item1 + " " + x.Item2);

            Console.ReadKey(true);
        }

        public static IEnumerable<Tuple<int, int>> FindTwoSum(List<int> list, int sum)
        {
            List<Tuple<int, int>> ListOfInt = new List<Tuple<int, int>>();
            for (int i = 0; i < list.Count; i++)
            {
                for (int j = 0; j < list.Count; j++)
                {
                    if (list[i] + list[j] == sum)
                    {
                        ListOfInt.Add(new Tuple<int, int>(i, j));
                    }
                }
            }

            foreach (var elemt in ListOfInt)
            {
                yield return elemt;
            }

        }
    }
}

Answer 3

I noticed a potential problem in your example, given the wording of the question. You mention distinct elements, but you seem to take no steps to ensure the values you are using are distinct. You also appear to be able to sum the same element (i ==j)!.

The solution below shows how you could avoid the problems above, as well as avoiding having to put elements in a list as you go:

public static Tuple<int, int> FindTwoSum(int[] collection, int sum)
{
    int[] distinct = collection.Distinct().ToArray();
    for (int x = 0; x < distinct.Length; x++)
    {
        for (int y = 0; y < distinct.Length; y++)
        {
            if (y != x && distinct[x] + distinct[y] == sum)
                return Tuple.Create(Array.IndexOf(collection, distinct[x]), Array.IndexOf(collection, distinct[y]));
        }
    }
    return null;
}

You could then print this result using:

Tuple<int, int> result = FindTwoSum(new[] { 1,3, 5, 7, 9}, 12);
if (result != null)
    Console.WriteLine(result.Item1 + "," + result.Item2);
else
    Console.WriteLine("No solution!");

Answer 4

If you want to get fancy, you can use Linq:

var numbers = new List<int> {1, 3, 5, 7, 9};

int target = 12;
var items = numbers.Select((value, index) => new {index, value});

var hits = 
    from a in items
    from b in items
    where (a.index != b.index) && (a.value + b.value == target)
    select new {index1 = a.index, index2 = b.index};

Console.WriteLine(string.Join("\n", hits.Select(x => 
    $"{x.index1}, {x.index2} ({numbers[x.index1]} + {numbers[x.index2]} = {target})")));

How it works

This firstly uses numbers.Select((value, index) => new {index, value}); to convert a list of numbers into a sequence of [value, index] tuples.

Then it effectively does a double-loop over that sequence of tuples by doing

from a in items
from b in items

which produces all combinations of items from the sequence of tuples.

Then it uses where to filter out all the items which have the same index (using (a.index != b.index) and also to determine which sums match the target value (using (a.value + b.value == target) ).

Next it selects the results into a new tuple with properties index1 and index2 .

Finally it uses string.Join() to output the results from that tuple.

Answer 5

This section will return as soon as it finds the first element in the List.

    foreach ( var elemt in ListOfInt)
    {
        return elemt;
    }

You need to return List<Tuple<int, int>> and then in your consuming code loop through printing out Item1 and Item2

Answer 6

I'm one of those LINQish fans. So I just wrote the function with LINQ methods:

private static IEnumerable<Tuple<int, int>> FindTwoSum(IEnumerable<int> candidates, int expectedSum)
{
    return candidates.SelectMany((Lhs, LhsIndex) => candidates.Select((Rhs, RhsIndex) => new { Rhs, RhsIndex }).Where(r => r.RhsIndex != LhsIndex).Select(r => new { Lhs, r.Rhs }))
                        .Where(pair => pair.Lhs + pair.Rhs == expectedSum)
                        .Select(pair => Tuple.Create(pair.Lhs, pair.Rhs));
}

The hard part is to create all pairings in the first step. I simply get for each value additionally the index and then create pairs for all combinations where the index are different. After that it gets quite easy to simply check if they sum up to the expected value and create the desired tuples for the output.

To call this method you simply use:

var results = FindTwoSum(new[] { 1, 3, 5, 7, 9 }, 12);

foreach (var tuple in results)
{
    Console.WriteLine(tuple);
}

Answer 7

This loop:

    foreach ( var elemt in ListOfInt)
    {
        return elemt;
    }

will never "loop" back. In the first iteration, if there is a first element in the list, it will return which exits and abandons the loop.

If you really just want the first good pair, get rid of the List<> :

public static Tuple<int, int> FindTwoSum(List<int> list, int sum)
{
    for (int i=0; i<list.Count; i++)
    {
        for(int j=0; j<i; j++)
        {
            if (list[i] + list[j] == sum) // may want to append:   && list[i] != list[j]
            {
                return Tuple.Create(j, i);
            }
        }
    }
    return null;
}

Do you want to allow i == j in the returned tuple? (Edit: Changed my own code to disallow that.) You do not have to search both i > j and i < j , so choose one of them (as I did above).

You can use Tuple.Create when you want to make a new Tuple<,> .

Answer 8

To read the values form a Tuple, you call .Item1, .Item2, etc.

var myTuple = new Tuple<int, string, string>(123, "Cat", "Dog");

var id = myTuple.Item1;
var pet1 = myTuple.Item2;
var pet2 = myTuple.Item3;