Urutan reverse-then-add (RTA) adalah urutan yang diperoleh dengan menambahkan nomor ke kebalikannya, dan mengulangi proses pada hasilnya. Untuk mis.,

Dengan demikian, urutan RTA 5 berisi 10, 11, 22, 44, 88, 176, dll.

The RTA akar dari sebuah nomor adalah jumlah terkecil yang baik sama dengan atau memberikan kenaikan gaji untuk dalam urutan RTA nya.$n$$n$$n$

Misalnya, 44 ditemukan dalam urutan RTA 5, 10, 11, 13, 22, 31, dll. Dari jumlah tersebut, 5 adalah yang terkecil, dan karenanya RTAroot (44) = 5.

72 bukan bagian dari urutan RTA angka apa pun, dan karenanya dianggap sebagai akar RTA-nya sendiri.

Input adalah bilangan bulat positif dalam rentang yang bahasa Anda bisa tangani secara alami.

Output adalah akar RTA dari angka yang diberikan, sebagaimana didefinisikan di atas.

Uji kasus

Input
Output

44
5

72
72

132
3

143
49

1111
1

999
999

OEIS terkait: A067031 . Output akan berupa angka dari urutan ini.

Perl 6 , 45 44 byte

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

Cobalah online!

Penjelasan:

->\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 berkat sundar memperhatikan bahwa saya punya {{dan}}

Penjelasan

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

maaf untuk penjelasan miring, ini adalah yang terbaik yang bisa saya buat

Cobalah online!

Haskell , 59 57 byte

^{-2 bytes terima kasih kepada user1472751 (menggunakan detik untilbukannya daftar-pemahaman & head)!}

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

Cobalah online!

Penjelasan

Ini akan dievaluasi untuk Trueuntuk setiap RTA-root:

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

Istilah (+)<*>read.reverse.showini adalah versi golf dari

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

yang menambahkan angka ke dirinya sendiri terbalik.

Fungsi ini untilberulang kali berlaku (+)<*>read.reverse.showhingga melampaui target kami.

Membungkus semua ini dengan untilmemulai lagi dengan 1dan menambahkan 1 dengan (+1)akan menemukan RTA-root pertama.

Jika tidak ada RTA-root yang tepat n, kita akhirnya sampai di ntempat yang untiltidak menerapkan fungsi itu n<=n.

05AB1E , 7 byte

Menggunakan versi baru 05AB1E (ditulis ulang dalam Elixir).

Kode

L.ΔλjÂ+

Cobalah online!

Penjelasan

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.

Jelly , 12 11 byte

ṚḌ+ƊС€œi¹Ḣ

$999$$1111$

Terima kasih kepada @JonathanAllan untuk bermain golf 1 byte!

Cobalah online!

Bagaimana itu bekerja

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

Cobalah online!

Fungsi rekursif yang berulang kali "membatalkan" operasi RTA hingga tiba di nomor yang tidak dapat diproduksi olehnya, lalu mengembalikan minimum.

Alih-alih menggunakan filter, yang panjang, saya malah hanya mapberkisar dari 1 hingga angka. Untuk setiap m dalam kisaran ini, jika m + rev (m) adalah angka, ia memanggil fungsi secara rekursif pada m ; jika tidak, ia mengembalikan n . Ini sama-sama menghilangkan kebutuhan untuk a filterdan memberi kita kasus dasar dari f (n) = n gratis.

Sorotan termasuk menyimpan satu byte dengan Integer#digits:

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

Yang terakhir akan menjadi satu byte lebih pendek, tetapi sayangnya, Ruby mem-parsing angka dimulai dengan 0sebagai oktal.

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

Cobalah online!

Pyth , 12 byte

fqQ.W<HQ+s_`

Lihatlah suite tes!

Sangat cepat dan efisien. Semua test case berjalan sekaligus membutuhkan waktu kurang dari 2 detik.

Bagaimana itu bekerja

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å}н

Cobalah online!

Penjelasan

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)

Cobalah online!

Berkomentar

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 terima kasih kepada @Emigna .

Cobalah online.

Penjelasan:

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

Arang , 33 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｎθ

$q$

≔⊗θη

$2q$$h$

Ｗ›ηθ«

$h>q$

≔Ｌ⊞Ｏυωη

$u$$h$

Ｗ‹ηθ

$h<q$

≧⁺Ｉ⮌Ｉηη

$h$ menjadi$h$.

»ＩＬυ

Cetak panjang akhir $u$ yang merupakan root yang diinginkan.

MATL , 17 byte

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

Cobalah online!

Penjelasan

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

Cobalah online.

Penjelasan:

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

Membalik bilangan secara aritmetika lebih panjang 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;}}

Cobalah online.

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

Cobalah online!

Input yang diberikan i, memeriksa setiap integer dari ike 0 untuk urutan yang mengandung i.

• i adalah nilai input
• o adalah nilai output (root minimum yang ditemukan sejauh ini)
• a apakah integer saat ini sedang diperiksa
• badalah elemen aurutan saat ini
• cdan ddigunakan untuk menambah bkebalikannya

Japt , 16 15 11 byte

@ÇX±swÃøU}a

Cobalah

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

Kredit untuk metode ini jatuh ke Doorknob .

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

Cobalah online!

C (gcc) , 89 byte

Saya menjalankan setiap urutan dalam [1, n ) sampai saya mendapatkan kecocokan; nol berbahan khusus karena tidak berakhir.

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

Cobalah online!