ลำดับ reverse-then-add (RTA) เป็นลำดับที่ได้รับโดยการเพิ่มตัวเลขใน reverse และทำซ้ำกระบวนการกับผลลัพธ์ สำหรับเช่น.

ดังนั้นลำดับ RTA 5 ของประกอบด้วย 10, 11, 22, 44, 88, 176, ฯลฯ

ราก RTAของจำนวนเป็นจำนวนที่น้อยที่สุดที่เป็นทั้งเท่ากับหรือให้ยกไปnในลำดับ RTA ของมันn $n$$n$$n$

ตัวอย่างเช่น, 44 พบได้ในลำดับ RTA ที่ 5, 10, 11, 13, 22, 31, และอื่น ๆ ในจำนวนนี้คือ 5 มีขนาดเล็กที่สุดและ RTAroot (44) = 5

72 ไม่ได้เป็นส่วนหนึ่งของลำดับ RTA ของหมายเลขใด ๆ และถือว่าเป็นรูท RTA ของตัวเอง

อินพุตเป็นจำนวนเต็มบวกในช่วงที่ภาษาของคุณสามารถจัดการได้อย่างเป็นธรรมชาติ

เอาท์พุทเป็นรากของ RTA ของจำนวนที่กำหนดตามที่กำหนดไว้ข้างต้น

กรณีทดสอบ

Input
Output

44
5

72
72

132
3

143
49

1111
1

999
999

OEIS ที่เกี่ยวข้อง: A067031 ผลลัพธ์จะเป็นตัวเลขจากลำดับนี้

Perl 6 , 45 44 ไบต์

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

Brachylog , 24 22 ไบต์

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

• 2 ไบต์ขอบคุณที่ซันดาร์สังเกตเห็นว่าฉันมี{{และ}}

คำอธิบาย

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

ขออภัยสำหรับคำอธิบายที่สกปรกนี่คือสิ่งที่ดีที่สุดที่ฉันจะได้รับ

ลองออนไลน์!

Haskell , 59 57 ไบต์

^{-2 ไบต์ขอขอบคุณuser1472751 (ใช้วินาทีuntilแทน list-comprehension & head)!}

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

ลองออนไลน์!

คำอธิบาย

สิ่งนี้จะประเมินTrueสำหรับ RTA-root ใด ๆ :

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

คำ(+)<*>read.reverse.showนี้เป็นเวอร์ชั่นของกอล์ฟ

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

ซึ่งจะเพิ่มตัวเลขกลับด้าน

ฟังก์ชั่นuntilการใช้งานซ้ำ ๆ(+)<*>read.reverse.showจนกว่ามันจะเกินเป้าหมายของเรา

การตัดทั้งหมดนี้ในอีกอันที่untilเริ่มต้นด้วย1และเพิ่ม 1 ด้วย(+1)จะค้นหา RTA-root แรก

หากไม่มี RTA-root ที่เหมาะสมnในที่สุดเราก็ไปยังnที่ที่untilไม่ใช้ฟังก์ชันตั้งแต่n<=nนั้นมา

05AB1E , 7 ไบต์

การใช้ 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.

เจลลี่ , 12 11 ไบต์

ṚḌ+ƊС€œi¹Ḣ

$999$$1111$

ขอบคุณ @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.

Ruby, 66 57 ไบต์

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 จะแยกวิเคราะห์ตัวเลขที่ขึ้นต้นด้วย0octal

Python 2 , 70 ไบต์

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

ลองออนไลน์!

Pyth , 12 ไบต์

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.

05AB1E , 13 ไบต์

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

JavaScript (ES6), 61 ไบต์

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

05AB1E , 21 16 15 ไบต์

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

ถ่าน 33 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

Ｎθ

$q$

≔⊗θη

$2q$$h$

Ｗ›ηθ«

$h>q$

≔Ｌ⊞Ｏυωη

$u$$h$

Ｗ‹ηθ

$h<q$

≧⁺Ｉ⮌Ｉηη

$h$$h$

»ＩＬυ

$u$

MATL , 17 ไบต์

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

Java 8, 103 ไบต์

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

ลองออนไลน์

C (gcc) , 120 100 99 ไบต์

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ตรวจสอบจำนวนเต็มจากทุกi0 iสำหรับลำดับที่มี

• i คือค่าอินพุต
• o คือค่าเอาต์พุต (รูทขั้นต่ำที่พบจนถึง)
• a เป็นจำนวนเต็มปัจจุบันกำลังตรวจสอบ
• bเป็นองค์ประกอบปัจจุบันของaลำดับ
• cและdถูกใช้เพื่อเพิ่มbกลับด้าน

Japt , 16 15 11 ไบต์

@ÇX±swÃøU}a

ลองมัน

@Ç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 ไบต์

เครดิตสำหรับวิธีการไปที่ลูกบิดประตู

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

ลองออนไลน์!

C (gcc) , 89 ไบต์

ฉันเรียกใช้แต่ละลำดับใน [1, n ) จนกว่าฉันจะได้รับการแข่งขัน ศูนย์เป็นกรณีพิเศษเพราะมันไม่ได้ยุติ

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

ลองออนไลน์!