Find Two Numbers with Sum

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  Ans = Table.AddColumn(
    Source, 
    "Answer", 
    (s) =>
      List.Last(
        List.Generate(
          () => [a = 1, b = 2], 
          each [a] + [b] <= s[Sum], 
          each [
            a = [a] + (if [b] + 1 > 9 then 1 else 0), 
            b = if [b] + 1 > 9 then [a] + 1 else [b] + 1
          ], 
          each if [a] <> [b] then Text.From([a]) & "+" & Text.From([b]) else null
        )
      )
  )
in
  Ans

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  Ans = Table.AddColumn(
    Source, 
    "Answer", 
    (s) =>
      Text.Combine(
        List.Select(
          List.Transform(
            {1 .. List.Min({s[Sum], 9})}, 
            each Text.Combine(
              List.Transform(
                List.Select({_ .. 9}, (a) => a > _ and a + _ = s[Sum]), 
                (b) => Text.From(_) & "+" & Text.From(b)
              ), 
              ", "
            )
          ), 
          each _ > ""
        ), 
        ", "
      )
  )
in
  Ans

let
 Fonte = Tabela1,
 a = Table.AddColumn(Fonte, "Personalizar", each [
a = {"1".."9"},
b = Lines.FromText(Text.From([Numbers])),
c = List.Difference(a,b) 
][c]),
 b = Table.ExpandListColumn(a, "Personalizar"),
 c = Table.AddColumn(b, "Personalizar.1", each [
a = List.Sum({[Numbers],Number.From([Personalizar])}),
b = Text.From([Numbers]) & " + " & Text.From([Personalizar])

]),
 d = Table.ExpandRecordColumn(c, "Personalizar.1", {"a", "b"}, {"a", "b"}),
 e = Table.Distinct(d, {"a"}),
 Filter = Table.SelectRows(e, each List.Contains(f[num],[a]) = true),
 f = hashtag#table({"num"},{{3},{5},{9},{10},{12},{15},{18}}),
 g = Table.NestedJoin(f, {"num"}, Filter, {"a"}, "f", JoinKind.LeftOuter),
 Result = Table.ExpandTableColumn(g, "f", {"b"}, {"b"})
in
 Result


                    
                  
          

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  SumToCheck = {3, 5, 9, 10, 12, 15, 18}, 
  ListOfNumbers = Source[Numbers], 
  Transformed = List.Transform(
    List.Combine(
      List.Transform(
        ListOfNumbers, 
        (a) =>
          List.Transform(
            List.Select(ListOfNumbers, (b) => b <> a), 
            (c) => Text.From(a) & "+" & Text.From(c)
          )
      )
    ), 
    each {_} & {Expression.Evaluate(_)}
  ), 
  Combinations = List.Transform(
    SumToCheck, 
    (s) =>
      Text.Combine(List.Transform(List.Select(Transformed, (d) => d{1} = s), (n) => n{0}), ", ")
  ), 
  Final = Table.FromColumns({SumToCheck, Combinations}, {"Sum", "Possible Combinations"})
in
  Final

let
 Source = Excel.CurrentWorkbook(){[Name="NumbersForSum"]}[Content],
 Custom = Table.AddColumn(Source, "Custom", each Source[Numbers]),
 Expanded = Table.ExpandListColumn(Custom, "Custom"),
 Addition = Table.AddColumn(Expanded, "Sum", each [Numbers] + [Custom], type number),
 Filtered = Table.SelectRows(Addition, each List.Contains(SumFromNumbers[Sum], [Sum]) and [Numbers]<>[Custom]),
 MergedCol = Table.CombineColumns(Table.TransformColumnTypes(Filtered, {{"Numbers", type text}, {"Custom", type text}}, "de-DE"),{"Numbers", "Custom"},Combiner.CombineTextByDelimiter("+", QuoteStyle.None),"Combinations"),
 MergedQuer = Table.NestedJoin(SumFromNumbers, {"Sum"}, MergedCol, {"Sum"}, "Filtered Rows", JoinKind.LeftOuter),
 Expanded2 = Table.ExpandTableColumn(MergedQuer, "Filtered Rows", {"Combinations"}, {"Combinations"}),
 Distinct = Table.Distinct(Expanded2, {"Sum"})
in
 Distinct


... alternative ALL possible number combinations:
 Grouped = Table.Group(Expanded2, {"Sum"}, {{"Combinations", each Text.Combine([Combinations], ", ")}})
in
 Grouped


                    
                  
          

let
 Source = Excel.CurrentWorkbook(){[Name="Table2"]}[Content],
 ToNumbers = Table.TransformColumnTypes(Source,{{"Sum", Int64.Type}})
in
 ToNumbers

Now Get Numbers Table (Table1) and Transform it (Next Comments)


                    
                  
          

let
  Nums = Excel.CurrentWorkbook(){[Name = "AllowedNumbers"]}[Content][Numbers], 
  Sums = Excel.CurrentWorkbook(){[Name = "Sums"]}[Content], 
  Result = Table.AddColumn(
    Sums, 
    "Answer", 
    each 
      let
        l = List.First(
          List.Select(
            List.Transform(
              Nums, 
              (a) =>
                [
                  c = List.Select(Nums, (b) => a + b = [Sum]), 
                  d = if not List.IsEmpty(c) then {a, c{0}} else null
                ][d]
            ), 
            (f) => f <> null and List.IsDistinct(f)
          )
        )
      in
        try (Text.From(l{0}) & " + " & Text.From(l{1})) otherwise null
  )
in
  Result

let
  Cartesian = () =>
    let
      s1 = List.Generate(
        () => [i = 1, j = 0, myList = {}], 
        each [i] <= 9, 
        each 
          if [j] < 9 then
            [i = [i], j = [j] + 1, myList = {i, j}]
          else
            [i = [i] + 1, j = 1, myList = {i, j}], 
        each _[myList]
      ), 
      s2 = List.Skip(s1)
    in
      s2, 
  Source = Table.FromRows(
    Json.Document(
      Binary.Decompress(
        Binary.FromText("i45WMlaK1YlWMgWTlmDS0ABCGUEoiJShhVJsLAA=", BinaryEncoding.Base64), 
        Compression.Deflate
      )
    ), 
    let
      _t = ((type nullable text) meta [Serialized.Text = true])
    in
      type table [sum = _t]
  ), 
  #"Changed Type" = Table.TransformColumnTypes(Source, {{"sum", Int64.Type}}), 
  #"Added Custom" = Table.AddColumn(
    #"Changed Type", 
    "Cartesian", 
    each 
      let
        ListWithCartesianProduct = Cartesian(), 
        ListSelected = List.Select(
          ListWithCartesianProduct, 
          (l) => (l{0} + l{1} = [sum]) and (l{0} <> l{1})
        ), 
        result = 
          if List.Count(ListSelected) = 0 then
            ""
          else
            Text.From(ListSelected{0}{0}) & " + " & Text.From(ListSelected{0}{1})
      in
        result
  )
in
  #"Added Custom"