Sunday Times Teaser 3274 – Anarithm

by BRG on June 22, 2025

by Colin Vout

Published Sunday June 22 2025 (link)

If you rearrange the letters of a word to form another word, it’s called an anagram. So I think that if you rearrange the digits of a number to form another number, it could be called an anarithm.

Some decimal numbers when expressed in two number bases have representations that are anarithms of each other. For instance, the decimal number 66 is 123 in base 7 and 231 in base 5.

I’ve recently been looking at numbers in base 8 and base 5 and found that it is possible to have a decimal number whose representations in base 8 and base 5 are anarithms of each other.

In decimal notation, what is the largest such number?

From → Uncategorized

7 Comments Leave one →

BRG permalink


# generate the digits of <n> in base <b> in reverse
def digits(n, b):
  while n:
    yield str(n % b)
    n //= b

# for saving the maximum solution
max_n, dgts = 0, None

# ranges exclude upper bound
# digits:     1       2         3           4
# base 5:  1..5   5..25   25..125   125.. 625
# base 8:  1..8   8..64   64..512   512..4096  
# overlap: 1..5   8..25   64..125   512.. 625

lo, hi = 8, 25
while lo < hi:
  # consider integers where the 5/8 base ranges overlap
  for nbr in range(lo, hi):
    # convert to base five and base eight 
    d5 = list(digits(nbr, 5))
    d8 = list(digits(nbr, 8))
    
    # do they use the same digits?
    if sorted(d5) == sorted(d8):
      if nbr > max_n:
        max_n = nbr
        dgts = (''.join(d5[::-1]), ''.join(d8[::-1]))
  lo, hi = 8 * lo, 5 * hi

print(f"{max_n} [{dgts[0]} (base 5) {dgts[1]} (base 8)]")

# generate the digits of <n> in base <b> in reverse

def digits(n, b):

while n:

yield str(n % b)

n //= b

# for saving the maximum solution

max_n, dgts = 0, None

# ranges exclude upper bound

# digits: 1 2 3 4

# base 5: 1..5 5..25 25..125 125.. 625

# base 8: 1..8 8..64 64..512 512..4096

# overlap: 1..5 8..25 64..125 512.. 625

lo, hi = 8, 25

while lo < hi:

# consider integers where the 5/8 base ranges overlap

for nbr in range(lo, hi):

# convert to base five and base eight

d5 = list(digits(nbr, 5))

d8 = list(digits(nbr, 8))

# do they use the same digits?

if sorted(d5) == sorted(d8):

if nbr > max_n:

max_n = nbr

dgts = (''.join(d5[::-1]), ''.join(d8[::-1]))

lo, hi = 8 * lo, 5 * hi

print(f"{max_n} [{dgts[0]} (base 5) {dgts[1]} (base 8)]")

John Z permalink


from itertools import product

# max anarithm found
n10max =(0,)

# A base 5 number will have more digits than its base 8 equivalent
# if it has > n digits when 8 ** n > 5 ** (n + 1)(credit: Brian Gladman)
n = 0
while 8 ** n < 5 ** (n + 1):
  n += 1

# generate up to n digit base 5 numbers; 
for n5 in product('01234', repeat = n):

  # strip leading zeroes from the base 5 number; keep last digit, even 0
  n5s = ''.join(n5[:-1]).lstrip('0') + n5[-1]
  n10 = int(n5s, 5)
  n8 = oct(n10)[2:] # base 8 removing the initial '0o'

  # is it an anarithm?
  if sorted(n5s) == sorted(n8):
    n10max = max((n10, n5s, n8), n10max)

print('base 5:',n10max[1], '; base 10:', n10max[0], '; base 8:', n10max[2])

from itertools import product

# max anarithm found

n10max =(0,)

# A base 5 number will have more digits than its base 8 equivalent

# if it has > n digits when 8 ** n > 5 ** (n + 1)(credit: Brian Gladman)

n = 0

while 8 ** n < 5 ** (n + 1):

n += 1

# generate up to n digit base 5 numbers;

for n5 in product('01234', repeat = n):

# strip leading zeroes from the base 5 number; keep last digit, even 0

n5s = ''.join(n5[:-1]).lstrip('0') + n5[-1]

n10 = int(n5s, 5)

n8 = oct(n10)[2:] # base 8 removing the initial '0o'

# is it an anarithm?

if sorted(n5s) == sorted(n8):

n10max = max((n10, n5s, n8), n10max)

print('base 5:',n10max[1], '; base 10:', n10max[0], '; base 8:', n10max[2])

Frits permalink

@John,

You seem to assume that there must be a solution for the “n” you have calculated.

Reply

BRG permalink

Hi John,

You could speed up your solution quite a bit since we know that the number is between 512 and 624. So possible base 5 numbers are ‘4xxx’ and base 8 numbers are ‘1xxx’. Hence we know two of the digits and your product could be replaced by a repeat of 2 with (1,4) added. We can go even further since three digits must be either (0,1,4) or (1,1,4) leaving only one digit to pick from ‘01234’.


from itertools import permutations

# we need the largest solution so try for a four digit value
# base 5 decimal range   125 ..  625 -> base 5: 4xxx  
# base 8 decimal range   512 .. 4096 -> base 8: 10xx or 11xx
# decimal range overlap  512 ..  625 

# we know two digits (1 and 4) and that a 3rd digit is 0 or 1
for d3 in ('01'):
  # we need a fourth digit in 0..4
  for d4 in '01234':
    # construct the base 5 value 4xxx 
    for p5 in permutations(('1', d3, d4)):
      s5 = ''.join(('4',) + p5)
      d5 = int(s5, 5)
      # construct the base 8 value 1xxx     
      for p8 in (('4', d4), (d4, '4')):
        s8 = ''.join(('1', d3) + p8)
        d8 = int(s8, 8)
        if (nbr := int(s5, 5)) == int(s8, 8):
          print(f"{nbr} [{s5} (base 5) {s8} (base 8)]")

from itertools import permutations

# we need the largest solution so try for a four digit value

# base 5 decimal range 125 .. 625 -> base 5: 4xxx

# base 8 decimal range 512 .. 4096 -> base 8: 10xx or 11xx

# decimal range overlap 512 .. 625

# we know two digits (1 and 4) and that a 3rd digit is 0 or 1

for d3 in ('01'):

# we need a fourth digit in 0..4

for d4 in '01234':

# construct the base 5 value 4xxx

for p5 in permutations(('1', d3, d4)):

s5 = ''.join(('4',) + p5)

d5 = int(s5, 5)

# construct the base 8 value 1xxx

for p8 in (('4', d4), (d4, '4')):

s8 = ''.join(('1', d3) + p8)

d8 = int(s8, 8)

if (nbr := int(s5, 5)) == int(s8, 8):

print(f"{nbr} [{s5} (base 5) {s8} (base 8)]")

John Z permalink

The inner loop (lines 18 – 22) execute 120 times but 4xxx base 5 comprises only 125 values, so retooling my code to start at 4000 is probably about as fast:


from itertools import product

# assume the solution is a number of the form 4xxx base 5
# generate the last three digits of a 4 digit base 5 number
for n5 in product('01234', repeat = 3):

  # append the three base 5 digits to '4'
  n5s = '4' + ''.join(n5)
  n10 = int(n5s, 5)
  n8 = oct(n10)[2:] # base 8 removing the initial '0o'

  # is it an anarithm?
  if sorted(n5s) == sorted(n8):
    print(f'base 5: {n5s}; base 10: {n10}; base 8: {n8}')

from itertools import product

# assume the solution is a number of the form 4xxx base 5

# generate the last three digits of a 4 digit base 5 number

for n5 in product('01234', repeat = 3):

# append the three base 5 digits to '4'

n5s = '4' + ''.join(n5)

n10 = int(n5s, 5)

n8 = oct(n10)[2:] # base 8 removing the initial '0o'

# is it an anarithm?

if sorted(n5s) == sorted(n8):

print(f'base 5: {n5s}; base 10: {n10}; base 8: {n8}')

BRG permalink

Their run-times are now both dominated by the cost of
their print statements. If rewritten as subroutines (i.e. not
including import and output costs) they both run in less
than 50 microseconds.

Reply

John Z permalink

Line 14 generates base 5 numbers from 0000 to 4444 (base 5) = 0 to 624 (base 10) = 0 to 1160 (base 8). Leading 0’s are stripping to determine if there is an anarithm.

Reply

Sunday Times Teaser 3274 – Anarithm

by Colin Vout

Published Sunday June 22 2025 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta