That was not clear at all from your question, but can easily be achieved:

ClearAll[RecurseSelectHelper,RecurseSelect]
RecurseSelectHelper[uniqsleft_List,remainingpairs_List,selectedpairs_List]:=Module[{sel,opts},
    If[Length[uniqsleft]>0,
        sel=First[uniqsleft];
        opts=Select[remainingpairs,MemberQ[#,sel]&];
        If[Length[opts]>0,
            Do[RecurseSelectHelper[Rest[uniqsleft],Complement[remainingpairs,o],Append[selectedpairs,o]],{o,opts}]
        ]
    ,
        Sow[selectedpairs]
    ]
]
RecurseSelect[pairs_List]:=Reap[RecurseSelectHelper[Union@@pairs,pairs,{}]][[2,1]]
ListSumPairSelect[list_List,sums_List]:=RecurseSelect[Select[Subsets[list,{2}],MemberQ[sums,Total[#]]&]]

Now calling the function:

list = {3, 2, 1, 6, 5, 4, 9, 7};
sums = {5, 6, 9, 10};
AbsoluteTiming[options = ListSumPairSelect[list, sums];]

Gives 864 options, in 47 milliseconds. Not that swapping each pair (a,b) and (b,a) have not been taken in to account (Replace Subset[...,{2}] by Tuples[...,2] to get all of them.

Hi Manjunath,

I think I finally understand what you want:

ClearAll[RecurseSelectHelper,RecurseSelect]
RecurseSelectHelper[uniqsleft_List,remainingpairs_List,selectedpairs_List]:=Module[{sel,opts},
    If[Length[uniqsleft]>0,
        sel=First[uniqsleft];
        opts=Select[remainingpairs,MemberQ[#,sel]&];
        Do[
            RecurseSelectHelper[Complement[uniqsleft,o],Select[remainingpairs,ContainsNone[#,o]&],Append[selectedpairs,o]]
           ,
            {o,opts}
        ]
    ,
        Sow[selectedpairs]
    ]
]
RecurseSelect[pairs_List]:=First[Reap[RecurseSelectHelper[Union@@pairs,pairs,{}]][[2]],{}]
ListSumPairSelect[list_List,sums_List]:=RecurseSelect[Select[Subsets[list,{2}],MemberQ[sums,Total[#]]&]]

calling it:

list = {3, 2, 1, 6, 5, 4, 9, 7}
sums = {5, 6, 9, 10};
AbsoluteTiming[options = ListSumPairSelect[list, sums]]

Gives:

{{{1, 9}, {2, 7}, {3, 6}, {5, 4}}}

One solution only. It can now only deal with unique values in 'list'. But that can be changed; I think you can deduce how the algorithm works and fine-tune it to your needs...

I'm surprised to not see this simple (and faster) method:

GroupBy[Select[Subsets[list, {2}], MemberQ[sums, Total[#]] &], Total]

One can also use GatherBy instead of GroupBy (whatever one prefers), output is slightly in a different form.

Hi I'm not really sure what you would like to achieve. It seems to me you have a list of numbers (sums) that can be constructed by summing up integers. The integerpartitions is exact what you need. When you go through that list for each item you generate the integerpartitions and next step is to see if any of these integer sets (or all?) is present in the list (use complement[]). I don't have mathematica at hand now but this should be easy when I see your code. But if your list contains eg (1,2,2,6) and sum is 5 you won't find a match if you only use pairs right? (1,2,2) would be a match but is missed in this approach. I hope this helps and this combined with Bill's suggestion you should be able to use much more then lists with 30 or more items. How many items do you have?

This should be enough of a hint to get you started.

Since it seems that you want to look at every possible pair of numbers from your list, you might look at the help page for the Outer function.

Outer[f, list, list]

is going to give every possible pair of numbers from your list to a function named f that you write. f is probably going to start with

f[ x_, y_ ] :=

and you need to think how you would complete that function, what you would return for a match and what would return for a non-match.