Sunday Times Teaser 3271 – Uncut Diamonds

by BRG on 1 June 2025

By Peter Good

Published Sunday June 01 2025 (link)

Andrew was building a rhombus-shaped patio. He could have paved it with equilateral triangular slabs with 1ft edges, but he wanted a layout with a hexagonal slab in place of six triangular ones at various places. He considered two layouts that were symmetrical in two perpendicular directions:

Layout 1: every triangular slab touches the perimeter of the patio in at least one point.

Layout 2: each group of three adjacent hexagonal slabs encloses exactly one triangular one.

The triangular and hexagonal slabs come in boxes of 12, and Andrew chose layout 1 because he would only need a third as many boxes of triangular slabs as layout 2.

What length were the sides of the patio and how many slabs in total would be left over?

From → Uncategorized

3 Comments Leave one →

BRG permalink


# The total number of unit side equilateral triangles in a 
# rhombus of side <n> is 2.n^2 
max = 30

# A rhombus composed of densely packed hexagons with triangles
# filling the unfilled units around its edges edges has n + 1
# sides, 2.(n + 1)^2 total unit side triangles and h hexagons
# (see below for the value which was calculated from a drawing)
d1ht = dict()
for n in range(1, max + 1):
  h = 3 * (n // 3) ** 2 + (n % 3) * (2 * (n // 3) + 1)
  t = 2 * (n + 1) ** 2 - 6 * h 
  d1ht[n + 1] = (h, t)

# A rhombus composed of repeated units each of threee hexagons
# enclosing a single unit eqiilateral triangle has 2.n sides, 
# n^2 hexagons and 2.n^2 extra unit triangles for n = 1,2, ...
d2ht = dict()
for n in range(1, max // 2 + 1):
  d2ht[2 * n] = (n ** 2, 2 * n ** 2)

# examine common side lengths
for s in sorted(set(d1ht.keys()).intersection(d2ht.keys())):
  h1, t1 = d1ht[s]
  h2, t2 = d2ht[s]
  # check for layout 1 needing 1/3 as many boxes of tris as layout 2
  bt1, bt2 = (t1 + 11) // 12, (t2 + 11) // 12 
  if 3 * bt1 == bt2:
    
    # hexagon boxes needed and unuused slabs
    bh1, bh2 = (h1 + 11) // 12, (h2 + 11) // 12
    bh1r, bh2r = 12 * bh1 - h1, 12 * bh2 - h2
    # triangle boxes needed and unuused slabs 
    bt1r, bt2r = 12 * bt1 - t1, 12 * bt2 - t2

    print(f"{s}ft sides, {bh1r + bt1r} unused slabs.\n"
          f"  1st layout: ({h1} hexagons + {t1:3} triangles)\n"
          f"  2nd layout: ({h2} hexagons + {t2:3} triangles)")
    
    print(f"  hexagons:\n    1st layout: {bh1} boxes ({bh1r} spare), "
          f"\n    2nd layout: {bh2} boxes ({bh2r} spare)")
    
    print(f"  triangles:\n    1st layout: {bt1:2} boxes ({bt1r} spare), "
          f"\n    2nd layout: {bt2} boxes ({bt2r} spare)")

# The total number of unit side equilateral triangles in a

# rhombus of side <n> is 2.n^2

max = 30

# A rhombus composed of densely packed hexagons with triangles

# filling the unfilled units around its edges edges has n + 1

# sides, 2.(n + 1)^2 total unit side triangles and h hexagons

# (see below for the value which was calculated from a drawing)

d1ht = dict()

for n in range(1, max + 1):

h = 3 * (n // 3) ** 2 + (n % 3) * (2 * (n // 3) + 1)

t = 2 * (n + 1) ** 2 - 6 * h

d1ht[n + 1] = (h, t)

# A rhombus composed of repeated units each of threee hexagons

# enclosing a single unit eqiilateral triangle has 2.n sides,

# n^2 hexagons and 2.n^2 extra unit triangles for n = 1,2, ...

d2ht = dict()

for n in range(1, max // 2 + 1):

d2ht[2 * n] = (n ** 2, 2 * n ** 2)

# examine common side lengths

for s in sorted(set(d1ht.keys()).intersection(d2ht.keys())):

h1, t1 = d1ht[s]

h2, t2 = d2ht[s]

# check for layout 1 needing 1/3 as many boxes of tris as layout 2

bt1, bt2 = (t1 + 11) // 12, (t2 + 11) // 12

if 3 * bt1 == bt2:

# hexagon boxes needed and unuused slabs

bh1, bh2 = (h1 + 11) // 12, (h2 + 11) // 12

bh1r, bh2r = 12 * bh1 - h1, 12 * bh2 - h2

# triangle boxes needed and unuused slabs

bt1r, bt2r = 12 * bt1 - t1, 12 * bt2 - t2

print(f"{s}ft sides, {bh1r + bt1r} unused slabs.\n"

f" 1st layout: ({h1} hexagons + {t1:3} triangles)\n"

f" 2nd layout: ({h2} hexagons + {t2:3} triangles)")

print(f" hexagons:\n 1st layout: {bh1} boxes ({bh1r} spare), "

f"\n 2nd layout: {bh2} boxes ({bh2r} spare)")

print(f" triangles:\n 1st layout: {bt1:2} boxes ({bt1r} spare), "

f"\n 2nd layout: {bt2} boxes ({bt2r} spare)")

Frits permalink

Most of the work has gone in correctly printing the two layouts.


# character to print hexagonals
hex_marks =  "01-2+3*4:5#6%7^8a9bcdefghijklmnopqrstuvwxyz"
hex_marks += "ABCDEFGHIJKLMNOPQRSTUVWXYZ!"    
seen = []

# return first free mark (not in <seen>)
def free_mark():
  global seen
  for h in hex_marks:
   if seen.count(h) == 0:
     return h

# get a new string of marks without using same marks in 3 consecutive rows
def new(s):
  global seen
  s_ = ""
  for x in s:
    if seen.count(x) > 1:
      s_ += free_mark()
      seen = [y for y in seen if y != x]
    else:
      s_ += x
    seen.append(s_[-1])  
  return s_    

# print layout 1
def layout1(nsides):  
  global seen
  seen = []
  s = list()
  print(" " * (nsides - 2) + "layout1:      (. = triangle)")
  print(" " * (nsides - 2) + "--------")
  print(" " * nsides + " .") # print last row
  for r in range(1, nsides):
    m = r % 3
    match(m):
      case(1):
        # add new prefix (and suffix)
        f = free_mark()
        seen.append(f)
        if r == 1:
          s.append(f)
        else:
          l = free_mark()
          seen.append(l)
          # add 2 new marks to previous row
          s.append(f + new(s[-1]) + l)
      case otherwise:
        # repeat previous row (using new marks if needed)
        s.append(new(s[-1]))  
    #pr(r, m, s)    
    sp = (nsides - r) * " " 
    # add leading/trailing triangles (.)
    (ld, tr) = (".", ".") if m == 2 else ("..", "..") if m == 0 else ("", "")
    # print row
    print(sp, ld + ''.join(3 * x for x in s[-1]) + tr)          

  for r in reversed(range(1, nsides)):
    m = r % 3
    if m == 0 and r < nsides - 1:
      s.append(new(s[-1][1:-1])) # last row minus leading/trailing "."
    else:
      s.append(new(s[-1]))       

    sp = (nsides - r) * " " 
    # add leading/trailing triangles (.)
    (ld, tr) = (".", ".") if m == 2 else ("..", "..") if m == 0 else ("", "")
    # print row
    print(sp, ld + ''.join(3 * x for x in s[-1]) + tr)    
  print(" " * nsides + " .")  # print final row
  
# print layout 2  
def layout2(nsides):  
  global seen
  seen = []
  s = list()
  prev = ""
  print(" " * (nsides - 4) + "layout2:     (. = triangle)")
  print(" " * (nsides - 4) + "--------")
  print(" " * (nsides - 2) + " .")
  for r in range(2, nsides + 1):
    m = r % 2
    ncols = 2 * r + 1
    # try to fit as many hexagon bloks of 3 cells as possible
    if r % 2:
      # repeat previous row
      s = "." + prev + "."
    else:
      # on a line of <ncols> cells we can just fit (ncols + 1) // 4 hexagons 
      # and (ncols - 3) // 4 triangles
      nhs = (ncols + 1) // 4  
      s = list()
      for _ in range(nhs):
        seen.append((fm := free_mark()))
        s.append(3 * fm)
      # try to reuse old marks
      seen = seen[max(0, r - nhs - 1):]  
      s = '.'.join(s)
    prev = s
    sp = (nsides - r) * " " 
    print(sp + s) # print row   
 
  for r in reversed(range(2, nsides + 1)):
    m = r % 2
    ncols = 2 * r + 1
    # try to fit as many hexagon bloks of 3 cells as possible
    if r == nsides:
      s = prev
    elif r % 2 == 0:
      s = prev[1:-1] # remove leading/trailing dot
    else:
      # between the new leading/trailing dot we have <ncols - 2> cells to fit
      # on a line of <ncols - 2> cells we can just fit 
      # (ncols - 1) // 4  hexagons and (ncols - 5) // 4 triangles
      nhs = (ncols - 1) // 4    
     
      s = list()
      for _ in range(nhs):
        s.append(3 * (fm := free_mark()))
        seen.append(fm)
      # try to reuse old marks
      seen = seen[max(0, r - nhs - 1):]  
      s = "." + '.'.join(s) + "."
    prev = s
    sp = (nsides - r) * " " 
    print(sp + s)  
  print(" " * (nsides - 2) + " .")  
      
# increase side lenghts of the rhombus until solution is found
for n, _ in enumerate(iter(bool, 1), 3): # infinite loop
  h = n // 2
  # calculate number of triangles
  t1 = 2 + sum(((n // 3 + 1) * [0, 4, 8])[:n - 1])
  n1, r1 = divmod(t1, 12)
  n2, r2 = divmod(t2 := 2 * h**2, 12)
  
  # only need a third as many boxes of triangular slabs as layout 2
  if 3 * (n1 + (r1 > 0)) == (n2 + (r2 > 0)):
    # total cells
    t = 2 * n**2
    # calculate number of hexagons
    h1, rh1 = divmod((t - t1) // 6, 12) 
    h2, rh2 = divmod((t - t2) // 6, 12) 
  
    # calculate slabs left over
    slo = 12 - r1 if r1 else 0
    slo += 12 - r2 if r2 else 0
    slo += 12 - rh1 if rh1 else 0
    slo += 12 - rh2 if rh2 else 0
    print(f"answer: length {n}ft and {slo} slabs left over\n")
    
    layout1(n)
    print()
    layout2(n)
    break

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

# character to print hexagonals

hex_marks = "01-2+3*4:5#6%7^8a9bcdefghijklmnopqrstuvwxyz"

hex_marks += "ABCDEFGHIJKLMNOPQRSTUVWXYZ!"

seen = []

# return first free mark (not in <seen>)

def free_mark():

global seen

for h in hex_marks:

if seen.count(h) == 0:

return h

# get a new string of marks without using same marks in 3 consecutive rows

def new(s):

global seen

s_ = ""

for x in s:

if seen.count(x) > 1:

s_ += free_mark()

seen = [y for y in seen if y != x]

else:

s_ += x

seen.append(s_[-1])

return s_

# print layout 1

def layout1(nsides):

global seen

seen = []

s = list()

print(" " * (nsides - 2) + "layout1: (. = triangle)")

print(" " * (nsides - 2) + "--------")

print(" " * nsides + " .") # print last row

for r in range(1, nsides):

m = r % 3

match(m):

case(1):

# add new prefix (and suffix)

f = free_mark()

seen.append(f)

if r == 1:

s.append(f)

else:

l = free_mark()

seen.append(l)

# add 2 new marks to previous row

s.append(f + new(s[-1]) + l)

case otherwise:

# repeat previous row (using new marks if needed)

s.append(new(s[-1]))

#pr(r, m, s)

sp = (nsides - r) * " "

# add leading/trailing triangles (.)

(ld, tr) = (".", ".") if m == 2 else ("..", "..") if m == 0 else ("", "")

# print row

print(sp, ld + ''.join(3 * x for x in s[-1]) + tr)

for r in reversed(range(1, nsides)):

m = r % 3

if m == 0 and r < nsides - 1:

s.append(new(s[-1][1:-1])) # last row minus leading/trailing "."

else:

s.append(new(s[-1]))

sp = (nsides - r) * " "

# add leading/trailing triangles (.)

(ld, tr) = (".", ".") if m == 2 else ("..", "..") if m == 0 else ("", "")

# print row

print(sp, ld + ''.join(3 * x for x in s[-1]) + tr)

print(" " * nsides + " .") # print final row

# print layout 2

def layout2(nsides):

global seen

seen = []

s = list()

prev = ""

print(" " * (nsides - 4) + "layout2: (. = triangle)")

print(" " * (nsides - 4) + "--------")

print(" " * (nsides - 2) + " .")

for r in range(2, nsides + 1):

m = r % 2

ncols = 2 * r + 1

# try to fit as many hexagon bloks of 3 cells as possible

if r % 2:

# repeat previous row

s = "." + prev + "."

else:

# on a line of <ncols> cells we can just fit (ncols + 1) // 4 hexagons

# and (ncols - 3) // 4 triangles

nhs = (ncols + 1) // 4

s = list()

for _ in range(nhs):

seen.append((fm := free_mark()))

s.append(3 * fm)

# try to reuse old marks

seen = seen[max(0, r - nhs - 1):]

s = '.'.join(s)

prev = s

sp = (nsides - r) * " "

print(sp + s) # print row

for r in reversed(range(2, nsides + 1)):

m = r % 2

ncols = 2 * r + 1

# try to fit as many hexagon bloks of 3 cells as possible

if r == nsides:

s = prev

elif r % 2 == 0:

s = prev[1:-1] # remove leading/trailing dot

else:

# between the new leading/trailing dot we have <ncols - 2> cells to fit

# on a line of <ncols - 2> cells we can just fit

# (ncols - 1) // 4 hexagons and (ncols - 5) // 4 triangles

nhs = (ncols - 1) // 4

s = list()

for _ in range(nhs):

s.append(3 * (fm := free_mark()))

seen.append(fm)

# try to reuse old marks

seen = seen[max(0, r - nhs - 1):]

s = "." + '.'.join(s) + "."

prev = s

sp = (nsides - r) * " "

print(sp + s)

print(" " * (nsides - 2) + " .")

# increase side lenghts of the rhombus until solution is found

for n, _ in enumerate(iter(bool, 1), 3): # infinite loop

h = n // 2

# calculate number of triangles

t1 = 2 + sum(((n // 3 + 1) * [0, 4, 8])[:n - 1])

n1, r1 = divmod(t1, 12)

n2, r2 = divmod(t2 := 2 * h**2, 12)

# only need a third as many boxes of triangular slabs as layout 2

if 3 * (n1 + (r1 > 0)) == (n2 + (r2 > 0)):

# total cells

t = 2 * n**2

# calculate number of hexagons

h1, rh1 = divmod((t - t1) // 6, 12)

h2, rh2 = divmod((t - t2) // 6, 12)

# calculate slabs left over

slo = 12 - r1 if r1 else 0

slo += 12 - r2 if r2 else 0

slo += 12 - rh1 if rh1 else 0

slo += 12 - rh2 if rh2 else 0

print(f"answer: length {n}ft and {slo} slabs left over\n")

layout1(n)

print()

layout2(n)

break

BRG permalink

An impressive feat of perseverance!

Reply

Sunday Times Teaser 3271 – Uncut Diamonds

By Peter Good

Published Sunday June 01 2025 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta