Tersine-sonra-ekleme (RTA) dizisi, tersine bir sayı eklenerek ve sonuçtaki işlemi tekrarlayarak elde edilen bir dizidir. Örneğin,

Böylece, 5'in RTA sekansı 10, 11, 22, 44, 88, 176, vb. İçerir.

RTA kökü bir dizi ya da eşit olan en küçük bir sayıdır , n ya da yükseltmeyi sağlayan n kendi RTA sekansında.$n$$n$$n$

Örneğin, 44, 5, 10, 11, 13, 22, 31, vb. RTA dizisinde bulunur. Bunlardan 5, en küçüktür ve bu nedenle RTAroot (44) = 5'tir.

72, herhangi bir sayıdaki RTA dizisinin bir parçası değildir ve bu nedenle kendi RTA kökü olarak kabul edilir.

Giriş , dilinizin doğal olarak işleyebileceği bir aralıktaki pozitif bir tamsayıdır.

Çıktı , yukarıda tanımlandığı gibi verilen sayının RTA köküdür.

Test durumları

Input
Output

44
5

72
72

132
3

143
49

1111
1

999
999

İlgili OEIS : A067031 . Çıktı bu diziden bir sayı olacaktır.

Perl 6 , 45 44 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

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

• Sundar sayesinde 2 bayt olduğunu {{ve}}

açıklama

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

riskli bir açıklama için üzgünüm, bulabildiğim en iyisi bu

Çevrimiçi deneyin!

Haskell , 59 57 bayt

^{User1472751 sayesinde -2 bayt until(liste-anlama yerine bir saniye kullanarak head)!}

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

Çevrimiçi deneyin!

açıklama

Bu Trueherhangi bir RTA kökü için değerlendirir :

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

Terim (+)<*>read.reverse.showbir golf versiyonudur

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

bu kendi başına bir sayı ekler.

İşlev , hedefimizi untilaşıncaya (+)<*>read.reverse.showkadar tekrar tekrar uygulanır .

Bunların hepsini bir başkasına sarmak ve bir başkasıyla untilbaşlamak , ilk RTA kökünü bulacaktır.1(+1)

Uygun bir RTA kökü yoksa, nnihayetinde işlevi uygulamayan nyere gideceğiz .untiln<=n

05AB1E , 7 bayt

05AB1E'nin yeni versiyonunu kullanarak (Elixir'de yeniden yazılmıştır).

kod

L.ΔλjÂ+

Çevrimiçi deneyin!

açıklama

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öle , 12 11 bayt

ṚḌ+ƊС€œi¹Ḣ

$999$$1111$

1 byte'lık golf için @JonathanAllan'a teşekkürler!

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

RTA işlemini tarafından üretilemeyen bir sayıya gelinceye kadar art arda "geri alan" özyinelemeli işlev, ardından minimum değeri döndürür.

filterUzun olanı kullanmak yerine map, 1'den sayıya kadar olan aralığı aşıyorum. Bu aralıktaki her m için, eğer m + rev (m) sayıysa, tekrarlı olarak m'yi çağırır ; aksi takdirde, bu geri n . Bu, hem a ihtiyacını ortadan kaldırıyor hem de filterbize f (n) = n taban durumunu ücretsiz veriyor.

Öne çıkan özellikler arasında bir bayt kaydetmeyi içerir Integer#digits:

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

Sonuncusu bir bayt daha kısa olacaktır, fakat ne yazık ki, Ruby 0, sekizlik ile başlayan sayıları ayrıştırır .

Python 2,70 bayt

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

Çevrimiçi deneyin!

Pyth , 12 bayt

fqQ.W<HQ+s_`

Test odasına göz atın!

Şaşırtıcı derecede hızlı ve verimli. Tüm test durumları bir kerede koştu 2 saniyeden daha az sürer.

Nasıl çalışır

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 bayt

LʒIFDÂ+})Iå}н

Çevrimiçi deneyin!

açıklama

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 bayt

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

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

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

@Emigna sayesinde -1 bayt .

Çevrimiçi deneyin.

Açıklama:

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

Kömür , 33 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

Ｎθ

$q$

≔⊗θη

$2q$$h$

Ｗ›ηθ«

$h>q$

≔Ｌ⊞Ｏυωη

$u$$h$

Ｗ‹ηθ

$h<q$

≧⁺Ｉ⮌Ｉηη

$h$$h$

»ＩＬυ

$u$

MATL , 17 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin.

Açıklama:

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

Tamsayının aritmetik olarak ters çevrilmesi 1 bayt daha uzundur ( 104 bayt ):

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

Çevrimiçi deneyin.

C (gcc) , 120 100 99 bayt

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

Çevrimiçi deneyin!

Verilen giriş i, iiçerdiği bir dizi için her bir tam sayıyı 0 ile kontrol eder i.

• i giriş değeri
• o çıktı değeri (şimdiye kadar bulunan minimum kök)
• a mevcut tamsayı kontrol ediliyor mu?
• badizisinin geçerli elemanıdır
• cve tersine deklemek biçin kullanılır

Japt , 16 15 11 bayt

@ÇX±swÃøU}a

Dene

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

Yöntemin kredisi Doorknob'a gidiyor .

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

Çevrimiçi deneyin!

C (gcc) , 89 bayt

Bir eşleşme elde edene kadar her bir diziyi [1, n ) 'de çalıştırıyorum ; sıfır özel kasalıdır çünkü sonlandırmaz.

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

Çevrimiçi deneyin!