Sunday Times Teaser 3172 – Light Show


from datetime import datetime, timedelta

# the set of primes less than 50
prms = {3, 5, 7}
prms = {2} | prms | {n for n in range(11, 50, 2) if all(n % p for p in prms)}

# the number of lit segments for digits 0..9 respectively
nseg = (6, 2, 5, 5, 4, 5, 6, 3, 7, 6)

# return the clock digits from a datetime object
dgts = lambda d: sum((divmod(x, 10) for x in
                        (d.month, d.day, d.hour, d.minute)), ())

# consider the minutes in a day (0 is in month so times start at 12:00)
for md in range(12 * 60, 24 * 60):
  # form the hours and minutes and the digits used in them
  h1, n1 = divmod(md, 60)
  dg_hn1 = set(divmod(h1, 10) + divmod(n1, 10))
  if len(dg_hn1) != 4:
    continue

  # consider the day of the month 
  for d1 in range(1, 32):
    dg_hnd1 = dg_hn1 | set(divmod(d1, 10))
    if len(dg_hnd1) != 6:
      continue

    # consider the month (up to July)
    for m1 in range(1, 8):
      # the day and month must be before 9th July
      if m1 == 7 and d1 >= 9:
        continue

      # the date has different digits and a prime number of lit segemnts 
      if len((dg_hndm1 := dg_hnd1 | set(divmod(m1, 10)))) != 8:
        continue
      if (ds1 := sum(nseg[d] for d in dg_hndm1)) not in prms: 
        continue

      # form the datetime objects for the date and the next day 
      t1 = datetime(year=2023, month=m1, day=d1, hour=h1, minute=n1)
      t2 = t1 + timedelta(days=1)

      # the next day has different digits and a prime number of lit segemnts 
      if len((dgs2 := dgts(t2))) != 8:
        continue      
      if (ds2 := sum(nseg[d] for d in dgs2)) not in prms:
        continue
      
      # move on a further minute and find the number of lit segments ...
      t3 = t2 + timedelta(minutes=1)
      ds3 = sum(nseg[d] for d in dgts(t3))
      # ... which must be the average of the earlier two 
      if 2 * ds3 == ds1 + ds2:
        fl = []
        for t, s in zip((t3, t2, t1), (ds3, ds2, ds1)):
          fl.append(f"{t.hour:02}:{t.minute:02} {t.day:02}:{t.month:02} ({s})")
        print(' <- '.join(fl))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

from datetime import datetime, timedelta

# the set of primes less than 50

prms = {3, 5, 7}

prms = {2} | prms | {n for n in range(11, 50, 2) if all(n % p for p in prms)}

# the number of lit segments for digits 0..9 respectively

nseg = (6, 2, 5, 5, 4, 5, 6, 3, 7, 6)

# return the clock digits from a datetime object

dgts = lambda d: sum((divmod(x, 10) for x in

(d.month, d.day, d.hour, d.minute)), ())

# consider the minutes in a day (0 is in month so times start at 12:00)

for md in range(12 * 60, 24 * 60):

# form the hours and minutes and the digits used in them

h1, n1 = divmod(md, 60)

dg_hn1 = set(divmod(h1, 10) + divmod(n1, 10))

if len(dg_hn1) != 4:

continue

# consider the day of the month

for d1 in range(1, 32):

dg_hnd1 = dg_hn1 | set(divmod(d1, 10))

if len(dg_hnd1) != 6:

continue

# consider the month (up to July)

for m1 in range(1, 8):

# the day and month must be before 9th July

if m1 == 7 and d1 >= 9:

continue

# the date has different digits and a prime number of lit segemnts

if len((dg_hndm1 := dg_hnd1 | set(divmod(m1, 10)))) != 8:

continue

if (ds1 := sum(nseg[d] for d in dg_hndm1)) not in prms:

continue

# form the datetime objects for the date and the next day

t1 = datetime(year=2023, month=m1, day=d1, hour=h1, minute=n1)

t2 = t1 + timedelta(days=1)

# the next day has different digits and a prime number of lit segemnts

if len((dgs2 := dgts(t2))) != 8:

continue

if (ds2 := sum(nseg[d] for d in dgs2)) not in prms:

continue

# move on a further minute and find the number of lit segments ...

t3 = t2 + timedelta(minutes=1)

ds3 = sum(nseg[d] for d in dgts(t3))

# ... which must be the average of the earlier two

if 2 * ds3 == ds1 + ds2:

fl = []

for t, s in zip((t3, t2, t1), (ds3, ds2, ds1)):

fl.append(f"{t.hour:02}:{t.minute:02} {t.day:02}:{t.month:02} ({s})")

print(' <- '.join(fl))

Reply

Frits permalink

I found extracting data from a date string easier than accessing the date fields directly.


from datetime import date, timedelta, datetime
from enigma import catch, is_prime

from itertools import permutations as perm

# number of segments per digit
seq = [('0', 6), ('1', 2), ('2', 5), ('3', 5), ('4', 4), 
       ('5', 5), ('6', 6), ('7', 3), ('8', 7), ('9', 6)]

# dictionary
d = dict(seq)

# check valid time for string hhmm
check_time = lambda s: (0 <= int(s[:2]) < 24) and (0 <= int(s[2:]) < 60)
  
# check valid date for string ddmm
check_date = lambda s: catch(date, 2023, int(s[2:]), int(s[:2])) is not None

# return month, day, hours and minutes from a date string
extract = lambda s: (s[5:7], s[8:10], s[11:13], s[14:16])

# return total of segments for elements in string <s>
total = lambda s: sum(d[x] for x in s)

# 1st day may not end on a zero/nine or where difference with next digit is odd
day_ends = [(x[0], y[1] - x[1]) for x, y in zip(seq[1:], seq[2:])
            if (y[1] - x[1]) % 2 == 0] 

# allowed changes in total from T2 to T3
allowed = {-x[1] // 2 for x in day_ends}

# 1st time may not end on a zero or cause a forbidden change in total   
minutes_ends = {x[0] for x, y in zip(seq[1:], seq[2:]) \
            if (y[1] - x[1]) in allowed} | {'9'}            

# display format: h1h2.t1t2 d1d2.m1m2 where m1=0 (<= july)
m1 = "0"
dgts = "123456789"
for d1 in "123":
  for d2 in [x[0] for x in day_ends if x[0] != d1]:
    # it happened recently so up till June (July dates have 2 zeroes) 
    for m2 in set("123456").difference([d1, d2]):
      if not check_date(ddmm := d1 + d2 + m1 + m2): continue
      for t2 in minutes_ends.difference([d1, d2, m2]):
        # choose digits for h1, h2 and t1
        for h1, h2, t1 in perm(set(dgts).difference([d1, d2, m2, t2]), 3):
          if not check_time(hhmm := h1 + h2 + t1 + t2): continue
          if not is_prime(T1 := total(hhmm + ddmm)): continue
          
          day1 = datetime(2023, int(ddmm[2:]), int(ddmm[:2]), 
                                int(hhmm[:2]), int(hhmm[2:]), 0)
          day2 = day1 + timedelta(days=1)

          mo2, da2, _, _ = extract(str(day2))
          # new display must also have different digits
          if len(set(s2 := hhmm + da2 + mo2)) != 8: continue

          if not is_prime(T2 := total(s2)): continue

          day3 = day2 + timedelta(minutes=1)
          mo3, da3, hr3, mn3 = extract(str(day3))
         
          # T3 should be the average of T1 and T2
          if 2 * total(hr3 + mn3 + mo3 + da3) != T1 + T2: continue
           
          print(f"answer: {hr3}.{mn3} {da3}.{mo3}")

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

from datetime import date, timedelta, datetime

from enigma import catch, is_prime

from itertools import permutations as perm

# number of segments per digit

seq = [('0', 6), ('1', 2), ('2', 5), ('3', 5), ('4', 4),

('5', 5), ('6', 6), ('7', 3), ('8', 7), ('9', 6)]

# dictionary

d = dict(seq)

# check valid time for string hhmm

check_time = lambda s: (0 <= int(s[:2]) < 24) and (0 <= int(s[2:]) < 60)

# check valid date for string ddmm

check_date = lambda s: catch(date, 2023, int(s[2:]), int(s[:2])) is not None

# return month, day, hours and minutes from a date string

extract = lambda s: (s[5:7], s[8:10], s[11:13], s[14:16])

# return total of segments for elements in string <s>

total = lambda s: sum(d[x] for x in s)

# 1st day may not end on a zero/nine or where difference with next digit is odd

day_ends = [(x[0], y[1] - x[1]) for x, y in zip(seq[1:], seq[2:])

if (y[1] - x[1]) % 2 == 0]

# allowed changes in total from T2 to T3

allowed = {-x[1] // 2 for x in day_ends}

# 1st time may not end on a zero or cause a forbidden change in total

minutes_ends = {x[0] for x, y in zip(seq[1:], seq[2:]) \

if (y[1] - x[1]) in allowed} | {'9'}

# display format: h1h2.t1t2 d1d2.m1m2 where m1=0 (<= july)

m1 = "0"

dgts = "123456789"

for d1 in "123":

for d2 in [x[0] for x in day_ends if x[0] != d1]:

# it happened recently so up till June (July dates have 2 zeroes)

for m2 in set("123456").difference([d1, d2]):

if not check_date(ddmm := d1 + d2 + m1 + m2): continue

for t2 in minutes_ends.difference([d1, d2, m2]):

# choose digits for h1, h2 and t1

for h1, h2, t1 in perm(set(dgts).difference([d1, d2, m2, t2]), 3):

if not check_time(hhmm := h1 + h2 + t1 + t2): continue

if not is_prime(T1 := total(hhmm + ddmm)): continue

day1 = datetime(2023, int(ddmm[2:]), int(ddmm[:2]),

int(hhmm[:2]), int(hhmm[2:]), 0)

day2 = day1 + timedelta(days=1)

mo2, da2, _, _ = extract(str(day2))

# new display must also have different digits

if len(set(s2 := hhmm + da2 + mo2)) != 8: continue

if not is_prime(T2 := total(s2)): continue

day3 = day2 + timedelta(minutes=1)

mo3, da3, hr3, mn3 = extract(str(day3))

# T3 should be the average of T1 and T2

if 2 * total(hr3 + mn3 + mo3 + da3) != T1 + T2: continue

print(f"answer: {hr3}.{mn3} {da3}.{mo3}")

Reply

John Z permalink


from datetime import datetime

p7 = (2, 3, 5, 7)
#generate primes up to the maximum total number of segments : 8 * 7
p100 = p7 + tuple(n for n in range (8, 56) if all(n % x for x in p7))

# number of segments for each digit
#     0  1  2  3  4  5  6  7  8  9
nd = (6, 2, 5, 5, 4, 5, 6, 3, 7, 6)

# initilalize dictionary so space, minus, colon have no segments
ndd = {" ": 0, "-": 0, ":": 0} 

#map str(digit value) to number of segments
for n in range(10):
  ndd[str(n)] = nd[n]

# year's worth of seconds
ys = 365 * 24 * 60 * 60

# assume not a leap year and end of year does not occur between the times
# consider all of the minutes in a year (happens to be 1970)
for t in range(0, ys + 1, 60):

  # get the time and date as a string leaving out the year digits
  ds = str(datetime.fromtimestamp(t))[5:16]
  ns = sum(ndd[x] for x in ds) # number of segments
  if not(len(set(ds)) == 11 and ns in (p100)):
    continue
  # one day later
  ds24 = str(datetime.fromtimestamp(t + 24 * 60 * 60))[5:16]
  ns24 = sum(ndd[x] for x in ds24) # number of segments
  if not(len(set(ds24)) == 11 and ns24 in (p100)):
    continue
  # one minute later
  ds24m = str(datetime.fromtimestamp(t + 24 * 60 * 60 + 60))[5:16]
  ns24m = sum(ndd[x] for x in ds24m) # number of segments
  if 2 * ns24m == ns + ns24:
    print(ds, ns, ds24, ns24)
    print(ds24m[6:8] + '.' + ds24m[9:11], ds24m[3:5] + '.' + ds24m[:2], ns24m)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

from datetime import datetime

p7 = (2, 3, 5, 7)

#generate primes up to the maximum total number of segments : 8 * 7

p100 = p7 + tuple(n for n in range (8, 56) if all(n % x for x in p7))

# number of segments for each digit

# 0 1 2 3 4 5 6 7 8 9

nd = (6, 2, 5, 5, 4, 5, 6, 3, 7, 6)

# initilalize dictionary so space, minus, colon have no segments

ndd = {" ": 0, "-": 0, ":": 0}

#map str(digit value) to number of segments

for n in range(10):

ndd[str(n)] = nd[n]

# year's worth of seconds

ys = 365 * 24 * 60 * 60

# assume not a leap year and end of year does not occur between the times

# consider all of the minutes in a year (happens to be 1970)

for t in range(0, ys + 1, 60):

# get the time and date as a string leaving out the year digits

ds = str(datetime.fromtimestamp(t))[5:16]

ns = sum(ndd[x] for x in ds) # number of segments

if not(len(set(ds)) == 11 and ns in (p100)):

continue

# one day later

ds24 = str(datetime.fromtimestamp(t + 24 * 60 * 60))[5:16]

ns24 = sum(ndd[x] for x in ds24) # number of segments

if not(len(set(ds24)) == 11 and ns24 in (p100)):

continue

# one minute later

ds24m = str(datetime.fromtimestamp(t + 24 * 60 * 60 + 60))[5:16]

ns24m = sum(ndd[x] for x in ds24m) # number of segments

if 2 * ns24m == ns + ns24:

print(ds, ns, ds24, ns24)

print(ds24m[6:8] + '.' + ds24m[9:11], ds24m[3:5] + '.' + ds24m[:2], ns24m)

Reply

Erling Torkildsen permalink


from collections import defaultdict

Ds = defaultdict() # for dates
hhmm = list()      # for clock displays

seg = (6, 2, 5, 5, 4, 5, 6, 3, 7, 6)
P = {7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59}
DinM = (0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

# Counting segments in number
def sgs(a):
  s = 0
  for i in range(len(a)):
    s += seg[int(a[i])]
  return s

# Return time-string for one minute later
def nxt(t):
  for i in range(1441):
    if hhmm[i] == t:
      return hhmm[i + 1]

# Map date-strings to day number
n = 0
for m in range(1, 13):
  for d in range(1, DinM[m] + 1):
    n += 1
    Ds[n] = str(d).zfill(2) + str(m).zfill(2)

# List consecutive time-stings for 24h
for h in range(24):
  for m in range(60):
    hhmm.append(str(h).zfill(2) + str(m).zfill(2))

# Look up consecutive dates with times..
for n in range(1, 365):
  for t1 in hhmm:
    s1 = Ds[n] + t1
    s2 = Ds[n + 1] + t1

    # ..that have different digits and prime number of segments lighting
    if len(set(s1)) == len(set(s2)) == 8 and sgs(s1) in P and sgs(s2) in P:

      # Find string showing time one minute later..
      t2 = nxt(t1)

      # ..that has average number of segments
      if sgs(Ds[n + 1]) + sgs(t2) == (sgs(s1) + sgs(s2))/2:
        print(f"{t2[:2]}.{t2[2:]} {Ds[n + 1][:2]}.{Ds[n + 1][2:]}")

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

from collections import defaultdict

Ds = defaultdict() # for dates

hhmm = list() # for clock displays

seg = (6, 2, 5, 5, 4, 5, 6, 3, 7, 6)

P = {7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59}

DinM = (0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

# Counting segments in number

def sgs(a):

s = 0

for i in range(len(a)):

s += seg[int(a[i])]

return s

# Return time-string for one minute later

def nxt(t):

for i in range(1441):

if hhmm[i] == t:

return hhmm[i + 1]

# Map date-strings to day number

n = 0

for m in range(1, 13):

for d in range(1, DinM[m] + 1):

n += 1

Ds[n] = str(d).zfill(2) + str(m).zfill(2)

# List consecutive time-stings for 24h

for h in range(24):

for m in range(60):

hhmm.append(str(h).zfill(2) + str(m).zfill(2))

# Look up consecutive dates with times..

for n in range(1, 365):

for t1 in hhmm:

s1 = Ds[n] + t1

s2 = Ds[n + 1] + t1

# ..that have different digits and prime number of segments lighting

if len(set(s1)) == len(set(s2)) == 8 and sgs(s1) in P and sgs(s2) in P:

# Find string showing time one minute later..

t2 = nxt(t1)

# ..that has average number of segments

if sgs(Ds[n + 1]) + sgs(t2) == (sgs(s1) + sgs(s2))/2:

print(f"{t2[:2]}.{t2[2:]} {Ds[n + 1][:2]}.{Ds[n + 1][2:]}")

Reply

BRG permalink

Congratulations Guys, A full house this week!

Reply

John Z permalink

More compact, doesn’t import ‘datetime’ but uses lots of memory


# number of days in each month (non leap year)
mo =(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

p7 = (2, 3, 5, 7)
#generate primes up to the maximum total number of segments : 8 * 7
p100 = p7 + tuple(n for n in range (11, 56) if all(n % x for x in p7))

# number of segments for each digit
#     0  1  2  3  4  5  6  7  8  9 
nd = (6, 2, 5, 5, 4, 5, 6, 3, 7, 6)

#map str(digit value) to number of segments; space, dot, colon don't count
ndd = {str(n): nd[n] for n in range(10)} | {" ": 0, ".": 0, ":": 0}

#generate a year's worth of displays, one string for every minute
dmhm = tuple(f'{h:02}:{mn:02} {d:02}.{mi:02}' 
                 for mi, m in enumerate(mo, 1) for d in range(1, m + 1)
                 for h in range(24) for mn in range(60))

# consider the display values over the year
for i, dp in enumerate(dmhm):

  # 8 different digits + (. : space)? sum of segments prime?
  if len(set(dp)) != 11 or (ns := sum(ndd[x] for x in dp)) not in p100:
    continue
  # 24 hours later
  dp24 = dmhm[i + 24 * 60]
  if len(set(dp24)) != 11 or (ns24 := sum(ndd[x] for x in dp24)) not in p100:
    continue
  # 1 minute later
  dp24m = dmhm[i + 24 * 60 + 1]
  if (ns24m := sum(ndd[x] for x in dp24m)) * 2 == ns + ns24:
    print(f'{dp} ({ns}) < {dp24} ({ns24}) < {dp24m} ({ns24m})')

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

# number of days in each month (non leap year)

mo =(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

p7 = (2, 3, 5, 7)

#generate primes up to the maximum total number of segments : 8 * 7

p100 = p7 + tuple(n for n in range (11, 56) if all(n % x for x in p7))

# number of segments for each digit

# 0 1 2 3 4 5 6 7 8 9

nd = (6, 2, 5, 5, 4, 5, 6, 3, 7, 6)

#map str(digit value) to number of segments; space, dot, colon don't count

ndd = {str(n): nd[n] for n in range(10)} | {" ": 0, ".": 0, ":": 0}

#generate a year's worth of displays, one string for every minute

dmhm = tuple(f'{h:02}:{mn:02} {d:02}.{mi:02}'

for mi, m in enumerate(mo, 1) for d in range(1, m + 1)

for h in range(24) for mn in range(60))

# consider the display values over the year

for i, dp in enumerate(dmhm):

# 8 different digits + (. : space)? sum of segments prime?

if len(set(dp)) != 11 or (ns := sum(ndd[x] for x in dp)) not in p100:

continue

# 24 hours later

dp24 = dmhm[i + 24 * 60]

if len(set(dp24)) != 11 or (ns24 := sum(ndd[x] for x in dp24)) not in p100:

continue

# 1 minute later

dp24m = dmhm[i + 24 * 60 + 1]

if (ns24m := sum(ndd[x] for x in dp24m)) * 2 == ns + ns24:

print(f'{dp} ({ns}) < {dp24} ({ns24}) < {dp24m} ({ns24m})')

Reply

Sunday Times Teaser 3172 – Light Show

by Victor Bryant

Published Sunday July 09 2023 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta