逆序加法（RTA）序列是通过在逆序上加一个数字，并对结果重复该过程而获得的序列。例如
因此，5的RTA序列包含10、11、22、44、88、176等。
数字n的RTA根是等于n或在其RTA序列中加n的最小数字。
例如，在RTA序列5、10、11、13、22、31等中找到44。其中5是最小的，因此RTAroot（44）= 5。
72不是任何数字的RTA序列的一部分，因此被视为其自己的RTA根。
输入是您的语言自然可以处理的范围内的正整数。
如上所述，输出是给定数字的RTA根。
Input
Output
44
5
72
72
132
3
143
49
1111
1
999
999
相关OEIS：A067031。输出将是此序列中的数字。
Answers:
->\a{first {a∈($_,{$_+.flip}...*>a)},1..a}->\a{ } # Anonymous code block
->\a # That takes a number a
first # Find the first element
1..a # In the range 1 to a
{ }, # Where
a∈ # a is an element of
( ... ) # A sequence defined by
$_, # The first element is the number we're checking
{$_+.flip} # Each element is the previous element plus its reverse
*>$a # The last element is larger than a{~{ℕ≤.&≜↔;?+}{|↰₁}|}ᶠ⌋
{{和}} -- f(n):
-- g(x):
{ -- h(y):
~ -- get z where k(z) = y
{ -- k(z):
ℕ≤. -- z>=0 and z<=k(z) (constrain so it doesn't keep looking)
&≜ -- label input (avoiding infinite stuff)
↔;?+ -- return z+reverse(z)
} --
{ --
|↰₁ -- return z and h(z) (as in returning either)
} --
| -- return h(x) or x (as in returning either)
} --
ᶠ -- get all possible answers for g(n)
⌋ -- return smallest of them
抱歉，您无法解释，这是我能提出的最好的解释
{|↰₁}那里的用法很简单但是很出色。干得好！
感谢user1472751 -2个字节（使用第二个until而不是list-comprehension＆head）！
f n=until((n==).until(>=n)((+)<*>read.reverse.show))(+1)1True对于任何RTA根，这将评估为：
(n==) . until (n<=) ((+)<*>read.reverse.show)这个词(+)<*>read.reverse.show是
\r-> r + read (reverse $ show r)这给本身增加了一个数字。
该功能会until反复应用，(+)<*>read.reverse.show直到超出我们的目标。
将所有这些包装在另一个until开头（并以11加）(+1)将找到第一个RTA根。
如果没有适当的RTA根目录n，我们最终会到达从n处until不应用该功能的地方n<=n。
until外部循环来节省2个字节：TIO
使用新版本的05AB1E（用Elixir重写）。
L.ΔλjÂ+
L # Create the list [1, ..., input]
.Δ # Iterate over each value and return the first value that returns a truthy value for:
λ # Where the base case is the current value, compute the following sequence:
Â+ # Pop a(n - 1) and bifurcate (duplicate and reverse duplicate) and sum them up.
# This gives us: a(0) = value, a(n) = a(n - 1) + reversed(a(n - 1))
j # A λ-generator with the 'j' flag, which pops a value (in this case the input)
# and check whether the value exists in the sequence. Since these sequences will be
# infinitely long, this will only work strictly non-decreasing lists.
j本质上检查输入值是否在序列中。£确保它返回序列的前n个值（与相同λ<...>}¹£）。
ṚḌ+ƊС€œi¹Ḣ
感谢@JonathanAllan打高尔夫球1个字节！
ṚḌ+ƊС€œi¹Ḣ Main link. Argument: n
€ Map the link to the left over [1, ..., n].
С For each k, call the link to the left n times. Return the array of k
and the link's n return values.
Ɗ Combine the three links to the left into a monadic link. Argument: j
Ṛ Promote j to its digit array and reverse it.
Ḍ Undecimal; convert the resulting digit array to integer.
+ Add the result to j.
œi¹ Find the first multindimensional index of n.
Ḣ Head; extract the first coordinate.
f=->n{(1..n).map{|m|m+(m.digits*'').to_i==n ?f[m]:n}.min}递归函数，它反复“撤消” RTA操作，直到得出无法生成的数字，然后返回最小值。
而不是使用filter冗长的，我只是map在1到数字之间的范围内。对于此范围内的每个m，如果m + rev（m）是数字，它将在m上递归调用该函数；否则，返回n。这既消除了对a的需求，filter又免费提供了f（n）= n的基本情况。
重点包括使用以下命令保存字节Integer#digits：
m.to_s.reverse.to_i
(m.digits*'').to_i
eval(m.digits*'')最后一个要短一个字节，但是可悲的是，Ruby解析0以八进制开头的数字。
fqQ.W<HQ+s_`
出人意料的快速和高效。所有测试用例一次运行不到2秒。
fqQ.W<HQ+s_` – Full program. Q is the variable that represents the input.
f – Find the first positive integer T that satisfies a function.
.W – Functional while. This is an operator that takes two functions A(H)
and B(Z) and while A(H) is truthy, H = B(Z). Initial value T.
<HQ – First function, A(H) – Condition: H is strictly less than Q.
+s_` – Second function, B(Z) – Modifier.
s_` – Reverse the string representation of Z and treat it as an integer.
+ – Add it to Z.
– It should be noted that .W, functional while, returns the ending
value only. In other words ".W<HQ+s_`" can be interpreted as
"Starting with T, while the current value is less than Q, add it
to its reverse, and yield the final value after the loop ends".
qQ – Check if the result equals Q.
LʒIFDÂ+})Iå}н
说明
L # push range [1 ... input]
ʒ } # filter, keep elements that are true under:
IF } # input times do:
D # duplicate
Â+ # add current number and its reverse
) # wrap in a list
Iå # check if input is in the list
н # get the first (smallest) one
global_counter..>。>
n=>(g=k=>k-n?g(k>n?++x:+[...k+''].reverse().join``+k):x)(x=1)n => // n = input
(g = k => // g() = recursive function taking k = current value
k - n ? // if k is not equal to n:
g( // do a recursive call:
k > n ? // if k is greater than n:
++x // increment the RTA root x and restart from there
: // else (k is less than n):
+[...k + ''] // split k into a list of digit characters
.reverse().join`` // reverse, join and coerce it back to an integer
+ k // add k
) // end of recursive call
: // else (k = n):
x // success: return the RTA root
)(x = 1) // initial call to g() with k = x = 1G¼N¹FÂ+йQi¾q]¹
-1个字节感谢@Emigna。
说明：
G # Loop `N` in the range [1, input):
¼ # Increase the global_counter by 1 first every iteration (0 by default)
N # Push `N` to the stack as starting value for the inner-loop
¹F # Inner loop an input amount of times
 # Bifurcate (short for Duplicate & Reverse) the current value
# i.e. 10 → 10 and '01'
+ # Add them together
# i.e. 10 and '01' → 11
Ð # Triplicate that value
# (one for the check below; one for the next iteration)
¹Qi # If it's equal to the input:
¾ # Push the global_counter
q # And terminate the program
# (after which the global_counter is implicitly printed to STDOUT)
] # After all loops, if nothing was output yet:
¹ # Output the input`@G:"ttVPU+]vG-}@
` % Do...while loop
@ % Push iteration index, k (starting at 1)
G:" % Do as many times as the input
tt % Duplicate twice
VPU % To string, reverse, to number
+ % Add
] % End
v % Concatenate all stack into a column vector. This vector contains
% a sufficient number of terms of k's RTA sequence
G- % Subtract input. This is used as loop condition, which is falsy
% if some entry is zero, indicating that we have found the input
% in k's RTA sequence
} % Finally (execute on loop exit)
@ % Push current k
% End (implicit). Display (implicit)
:!`tG=~yV2&PU*+tG>~*tXzG=A~]f1) 在线尝试！
n->{for(int i=0,j;;)for(j=++i;j<=n;j+=n.valueOf(new StringBuffer(j+"").reverse()+""))if(n==j)return i;}说明：
n->{ // Method with Integer as both parameter and return-type
for(int i=0,j;;) // Infinite loop `i`, starting at 0
for(j=++i; // Increase `i` by 1 first, and then set `j` to this new `i`
j<=n // Inner loop as long as `j` is smaller than or equal to the input
; // After every iteration:
j+= // Increase `j` by:
n.valueOf(new StringBuffer(j+"").reverse()+""))
// `j` reversed
if(n==j) // If the input and `j` are equal:
return i;} // Return `i` as result算术地将整数反转1个字节（104个字节）：
n->{for(int i=0,j,t,r;;)for(j=++i;j<=n;){for(t=j,r=0;t>0;t/=10)r=r*10+t%10;if((j+=r)==n|i==n)return i;}}f(i,o,a,b,c,d){for(a=o=i;b=a;o=i/b?a:o,a--)for(;b<i;b+=c)for(c=0,d=b;d;d/=10)c=c*10+d%10;return o;}给定输入i，检查从i到0的每个整数是否包含序列i。
i 是输入值o 是输出值（到目前为止找到的最小根）a 是正在检查的当前整数b是a的序列的当前元素c并d用于增加b其反向