Yet another exciting math problem that requires an algorithmic approach to arrive at a quick solution! There is a penpaper approach to it too, but this post assumes we’re more interested in discussing the programming angle.
First, the problem:
Working clockwise, and starting from the group of three with the numerically lowest external node (4,3,2 in this example), each solution can be described uniquely. For example, the above solution can be described by the set: 4,3,2; 6,2,1; 5,1,3.
It is possible to complete the ring with four different totals: 9, 10, 11, and 12. There are eight solutions in total.
Total Solution Set:
9 4,2,3; 5,3,1; 6,1,2
9 4,3,2; 6,2,1; 5,1,3
10 2,3,5; 4,5,1; 6,1,3
10 2,5,3; 6,3,1; 4,1,5
11 1,4,6; 3,6,2; 5,2,4
11 1,6,4; 5,4,2; 3,2,6
12 1,5,6; 2,6,4; 3,4,5
12 1,6,5; 3,5,4; 2,4,6
By concatenating each group it is possible to form 9digit strings; the maximum string for a 3gon ring is 432621513.
Problem
Using the numbers 1 to 10, and depending on arrangements, it is possible to form 16 and 17digit strings. What is the maximum 16digit string for a “magic” 5gon ring?
Algorithm
In attempting this problem, I choose to label the 5 inner nodes as i, j, k, l, and m.
α, β, γ, δ, and θ being the corresponding outer nodes.
Let x be the sum total of each triplet line, i.e.,
x = α + i + j = β + j + k = γ + k + l = δ + l + m = θ + m + i
First Observation:
For the string to be 16digits, 10 has to be in the outer ring, as each number in the inner ring is included in the string twice. Next, we fill the inner ring in an iterative manner.
Second Observation:
There 9 numbers to choose from for the inner ring — 1, 2, 3, 4, 5, 6, 7, 8 and 9.
5 have to be chosen. This can be done in 9C5 = 126 ways.
According to circular permutation, if there are n distinct numbers to be arranged in a circle, this can be done in (n1)! ways, where (n1)! = (n1).(n2).(n3)…3.2.1. So 5 distinct numbers can be arranged in 4! permutations, i.e., in 24 ways around a circle, or pentagonal ring, to be more precise.
So in all, this problem can be solved in 126×24 = 3024 iterations.
Third Observation:
For every possible permutation of an innerring arrangement, there can be one or more values of x (triplet linesum) that serve as a possible contenders for a “magic” string whose triplets add up to the same number, x. To ensure this, we only need that the values of α through θ of the outer ring are distinct, different from the inner ring, with the greatest of these equal to 10.
Depending on the relative positioning of the numbers in the inner ring, one can narrow the range of xvalues one might have to check for each permutation. To zerodown on such a range, let’s look at an example. Shown in the figure below is a randomly chosen permutation of number in the inner ring – 7, 2, 3, 4 and 5, in that order.
So 10, 9, 8, 6 and 1 must fill the outer circle. It’s easy to notice that the 5, 7 pair is the greatest adjacent pair. So whatever x is, it has to be at least 5 + 7 + 1 = 13 (1 being the smallest number of the outer ring). Likewise, 2, 3 is the smallest adjacent pair, so whatever x is, it can’t be any more than 2 + 3+ 10 = 15 (10 being the largest number of the outer ring). This leaves us with a narrow range of xvalues to check – 13, 14 and 15.
Next, we arrange the 5 triplets in clockwise direction starting with the triplet with the smallest number in the outer ring to form a candidate string. This exercise when done for each of the 3024 permutations will shortlist a range of candidates, of which, the maximum is chosen.
That’s all there is to the problem!
Here’s the Python Code. It executes in about a tenth of a second!

from itertools import permutations 

from itertools import combinations 

# array of candidate solutions empty at the beginning 

record = [] 



# choose 5 numbers for inner cells between 1 and 9; there are 9C5 combinations 

# the problem ask for a 16digit number, so 10 is not to be included in inner cells 

cells = range(1,10) 

inner_cells = [map(int,comb) for comb in combinations(cells,5)] 



# code to calculate min and max couple in an array 

def minCouple(array): 

answer = array[0]+array[1] 

for i in xrange(len(array)1): 

coupleSum = array[i] + array[i+1] 

if coupleSum < answer: 

answer = coupleSum 

return answer 



def maxCouple(array): 

answer = 0 

for i in xrange(len(array)1): 

if i==0: 

coupleSum = array[0]+ array[1] 

if coupleSum > answer: 

answer = coupleSum 

else: 

coupleSum = array[i]+ array[i+1] 

if coupleSum > answer: 

answer = coupleSum 

return answer 



# Algorithm 

for array in inner_cells: 

pivot = array[0] 

perm_array = array[1:] 

perms = [map(int,perm) for perm in permutations(perm_array,4)] 

for perm in perms: 

checkArray = perm 

checkArray.insert(0,pivot) 

outerRing = [el for el in range(1,11) if el not in checkArray] 

xMax = minCouple(checkArray) + max(outerRing) 

xMin = maxCouple(checkArray) + min(outerRing) 

if xMax >= xMin: 

for x in xrange(xMin, xMax+1): 

i = checkArray[0] 

j = checkArray[1] 

k = checkArray[2] 

l = checkArray[3] 

m = checkArray[4] 



alpha = xij 

beta = xjk 

gamma = xkl 

delta = xlm 

theta = xmi 



outerCalculated = [alpha, beta, gamma, delta, theta] 



if sorted(outerCalculated) == sorted(outerRing): 

a = [alpha, i, j] 

b = [beta, j, k] 

c = [gamma, k, l] 

d = [delta, l, m] 

e = [theta, m, i] 

min_val = min(alpha, beta, gamma, delta, theta) 

if alpha == min_val: 

append = a+b+c+d+e 

elif beta == min_val: 

append = b+c+d+e+a 

elif gamma == min_val: 

append = c+d+e+a+b 

elif delta == min_val: 

append = d+e+a+b+c 

elif theta == min_val: 

append = e+a+b+c+d 

l = [str(i) for i in append] 

s = ''.join(l) 

integer_list = int(s) 

record.append(integer_list) 

print max(record) 
Ans: 6531031914842725
Like this:
Like Loading...