How to identify Self Complementing Code?
I think the table would go like this:  

Base 6   | Code
---------+-------
0        | 000       (0+0+0)
1        | 001       (0+0+1)
2        | 010       (0+2+0)
3        | 101       (2+0+1)
4        | 110       (2+2+0)
5        | 111       (2+2+1)


The weighting for each of the bits is 2, 2, 1 (see sum in brackets above for how each value is calculated)
In "normal" binary code the weighting goes 1, 2, 4, 8, 16, 32 etc. For example 4 is 100 (4 * 1) + (2 * 0) + (1 * 0)
As you can see reversing the bits turns n into 5-n.
e.g.
4 = 110 -> 5-4 = 001 (110, which is 4, when reversed to 001 which is 5-4 = 1)
3 = 101 -> 5-3 = 010 (101, which is 3, when reversed to 010 which is 5-3 = 2)   

Here is a useful document (see page 13)
Another one here

EDIT (more info) - A self complementing code is one in which the bits can be reversed (1's complement) to produce the base-1's complement of the number. Usually this would be the 9's complement for decimal, but your example above is base 6 so you take the 5's complement (e.g. 6-1).
The weights of a self complementing code must add up to base-1 (e.g. 2+2+1=5) because 0 is always represented by all bits at 0 (e.g. 000 in your example), and n-1 needs to complement this (e.g. 5 = 111 in your example)
Knowing the above, it is simply a matter of trying different weightings to see what fits given the initial information. If we know 010 is 2, then the middle bits weight must be 2. Using this information we proceed to 110, and we now know the third bits weight must be 2 to make 4. This only leaves the first bit, which must have a value of 1 to adhere to the weights adding up to base-1 (e.g. 5) stated above (also you could discover this by taking the 1's complement of the code for 4 (110) to produce the code for (5-4=1) 001)