Trình tự đảo ngược sau đó thêm (RTA) là một chuỗi có được bằng cách thêm một số vào đảo ngược của nó và lặp lại quá trình trên kết quả. Ví dụ:

Do đó, chuỗi RTA của 5 chứa 10, 11, 22, 44, 88, 176, v.v.

Các RTA gốc của một số là số nhỏ nhất mà là một trong hai bằng hoặc cung cấp cho tăng tới theo thứ tự RTA của nó.n $n$$n$$n$

Ví dụ: 44 được tìm thấy trong chuỗi RTA gồm 5, 10, 11, 13, 22, 31, v.v. Trong số này, 5 là nhỏ nhất và do đó RTAroot (44) = 5.

72 không phải là một phần của chuỗi RTA của bất kỳ số nào, và do đó được coi là gốc RTA của chính nó.

Đầu vào là một số nguyên dương trong một phạm vi mà ngôn ngữ của bạn có thể xử lý một cách tự nhiên.

Đầu ra là gốc RTA của số đã cho, như được định nghĩa ở trên.

Các trường hợp thử nghiệm

Input
Output

44
5

72
72

132
3

143
49

1111
1

999
999

Liên quan OEIS: A067031 . Đầu ra sẽ là một số từ chuỗi này.

Perl 6 , 45 44 byte

->\a{first {a∈($_,{$_+.flip}...*>a)},1..a}

Hãy thử trực tuyến!

Giải trình:

->\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

Brachylog , 24 22 byte

{~{ℕ≤.&≜↔;?+}{|↰₁}|}ᶠ⌋

• 2 byte nhờ Nhận ra Sundar rằng tôi đã có một {{và}}

Giải trình

                --  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

xin lỗi vì lời giải thích rườm rà, đây là điều tốt nhất tôi có thể nghĩ ra

Hãy thử trực tuyến!

Haskell , 59 57 byte

^{-2 byte nhờ user1472751 (sử dụng giây untilthay vì hiểu danh sách & head)!}

f n=until((n==).until(>=n)((+)<*>read.reverse.show))(+1)1

Hãy thử trực tuyến!

Giải trình

Điều này sẽ đánh giá Truecho bất kỳ RTA-root:

(n==) . until (n<=) ((+)<*>read.reverse.show)

Thuật ngữ (+)<*>read.reverse.shownày là một phiên bản golf của

\r-> r + read (reverse $ show r)

trong đó thêm một số cho chính nó đảo ngược.

Các chức năng untilliên tục áp dụng (+)<*>read.reverse.showcho đến khi nó vượt quá mục tiêu của chúng tôi.

Bao bọc tất cả những thứ này trong một cái khác untilbắt đầu bằng 1và thêm 1 với (+1)sẽ tìm ra RTA-root đầu tiên.

Nếu không có RTA gốc n, cuối cùng chúng ta sẽ đến nnơi untilkhông áp dụng chức năng kể từ đó n<=n.

05AB1E , 7 byte

Sử dụng phiên bản mới của 05AB1E (viết lại trong Elixir).

Mã

L.ΔλjÂ+

Hãy thử trực tuyến!

Giải trình

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.

Thạch , 12 11 byte

ṚḌ+ƊС€œi¹Ḣ

$999$$1111$

Cảm ơn @Jonathan ALLan vì đã chơi golf 1 byte!

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

ṚḌ+ƊС€œ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.

Ruby, 66 57 byte

f=->n{(1..n).map{|m|m+(m.digits*'').to_i==n ?f[m]:n}.min}

Hãy thử trực tuyến!

Hàm đệ quy liên tục "hoàn tác" hoạt động RTA cho đến khi đến một số không thể được tạo bởi nó, sau đó trả về mức tối thiểu.

Thay vì sử dụng filter, nó dài, thay vào đó tôi chỉ đơn giản là maptrong phạm vi từ 1 đến số. Với mỗi m trong phạm vi này, nếu m + rev (m) là số, nó gọi hàm đệ quy trên m ; mặt khác, nó trả về n . Điều này vừa loại bỏ sự cần thiết của a filtervà cung cấp cho chúng ta trường hợp cơ bản là f (n) = n miễn phí.

Điểm nổi bật bao gồm lưu một byte với Integer#digits:

m.to_s.reverse.to_i
(m.digits*'').to_i
eval(m.digits*'')

Cái cuối cùng sẽ ngắn hơn một byte, nhưng thật đáng buồn, Ruby phân tích các số bắt đầu bằng số 0bát phân.

Python 2 , 70 byte

f=lambda n,i=1,k=1:i*(k==n)or f(n,i+(k>n),[k+int(`k`[::-1]),i+1][k>n])

Hãy thử trực tuyến!

Bình thường , 12 byte

fqQ.W<HQ+s_`

Kiểm tra một bộ thử nghiệm!

Đáng ngạc nhiên là nhanh chóng và hiệu quả. Tất cả các trường hợp thử nghiệm chạy cùng một lúc mất ít hơn 2 giây.

Làm thế nào nó hoạt động

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.

05AB1E , 13 byte

LʒIFDÂ+})Iå}н

Hãy thử trực tuyến!

Giải trình

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

JavaScript (ES6), 61 byte

n=>(g=k=>k-n?g(k>n?++x:+[...k+''].reverse().join``+k):x)(x=1)

Hãy thử trực tuyến!

Đã bình luận

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

05AB1E , 21 16 15 byte

G¼N¹FÂ+йQi¾q]¹

-1 byte nhờ @Emigna .

Hãy thử trực tuyến.

Giải trình:

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

Than , 33 byte

Ｎθ≔⊗θηＷ›ηθ«≔Ｌ⊞ＯυωηＷ‹ηθ≧⁺Ｉ⮌Ｉηη»ＩＬυ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｎθ

$q$

≔⊗θη

$2q$$h$

Ｗ›ηθ«

$h>q$

≔Ｌ⊞Ｏυωη

$u$$h$

Ｗ‹ηθ

$h<q$

≧⁺Ｉ⮌Ｉηη

$h$$h$

»ＩＬυ

$u$

MATL , 17 byte

`@G:"ttVPU+]vG-}@

Hãy thử trực tuyến!

Giải trình

`         % 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)

Java 8, 103 byte

n->{for(int i=0,j;;)for(j=++i;j<=n;j+=n.valueOf(new StringBuffer(j+"").reverse()+""))if(n==j)return i;}

Hãy thử trực tuyến.

Giải trình:

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

Số nguyên đảo ngược số nguyên dài hơn 1 byte ( 104 byte ):

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;}}

Hãy thử trực tuyến.

C (gcc) , 120 100 99 byte

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;}

Hãy thử trực tuyến!

Cho đầu vào i, kiểm tra mọi số nguyên từ i0 đến một chuỗi chứa i.

• i là giá trị đầu vào
• o là giá trị đầu ra (gốc tối thiểu được tìm thấy cho đến nay)
• a là số nguyên hiện tại đang được kiểm tra
• blà yếu tố hiện tại của achuỗi
• cvà dđược sử dụng để thêm bvào đảo ngược của nó

Japt , 16 15 11 byte

@ÇX±swÃøU}a

Thử nó

@Ç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?

Physica , 57 byte

Tín dụng cho phương pháp đi đến Doorknob .

F=>N:Min@Map[->m:N==m+Int[Str[m]{%%-1}]&&F@m||N;…[1;N]]

Hãy thử trực tuyến!

C (gcc) , 89 byte

Tôi chạy từng chuỗi trong [1, n ) cho đến khi tôi nhận được một trận đấu; số không là đặc biệt vì nó không chấm dứt.

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;}

Hãy thử trực tuyến!