Wir alle wissen, dass jedes Mal, wenn eine rationale Zahl dezimal geschrieben wird, das Ergebnis entweder terminierend oder (irgendwann) periodisch ist. Wenn zum Beispiel 41/42 dezimal geschrieben wird, ist das Ergebnis

0.9 761904 761904 761904 761904 761904 761904 761904 ...

mit einer anfänglichen Folge von Ziffern, 0.9gefolgt von der Folge, die 761904immer und immer wieder wiederholt wird. (Eine bequeme Schreibweise hierfür ist, 0.9(761904)wenn die Klammern den Ziffernblock umschließen.)

Ihr Ziel bei dieser Herausforderung ist es, eine positive rationale Zahl zu nehmen, die erste Ziffer zu löschen, die Teil der Wiederholungssequenz ist, und die resultierende rationale Zahl zurückzugeben. Wenn wir dies beispielsweise mit 41/42 tun, erhalten wir

0.9  61904 761904 761904 761904 761904 761904 761904 ...

oder 0.9(619047)kurz: 101/105.

Wenn die rationale Zahl eine endende Dezimalerweiterung wie 1/4 = 0.25hat, sollte nichts passieren. Sie können sich 1/4 entweder als 0.250000000...oder als 0.249999999...vorstellen, aber in beiden Fällen bleibt die Zahl unverändert, wenn Sie die erste Ziffer des sich wiederholenden Teils löschen.

Einzelheiten

• Die Eingabe ist eine positive rationale Zahl, entweder als Paar positiver Ganzzahlen, die Zähler und Nenner darstellen, oder (wenn Ihre Sprache dies zulässt und Sie möchten) als eine Art rationales Zahlenobjekt.
• Die Ausgabe ist auch eine rationale Zahl, auch in jeder Form. Wenn das Ergebnis eine Ganzzahl ist, können Sie die Ganzzahl anstelle einer rationalen Zahl zurückgeben.
• Wenn Sie ein Zahlenpaar als Eingabe verwenden, können Sie davon ausgehen, dass diese relativ prim sind. Wenn Sie ein Zahlenpaar als Ausgabe erzeugen, müssen Sie dafür sorgen, dass sie relativ prim sind.
• Achten Sie darauf, dass Sie die erste Ziffer finden, die einen Wiederholungsblock startet. Zum Beispiel könnte man 41/42 schreiben, 0.97(619047)aber das macht 2041/2100 (mit der Dezimalerweiterung 0.97(190476)) nicht zu einer gültigen Antwort.
• Sie können davon ausgehen , dass Sie in der Eingabe zu erhalten, die erste periodische Ziffer nach dem Komma, so dass 120/11= 10.909090909...ungültige Eingabe: (seine erste periodische Ziffer könnte die in Betracht gezogen wird 0in 10). Sie können an solchen Eingaben alles tun, was Sie möchten.
• Das ist Code-Golf : Die kürzeste Lösung gewinnt.

Testfälle

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 Language (Mathematica) , 59 Bytes

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

Probieren Sie es online!

Erläuterung

RealDigits@#

Suchen Sie die Dezimalstellen der Eingabe.

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

Wenn es sich wiederholende Ziffern gibt, RotateLeftdiese. ( List@@#Verhindert, dass der Code versucht, die letzte Dezimalstelle zu drehen, wenn die rationale Zahl endet.)

FromDigits@

Konvertieren Sie zu rational.

Jelly , 36 32 31 30 Bytes

-1 Byte Danke an Erik den Outgolfer !

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

Probieren Sie es online!

Sollte stimmen. Gleitkomma-Ungenauigkeit addieren 3 Bytes für +.Ḟ.

Verlässt sich darauf, dass der Eingang nicht reduzierbar ist.

Erläuterung

Dies setzt voraus:

• Der Zähler sei n/din seiner einfachsten Form. Dann gibt der Link, auf den ọ2,5Ṁangewendet wurde d, die Nummer der nichtperiodischen Ziffer nach dem Radixpunkt an.

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

^{-21 Bytes dank 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])))

Probieren Sie es online!

Die Eingabe erfolgt als Tupel (numerator, denominator); output ist ein fractions.FractionObjekt.

Hierbei wird eine Methode mit langer Teilung verwendet, um die Start- und Wiederholungsziffern der Antwort abzurufen. Anschließend wird die erste Wiederholungsziffer an das Ende verschoben und mithilfe der Zeichenfolgenmanipulation fraction.Fractionwieder in ein Verhältnis umgewandelt.

Ungolfed-Version:

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 Bytes

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)

Probieren Sie es online!

Wolfram Language (Mathematica) , 70 67 Bytes

Danke an diesen (jetzt gelöschten) Tipp für -3 Byte!

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

Probieren Sie es online!

Ein Port meiner Gelee-Antwort . Länger als die existierende Mathematica-Antwort um 8 Bytes ...

Die Funktion nimmt 2 Eingänge auf [denominator, numerator], so dass GCD[denominator, numerator] == 1.

Perl 6 , 102 Bytes

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

Versuch es

Nimmt eine Rational- Nummer und gibt eine Rational- oder Int- Nummer zurück.

Erweitert:

{  # 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
    )
}

Hinweis behandelt Nenner bis uint64.Range.maxzu größeren Nennern verwenden FatRat(9 x$1.chars) Try it .