[Question]
  [
The reverse-then-add (RTA) sequence is a sequence obtained by adding a number to its reverse, and repeating the process on the result. For eg., 
$$ 5 + 5 = 10 \Rightarrow 10 + 01 = 11 \Rightarrow 11 + 11 = 22 \Rightarrow 22 + 22 = 44 \Rightarrow\text{ }... $$
Thus, 5's RTA sequence contains 10, 11, 22, 44, 88, 176, etc. 
The *RTA root* of a number \$n\$ is the smallest number that is either equal to \$n\$ or gives raise to \$n\$ in its RTA sequence. 
For eg., 44 is found in the RTA sequence of 5, 10, 11, 13, 22, 31, etc. Of these, 5 is the smallest, and hence RTAroot(44) = 5. 
72 is not part of any number's RTA sequence, and so is considered its own RTA root. 
**Input** is a positive integer in a range that your language can naturally handle. 
**Output** is the RTA root of the given number, as defined above. 
### Test cases
```
Input
Output
44
5
72
72
132
3
143
49
1111
1
999
999
```
Related OEIS: [A067031](http://oeis.org/A067031). The output will be a number from this sequence. 
  
[Answer]
# ~~[Perl 6](https://github.com/nxadm/rakudo-pkg)~~ Raku, ~~45 44~~ 39 bytes
```
{+(1...{$_∈($^a,{$_+.flip}...*>$_)})}
```
[Try it online!](https://tio.run/##NUvNCoMwDL7nKYKUoVM7tN1GGcoeYueJAwtlnYrVwxDvPudexGUyQ5Iv30/aqrOn5fXGncYMlzH0E875yIrPPPvsXkZ0hlxb006k73NWBFMwLYOr8Fa5/gJAv9eeTkf/1tSVI621Zf1XD4K4brotFOfITB0ha4ae9oOSTxwB0TjUfkhesJkeEczylXkwwSIlHAHO6a8hESkIAilAKkIqSACUUuvE8Rc "Perl 6 – Try It Online")
### Explanation:
```
{                                   }  # Anonymous code block
 +(1...                            )     # Find the first integer
       {                          }      # Where
        $_∈                              # The input is an element of
           (              ...    )         # A sequence defined by
            $^b,                           # The first element is the number we're checking
                {$_+.flip}                 # Each element is the previous element plus its reverse
                             *>$_          # The last element is larger than the input
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 24 22 bytes
```
{~{ℕ≤.&≜↔;?+}{|↰₁}|}ᶠ⌋
```
* 2 bytes thanks to sundar noticing that I had a `{{` and `}}`
# Explanation
```
                --  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
```
sorry for the wonky explanation, this is the best i could come up with
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/v7qu@lHL1EedS/TUHnXOedQ2xdpeu7a65lHbhkdNjbU1tQ@3LXjU0/3/vyEQ/I8CAA "Brachylog – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~59~~ 57 bytes
-2 bytes thanks to [user1472751](https://codegolf.stackexchange.com/users/65900/user1472751?tab=profile) (using a second `until` instead of list-comprehension & `head`)!
```
f n=until((n==).until(>=n)((+)<*>read.reverse.show))(+1)1
```
[Try it online!](https://tio.run/##JY1BC4JAEIXv/opBOsykLW0KYbheutapY0UIbSnpKLtr/Xxb9cHAx7wHX1Xaj26acXwBq4Fd3SCyUiQWLhQTYkT5ujC6fAqjv9pYLWzV/YgwkiTHtqwZFLRlf34A3nhTQD@4izMnhhVMS2CIIgjBN@FE8w@9kQgCmCIA8eC0dZY8TypaCpXn8Nbu2LHT7GwQzCOvu6ZpvN/FMvGXJrH0ibMsu49yK/8 "Haskell – Try It Online")
## Explanation
This will evaluate to `True` for any RTA-root:
```
(n==) . until (n<=) ((+)<*>read.reverse.show)
```
The term `(+)<*>read.reverse.show` is a golfed version of
```
\r-> r + read (reverse $ show r)
```
which adds a number to itself reversed.
The function `until` repeatedly applies `(+)<*>read.reverse.show` until it exceeds our target.
Wrapping all of this in yet another `until` starting off with `1` and adding 1 with `(+1)` will find the first RTA-root.
If there is no proper RTA-root of `n`, we eventually get to `n` where `until` doesn't apply the function since `n<=n`.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes
Using the new version of 05AB1E (rewritten in Elixir).
### Code
```
L.ΔλjÂ+
```
[Try it online!](https://tio.run/##yy9OTMpM/f/fR@/clHO7sw43af//b2ICAA "05AB1E – Try It Online")
### Explanation
```
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.
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~12~~ 11 bytes
```
ṚḌ+ƊÐ¡€œi¹Ḣ
```
This is a full program. Run time is roughly quadratic; test cases \$999\$ and \$1111\$ time out on TIO.
*Thanks to @JonathanAllan for golfing off 1 byte!*
[Try it online!](https://tio.run/##ASUA2v9qZWxsef//4bma4biMK8aKw5DCoeKCrMWTacK54bii////MTQz "Jelly – Try It Online")
### How it works
```
ṚḌ+ƊÐ¡€œ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.
```
[Answer]
## Ruby, ~~66~~ 57 bytes
```
f=->n{(1..n).map{|m|m+(m.digits*'').to_i==n ?f[m]:n}.min}
```
[Try it online!](https://tio.run/##KypNqvz/P81W1y6vWsNQTy9PUy83saC6JrcmV1sjVy8lMz2zpFhLXV1TryQ/PtPWNk/BPi06N9Yqr1YvNzOv9n@BQrSJiY65kY6hMRCbGOsYAoGOpaVlLMgcDbU0zf8A)
Recursive function that repeatedly "undoes" the RTA operation until arriving at a number that can't be produced by it, then returns the minimum.
Instead of using `filter`, which is long, I instead simply `map` over the range from 1 to the number. For each *m* in this range, if *m + rev(m)* is the number, it calls the function recursively on *m*; otherwise, it returns *n*. This both removes the need for a `filter` and gives us a base case of *f(n) = n* for free.
Highlights include saving a byte with `Integer#digits`:
```
m.to_s.reverse.to_i
(m.digits*'').to_i
eval(m.digits*'')
```
The last one would be a byte shorter, but sadly, Ruby parses numbers starting with `0` as octal.
[Answer]
# [Python 2](https://docs.python.org/2/), 70 bytes
```
f=lambda n,i=1,k=1:i*(k==n)or f(n,i+(k>n),[k+int(`k`[::-1]),i+1][k>n])
```
[Try it online!](https://tio.run/##FU3BCoMwFLvvK95FbGcdqxaGhfojIuimske1lbY7@PXuGUgOSUj2I329q07cdh8SxCPeiI84pzB/fiGidytumJh8Evi5mHXc3tMITqCRwhqp8c6sMY77AAsju2C2dVx0tkCX2GCHTutS9pwS2XeU9TRDZQfogCkl4FUJkPUlqiYhCGiahusbwB5oBfJMTVC2kFVTDhnQzfXF@fkH "Python 2 – Try It Online")
[Answer]
# [Pyth](https://pyth.readthedocs.io), 12 bytes
```
fqQ.W<HQ+s_`
```
[Check out a test suite!](https://pyth.herokuapp.com/?code=fqQ.W%3CHQ%2Bs_%60&input=44&test_suite=1&test_suite_input=44%0A72%0A132%0A143%0A1111%0A999&debug=0)
Surprisingly fast and efficient. All the test cases ran at once take less than 2 seconds.
### How it works
```
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.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 13 bytes
```
LʒIFDÂ+})Iå}н
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f59QkTzeXw03atZqeh5fWXtj7/7@hiTEA "05AB1E – Try It Online")
**Explanation**
```
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
```
[Answer]
# JavaScript (ES6), 61 bytes
```
n=>(g=k=>k-n?g(k>n?++x:+[...k+''].reverse().join``+k):x)(x=1)
```
[Try it online!](https://tio.run/##XcnRCoMgAIXh6@0pdpciGaYjDLQHGYOimZShQ0f49i5wN/NcHf5vm44pzH59f2rrXiotIlkhgRZGSFPbQQMj7YBQ7NEDY2xQVT2xV4fyQQGIN7facUQG9hGCKAhMs7PB7QrvToMFMAbhpWlu9@t/79rcu7YAQn9CS2A0A@OlnMtECuGcZzhP@gI "JavaScript (Node.js) – Try It Online")
### Commented
```
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 = 1
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~21~~ ~~16~~ 15 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
G¼N¹FÂ+Ð¹Qi¾q]¹
```
-1 byte thanks to *@Emigna*.
[Try it online.](https://tio.run/##ASMA3P8wNWFiMWX//0fCvE7CuUbDgivDkMK5UWnCvnFdwrn//zEzMg)
**Explanation:**
```
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
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 33 bytes
```
Ｎθ≔⊗θηＷ›ηθ«≔Ｌ⊞ＯυωηＷ‹ηθ≧⁺Ｉ⮌Ｉηη»ＩＬυ
```
[Try it online!](https://tio.run/##NY1BDoIwEEXXcIoup0ldqEtWRhNjgkq4QcEJJakFOi0sjGevjZTlvP/fn1ZJ2w5Sh3Azo3cP/27QwsSL/ETUdwYug280viISTEW8qF4jg6tF6WJTCTZxzj55lvolms4pqDyp54hWusGCF2zhyc/SQIlEm32X42rXfaccVNqTYGdJDmqc0RLC/1B8G/nmle2NW3H66GNahLA/HsJu1j8 "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｎθ
```
Input \$q\$.
```
≔⊗θη
```
Assign \$2q\$ to \$h\$ so that the loop starts.
```
Ｗ›ηθ«
```
Repeat while \$h>q\$:
```
≔Ｌ⊞Ｏυωη
```
push a dummy null string to \$u\$ thus increasing its length, and assign the resulting length to \$h\$;
```
Ｗ‹ηθ
```
repeat while \$h<q\$:
```
≧⁺Ｉ⮌Ｉηη
```
add the reverse of \$h\$ to \$h\$.
```
»ＩＬυ
```
Print the final length of \$u\$ which is the desired root.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 17 bytes
```
`@G:"ttVPU+]vG-}@
```
[Try it online!](https://tio.run/##y00syfn/P8HB3UqppCQsIFQ7tsxdt9bh/39DE2MA "MATL – Try It Online")
### Explanation
```
`         % 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)
```
[Answer]
# Java 8, 103 bytes
```
n->{for(int i=0,j;;)for(j=++i;j<=n;j+=n.valueOf(new StringBuffer(j+"").reverse()+""))if(n==j)return i;}
```
[Try it online.](https://tio.run/##ZZCxTsMwEIb3PsUpky3TqKWRUDBmYGOgDB2BwaSXyia9VLYThKo8e3DSDKnqwdL33@nu01nd6qXd//RFpb2HN23ovAAwFNCVukDYDjgGULDXGB/QAXEZ024RPx90MAVsgUBBT8vnc1k7NrQbtbqzUvKBrRLCSPukSFqhKG111eB7yQh/YRecocNLU5YYG0WS8NRhi84j4wNxE/uUstxhaByBkV0vh9Wn5ruKqyeDtjZ7OEZ/dhn48QWaX@QD@sDWq1F6oiyb08P9nNaba8w2VxjfnPM8v7nG6DJWx0NMGrs/H/CY1k1IT9EwVMSMSB4/QyIoLZjh05yu/wc)
**Explanation:**
```
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
```
---
Arithmetically reversing the integer is 1 byte longer (**104 bytes**):
```
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;}}
```
[Try it online.](https://tio.run/##ZZDBasMwDIbvfQpRGNhzmiVrYGSee99hvfS47eClTpGXOsVRCqPLs2dOFljKBBZ8v4T0W1af9cruP/ui0k0DLxrdZQGAjowvdWFgO@AoQMGeg3wwHhyXQe0WITWkCQvYggMFvVttLmXt2dCOKolsRJGXkg@aVUKgtE/KST42kbKRV4mkTXh3Kk24V/42TQTdpInEkjErlOdKuW8MiXtDrXeAsut6Oew@tR9V2D1ZONe4h2P4ANuRR3d4fQfNf92TaYiF@fKPsmxOD/dzStfXmK2vMMSc8zz/d47Ry1gdLzHZ2H01ZI5x3VJ8Cg6pcgzF8vGNlsLFBUM@zen6Hw)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 120 100 99 bytes
```
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;}
```
[Try it online!](https://tio.run/##JY3LCsIwEEX3fkUQComdYqKlUsfRD1EXeViZha0EXZV@e03qhXmey4yvnt7PcycZBrDgwENQYzdEaWkgRkcWU926iz0mQ1WpzNCdEirJL5MnDYEcBgxbMlp58hujy1AYjfHx@cZeDDjN3H/Ey3IvlRhXIikvbIzX5k5jXcNhB2afot5D27ZgkiZcjPlJNjNpFHxqUipLtaCsd0ywk@uCRXUWBd/6NSyH@Q6ik/9OKVxN8w8 "C (gcc) – Try It Online")
Given input `i`, checks every integer from `i` to 0 for a sequence containing `i`.
* `i` is the input value
* `o` is the output value (the minimum root found so far)
* `a` is the current integer being checked
* `b` is the current element of `a`'s sequence
* `c` and `d` are used to add `b` to its reverse
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~16~~ ~~15~~ 11 bytes
```
@ÇX±swÃøU}a
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=QMdYsXN3w/hVfWE=&input=NDQ=)
```
@ÇX±swÃøU}a     :Implicit input of integer U
@        }a     :Loop over the positive integers as X & output the first that returns true
 Ç              :  Map the range [0,U)
  X±            :    Increment X by
    sw          :    Its reverse
      Ã         :  End map
       øU       :  Contains U?
```
[Answer]
# [Physica](https://github.com/Mr-Xcoder/Physica), 57 bytes
Credit for the method goes to [Doorknob](https://codegolf.stackexchange.com/a/170479/59487).
```
F=>N:Min@Map[->m:N==m+Int[Str[m]{%%-1}]&&F@m||N;…[1;N]]
```
[Try it online!](https://tio.run/##K8ioLM5MTvz/383Wzs/KNzPPwTexIFrXLtfKz9Y2V9szryQ6uKQoOje2WlVV17A2Vk3NzSG3psbP@lHDsmhDa7/Y2P9u@UUKngqPOjoUqk1MrBXMjawVDI1BhIkxkAACawVLS8taKy4FIAgoyoQa6Rmrl5NVWlwSbRJrraCkoGunoGSt4AYUjv0PAA "Physica – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 89 bytes
I run each sequence in [1,*n*) until I get a match; zero is special-cased because it doesn't terminate.
```
j,k,l,m;r(i){for(j=k=0;k-i&&++j<i;)for(k=j;k<i;k+=m)for(l=k,m=0;l;l/=10)m=m*10+l%10;j=j;}
```
[Try it online!](https://tio.run/##VVBNb8IwDL3nV1ggUNMGaCU4oBCkHabtgDhM7MTQ1PUD3KbNlHYchvjtnVM2ieWQ2C/Pz89OJsck6YZYJ/orzWDVtCma6WnN/kEaPwjrClEKLSppPeSX3FivUKUKZTnB8TgIihVK7tBSFbKkpAxU1QNalaIiopZ6pqKQV6ryozDQoyiUBZGv3TDNcqwz2Dxun3bPXszBa/A7MzmFs9/Ijzln7GwwhU@Ldftu29ijF5DDhcENzL3By@4BrDEtmBxGKWBD9/StHggUzjiX7MqYq6tirHuB2B4TkZxiC75P8fmm10uL2Nr9QV3mc7FYiOVyKSI6V8kcgdxR5TrilMCdqaa1rdHu87yPDmL7utkIGps6A2S6yXq6WwzSUnD1N7S1XGIQ3NTu9ZwHPDjj3Q8 "C (gcc) – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 9 bytes
```
ḟo£⁰¡S+↔N
```
[Try it online!](https://tio.run/##ARwA4/9odXNr///huJ9vwqPigbDCoVMr4oaUTv///zQ0 "Husk – Try It Online")
first element in natural numbers which has an infinite list that contains the input.
]