Member Avatar for Dietrich_3

I am asking this because I am habitually intrigued by numbers. Python seems to be a good language to explore all sorts of numeric facts. Do you have any 'tricks' hidden away? Here is one about the number 61 I recently bumped into:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' decimal_reciprocal61.py

For the folks who like to play with numbers!
The number 61 has a reciprocal of 1/61
with a period of 60 (repeats every 60 characters)
Every digit appears 6 times in each period

tested with SublimeText IDE on LinuxMint    vegaseat  15jun2026
'''

from decimal import *

getcontext().prec = 120

reciprocal61 = Decimal('1.0')/Decimal('61.0')
print("I put in the underline character to show the break:")
# take the '0.'into account to show the period of 60
print('-'*62)
print(reciprocal61)
print('-'*60)

print("the first repeating period of 60:")
# slice off the first 2 characters = '0.'
print(str(reciprocal61)[2:62])
print("the second repeating period of 60:")
# the next period
print(str(reciprocal61)[62:122])


'''
I put in the underline character to show the break:
--------------------------------------------------------------
0.016393442622950819672131147540983606557377049180327868852459_
0163934426229508196721311475409836065573770491803278688524590
------------------------------------------------------------
the first repeating period of 60:
016393442622950819672131147540983606557377049180327868852459
the second repeating period of 60:
016393442622950819672131147540983606557377049180327868852459
'''
  • 5 Contributors
  • 22 Replies
  • 85 Views
  • 2 Weeks Discussion Span
  • Latest Post Latest Post by Dietrich_3

Recommended Answers

All 22 Replies

Member Avatar for Reverend Jim

Haven't really used Python to play with numbers, however, I have done a lot of playing around (although not recently) in . I used APL extensively back in my university days (the 70s). It was fun then and fun now. In fact, Python list comprehensions have their roots in APL.

Member Avatar for Dietrich_3

The prime number 37 is very humble, but has some tricks up it sleeves:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' magic_prime37.py

The prime number 37 multiplied by 3, 6, 9, 12, ...

tested with VSCodium IDE on LinuxMint  VegasEat 28aug2026
'''

# magic prime 37
n = 37

for k in range(3, 28, 3):
    print( n * k )

""" result...
111
222
333
444
555
666
777
888
999
"""
Member Avatar for Dietrich_3

Python can handle large integer values without a sweat:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' up_down_number.py

How to go from 1 to 9 and down again

tested with VSCodium IDE on LinuxMint  VegasEat 219aug2026
'''

print("result is a number that goes from 1 to 9 and down again")

n = 111111111   # that's nine ones

print("{:d} * {:d} = {:d}".format(n, n, n * n))

"""
result is a number that goes from 1 to 9 and down again
111111111 * 111111111 = 12345678987654321
"""
Member Avatar for rproffitt

Now put in a really large number such as the number of observeable stars today. That's 200 billion trillion stars (2 × 10²² to 7 × 10²² or more).

commented: Who counted them? +3
Member Avatar for Dietrich_3

Stars in the Universe is close to Avogadro's number N = 6.023 * 10**(23) molecules/mole

SI prefixes (sometimes useful)

yotta = 1e24
zetta = 1e21
exa = 1e18
peta = 1e15
tera = 1e12
giga = 1e9
mega = 1e6
kilo = 1e3
hecto = 1e2
deka = 1e1
deci = 1e-1
centi = 1e-2
milli = 1e-3
micro = 1e-6
nano = 1e-9
pico = 1e-12
femto = 1e-15
atto = 1e-18
zepto = 1e-21

Here is the curious example of the missing number 8 normal and on steroids:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' number_8_missing.py

This number 12345679 has the 8 missing, but is a show stopper.

tested with VSCodium IDE on LinuxMint  VegasEat 22aug2026
'''

n = 12345679  # that's 1 to 9 with the 8 is left out!

# k goes from 9 to <82 in steps of 9
for k in range(9, 82, 9):
    print( n * k )

""" result...
111111111
222222222
333333333
444444444
555555555
666666666
777777777
888888888
999999999
"""

print('='*18)

# a billion and 1 is the steroid here
steroid = 1_000_000_001
n = 12345679  # that's 1 to 9 with the 8 is left out!

for k in range(9, 82, 9):
    print( steroid * n * k )

""" result...
111111111111111111
222222222222222222
333333333333333333
444444444444444444
555555555555555555
666666666666666666
777777777777777777
888888888888888888
999999999999999999
"""

'''
How big is for instance  222222222222222222 ?
In english words it is:
two hundred twenty two quadrillion two hundred twenty two trillion two 
hundred twenty two billion two hundred twenty two million two hundred 
twenty two thousand two hundred twenty two 
'''
Edited by Dietrich_3
Member Avatar for Dietrich_3

Who counts such things? That would be Count von Count.
With our luck it's the folks in charge of the National Debt!

Member Avatar for Dietrich_3

Who would have thought that the sum of a list of integers could be so predictable?

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' sum_integer_list.py

Do you see the double number pattern?

tested with VSCodium IDE on LinuxMint  VegasEat 20aug2026
'''
sum10 = sum(range(10 + 1))
print(sum10)   # 55

sum100 = sum(range(100 + 1))
print(sum100)   # 5050

sum1000 = sum(range(1000 + 1))
print(sum1000)   # 500500

sum10000 = sum(range(10000 + 1))
print(sum10000)   # 50005000

sum100000 = sum(range(100000 + 1))
print(sum100000)   # 5000050000
Edited by Dietrich_3
commented: Now find the routine that always returns 6174 +16
Member Avatar for Dietrich_3

The classic tale about the chess game:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' chessboard_grains.py

A classical Indian story:
Putting one grain of rice on the first square of a chess board
and doubling it every square, this is what the inventor of the chess 
game asked his 'leader', who wanted to give him a reward.
A simple request, until you do the math!

tested with VSCodium IDE on LinuxMint  VegasEat 29aug2026
'''

grains_sum = 0
grains = 1
for square in range(1, 64+1):
    grains = 2**(square-1)
    grains_sum = (2**square) - 1
    # test print to show we are are on the right track
    #print(f"square {square}  grains = {grains}  total = {grains_sum:_}")

print(f"{grains_sum:_} grains of rice")

# assume 7000 grains per pound of the rice
rice_pounds = grains_sum//7000
print(f"{rice_pounds:_} pounds of required rice")

''' result...
18_446_744_073_709_551_615 grains of rice
2_635_249_153_387_078 pounds of required rice
'''

# more...
print('-'*60)
ww_tonnes = 678_688_289
print(f"Worldwide Rice Production in 2009: {ww_tonnes:_} tonnes")
ww_pounds = ww_tonnes * 2000
print(f"or {ww_pounds:_} pounds")
print(f"The required {rice_pounds:_} pounds would consume")
ww_productions = int(rice_pounds / ww_pounds)
print(f"{ww_productions:,d} world productions.")

''' result...
Worldwide Rice Production in 2009: 678_688_289 tonnes
or 1_357_376_578_000 pounds
The required 2_635_249_153_387_078 pounds would consume
1,941 world productions.
'''
Member Avatar for Dietrich_3

"Now find the routine that always returns 6174"
Here is my Python hack:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' result6174.py

the final value is always 6174
iterate until it reaches that value, no further changes possible

tested with VSCodium IDE on LinuxMint  VegasEat 2sep2026
'''

def num2list(n):
    '''convert a number to a list of its integers'''
    lst = [int(c) for c in str(n)]
    return lst

def list2num(lst):
    '''convert a list of integers to a number'''
    num = int("".join(str(d) for d in lst))
    return num

# any 4 digit integer number (max 2 digits alike)
n = 8459
num_new = n
count = 1
while True:
    print(f"{count = }")
    lst2 = num2list(num_new)
    print(lst2)
    lst_sort = sorted(lst2)
    lst_sort_rev = sorted(lst2, reverse=True)
    # number sorted low val first
    num_sort = list2num(lst_sort) 
    # number sorted high val firsr
    num_sort_rev = list2num(lst_sort_rev)
    print(num_sort)
    print(num_sort_rev)
    # deduct low number from high number
    if num_sort_rev > num_sort:
        num_new = num_sort_rev - num_sort
    print(num_new) 
    # stop possible endless loop
    count += 1
    if count > 10 or num_new == 6174:
        break

print(f"final value = {num_new}")
commented: Nice practice unit. +0
Member Avatar for Dietrich_3

Some folks like approximations of pi. One person that really used his brains was Srinivasa Ramanujan, doing well! In commemoration of Professor Badii, the giggling professor, whose 4 semesters of advanced calculus I took with joy! May he never miss his curry stew!

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
""" pi_approximate_Ramanujan.py

Some functions which give an approximation
of the famous irrational number pi ()
The approximation by Ramanujan is very good!

Srinivasa Ramanujan (18871920) was an Indian mathematician

tested with VSCodium IDE on LinuxMint  VegasEat 29aug2026
"""

from math import factorial
from decimal import Decimal, getcontext


def pi_riemann(n_max, digits=50):
    """
    Riemann's algorithm to calculate
    pi () coverges slowly so
    uses module decimal
    """
    getcontext().prec = digits
    pi = 0
    k = 1
    while k <= n_max:
        pi += Decimal(1)/k**2
        k += 1
    return (6 * pi).sqrt()


def pi_euler(n_max, digits=50):
    """
    Euler's algorithm to calculate pi
    () converges slowly
    uses module decimal
    """
    getcontext().prec = digits
    pi = 0
    k = 1
    while k <= n_max:
        pi += Decimal(1)/k**4
        k += 1
    return (90*pi).sqrt().sqrt()


def pi_ramanujan(n_max, digits=50):
    """
    Ramanujan's algorithm to calculate
    pi () that converged extremely fast
    4 to 6  iterations are actually good enough!
    uses Python module decimal
    """
    getcontext().prec = digits
    ipi = 0
    k = 0
    while k <= n_max:
        ipi += (Decimal(factorial(4*k))/Decimal(factorial(k)**4))*\
            Decimal((1103 + 26390*k))/Decimal((4*99)**(4*k))
        k += 1
    return 9801/(2*Decimal(2).sqrt()*ipi)


if __name__ == "__main__":
    # testing...
    print("50 digits published pi:")
    print("3.1415926535897932384626433832795028841971693993751")
    print("pi_ramanujan(6):")
    print(pi_ramanujan(6))
    print("pi_riemann(1000):")
    print(pi_riemann(1000))
    print("pi_euler(100):")
    print(pi_euler(100))

    ''' result...
50 digits published pi:
3.1415926535897932384626433832795028841971693993751
pi_ramanujan(6):
3.1415926535897932384626433832795028841971693993751
pi_riemann(100):
3.1320765318091059044445112609662110476408802241920
pi_euler(100):
3.1415924153073680619056438548725969359226080339811
    '''
Edited by Dietrich_3
Member Avatar for Dietrich_3

This afternoon I will see my kidney doctor, a very fine lady from India. I am sure she is proud of all the great mathematicians that India has produced. Here is a python snippet that converts a number into english words:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' Number2Word.py

Integer number to english word conversion
Can be used for numbers as large as 999 vigintillion 
(a vigintillion is 10 to the power 60)

tested with VSCodium IDE on LinuxMint  VegasEat 02sep2026
'''

def int2word(n):
    """
    takes an integer number n and converts it into 
    a string of english words, returns the string
    """
    if n == 0:
        return "zero "
    # make sure n is a positive integer
    n = int(abs(n))

    # break the number into groups of 3 digits using slicing
    # each group representing hundred, thousand, million, billion, ...
    n3_list = []
    # create numeric string
    ns = str(n)
    for k in range(3, 66, 3):
        r = ns[-k:]
        q = len(ns) - k
        # break if end of ns has been reached
        if q < -2:
            break
        else:
            if  q >= 0:
                n3_list.append(int(r[:3]))
            elif q >= -1:
                n3_list.append(int(r[:2]))
            elif q >= -2:
                n3_list.append(int(r[:1]))
    # the lists of number words ...
    ones_list = ["", "one ","two ","three ","four ", "five ",
        "six ","seven ","eight ","nine "]
    tens_list = ["ten ","eleven ","twelve ","thirteen ", "fourteen ",
        "fifteen ","sixteen ","seventeen ","eighteen ","nineteen "]
    twenties_list = ["","","twenty ","thirty ","forty ",
        "fifty ","sixty ","seventy ","eighty ","ninety "]
    thousands_list = ["","thousand ","million ", "billion ", 
        "trillion ", "quadrillion ", "quintillion ", "sextillion ", 
        "septillion ", "octillion ", "nonillion ", "decillion ", 
        "undecillion ", "duodecillion ", "tredecillion ", 
        "quattuordecillion ", "sexdecillion ", "septendecillion ", 
        "octodecillion ", "novemdecillion ", "vigintillion "]
    # form a string of words
    n2w = ""
    for i, x in enumerate(n3_list):
        # break each group of 3 digits into
        # ones_list, tens_list/twenties_list, hundreds
        hun = x % 10
        ten = (x % 100)//10
        one = (x % 1000)//100
        if x == 0:
            continue  # skip
        else:
            t = thousands_list[i]
        if ten == 0:
            n2w = ones_list[hun] + t + n2w
        elif ten == 1:
            n2w = tens_list[hun] + t + n2w
        elif ten > 1:
            n2w = twenties_list[ten] + ones_list[hun] + t + n2w
        if one > 0:
            n2w = ones_list[one] + "hundred " + n2w
    return n2w


# testing ...
if __name__ == '__main__':
    n = 1
    print(n)
    print( int2word(n) )
    print("-"*50)
    n = 1999
    print(n)
    print( int2word(n) )
    print("-"*50)
    n = 12345678
    print(n)
    print( int2word(n) )
    print("-"*50)
    n = 12345678
    print(n)
    print( int2word(n) )  

""" result...
1
one 
--------------------------------------------------
1999
one thousand nine hundred ninety nine 
--------------------------------------------------
12345678
twelve million three hundred forty five thousand six hundred seventy eight 
--------------------------------------------------
4321234567890
four trillion three hundred twenty one billion two hundred thirty four 
million five hundred sixty seven thousand eight hundred ninety
"""
Edited by Dietrich_3
Member Avatar for Reverend Jim

Indian mathematicians have nothing to be proud of.

commented: I'm giving you nothing for that comment. +0
Member Avatar for Dietrich_3

Yes to the folks in India and Persia who came up with the decimal system! There must be reason we have ten fingers.
Can you imagine doing even simple accounting with roman numerals?

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' RomanNumeral.py

A function to convert a decimal (denary number) to roman numeral

tested with VSCodium IDE on LinuxMint  VegasEat 28aug2026
'''

def int2roman(number):
    '''convert a denary number to roman numerals'''
    numerals = {
    1: "I", 4: "IV", 5: "V", 9: "IX", 10: "X", 40: "XL", 50: "L",
    90: "XC", 100: "C", 400: "CD", 500: "D", 900: "CM", 1000: "M"
    }
    result=""
    for value, numeral in sorted(numerals.items(), reverse=True):
        #print(value, numeral)  # for testing
        while number >= value:
            result += numeral
            number -= value
            #print(result, value)  # for testing only
    return result

# test ...
num = 14
print("{} --> {}".format(num, int2roman(num)))
num = 140
print("{} --> {}".format(num, int2roman(num)))
num = 1941
print("{} --> {}".format(num, int2roman(num)))
num = 2026
print("{} --> {}".format(num, int2roman(num)))

''' result...
14 --> XIV
140 --> CXL
1941 --> MCMXLI
2026 --> MMXXVI
'''
Member Avatar for Reverend Jim

Indian mathematicians have nothing to be proud of.

Judging by the downvote, at least one person missed the point entirely.

commented: 🧑‍⚖️🧑‍⚖️🧑‍⚖️🧑‍⚖️🧑‍⚖️🧑‍⚖️🧑‍⚖️🧑‍⚖️🧑‍⚖️ +16
commented: Like the play on words nothing=zero +3
Member Avatar for Dietrich_3

Is Python good with numbers?
Here is one test:

IPython 8.20.0 -- An enhanced Interactive Python.
nothing = 0
nothing ** nothing
Out[2]: 1

Python follows convention that anything to the power zero is one.

Member Avatar for Dietrich_3

As some of you might have noticed, I am playing around with the Arduino line of interface boards. Checking out an OLED (Organic Light Emitting Diode) display I used the function millis() in the Arduino IDE that is used to program Arduino boards. This function accesses a stream of integer millisecond values generated by the onboard quarz crystal oscillator.

The standard Arduino IDE runs C++, but can also use MicroPython for boards like the inexpensive 'Arduino Nano ESP32'
// millis() uses unsigned long values
// 0 to 4,294,967,295 (2^32 - 1) or about 50 days in millisec
// after that it will reset to zero and count up again
display.setCursor(0, 0); // ULC column, row in pixels
unsigned long millisec = millis();
unsigned long sec = millisec/1000;
unsigned long min = sec/60;
unsigned long hr = min/60;
...

So my mind is going overtime, mathematically what can you do with a continuous data stream like that?
This one is only possible in the computer-age.

Edited by Dietrich_3
Member Avatar for Annie warner

That is a really interesting way to use Python! I am also fascinated by these little number patterns and mathematical tricks. I would definitely love to see the trick you found with 61. Once you share it I can try to find a few similar ones too.

Member Avatar for Dietrich_3

Annie, you might want to take a closer look into how Python handles the concept of "Nothing". For instance "n/0" goes to "infinity", the most opposite of nothing. Is infinity then the inverse of nothing? Give it a thought.

Member Avatar for Dietrich_3

Add two even numbers together and you get an even number
Add two odd numbers together and you get an even number
The only way to get an odd number is to add an even number to an odd one

Would it be logical to say that there are more even numbers than odd once?

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.