Special subdivision of numbers from 1 to 99

Question

I've been lately working on a problem I still can't solve. The problem is:

Can we divide numbers from 1 to 99 into 33 groups of three numbers, such that in every group one number is the sum of the two remaining elements?

Thank you in advance for any help or indication :)

Answer 1

If it works for $n$ then it works for $4n$ and $4n+3$. This can be seen as follows: assume it works for $n$, then it works for the even numbers until $2n$ (just multiply everything by 2).

Now we take following combinations: $(2n+1)+(2n+2)=4n+3$, $(2n-1)+(2n+3)=4n+2$, $(2n-3)+(2n+4)=4n+1$, $\ldots$, $1+(3n+2)=3n+3$.

The only numbers we did not use are the even numbers until $2n$.

An analogous argument shows that it works for $4n$ if it works for $n$.

user7530 has shown that it works for $n=24$ in another answer, so we have an affirmative answer, since $99=4*24+3$.

(Thanks for showing the error in my previous answer, Dennis. I hope this one makes more sense.)

Answer 2

Not an answer, but some numerical data, generated using the following quick code:

#include <vector>
#include <iostream>
#include <cstdlib>

using namespace std;

void getCandidates(int sum, const vector<bool> &nums, vector<int> &choices)
{
    choices.clear();
    for(int i=0; i<(sum-1)/2; i++)
    {
        if(nums[i] && nums[sum-i-2] && i != sum-i-2)
        {
            choices.push_back(i);
        }
    }
}

bool recurse(const vector<bool> &nums)
{
    int max=-1;
    for(int i=0; i<nums.size(); i++)
    {
        if(nums[i])
            max = i;
    }
    if(max == -1)
    {
        return true;
    }
    vector<int> cands;
    getCandidates(max+1, nums, cands);
    for(int i=0; i<cands.size(); i++)
    {
        vector<bool> copy = nums;
        copy[max] = false;
        copy[cands[i]] = false;
        copy[max-cands[i]-1] = false;
        if(recurse(copy))
            return true;
    }
    return false;
}

void testSize(int size)
{
    vector<bool> nums;
    for(int i=0; i<size; i++)
        nums.push_back(true);
    cout << size << ": ";
    if(recurse(nums))
        cout << "yes";
    else
        cout << "no";
    cout << endl;
}

int main()
{
    for(int i=0; i<33; i++)
        testSize(3*i);
    return 0;
}

Output so far is pasted below. Worst-case runtime is exponential, so it may never get to 99, but I'll keep this updated as the program keeps running.

0: yes
3: yes
6: no
9: no
12: yes
15: yes
18: no
21: no
24: yes
27: yes
30: no
33: no
36: yes
39: yes
42: no
45: no
48: yes
51: yes
54: no
57: no
60: yes
63: yes

So far the answer seems to be "yes" whenever $n$ satisfies the necessary condition that $\frac{n(n+1)}{2}$ is even.

EDIT: Here is the solution for 24 as requested by Leen above.

(14, 4, 10) (15, 3, 12) (17, 8, 9) (18, 7, 11) (19, 6, 13) (21, 5, 16) (22, 2, 20) (24, 1, 23)