Yet another exciting math problem that requires an algorithmic approach to arrive at a quick solution! There is a pen-paper 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 * 9-digit strings*;

*the maximum string for a 3-gon ring is*

**432621513**.

**Problem**

** Using the numbers 1 to 10**, and depending on arrangements, it is

*possible to form*. What is the maximum

**16-****and 17-digit**strings**16-digit**string for a “

**magic**”

*5-gon*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 **16-digits**, **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 **(n-1)!** ways, where **(n-1)!** **= (n-1).(n-2).(n-3)…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 inner-ring arrangement, there can be one or more values of **x** **(triplet line-sum)** 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 x-values** one might have to check for each permutation. To zero-down 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 x-values to check – **13**, **14** and **15**.

Next, we arrange the 5 triplets in clock-wise 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 16-digit 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 = x-i-j | |

beta = x-j-k | |

gamma = x-k-l | |

delta = x-l-m | |

theta = x-m-i | |

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*