# How to calculate a repeating decimal for any fraction?

I have been struggling for a while to try to code a program to convert any fraction 1/n to a repeating decimal. So far, my program works only for numbers that end in 1, 3, 7, or 9 (n cannot divide 2 or 5, since those numbers divide 10, our numeral base). Here is my program: click here

What the program does is it finds a long string of 9s that is divisible by n. So for 1/7, you keep looking through strings of 9s until you get 999999, which is divisible by 7. When you divide that by 7, you get 142857, so thus, 1/7 is equal to 0.142857 with all digits after the 0. repeated. I have found a lot of really cool things with this program. You may know that 1/81 is 0.012345679... without the 8. However, 1/998001 (999^2) is equal to 0.000001002003004005...995996997999 (without the 998). That's really cool!

But there's more. Any fraction of the form 1/(9^n) is exactly 9^(n-1) digits long! So 1/59049 has exactly 6561 digits before repeating. And for 1/(7^n), the decimal expansion has exactly 6*(7^(n-1)) digits. So 1/49 has exactly 42 digits. Cool! Another thing I discovered is that 1/n CANNOT have more than n-1 digits in its decmial (can anyone prove this?)

While some numbers have huge decimal expansions (1/225983 has 225982 digits, that's the largest decimal expansion I have discovered so far), there is something cool. 1/7 is rather long for its size, but numbers like 1/7777777777777777777777777 actually aren't long at all! If you changed a digit in that string of sevens, you would encounter complete and utter chaos, as you could imagine.

The program is really cool and can discover a lot of cool things, but, the program does not work for values of n that are divisible by 2 or 5 since obviously you can never have a long string of 9s divisible by either of those numbers. Obviously, an even number ends in 0, 2, 4, 6, or 8, and numbers divisible by 5 end in 0 or 5. So your long string of 9s does not work!

Can anyone help me improve my program to work for all values of n? I have a feeling that I should divide the value of n until it is not divisible by 2 or 5 anymore. I tried that, and the program terminated, but not with the correct values. Can someone help me make it work?

Thank you!

• – Joseph Eck Jul 9 '18 at 22:00

Multiply $\frac1n$ by $10$ several times until you get a number $\frac{10^k}n$ such that, when expressed as $\frac ab$ with $\gcd(a,b)=1$, the number $b$ is prime with both $2$ and $5$. Then divide the result by $10^k$.

For instance, suppose that you have $\frac1{350}$. Then$$\frac{100}{350}=\frac27=0.285714285714\ldots$$and therefore$$\frac1{350}=0.00285714285714\ldots$$

Let the "dividend" $d$ be the number $1$. Write a zero to the right of $d$. Compute $\left\lfloor\dfrac dn\right\rfloor$, the next digit, and $d\bmod n$, the next dividend, which is certainly less than $n$.

Write a zero to the right of the dividend and so on...

$$1:7\\1\to10=1\times7+3\\3\to30=4\times7+2\\2\to20=2\times7+6\\6\to60=8\times 7+4\\\cdots$$

Stop when the same remainder appears.

This will work for any $n$. If at some stage the remainder is $0$, you can also stop: the number has a finite fractional part.

\begin{align}1&:125\\1\to10&=0\times125+10\\10\to100&=0\times125+100\\100\to1000&=8\times125+0.\end{align}

Update: Worked on the program's comments to make it easier to understand.

Joseph Eck pointed out the 'math-is-fun' site in his comment to the OP.

The OP wanted help with his python program, and I say to myself:

What could be more fun than working on python and math together?

Python Program:

import sys
from fractions import Fraction

while 1:
n = input("Enter numerator (0 to EXIT): ")
if int(n) == 0: sys.exit()
d = input("Enter denominator: ")
if int(d) <= int(n):
print("numerator must be smaller than denominator!")
continue
Start_Fraction = Fraction(int(n), int(d))
r = Start_Fraction
decExp = ''
processedFractionList = []
while 1:
#                                  # r < 1
#                                  # so check if we've
#                                  #   'been there, done that'
try:
#                                  # decimal now repeating?
print('Fraction: ', Start_Fraction, '||| Expansion:', '0.' + decExp, "; Exp Length =",len(decExp), '; Repeat Start Index (offset) =', processedFractionList.index(r), "; Repeating length =",len(decExp)-processedFractionList.index(r))
#                                  #   Yes? - then break loop
break
except ValueError:
#                                  # We check this 1st entry as 'processed'
#                                  # but we must also check off the
#                                  # "10 * r < 1" block

processedFractionList.append(r)
#                                  # we now process this r
while 1:
r = 10 * r
if r < 1:
#                                  # 2-step update process
#                                  # check off this "10 * r < 1" entry
decExp = decExp + '0'
processedFractionList.append(r)
continue
break
#                                  # r >= 1 is True
d = 0
while 1:
if r >= 1:
r = r - 1
d = d + 1
continue
break
#                                  # r < 1 is True
#                                  # 1-step update processs
decExp = decExp + str(d)
#                                  # Is the expansion process now terminated?
if r == 0:
print('Fraction: ', Start_Fraction, '||| Expansion:', '0.' + decExp, "; Exp Length =",len(decExp))
break
if len(decExp) > 5000:
print("taking too long!")
print('Fraction: ', Start_Fraction, '||| Expansion:', '0.' + decExp, "; Exp Length =",len(decExp))
break
continue


I input the OP's $\text{1}$ over $\text{998,001}$ and this came out (use horizontal scrolling):

Enter numerator (0 to EXIT): 1
Enter denominator: 998001
Fraction:  1/998001 ||| Expansion: 0.000001002003004005006007008009010011012013014015016017018019020021022023024025026027028029030031032033034035036037038039040041042043044045046047048049050051052053054055056057058059060061062063064065066067068069070071072073074075076077078079080081082083084085086087088089090091092093094095096097098099100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997999 ; Exp Length = 2997 ; Repeat Start Index (offset) = 0 ; Repeating length = 2997
Enter numerator (0 to EXIT):


The program just kept running when I entered the OP's $\text{1}$ over $\text{225,983}$. It is still running today! (lol)

• Thank you so much, the program worked! I am very grateful :D And it works for every fraction! But is there any way to make it work faster? since after running both programs a few times i realized that mine was a little bit faster (that's probably why the 1/225983 never terminated). – Anonymous Jul 12 '18 at 13:50
• Sounds like your program doesn't terminate with $1/225983$ either. If it does, include the code in your question so I can easily copy/paste/experiment with it. – CopyPasteIt Jul 12 '18 at 14:24
• from math import log10 n, i = int(input("Enter a fraction, and it will be converted to a repeating decimal: 1/")), 9 while True: if i % n == 0: break i = (10 * i) + 9 i = i * (2 ** extras[0]) * (5 ** extras[1]) i = "0." + (int(log10(n))) * "0" + str(i // n) print("Your decimal: " + i + ". All " + str(len(i) - 2) + " digits after the \"0.\" are repeated.") you can look at the program by clicking on a link above in the problem description – Anonymous Jul 13 '18 at 17:09
• My program does terminate with 1/225983, except it takes a really long time. 10^225983, as you can imagine, takes a while to calculate for even a computer, and that kind of number takes up a lot of space! Numbers with under 10,000 decimal places, however, are far easier to compute since 10^10,000 doesn't lag out a computer. – Anonymous Jul 13 '18 at 17:10