คำอธิบายการท้าทาย

ลองใช้จำนวนเต็มบวกnกลับตัวเลขเพื่อรับrev(n)และรับค่าสัมบูรณ์ของผลต่างของตัวเลขสองตัวนี้: |n - rev(n)|(หรือabs(n - rev(n)))

ตัวอย่าง:

n = 5067 
rev(n) = 7605
|n - rev(n)| = |5067 - 7605| = |-2538| = 2538

หลังจากทำซ้ำการดำเนินการนี้หลายครั้งเพียงพอตัวเลขส่วนใหญ่จะกลายเป็น0(ดังนั้นการยกเลิกการวนซ้ำ) ...

5067 -> 2538 -> 5814 -> 1629 -> 7632 -> 5265 -> 360 -> 297 -> 495 -> 99 -> 0

... แม้ว่าตัวเลข (เช่น1584) จะติดอยู่ในวงวนไม่สิ้นสุด:

1584 -> 3267 -> 4356 -> 2178 -> 6534 -> 2178 -> 6534 -> 2178 -> 6534 -> ...
                        ^ infinite loop starts here

งานของคุณคือการตรวจสอบว่าจำนวนเต็มที่กำหนดติดอยู่ในวงวนไม่สิ้นสุด

คำอธิบายอินพุต

จำนวนเต็มบวก

คำอธิบายผลลัพธ์

ค่าความจริง ( True, 1) ถ้าตัวเลขติดอยู่ในการวนซ้ำไม่สิ้นสุดค่าเท็จ ( False, 0) มิฉะนั้น

หมายเหตุ

• ศูนย์ต่อท้ายควร ommited rev(5020) = 205กล่าวคือ
• โปรดจำไว้ว่านี่คือcode-golfดังนั้นจงทำให้รหัสของคุณสั้นที่สุด!
• ลำดับที่เกี่ยวข้อง: A072140

Pyth, 5 ไบต์

4 ไบต์ขอบคุณ FryAmTheEggman

uas_`

ชุดทดสอบ

ค่าความจริงคือหนึ่งในตัวเลขในลูป

ค่า falsey 0คือ

คำอธิบาย

uas_`      Input:Q
uas_`GGQ   Implicit filling of variables.

u      Q   Set G as Q: do this repeatedly until result seen before: Set G as
 a             the absolute difference of
     G             G
    `              convert to string
   _               reverse
  s                convert to integer
      G        and G

Mathematica, 39 37 ไบต์

Nest[Abs[#-IntegerReverse@#]&,#,#]<1&

เพียงใช้การแปลงnเวลาย้อนกลับ / ลบกับอินพุตnจากนั้นตรวจสอบว่าผลลัพธ์เป็น0อย่างไร มันไม่สามารถใช้เวลานานกว่า10nขั้นตอนที่จะไปถึงห่วงเพราะการเปลี่ยนแปลงไม่สามารถเพิ่มจำนวนของตัวเลขและมีน้อยกว่าตัวเลขที่ไม่มีตัวเลขมากกว่า10n ดูหลักฐานของเดนนิสสำหรับวิธีลดขอบเขตนี้nn

เยลลี่ , 6 5 ไบต์

ṚḌạµ¡

ลองออนไลน์!

พื้นหลัง

การใช้งานนี้@ MartinEnder ผูกพันบนของ10Nซ้ำและข้อสังเกตดังต่อไปนี้

1. มี9 × 10 ^{k - 1}จำนวนเต็มบวกnด้วยตัวเลขk

2. ความแตกต่างของจำนวนและการย้อนกลับของมันจะเป็นผลคูณของ9เสมอดังนั้นมีเพียง10 ^{k - 1}เท่านั้นที่สามารถเกิดขึ้นได้หลังจากการทำซ้ำครั้งแรก

3. ของทวีคูณมากกว่า1/10จะสูญเสียตัวเลขในการทำซ้ำครั้งถัดไป (สำหรับผู้เริ่มต้นสิ่งที่เริ่มต้นและสิ้นสุดด้วยตัวเลขเดียวกันและประมาณสองเท่าเป็นจำนวนมากหากหลักแรกไม่ใช่1หรือ9 ) มันใช้เวลาไม่เกิน9 × 10 ^{k - 2}ในการวนซ้ำหรือสูญเสียตัวเลข

4. การใช้เหตุผลเดียวกันกับจำนวนเต็มผลในที่สุดของk - 1หลักและอื่น ๆ จะใช้เวลามากที่สุด9 × 10 ^{k - 2} + 9 × 10 ^{k - 2} + …≤ 10 ^{k - 1} ≤ nซ้ำเพื่อป้อนลูปหรือ ถึง0

มันทำงานอย่างไร

ṚḌạµ¡  Main link. Argument: n

   µ¡  Iteratively apply the chain to the left n times.
Ṛ      Reverse n (casts to digits).
 Ḍ     Undecimal; convert from base 10 to integer.
  ạ    Take the absolute difference of the result and the argument.

Oracle SQL 11.2, 136 ไบต์

WITH v(n)AS(SELECT :1 FROM DUAL UNION ALL SELECT ABS(n-REVERSE(n||''))FROM v WHERE n>0)CYCLE n SET c TO 0 DEFAULT 1 SELECT MIN(c)FROM v;

ยกเลิกแข็งแรงเล่นกอล์ฟ

WITH v(n) AS
(
  SELECT :1 FROM DUAL
  UNION ALL
  SELECT ABS(n-REVERSE(n||''))FROM v WHERE n>0 
) CYCLE n SET c TO 0 DEFAULT 1
SELECT MIN(c)FROM v

APL, 26 ตัวอักษร

0∘{⍵∊⍺:×⍵⋄(⍺,⍵)∇|⍵-⍎⌽⍕⍵}

เราใช้อาร์กิวเมนต์ซ้ายเป็นตัวสะสมของค่าที่เราได้เห็นไปแล้ว เรากำหนดค่าเริ่มต้นเป็น "0" ซึ่งเป็นหนึ่งในสองเงื่อนไขการยกเลิก ยาม⍵∊⍺:×⍵ถูกอ่าน: "เป็นอาร์กิวเมนต์ที่ถูกต้องสิ่งที่เราเคยเห็นมาแล้ว (และนั่นรวมถึงศูนย์) ถ้าส่งคืนเครื่องหมายของตัวเลขนั่นคือ 1 หรือ 0" มิฉะนั้นเราจะเรียกคืนด้วยการเรียกตัวเราเองด้วยค่าสัมบูรณ์ของการลบหลังจากทำการ catenated ค่าปัจจุบันไปที่อาร์กิวเมนต์ด้านซ้าย

รูปแบบใหม่ของการแก้ปัญหาทางคณิตศาสตร์โดย Martin Ender จะนาฬิกาที่21 ตัวอักษร :

 {×{|⍵-⍎⌽⍕⍵}⍣(10×⍵)⊣⍵}

มันอ่านว่า: "อะไรคือสัญญาณของผลหลังจากใช้ 10n ครั้งที่ต้องการ"

Python 2, 50 ไบต์

n=input()
exec'n=abs(n-int(`n`[::-1]));'*n
print n

ทดสอบบนIdeone

พื้นหลัง

การใช้งานนี้@ MartinEnder ผูกพันบนของ10Nซ้ำและข้อสังเกตดังต่อไปนี้

1. มี9 × 10 ^{k - 1}จำนวนเต็มบวกnด้วยตัวเลขk

2. ความแตกต่างของจำนวนและการย้อนกลับของมันจะเป็นผลคูณของ9เสมอดังนั้นมีเพียง10 ^{k - 1}เท่านั้นที่สามารถเกิดขึ้นได้หลังจากการทำซ้ำครั้งแรก

3. ของทวีคูณมากกว่า1/10จะสูญเสียตัวเลขในการทำซ้ำครั้งถัดไป (สำหรับผู้เริ่มต้นสิ่งที่เริ่มต้นและสิ้นสุดด้วยตัวเลขเดียวกันและประมาณสองเท่าเป็นจำนวนมากหากหลักแรกไม่ใช่1หรือ9 ) มันใช้เวลาไม่เกิน9 × 10 ^{k - 2}ในการวนซ้ำหรือสูญเสียตัวเลข

4. การใช้เหตุผลเดียวกันกับจำนวนเต็มผลในที่สุดของk - 1หลักและอื่น ๆ จะใช้เวลามากที่สุด9 × 10 ^{k - 2} + 9 × 10 ^{k - 2} + …≤ 10 ^{k - 1} ≤ nซ้ำเพื่อป้อนลูปหรือ ถึง0

CJam, 15 13 ไบต์

ri_{_sW%i-z}*

ทดสอบที่นี่

เหมือนกับคำตอบ Mathematica ของฉัน

งูหลาม, 129 120 96 ไบต์

หากมีข้อผิดพลาดเกิดขึ้น (ปกติจะเป็นข้อยกเว้นเพียงอย่างเดียวที่สามารถใช้กับฟังก์ชันนี้ได้คือ RuntimeError เนื่องจากการเรียกซ้ำไม่สิ้นสุด) ให้พิมพ์ 1 มิฉะนั้นให้พิมพ์ผลลัพธ์เป็น 0

def r(n):a=abs(n-int(str(n)[::-1]));return a and r(a)
try:print(r(int(input())))
except:print(1)

ขอบคุณ @LeakyNun
ขอบคุณ @shooqie

Python 101 101ไบต์

อัลกอริทึมเต่าและกระต่าย

Truthy เป็นค่าใด ๆ ในวง, falsey 0คือ

g=lambda n:abs(n-int(str(n)[::-1]))
def r(n):
    t=g(n);h=g(t)
    while t-h:h=g(g(h));t=g(t)
    return h

ไอเดียมัน!

Python 2, 85 84 83 ไบต์

L=[]
def f(n,L=L):
    if n<1or n in L:print n<1
    else:L+=[n];f(abs(n-int(`n`[::-1])))

งูหลามอีกคำตอบ มันจะเพิ่ม n ไปยังรายการสำหรับทุกซ้ำและถ้า n Falseมีอยู่แล้วในรายการมันเอาท์พุท มิฉะนั้นจะใช้งานได้ถึง 0

ขอบคุณ @NonlinearFruit สำหรับหนึ่งไบต์

05AB1E, 11 8 6 ไบต์

DFÂï-Ä

อธิบาย

DF          # input number of times do
  Â         # push current number and its reverse
   ï-       # convert reverse to int and subtract
     Ä      # absolute value
            # implicitly print after loop ends

ค่าความจริงคือตัวเลขจากลูป
ค่าเท็จคือ 0

ลองออนไลน์

ใช้ขอบเขตบนอธิบายไว้ในคำตอบของ Dennis 'Jelly

บันทึก 2 ไบต์ขอบคุณ @Adnan

ในเวอร์ชัน 7.9ของ 05AB1E โซลูชัน 5 ไบต์ต่อไปนี้ทำงานตามที่ระบุไว้โดย @Adnan

DFÂ-Ä

Java 7, 161 ไบต์

ต้องมีการนำเข้า แต่ฉันเขียนเป็นฟังก์ชัน ตะโกนใส่ฉันในความคิดเห็นหากโปรแกรมเต็มรูปแบบเป็นที่ต้องการในสถานการณ์นี้ ส่งออก 1 หากมีวงไม่สิ้นสุดและ 0 ถ้าค่าได้รับถึง 0

import java.util.*;int z(int a){int o,r,c=a;Set s=new HashSet();while(c!=0){for(r=0,o=c;o!=0;r=r*10+o%10,o/=10);c=Math.abs(c-r);if(!s.add(c))return 1;}return 0;}

Brachylog , 49 32 23 ไบต์

:10*N,?:N:{r:?-+.}itT'0

ส่งคืนtrueลูปไม่สิ้นสุดและfalseอื่น ๆ

นี่คือการปรับอัลกอริทึมของ Martin Ender

คำตอบก่อนหน้า 32 ไบต์

g{tTr:T-+U(0!\;?:ImU;?:[U]c:1&)}

คำอธิบายของคำตอบก่อนหน้า

g{                             } Call predicate with [Input] as input
  tT                             T is the last element of Input
    r:T-                         Subtract T from the reverse of T
        +U                       U is the absolute value of T
          (0!\                   If U is 0, return false
              ;                  Or
               ?:ImU             If U is in Input, return true
                    ;            Or
                     ?:[U]c:1&)  Recursive call with U concatenated to the Input

PowerShell v2 +, 94 ไบต์

param($n)for($a=,0;){if(($n=[math]::Abs($n-(-join"$n"["$n".length..0])))-in$a){$n;exit}$a+=$n}

รับอินพุต$nเริ่มการforวนซ้ำไม่สิ้นสุดพร้อมกับ$a=,0เงื่อนไขเริ่มต้น (ซึ่งใช้ตัวดำเนินการคอมม่าเพื่อตั้งค่า$aให้เป็นอาร์เรย์ขององค์ประกอบหนึ่ง0) นี่$aคือค่านิยมที่เราเห็นอยู่แล้ว

แต่ละวงซ้ำที่เราตรวจสอบ ifเงื่อนไขแรกกำหนดค่าต่อไปของการ$nใช้สตริงย้อนกลับและ[math]::Absโทร .NET -in $aและตรวจสอบว่าค่าที่มีอยู่แล้ว ถ้าเป็นเช่นนั้นเราส่งออกและ$n exitมิฉะนั้นเราจะเพิ่มค่านั้นลงในอาร์เรย์และดำเนินการต่อ

เอาท์พุ0ทสำหรับค่าอินพุตที่ไม่เข้าสู่วงวนไม่สิ้นสุด (ซึ่งเป็นเท็จใน PowerShell) และส่งออกค่าที่พบลูปเป็นอย่างอื่น (จำนวนเต็มไม่ใช่ศูนย์เป็นความจริง) ยกตัวอย่างเช่นเอาท์พุทสำหรับการป้อนข้อมูล21781584

Haskell, 65 ไบต์

_#0=0
a#n|elem n a=1|1<2=(n:a)#abs(n-(read$reverse$show n))
([]#)

ส่งคืน0ค่าเท็จและ1จริง ตัวอย่างการใช้งาน: ->([]#) 15841

แนวทางที่ชัดเจน: เก็บรายการที่มีผลลัพธ์ทั้งหมดที่เห็น คำนวณหมายเลขถัดไปจนกระทั่ง0หรืออยู่ในรายการ

JavaScript (ES6), 75 ไบต์

f=(n,...a)=>a.includes(n=n<0?-n:n)?n:f([...n+``].reverse().join``-n,n,...a)

n<0?n=-n:nและn*=n>0||-1ยังทำงาน อัลกอริทึมคล้ายกับคำตอบของ PowerShell แม้ว่านี่จะเป็นสูตรที่เรียกซ้ำ

Ruby, 57 ไบต์

->n,*h{h[n]=n=(n-"#{n}".reverse.to_i).abs until h[n];n>0}

อาร์เรย์ที่ว่างเปล่าในตอนแรกจะhติดตามค่าที่ได้รับก่อนหน้านี้ เราวนซ้ำจนกว่าเราจะตีค่าก่อนหน้าจากนั้นตรวจสอบค่าในการทำซ้ำครั้งล่าสุด เนื่องจาก 0 เป็นวัฏจักรของ 1 มันจะเป็น 0 ถ้าหากไม่มีวงจรที่ใหญ่กว่า ฉันใช้ 2 ไบต์พิเศษเพื่อแปลงเป็นบูลีนเพราะ 0 เป็นความจริงในทับทิม

Perl 6  58 53 33  30 ไบต์

sub {$/=%;$^a,{return ?1 if $/{$_}++;abs $_-.flip}...0;?0}
{$/=%;?($_,{last if $/{$_}++;abs $_-.flip}...0)[*-1]}
{?($_,{abs $_-.flip}...0)[10**$_]}

{?($_,{abs $_-.flip}...0)[$_]}

คำอธิบาย:

{ # block lambda with implicit parameter $_

  # coerce the following to Bool
  # ( False for Nil or 0, True otherwise )
  ?

  (

    $_, # start a sequence with the input

    # block lambda with implicit parameter $_
    # subtracts the previous value in the sequence and its reverse
    # ( .flip is short for $_.flip where a term is expected )
    { abs $_ - .flip } 

    ... # repeat that lambda
    0   # until you get 0

  # get the element indexed with the block's input
  # may be 0, Nil, or a number that is part of a repeating sequence
  )[ $_ ]
}

(ขึ้นอยู่กับการสังเกตก่อนหน้านี้ที่คุณจะต้องทำการเปลี่ยนแปลงนี้ในnเวลาส่วนใหญ่เท่านั้น)

Perl 5, 31 29 ไบต์

perl -pe'for$x(1..$_){$_=abs$_-reverse}'

perl -pe'eval"\$_=abs\$_-reverse;"x$_'

มันวนซ้ำn=|n-rev(n)|n ครั้งดังนั้นเอาต์พุตคือ 0 หากไม่มีลูป> 0 เป็นอย่างอื่น เดนนิสได้พิสูจน์แล้วว่านี่ก็เพียงพอแล้ว

เวอร์ชันใหม่ใช้evalและxโอเปอเรเตอร์การทำซ้ำแทนการforวนซ้ำ

Matlab, 89 84 ไบต์

n=input('');z=n;while n
z=abs(z-str2num(fliplr(num2str(z))));n=[n z]*all(n~=z);end
z

วิธีการง่าย ๆ - วางตัวเลขทั้งหมดและตรวจสอบว่ามีตัวเลขปรากฏก่อนหน้านี้หรือไม่

คำอธิบาย

n=input('');z=n;  -- take input, initiate z
while n           -- n is said to be positive
z=abs(z-str2num(fliplr(num2str(z)))) -- calculate the "reverse and substract"
n=[n z]           -- put the value at the end of the vector
       *all(n~=z) -- make the n all zeroes if z is previously in the vector (break the loop)
end
z                 -- print z (0 when not entered loop, >0 otherwise)