เราทุกคนรู้ว่าเมื่อใดก็ตามที่จำนวนตรรกยะเขียนเป็นทศนิยมผลลัพธ์จะสิ้นสุดลงหรือ (เป็นระยะ) ในที่สุด ตัวอย่างเช่นเมื่อเขียน 41/42 เป็นทศนิยมผลลัพธ์จะเป็น

0.9 761904 761904 761904 761904 761904 761904 761904 ...

ด้วยลำดับเริ่มต้นของตัวเลข0.9ตามด้วยลำดับ761904ซ้ำแล้วซ้ำอีก (สัญลักษณ์ที่สะดวกสำหรับสิ่งนี้คือ0.9(761904)ที่วงเล็บล้อมรอบบล็อกของตัวเลขที่ซ้ำกัน)

เป้าหมายของคุณในการท้าทายนี้คือการใช้จำนวนตรรกยะเป็นบวกลบตัวเลขแรกที่เป็นส่วนหนึ่งของลำดับการทำซ้ำและส่งกลับจำนวนตรรกยะที่เกิดขึ้น ตัวอย่างเช่นถ้าเราทำสิ่งนี้กับ 41/42 เราจะได้

0.9  61904 761904 761904 761904 761904 761904 761904 ...

หรือ0.9(619047)สั้น ๆ ซึ่งก็คือ 101/105

หากจำนวนตรรกยะมีการขยายทศนิยมที่สิ้นสุดเช่น 1/4 = 0.25จะไม่มีอะไรเกิดขึ้น คุณสามารถนึกได้ว่า 1/4 ไม่ว่าจะเป็น0.250000000...หรือ0.249999999...ในกรณีใดกรณีหนึ่งการลบตัวเลขแรกของส่วนที่ทำซ้ำจะทำให้หมายเลขนั้นไม่เปลี่ยนแปลง

รายละเอียด

• อินพุตเป็นจำนวนตรรกยะเป็นบวกไม่ว่าจะเป็นคู่ของจำนวนเต็มบวกที่เป็นตัวแทนตัวเศษและส่วนหรือ (หากภาษาที่คุณเลือกอนุญาตให้ใช้และคุณต้องการ) เป็นวัตถุเชิงเหตุผลจำนวนหนึ่ง
• ผลลัพธ์ยังเป็นจำนวนตรรกยะเช่นกันในรูปแบบใดรูปแบบหนึ่ง หากผลลัพธ์เป็นจำนวนเต็มคุณอาจส่งคืนจำนวนเต็มแทนที่จะเป็นจำนวนตรรกยะ
• หากใช้ตัวเลขเป็นคู่คุณอาจคิดว่ามันค่อนข้างดี หากผลิตตัวเลขเป็นคู่คุณจะต้องทำให้มันค่อนข้างสำคัญ
• ระวังว่าคุณพบตัวเลขแรกที่เริ่มบล็อกการทำซ้ำ ตัวอย่างเช่นหนึ่งสามารถเขียน 41/42 เป็น0.97(619047)แต่ที่ไม่ได้ทำ 2041/2100 (ด้วยการขยายทศนิยม0.97(190476) ) คำตอบที่ถูกต้อง
• คุณอาจสมมติว่าในอินพุตที่คุณได้รับตัวเลขตามช่วงเวลาแรกคือหลังจุดทศนิยมทำให้120/11= 10.909090909...อินพุตไม่ถูกต้อง: (ตัวเลขเป็นครั้งแรกของงวดอาจพิจารณาเป็น0ใน10) คุณสามารถทำอะไรก็ได้ที่คุณชอบในอินพุตดังกล่าว
• นี่คือcode-golf : ทางออกที่สั้นที่สุดชนะ

กรณีทดสอบ

41/42 => 101/105
101/105 => 193/210
193/210 => 104/105
104/105 => 19/21
1/3 => 1/3
1/4 => 1/4
2017/1 => 2017/1
1/7 => 3/7
1/26 => 11/130
1234/9999 => 2341/9999

ภาษา Wolfram (Mathematica) , 59 ไบต์

FromDigits@MapAt[RotateLeft@*List@@#&,RealDigits@#,{1,-1}]&

ลองออนไลน์!

คำอธิบาย

RealDigits@#

ค้นหาตัวเลขทศนิยมของอินพุต

MapAt[RotateLeft@*List@@#&, ..., {1,-1}]

หากมีตัวเลขที่ซ้ำกันRotateLeftพวกเขา ( List@@#ป้องกันไม่ให้รหัสพยายามหมุนทศนิยมหลักสุดท้ายหากจำนวนตรรกยะถูกยกเลิก)

FromDigits@

แปลงเป็นเหตุผล

เยลลี่ , 36 32 31 30 ไบต์

-1 ไบต์ขอบคุณErik the Outgolfer !

ọ2,5Ṁ⁵*©×Ɠ÷µ×⁵_Ḟ$+Ḟ,®×³+.Ḟ÷g/$

ลองออนไลน์!

ควรถูกต้อง ความไม่แน่นอนของจุดลอยตัวเพิ่ม 3 ไบต์สำหรับ+.Ḟไบต์

อาศัยอินพุตที่ลดลงไม่ได้

คำอธิบาย

สิ่งนี้อาศัย:

• ปล่อยให้ตัวเศษอยู่n/dในรูปแบบที่ง่ายที่สุด จากนั้นลิงก์ที่ọ2,5Ṁนำไปใช้dจะให้จำนวนตัวเลขที่ไม่เป็นระยะหลังจากจุดฐาน

ọ2,5Ṁ⁵*©×Ɠ÷µ×⁵_Ḟ$+Ḟ,®×³+.Ḟ÷g/$     Main link (monad take d as input)

    Ṁ                              Maximum
ọ                                  order of
 2,5                               2 or 5 on d
     ⁵*                            10 power
       ©                           Store value to register ®.
        ×Ɠ                         Multiply by eval(input()) (n)
          ÷                        Divide by first argument (d).
                                   Now the current value is n÷d×®.
           µ                       With that value,
            ×⁵                     Multiply by ⁵ = 10
              _Ḟ$                  subtract floor of self
                 +Ḟ                add floor or value (above)
                                   Given 123.45678, will get 123.5678
                                   (this remove first digit after `.`)
                   ,®              Pair with ®.
                     ׳            Scale
                       +.Ḟ         Round to integer
                          ÷g/$     Simplify fraction

Python 2 , 237 235 214 ไบต์

^{-21 ไบต์ขอบคุณ Mr. Xcoder}

from fractions import*
F=Fraction
n,d=input()
i=n/d
n%=d
R=[]
D=[]
while~-(n in R):R+=n,;n*=10;g=n/d;n%=d;D+=g,
x=R.index(n)
r=D[x+1:]+[D[x]]
print i+F(`r`[1::3])/F('9'*len(r))/10**x+F("0."+"".join(map(str,D[:x])))

ลองออนไลน์!

ป้อนข้อมูลทำตามขอบเขตของ(numerator, denominator); เอาท์พุทเป็นfractions.Fractionวัตถุ

วิธีนี้ใช้วิธีการแบ่งส่วนแบบยาวเพื่อให้ได้ตัวเลขเริ่มต้นและซ้ำของคำตอบจากนั้นย้ายตัวเลขซ้ำแรกไปยังจุดสิ้นสุดและใช้การจัดการสตริงและfraction.Fractionแปลงกลับเป็นอัตราส่วน

เวอร์ชันที่ไม่ถูกปรับแต่ง:

import fractions

num, denom = input()
integer_part, num = divmod(num, denom)

remainders = []
digits = []
current_remainder = num
while current_remainder not in remainders:
    remainders.append(current_remainder)
    current_remainder *= 10
    digit, current_remainder = divmod(current_remainder, denom)
    digits.append(digit)

remainder_index = remainders.index(current_remainder)
start_digits = digits[:remainder_index]
repeated_digits = digits[remainder_index:]

repeated_digits.append(repeated_digits.pop(0))

start_digits_str = "".join(map(str, start_digits))
repeated_digits_str = "".join(map(str, repeated_digits))

print(integer_part+int(repeated_digits_str)/fractions.Fraction('9'*(len(repeated_digits_str)))/10**len(start_digits_str)+fractions.Fraction("0."+start_digits_str))

Python 3 , 177 173 169 ไบต์

from fractions import*
def f(n,d):
 i=1;r=[]
 while~-(i%d in r):r+=[i%d];i*=10
 r=10**r.index(i%d);u=i-r;v=i//r-1;t=u//d*n
 return Fraction(t-t%v+t%v*10//v+t%v*10%-~v,u)

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 70 67 ไบต์

ขอบคุณเคล็ดลับนี้ (ตอนนี้ถูกลบ) สำหรับ -3 ไบต์!

(x=10^Max@IntegerExponent[#,{2,5}];(Floor@#+Mod[10#,1])/x&[x#2/#])&

ลองออนไลน์!

พอร์ตของฉันคำตอบวุ้น นานกว่าคำตอบทางคณิตศาสตร์ที่มีอยู่ 8 ไบต์ ...

ฟังก์ชั่นใช้เวลา 2 ป้อนข้อมูลดังกล่าวว่า[denominator, numerator]GCD[denominator, numerator] == 1

Perl 6 , 102 ไบต์

{$/=.base-repeating;(+$0//$0~0)+([~]([$1.comb].rotate)/(9 x$1.chars)*.1**(($0~~/\.<(.*/).chars)if $1)}

ลองมัน

ใช้เหตุผลจำนวนและผลตอบแทนเหตุผลหรือIntจำนวน

ขยาย:

{  # bare block lambda with implicit Rational parameter ｢$_｣

  $/ = .base-repeating; # store in ｢$/｣ the two strings '0.9' '761904'

    # handle the non-repeating part
    (
      +$0        # turn into a number
      // $0 ~ 0  # if that fails append 0 (handle cases like '0.')
    )

  +

    # handle the repeating part
    (
          [~]( [$1.comb].rotate ) # rotate the repeating part
        /
          ( 9 x $1.chars )        # use a divisor that will result in a repeating number

        *

         # offset it an appropriate amount

         .1 ** (
           ( $0 ~~ / \. <( .* / ).chars # count the characters after '.'
         )

      if $1  # only do the repeating part if there was a repeating part
    )
}

หมายเหตุจะจัดการตัวส่วนเกินuint64.Range.maxที่จะจัดการกับตัวส่วนใหญ่ใช้ลองFatRat(9 x$1.chars)