TRUE XOR TRUE = FALSE

From the unit digit column,

$\begin{aligned} 2E + R &= 10n + E \hspace{5mm} \text{for some integer n} \\ E + R &= 10n \\ \implies E+R &= 10 \hspace{15mm} \because \text{0<E+R<20} \end{aligned}$

Scroll down for python exhaustive search.

We just have to look at the last column:

$E + R + E \pmod{10} = E | - E$

$R + E \pmod{10} = 0$

since R and E can't be 0 at the same time, R + E must equal 10.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

# does an exhaustive search of all possible combinations
def cryptogramSolver():
    possibleVals = list(range(10))

    inStr = ["TRUE", "XOR", "TRUE"]
    outStr = "FALSE"
    valMap = {}  # will be generated later

    # create entries for unknown chars
    def generateValueMap(s):
        for char in s:
            if char not in valMap:
                if not valMap.values():
                    valMap[char] = 0
                else:
                    valMap[char] = max(valMap.values()) + 1

    # ignore leading 0 cases
    def constraints(permutation):
        return permutation[valMap["T"]] is not 0 \
               and permutation[valMap["X"]] is not 0 \
               and permutation[valMap["F"]] is not 0

    def cryptogramToInt(cryptogram, permutation):
        accumulator = 0
        for index, char in enumerate(cryptogram):
            accumulator += permutation[valMap[char]] * (10 ** (len(cryptogram) - index - 1))
        return accumulator

    def addsUp(permutation):
        inI = 0
        for inS in inStr:
            inI += cryptogramToInt(inS, permutation)
        outI = cryptogramToInt(outStr, permutation)
        return inI == outI and constraints(permutation)

    for inS in inStr:
        generateValueMap(inS)
    generateValueMap(outStr)

    workingPermutations = set()
    for perm in itertools.permutations(possibleVals):
        if addsUp(perm):
            # ignore unused indices in the permutation
            workingPermutations.add(perm[:len(valMap)])

    for perm in workingPermutations:
        print("Working permutation:")
        for key in valMap:
            print(key, perm[valMap[key]])
        print("R + E =", perm[valMap["E"]] + perm[valMap["R"]], "\n")


cryptogramSolver()

$R+E = 10$ every time.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103

Working permutation:
T 5
R 7
U 8
E 3
X 4
O 9
F 1
A 2
L 0
S 6
R + E = 10 

Working permutation:
T 7
R 8
U 0
E 2
X 9
O 3
F 1
A 6
L 5
S 4
R + E = 10 

Working permutation:
T 6
R 7
U 8
E 3
X 5
O 2
F 1
A 4
L 0
S 9
R + E = 10 

Working permutation:
T 4
R 8
U 9
E 2
X 5
O 7
F 1
A 0
L 3
S 6
R + E = 10 

Working permutation:
T 6
R 2
U 7
E 8
X 5
O 4
F 1
A 3
L 0
S 9
R + E = 10 

Working permutation:
T 7
R 2
U 6
E 8
X 9
O 0
F 1
A 5
L 4
S 3
R + E = 10 

Working permutation:
T 6
R 8
U 3
E 2
X 9
O 0
F 1
A 4
L 5
S 7
R + E = 10 

Working permutation:
T 6
R 2
U 7
E 8
X 9
O 0
F 1
A 3
L 4
S 5
R + E = 10 

Just used simple code to solve this:

1
2
3
4
5

from itertools import permutations

for t,r,u,e,x,o,f,a,l,s in permutations('0123456789',10):
    if 2*int(t+r+u+e)+int(x+o+r)==int(f+a+l+s+e):
        print(int(r)+int(e))

1

10

E+R+E is equal to some number ending in the digit E. Therefore R+E is either 10 or 20. 20 is not a choice, so the answer is 10.

$\boxed{4}+\boxed{6}+\boxed{4}=1\boxed{4}$

$R= 6, E=4, R+E=\boxed{10}$

I guessed and then the thing worked. so do the thing and the thing dies the thing. the thing works is you just do the thing

The equation consisting the last column elements will be equal to

2E +R = E

Rearranging it,

E+R = 0

From the options given below , we only have one such number whose unit place has 0.

So,

E+R =10

EZY :-)