Sunday Times Teaser 3088 – Bog Standard Deviation

by BRG on November 26, 2021

by Stephen Hogg

Published Sunday November 28 2021 (link)

My four toilet rolls had zigzag-cut remnants (not unlike that shown). Curiously, each polygonal remnant had a different two-figure prime number of sides, each with a digit sum itself prime.

Calculating the average number of sides for the four remnants and the average of their squares, I found that the average of the squares minus the square of the average had a value whose square root (the “standard deviation”) was a whole number.

I also noticed that a regular convex polygon with a number of sides equal to the average number of sides would have an odd whole-number internal angle (in degrees).

Give the “standard deviation”.

From → Uncategorized

2 Comments Leave one →

Brian Gladman permalink

This solution works ‘backwards’ starting with the internal angles of regular polygons


# list two digit primes that have prime digit sums 
pr = {3, 5, 7}
pr |= {2} | {x for x in range(11, 100, 2) if all(x % p for p in pr)}
pr = sorted(p for p in pr if p > 9 and sum(divmod(p, 10)) in pr)

# generate all ordered combinations of <n> values from <ns> with sum <t>
def find(ns, n, t, seq=()):
  if n == 0:
    if t == 0:
      yield seq
  else:
    for s in ns:
      if (not seq or s > seq[-1]) and s <= t:
        yield from find(ns, n - 1, t - s, seq + (s,))

# consider the average number of sides
for av_sides in range(sum(pr[:4]) // 4, sum(pr[-4:]) // 4 + 1):
  
  # find numbers of sides for which a regular polygon
  # will hve odd integer internal angles
  iang, r = divmod(180 * av_sides - 360, av_sides)
  if not r and iang & 1:
    
    # consider all combinations of four 'special primes'
    # with this average number of sides
    for sides in find(pr, 4, 4 * av_sides):
      
      # find the standard deviation
      av_sqs, r = divmod(sum(x * x for x in sides), 4)
      sd2 = av_sqs - av_sides * av_sides
      std = round(sd2 ** 0.5)
      # which must be an integer
      if not r and std * std == sd2:
        print(f"{std=} [{sides=}, {av_sides=}, {av_sqs=}, {iang=}]")

# list two digit primes that have prime digit sums

pr = {3, 5, 7}

pr |= {2} | {x for x in range(11, 100, 2) if all(x % p for p in pr)}

pr = sorted(p for p in pr if p > 9 and sum(divmod(p, 10)) in pr)

# generate all ordered combinations of <n> values from <ns> with sum <t>

def find(ns, n, t, seq=()):

if n == 0:

if t == 0:

yield seq

else:

for s in ns:

if (not seq or s > seq[-1]) and s <= t:

yield from find(ns, n - 1, t - s, seq + (s,))

# consider the average number of sides

for av_sides in range(sum(pr[:4]) // 4, sum(pr[-4:]) // 4 + 1):

# find numbers of sides for which a regular polygon

# will hve odd integer internal angles

iang, r = divmod(180 * av_sides - 360, av_sides)

if not r and iang & 1:

# consider all combinations of four 'special primes'

# with this average number of sides

for sides in find(pr, 4, 4 * av_sides):

# find the standard deviation

av_sqs, r = divmod(sum(x * x for x in sides), 4)

sd2 = av_sqs - av_sides * av_sides

std = round(sd2 ** 0.5)

# which must be an integer

if not r and std * std == sd2:

print(f"{std=} [{sides=}, {av_sides=}, {av_sqs=}, {iang=}]")

This version starts from the four ‘special’ prime sequences.


# generate all ordered combinations of <n> values from <ns>
def comb(ns, n, seq=()):
  if n == 0:
    yield seq
  else:
    for s in ns:
      if not seq or s > seq[-1]:
        yield from comb(ns, n - 1, seq + (s,))
        
# list two digit primes that have prime digit sums 
pr = {3, 5, 7}
pr = {2} | pr | {x for x in range(11, 100, 2) if all(x % p for p in pr)}
pr = sorted(p for p in pr if p > 9 and sum(divmod(p, 10)) in pr)

# consider all combinations of four such primes
for sides in comb(pr, 4):
  # find the average numbers of sides
  av_sides, r = divmod(sum(sides), 4)
  if r:
    continue

  # find the average of the squared numbers of sides
  av_sqs = sum(x * x for x in sides) / 4
  
  # consider only integer 'standard deviations'
  t = av_sqs - av_sides * av_sides
  std = round(t ** 0.5)
  if std * std != t:
    continue

  # find solutions for which a regular polygon with the same
  # number of sides would have an odd integer internal angle 
  iang, r = divmod(180 * av_sides - 360, av_sides)
  if r == 0:
    print(f"{std=} [{sides=}, {av_sides=}, {av_sqs=}, {iang=}]")

# generate all ordered combinations of <n> values from <ns>

def comb(ns, n, seq=()):

if n == 0:

yield seq

else:

for s in ns:

if not seq or s > seq[-1]:

yield from comb(ns, n - 1, seq + (s,))

# list two digit primes that have prime digit sums

pr = {3, 5, 7}

pr = {2} | pr | {x for x in range(11, 100, 2) if all(x % p for p in pr)}

pr = sorted(p for p in pr if p > 9 and sum(divmod(p, 10)) in pr)

# consider all combinations of four such primes

for sides in comb(pr, 4):

# find the average numbers of sides

av_sides, r = divmod(sum(sides), 4)

if r:

continue

# find the average of the squared numbers of sides

av_sqs = sum(x * x for x in sides) / 4

# consider only integer 'standard deviations'

t = av_sqs - av_sides * av_sides

std = round(t ** 0.5)

if std * std != t:

continue

# find solutions for which a regular polygon with the same

# number of sides would have an odd integer internal angle

iang, r = divmod(180 * av_sides - 360, av_sides)

if r == 0:

print(f"{std=} [{sides=}, {av_sides=}, {av_sqs=}, {iang=}]")

John Z permalink


from itertools import combinations

# generate set of prime numbers < 100 using Brian's method
pr = {3, 5, 7, 11, 13}
pr |= {2} | {x for x in range(17, 100, 2) if all(x % p for p in pr)}

# list of angles of reg convex poly with odd whole number internal angle * 4
an = [n * 4 for n in range(3, 200)
           if (ar := divmod((n - 2) * 180, n)) and ar[0] & 1 and not ar[1]]

# make list of sides that are 2 digit primes and whose sum of digits is prime
pp = sorted((p for p in pr if 10 < p < 99 and sum(divmod(p, 10)) in pr))

# consider combinations of 4 sides
for cs in combinations(pp, 4):
  
  # is average of sides * 4 == n * 4 sides of regular polygon 'an' 
  asm = sum(cs)
  if asm not in an:
    continue
  
  # average number of sides
  avgs  = asm // 4

  # average of square of sides
  avgs2 = sum(x * x for x in cs) / 4

  sd2 = avgs2 - avgs ** 2

  if int(sd2 ** 0.5) ** 2 == sd2:
    print(f'standard deviation {sd2 ** 0.5} sides {cs}')

from itertools import combinations

# generate set of prime numbers < 100 using Brian's method

pr = {3, 5, 7, 11, 13}

pr |= {2} | {x for x in range(17, 100, 2) if all(x % p for p in pr)}

# list of angles of reg convex poly with odd whole number internal angle * 4

an = [n * 4 for n in range(3, 200)

if (ar := divmod((n - 2) * 180, n)) and ar[0] & 1 and not ar[1]]

# make list of sides that are 2 digit primes and whose sum of digits is prime

pp = sorted((p for p in pr if 10 < p < 99 and sum(divmod(p, 10)) in pr))

# consider combinations of 4 sides

for cs in combinations(pp, 4):

# is average of sides * 4 == n * 4 sides of regular polygon 'an'

asm = sum(cs)

if asm not in an:

continue

# average number of sides

avgs = asm // 4

# average of square of sides

avgs2 = sum(x * x for x in cs) / 4

sd2 = avgs2 - avgs ** 2

if int(sd2 ** 0.5) ** 2 == sd2:

print(f'standard deviation {sd2 ** 0.5} sides {cs}')

Sunday Times Teaser 3088 – Bog Standard Deviation

by Stephen Hogg

Published Sunday November 28 2021 (link)

Leave a comment to Brian Gladman Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta