Three baskets and transferring apples This is from a math contest, and I do not have the idea how to approach it:

There are 6, 7, and 11 apples in three baskets. The goal is to make
  all basket contain equal number of apples, but while transferring
  apples from one basket to another, one can transfer only the number of
  apples that is already contained in destination basket. Also, only
  three such transfers are allowed. Is that possible?

Obviously, the answer can be deduced by computer brute force simulation, but this is not the spirit of the desired answer.
I appreciate any idea.
 A: From the rules it is obvious that you have to make transfers from baskets with more apples to baskets with less apples. Moreover, you have in total $24$ apples which means that you should aim at $8$ apples per basket (if possible). 
Now, working backwards, before the third transfer you need to make the move $$(8,4,12)\to(8,8,8)$$ But in order to achieve the state $(8,4,12)$ you need to go back to the first step and think of making all numbers even. Therefore a good initial transfer is $$(6,7,11)\to(6,14,4)$$ Now this allows the second transfer to be $$(6,14,4)\to(12,8,4)$$ and you are done. Summing up $$(7,11,6)\to(14,4,6)\to(8,4,12)\to(8,8,8)$$
A: The final configuration is evidently $8,8,8$, so the preceding configuration must be $4,8,12$.
In general, if a configuration has $a,b,2c$ (in some order) then preceding configurations are $a+c,b,c$ and $a,b+c,c$.  There are at most 6 configurations that can precede a given configuration.  So using brute force to work back one more step does not take too long.
The possible configurations before $4,8,12$ are:
$$\begin{array}{cc}
4 & 14 & 6 \\
2 & 10 & 12 \\
2 & 8 & 14 \\
10 & 8 & 6 \\
4 & 4 & 16
\end{array}$$
Since we are allowed only one more backwards move  to get back to the beginning, and since each move changes at most two of the piles, we can eliminate the configurations above that do not already have at least one of $6,7,$ or $11$. This eliminates all but two lines: 
$$\begin{array}{cc}
4 & 14 & 6 \\
10 & 8 & 6 \\
\end{array}$$
The $14$ is immediately suggestive bceause we need to work backwards to a pile with $7$, and the $14$ could have been $7$ before the first transfer; there is no way to work backward from $10,8,6$ to get a pile with $7$.  
So the solution is $$6,7,11\to 6,14,4\to 12,8,4\to 8,8,8.$$

I think the things to take away from this are:


*

*Working backwards from a known end state is sometimes easier than working forwards from a known start state. (I'm pretty sure this is one of the heuristics suggested by Pólya in How to Solve it.)

*Sometimes a small amount of brute force is worth a lot of reasoning.

*Watch out for suggestive results: the start state is known to have a $7$, so the appearance of the $14$ should be like lamp lighting up; each move doubles the size of one pile, and 14 could be the double of 7.

A: I'm not sure whether there is an approach that goes beyond what you could call "educated guessing" - namely a brute force search, but without a computer, but only with reasoning as a pruning criterion. 
I looked at the first options, which are
$(12, 1, 11)$, $(6,14,4)$, or $(12,7,5)$
The first one did not look promising after some further steps. The second one yielded
$(6,10,8)$ and $(12,4,8)$ as the next steps, which then can be converted into $(8,8,8)$.

Or, to phrase it that way: Given three baskets with $(a_0,b_0,c_0)$ apples, is there sequence of steps (according to the given rules) that yields baskets with $(a_i,b_i,c_i)$ apples where $a_i=b_i=c_i$ ? I think there is no way for systematically find the sequence of moves that is simpler than an exhaustive brute-force search. 

EDIT: It's indeed an interesting problem. I wrote a brute force solver, and tried to find other configurations that are solvable (just to give them here as examples to show why it's hard to find a systematic approach). However, I found it hard to find other solvable examples, so I ran a search for solvable configurations. In fact, there are 191 distinct configurations that result in $(8,8,8)$. I'll just drop the code here, maybe someone finds it interesting as well:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class AppleTransfer
{
    public static void main(String[] args)
    {
        List<Integer> list = Arrays.asList(6,7,11);
        computeResult(list);

        //search(24);
    }

    private static void search(int max)
    {
        Set<Set<Integer>> checked = new HashSet<Set<Integer>>();
        List<Integer> list = new ArrayList<Integer>(Arrays.asList(1,1,1));
        while (true)
        {
            Set<Integer> set = new HashSet<Integer>(list);
            if (!checked.add(set))
            {
                boolean b = computeResult(list);
                if (b)
                {
                    int sum = 0;
                    for (Integer s : list)
                    {
                        sum += s;
                    }
                    if (sum==24) System.out.println("Worked for "+list);
                }
            }
            list = new ArrayList<Integer>(list);
            if (!increment(list, max))
            {
                break;
            }
        }
    }

    private static boolean increment(List<Integer> list, int max)
    {
        return increment(list, list.size()-1, max);
    }

    private static boolean increment(List<Integer> list, int index, int max)
    {
        if (index == -1)
        {
            return false;
        }
        int n = list.get(index)+1;
        if (n > max)
        {
            list.set(index, 0);
            return increment(list, index-1, max);
        }
        list.set(index, n);
        return true;
    }

    private static boolean allEqual(List<Integer> list)
    {
        for (int i=1; i<list.size(); i++)
        {
            if (list.get(0) != list.get(i))
            {
                return false;
            }
        }
        return true;
    }

    private static boolean computeResult(List<Integer> input)
    {
        Map<List<Integer>, List<Integer>> predecessors = 
            new IdentityHashMap<List<Integer>, List<Integer>>();
        Set<List<Integer>> current = new LinkedHashSet<List<Integer>>();
        current.add(input);
        while (true)
        {
            //System.out.println("Searching "+current.size());
            Set<List<Integer>> next = computeSuccessors(current, predecessors);
            for (List<Integer> list : next)
            {
                if (allEqual(list))
                {
                    reportResult(list, predecessors);
                    return true;
                }
            }
            if (current.equals(next))
            {
                return false;
            }
            current = next;
        }
    }

    private static void reportResult(List<Integer> list,
        Map<List<Integer>, List<Integer>> predecessors)
    {
        System.out.println("Result:");
        List<Integer> current = list;
        while (current != null)
        {
            System.out.println(current);
            current = predecessors.get(current);
        }
    }

    private static Set<List<Integer>> computeSuccessors(
        Set<List<Integer>> current, Map<List<Integer>, List<Integer>> predecessors)
    {
        Set<List<Integer>> result = new LinkedHashSet<List<Integer>>();
        for (List<Integer> list : current)
        {
            result.addAll(computeSuccessors(list, predecessors));
        }
        return result;
    }

    private static Set<List<Integer>> computeSuccessors(
        List<Integer> list, Map<List<Integer>, List<Integer>> predecessors)
    {
        Set<List<Integer>> result = new LinkedHashSet<List<Integer>>();
        for (int s=0; s<list.size(); s++)
        {
            for (int t=0; t<list.size(); t++)
            {
                if (s != t)
                {
                    if (list.get(t) < list.get(s))
                    {
                        List<Integer> newList = new ArrayList<Integer>(list);
                        newList.set(t, list.get(t)+list.get(t));
                        newList.set(s, list.get(s)-list.get(t));
                        result.add(newList);
                        predecessors.put(newList, list);
                    }
                }
            }
        }
        return result;
    }
}

(Apologies that it's not Matlab or such ...)
A: A little late to the party, but here goes...
Every transfer does two things: it reduces the source basket's quantity by the quantity of the target basket (a - b), and it doubles the quantity of the target basket (b + b). We know from the fact that there are 24 apples (6 + 7 + 11 = 24) that our goal is to have 8 apples in each basket (24 / 3 = 8). We want to achieve that by performing a maximum of 3 transfers. Each transfer should bring us closer to our goal, therefore a transfer is considered most optimal if it results in a basket of 8, or slightly less optimal but still worthwhile if it results in a basket of 4, which can be doubled to 8 in a subsequent transfer (4 + 4 = 8).
So, on each transfer, assess the following questions, in order:
1) Are there two baskets such that a - b = 8?
2) Are there two baskets such that a - b = 4?

If the first answer is yes, then transfer from a to b and start over with the new basket configuration.
If the second answer is yes, then transfer from a to be and start over with the new basket configuration.
If both answers are no, then it probably cannot be done.
Using this process, we get the following:
(6, 7, 11)
1) There are no baskets such that a - b = 8.
2) 11 - 7 = 4, so transfer from the third basket to the second.

(6, 14, 4)
1) 14 - 6 = 8, so transfer from the second basket to the first.

(12, 8, 4)
1) 12 - 4 = 8, so transfer from the first basket to the third.

(8, 8, 8)

