Vyxal, 8 bytes

s5ḋU'∑⁰= 

Try it Online!

-2 from emanresu

Takes list then target.

Explained

s5ḋU'∑⁰=­⁡​‎‎⁡⁠⁡‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁢‏⁠‎⁡⁠⁣‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁤‏‏​⁡⁠⁡‌⁤​‎‎⁡⁠⁢⁡‏‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁢⁢‏⁠‎⁡⁠⁢⁤‏‏​⁡⁠⁡‌⁢⁢​‎‎⁡⁠⁢⁣‏‏​⁡⁠⁡‌­ s # ‎⁡Sort the input. This helps with uniquification later 5ḋ # ‎⁢Get all combinations without replacement of length 5 U # ‎⁣Filter out duplicate instances of combinations ' # ‎⁤Keep combinations where: ∑ = # ‎⁢⁡ The sum equals ⁰ # ‎⁢⁢ The target 💎 

Created with the help of Luminespire.

Python 3, 95 bytes

f=lambda t,a,*p:[p][t*t:len(p)==5]or{i for v in[*a]for i in f(t-a.pop(0),[*a],*sorted([*p,v]))} 

Try it online!

Input target value and the array of nums, output a set of tuples.

Charcoal, 57 bytes

Ｗ⁻θυＦ№θ⌊ι⊞υ⌊ι≔⟦⟧θＦＥＸ²ＬυＥ⌕Ａ⮌⍘ι²1§υλＦ⁼⁵ＬιＦ⁼ηΣιＦ¬№θι⊞θιＥθ⭆¹ι 

Try it online! Link is to verbose version of code. Explanation:

Ｗ⁻θυＦ№θ⌊ι⊞υ⌊ι 

Sort the input list.

≔⟦⟧θ 

Start with no results.

ＦＥＸ²ＬυＥ⌕Ａ⮌⍘ι²1§υλ 

Get all subsets of the sorted list.

Ｆ⁼⁵Ｌι 

Filter on those that have length 5.

Ｆ⁼ηΣι 

Filter on those with the desired total.

Ｆ¬№θι 

Filter on those that are distinct.

⊞θι 

Keep only the distinct subsets of 5 with the correct total.

Ｅθ⭆¹ι 

Pretty-print the found subsets.

Jalapeño, 7 bytes

cₓ5u↥{Σ= 

Explained

cₓ5u↥{Σ= cₓ5 # Choices of length 5 of implicit input u # Unique only ↥{ # Where Σ= # Sum is equal to implicit second input 

Hex-Dump of Bytecode

 0 1 2 3 4 5 6 7 8 9 A B C D E F 0000: e8 35 e4 d1 c4 e9 59 

Try it Online!

Vyxal, 20 bytes

→tṖƛ5Þİ_;'∑←t=;λsS;ε 

First Vyxal submission 🎉 Almost certainly golf-able.

Explained

→t # Assign the target to t Ṗ # Get all permutations of the input list ƛ5Þİ_; # Taking the first 5 elements of each permutation '∑←t=; # Where the sum is equal to t λsS;ε # Uniqueify by the sorted string 

Try it Online!

Uiua, 11 bytes

◴▽=⤚≡/+⧅<5⍆ 

Try it!

◴▽=⤚≡/+⧅<5⍆ ⍆ # sort ⧅<5 # get quintuples ▽=⤚≡/+ # keep those for which the sum equals the target ◴ # and deduplicate 

05AB1E, 8 bytes

{5.ÆÙʒOQ 

Inputs in the order \$array,target\$. Outputs [] if there is no valid result.

Try it online or verify all test cases.

Explanation:

{ # Sort the first (implicit) input-list 5.Æ # Get all 5-element combinations of this list Ù # Uniquify this list of quintuplets ʒ # Filter it by: O # Where the sum of the quintuplet Q # Equals the second (implicit) input-integer # (after which the result is output implicitly) 

Japt, 12 bytes

Outputs an empty array if no solution is possible.

Íà5 â fÈx ¶V 

Try it

Íà5 â fÈx ¶V :Implicit input of array U & target integer V Í :Sort U à5 :Combinations of length 5 â :Deduplicate f :Filter by È :Passing through the following function x : Reduce by addition ¶V : Equal to V? 

JavaScript (V8), 91 bytes

f=([c,...x],s,n=R=[])=>1/n[4]?s||R[n.sort()]||print(R[n]=n):1/c&&f(x,s,n)^f(x,s-c,[...n,c]) 

Try it online!

JavaScript (Node.js), 97 bytes

f=([c,...x],s,n=R=[])=>1/n[4]?s||R[n.sort()]?[]:[R[n]=n]:1/c?[...f(x,s,n),...f(x,s-c,[...n,c])]:x 

Try it online!

JavaScript (Node.js), 98 bytes

f=(x,s,i=R={},...n)=>1/n[4]?s||R[n.sort()]?[]:[R[n]=n]:x.flatMap((e,j)=>i<=j?[]:f(x,s-e,j,...n,e)) 

Try it online!

Dedup

Wolfram Language (Mathematica), 68 bytes 50 bytes 40 bytes 37 bytes

Union@Pick[a=#~Subsets~{5},Tr/@a,#2]& 

Try it online!

Note

Returning "all possible permutations of one single array" is permitted eg test case 7:

Array: [1,0,9,6,5,0] Target: 21 Output: [[1,0,9,6,5],[1,9,6,5,0]] 

Saved 31 bytes by

1. Switching to Cases from Select allowed me to use a pure function

2. Union instead of DeleteDuplicates

3. Using Infix ~ on Subset

4. Using Tr instead of Total (thanks att!)

5. Not pre-sorting (Sort/@) input as permutations of output is permitted

6. Using Pick instead of Cases (thanks again att!)

JavaScript (V8), 91 bytes

f=([v,...a],n,o=q=[])=>o[4]?n||q[o.sort()]||print(q[o]=o):v+1&&f(a,n-v,[...o,[v]])|f(a,n,o) 

Try it online!

Commented

f = ( // f is a recursive function taking: [v, // v = next value from the input array ...a], // a[] = remaining values n, // n = target sum o = // o[] = current output array q = [] // q = object to keep track of output arrays ) => // o[4] ? // if o[4] is defined: n || // unless n is not 0 q[o.sort()] || // or q[o] is defined (with o[] sorted), print(q[o] = o) // print o[] and set q[o] : // else: v + 1 && // unless v is undefined, f( // do a 1st recursive call: a, // pass a[] n - v, // subtract v from n [...o, [v]] // append [v] to o[] ) | // end of recursive call f(a, n, o) // do a 2nd recursive call with everything unchanged 

R, 52 bytes

\(x,n)unique(t(combn(x,5,sort)[,combn(x,5,sum)==n])) 

Attempt This Online!

Returns quintuplets as rows of a matrix.

APL, 63 chars

{⍺{⍵/⍨(⍺∘=+/∧5∘=∘≢)¨⍵}{0=≢⍵:1⍴⊂⍬⋄⊃,/(⊃⍵){(⊂⍵),⊂⍵,1⍴⍺}¨(∇1↓⍵)}⍵} 

Takes the target on the left and the list of numbers on the right. Explanation, broken out slightly into a helper function:

combos←{0=≢⍵:1⍴⊂⍬⋄⊃,/(⊃⍵){(⊂⍵),⊂⍵,1⍴⍺}¨(∇1↓⍵)} ⍝ Recursively generate all combinations of the input array 0=≢⍵: ⍝ If the input is empty 1⍴⊂⍬ ⍝ return a one-element array containing an empty array (∇1↓⍵) ⍝ Otherwise recursively call with the tail of the list (⊃⍵){ }¨ ⍝ And apply to each result with the head of the list as the left input ⊂⍵,1⍴⍺ ⍝ Concat the right input with an array made from the left input (⊂⍵), ⍝ And concat with the input itself ⊃,/ ⍝ Join and disclose to not further nest the result {⍺{⍵/⍨(⍺∘=+/∧5∘=∘≢)¨⍵} combos ⍵} { ¨⍵} ⍝ Take all the possible combinations ⍵/⍨ ⍝ And replicate those that pass: ( ∧ ) ⍝ the AND of ⍺∘=+/ ⍝ the left input matches their sum 5∘=∘≢ ⍝ the right input has 5 elements 

Scala 3, 36 bytes

t=>_ combinations 5 filter(_.sum==t) 

Attempt This Online!

A function of type Int => Seq[Int] => Iterator[Seq[Int]].

Haskell + hgl, 21 bytes

nB sr<<ss5><fl<eq^.sm 

Attempt This Online!

Explanation

The order of operations is a bit strange here.

• ss5 get all quintuples
• fl filter those that ...
• sm their sum ...
• eq is equal to the input
• nB sr remove duplicates after sorting.

Reflection

We have some pretty good builtins here. The only 3-byte builtin is ss5 which definitely should not be a 2-byte function. It seems like we use a lot of glue, but it's not an area I can see much improvement. I really have all the glue I want. There's no parens and we don't even use any 3-byte composes.

It seems long but I don't really know how it could be shorter.

The only possible improvement is to make nB sr a builtin. I don't really know if this would be useful in the long term.

Arturo, 51 bytes

$[a,t][a|sort|combine.by:5|select=>[t=∑&]|unique] 

Jelly, 9 bytes

Ṣœc5S=¥ƇQ 

Try it online!

Loses to the Vyxal answer by 1 char as Jelly's combinations monad is 2 characters: œc.

Ṣœc5S=¥ƇQ Main, dyadic link. Arguments: list, n Ṣ Sort (to help with dedup) œc5 Generate all 5-permutations S=¥ Dyadic link: is the sum of the list = n? Ƈ Filter by Q Deduplicate 

Nekomata, 9 bytes

oS5Lũᵖ{∑= 

Attempt This Online!

oS5Lũᵖ{∑= o Sort the first input S Find a subset 5L Check that it has length 5 ũ Remove duplicate values of a non-deterministic object ᵖ{ Check that it satisfies the following condition: ∑ Its sum = Is equal to the second input 

Zsh, 99 bytes

Non-deterministic, but repeated calls to shuf is a good-enough solution for picking 5 numbers from a list.

t=$1;shift;${5?};{repeat $[2**#] S=(`shuf -n5<<<${(F)@}`)&&((${(j:+:)S}==t))&&echo ${(n)S}}|sort -u 

Try it online!, or try the 160-byte deterministic solution _{175b 189b 192b}

Husk, 8 bytes

ufo=⁰ΣṖ5 

Try it online!

Inputs target and array as separate arguments. Outputs [] if there is no valid solution.

Commented:

 Ṗ5 -- make a list of all possible quintuplets f -- filter the quintuplets... o=⁰Σ -- | that sum to the target u -- deduplicate 

Python 3, 755 674 576 573 376 88 85 77 71 bytes

-81 bytes thanks to @corvus_192
-98 bytes
-3 bytes
-197 bytes
-288 bytes thanks to @roblogic
-3 bytes
-8 bytes
-6 bytes

Changelog

Date Time Size Byte save User Credit (OG-csize)/OG -----------+-----------+-----------+------------+------------+-------------+ 2024-12-11 | 01:21:34Z | 755 bytes | -000 bytes | CrSb0001 | 00.00% | -----------+-----------+-----------+------------+------------+-------------+ 2024-12-13 | 15:32:42Z | 674 bytes | -081 bytes | corvus_192 | 10.73% | -----------+-----------+-----------+------------+------------+-------------+ 2025-01-06 | 21:34:44Z | 576 bytes | -098 bytes | CrSb0001 | 23.71% | -----------+-----------+-----------+------------+------------+-------------+ 2025-01-22 | 19:02:07Z | 573 bytes | -003 bytes | CrSb0001 | 24.11% | -----------+-----------+-----------+------------+------------+-------------+ 2025-03-19 | 23:33:17Z | 376 bytes | -197 bytes | CrSb0001 | 50.20% | -----------+-----------+-----------+------------+------------+-------------+ 2025-03-20 | 00:34:46Z | 088 bytes | -288 bytes | roblogic | 88.34% | | | | | CrSb0001 | | -----------+-----------+-----------+------------+------------+-------------+ 2025-03-20 | 00:49:56Z | 085 bytes | -003 bytes | CrSb0001 | 88.70% | -----------+-----------+-----------+------------+------------+-------------+ 2025-03-20 | 14:52:00Z | 077 bytes | -008 bytes | CrSb0001 | 89.80% | -----------+-----------+-----------+------------+------------+-------------+ 2025-03-21 | 16:07:30Z | 071 bytes | -006 bytes | CrSb0001 | 90.60% | -----------+-----------+-----------+------------+------------+-------------+ 

@corvus_192's comment from 2024-12-13
@roblogic's comment from 2025-02-06

from itertools import* lambda:{c for c in combinations(n,5)if sum(c)==t} 

(returns a list set of sorted lists tuples, or set() if there are none/array len is less than 5.)

Note that this is still a valid solution as 1) it's still a lambda function, just anonymous and 2) we can simply define n and t below before doing the unittests.

I've been trying to figure out how I can use itertools to help, but I'm admittedly unable to come up with anything. @roblogic, I am SO sorry for not taking the time to look into itertools.combinations, it ended up saving me a total of 667 670 684 bytes compared to my original solution!

Old 755:

def fiveSum (nums,target): nums.sort() s=[] for i in range(len(nums)-4): if i>0 and nums[i]==nums[i-1]: continue for j in range(i+1,len(nums)-3): for k in range(j+1,len(nums)-2): l,m=k+1,len(nums)-1 while l<m: a=nums[i]+nums[j]+nums[k]+nums[l]+nums[m] if a<target: l+=1 elif a>target: m-=1 else: s.append((nums[i],nums[j],nums[k],nums[l],nums[m])) l+=1 while nums[l]==nums[l-1] and l<m: l+=1 k=[] for b in list(set(s)): k.append(list(b)) return k 

Explanation:

def fiveSum (nums,target): nums.sort() # does NOT return all 4 solutions for the last case if removed, unsure why s=[] # ^ (only returns two/four arrays) for i in range(len(nums)-4): # i < j < k < l < m if i>0 and nums[i]==nums[i-1]: # later loops will cover all of the continue # other cases, so no need to recurse through them again for j in range(i+1,len(nums)-3): # for j in range for k in range(j+1,len(nums)-2): # for k in range l,m=k+1,len(nums)-1 # No more "_ in range" needed anymore while l<m: # i < j < k < l < m a=nums[i]+nums[j]+nums[k]+nums[l]+nums[m] # The sum if a<target: # check if nums[0]+nums[1]+...+nums[4] == target l+=1 # it probably doesn't, so increment l by 1 elif a>target: # if overshoot m-=1 # if it does, decrement m by 1 else: s.append((nums[i],nums[j],nums[k],nums[l],nums[m])) # append to list l+=1 while nums[l]==nums[l-1] and l<m: # More incrementation! (Yay?) l+=1 k=[] # The final list for b in list(set(s)): k.append(list(b)) return k # return List[List[str]] 

Maple, 57 bytes

(n,t)->[{select(x->add(x)=t,combinat:-choose(n,5))[]}[]]; 

Explanation:

Input: n = nums (list), t = target.

combinat:-choose outputs combinations in lex order.

select filters for those that add to the target.

conversion from list to set {...[]} makes unique, then [...[]] converts back to a list.