Constructing a set of numbers so that all 3 element partitions have different subset sums I am interested in constructing a set of $S$ of $24$ positive integers so that any partition into $8$ $3$-element subsets, $S_1,\dots,S_8$ has the property that the sums
$$\sum_{s \in S_i} s$$
are different for every $i =1,2,\dots,8$. I would like to do this using the smallest possible maximum value of any element in the set, that is minimize $$\max_{s \in S} s.$$ I imagine that this has been studied and I simply do not know the right name for the problem.
Note that what I want is different from the "subset sum" problem which says ALL subsets of our 24 integers have different sums, although I suppose this answers the question with a (most likely) suboptimal construction.
More generally, I'm curious what is known about such sets -- for $n$ integer, how do we construct a set of $n$ positive integers such that every partition into $k$-element subsets has the property that the $k$ element subsets all have a different sum.
 A: I tried the greedy approach I suggested in a comment, and it produced a maximum of $13796$, as opposed to the value $17404$ in the OEIS table mentioned in the comments.
I wrote this little python script:
from itertools import combinations

xs = [1,2,3]
twos = {3,4,5}
threes = {6}
nextX = 4
while len(xs) < 24:
    if len(xs) != 23:
        newTwos = {nextX + x for x in xs}
        if newTwos & twos:
            nextX += 1
            continue
    newThrees = {nextX + t for t in twos}
    if newThrees & threes:
        nextX += 1
        continue
    twos |= newTwos
    threes |= newThrees
    xs.append(nextX)
    nextX += 1
print(xs)

# audit
test3 = {sum(t) for t in combinations(xs,3)}
if len(test3)== 24*23*22//6:
    print('Passed audit')
else:
    print('Failed audit')

We start with $\{1,2,3\}$ and repeatedly try adding the smallest integer not yet tested to the set.  We keep track of all the $2$-sums and $3$-sums.  When we test a new element we accept it if its addition would not create a duplicate $2$-sum or $3$-sum.  The $2$-sum test is necessary because if there were a duplicate  $2$-sum, the addition of an further element would necessarily create a duplicate $3$-sum.  This test is unnecessary when we add the $24$th elements to the set.
The script produced the output
[1, 2, 3, 5, 8, 14, 25, 45, 82, 140, 235, 388, 559, 839, 1286, 1582, 2221, 3144, 4071, 5795, 6872, 9204, 11524, 13796]
Passed audit

Of course, there's no guarantee that the greedy algorithm produces the optimal answer.  The greedy algorithm is guaranteed to work only when we have an underlying matroid.  We might define a set to be independent if all of its $3$-subsets have distinct sums.  A subset of an independent set is independent, but we don't have the property that all maximal independent subsets have the same size.  $\{1,2,3,4\}$ and $\{1,2,3,5,8\}$ are both maximal independent subsets of $\{1,2,3,4,5,6,7,8\}$.  So, we should call a set independent if all of its $3$-subsets have distinct sums, and all of its $2$-subsets have distinct sums.  Now it doesn't seem so easy to produce a counterexample, though if I were forced to guess, I'd say it's still not a matroid.
Even if it did turn out to be a matroid, we'd only have found the minimum for a superset of $\{1,2,3\}$, so we'd have work left to do.
