Ponder This Challenge - February 2026 - Blot-avoiding backgammon strategy
- Ponder This
We generate a sequence of strings in the following manner:
G -> T
T -> CA
C -> TG
A -> C
The first few steps yield the strings
CAT
TGCCA
CATTGTGC
TGCCACATCATTG
And so forth. One can see from the list that is "CACA" (here means "all the letters, starting from the index , up to and not including the index , where indexing starts from 0")
Your goal: Find for
A bonus "*" will be given for finding for where the sequence is defined simiarily to but with the initial value = "RABBITS" and the rules
G -> T,
T -> CA,
C -> BR,
A -> I,
R -> B,
B -> IS,
I -> TG,
S -> C,
The solutions are
TGTGCTGCCATGCCACATTGCCACATCATTGCATTGTGCTGCCATGCCACATTGCCACATCATTGTGCCACATCATTGCATTGTGCTGCCACATCATTGCATTGTGCCATTGTGCTGCCACATTGTGCTGCCATGCCACATCATTGTGCTGCCATGCCACATTGCCACATCATTGCATTGTGCTGCCATGCCACATTGCCACATCATTGTGCCACATCATTGCATTGTGCCATTGTGCTGCCATGCCACATTGCCACATCATTGTGCCACATCATTGCATTGTGCTGCCACATCATTGCATTGTGCCATTGTGCTGCCACATTGTGCTGCCATGCCACATTGCCACATCATTGTGCCACATCATTGCATTGTGCTGCCACATCATTGCATTGTGCCATTGTGCTGCCATGCCACATCATTGCATTGTGCCATTGTGCTGCCACATTGTGCTGCCATGCCACATTGCCACATCATTGCATTGTGCCATTGTGCTGCCACATTGTGCTGCCATGCCACATCATTGTGCTGCCATGCCACATTGCCACATCATTGTGCCACATCATTGCATTGTGCCATTGTGCTGCCACATTGTGCTGCCATGCCACATCATTGTGCTGCCATGCCACATTGCCACATCATTGCATTGTGCTGCCATGCCACATTGCCACATCATTGTGCCACATCATTGCATTGTGCTGCCACATCATTGCATTGTGCCATTGTGCTGCCACATTGTGCTGCCATGCCACATCATTGTGCTGCCATGCCACATTGCCACATCATTGCATTGTGCTGCCATGCCACATTGCCACATCATTGTGCCACATCATTGCATTGTGCCATTGTGCTGCCATGCCACATTGCCACATCATTGTGCCACATCATTGCATTGTGCTGCCACATCATTGCATTGTGCCATTGTGCTGCCATGCCACATCATTGCATTGTGCCATTGTGCTGCCACATTGTGCTGCCATGCCACATCATTGTGCTGCCATGC
And
BRTGCBRICATGCISCATBRICAISBCATBRISBTGBRITGCISBRICAISBTGCISCATISBTGBRICAISBCATBRISBTGBRITGCISCATISBTGCATBRTGCISBTGBRITGCISCATBRTGCBRICATGCISCATISBTGBRITGCISBRICAISBTGCISCATISBTGCATBRTGCBRICATGCISCATBRICAISBCATBRTGCISCATISBTGCATBRTGCISBTGBRITGCISBRICAISBTGCISCATISBTGBRICAISBCATBRISBTGBRITGCISCATISBTGCATBRTGCISBTGBRITGCISCATBRTGCBRICATGCISCATBRICAISBCATBRTGCISCATISBTGCATBRTGCBRICAISBCATBRISBTGBRICATBRTGCBRICATGCISCATISBTGCATBRTGCISBTGBRITGCISCATBRTGCBRICATGCISCATBRICAISBCATBRISBTGBRICATBRTGCBRICAISBTGBRITGCISBRICAISBCATBRTGCBRICATGCISCATBRICAISBCATBRTGCISCATISBTGCATBRTGCISBTGBRITGCISCATBRTGCBRICATGCISCATISBTGBRITGCISBRICAISBTGCISCATISBTGCATBRTGCBRICATGCISCATBRICAISBCATBRTGCISCATISBTGCATBRTGCBRICAISBCATBRISBTGBRICATBRTGCBRICAISBTGBRITGCISBRICAISBCATBRTGCBRICATGCISCATBRICAISBCATBRISBTGBRITGCISBRICAISBTGCISCATISBTGBRICAISBCATBRISBTGBRICATBRTGCBRICATGCISCATBRICAISBCATBRTGCISCATISBTGCATBRTGCBRICAISBCATBRISBTGBRICATBRTGCBRICATGCISCATISBTGCATBRTGCISBTGBRITGCISCATBRTGCBRICATGCISCATISBTGBRITGCISBRI
The key observation is that for each letter, the length of the word generated from that letter grows exponentially, so after a very managable number of steps (around 500) the generated words will already be of length . This enables to compute the letter in a specific position in the following recursive manner, which was written very compactly in Python by Li Li (thanks!):
D = {'G': 'T', 'T':'CA', 'C': 'TG', 'A': 'C'}
#D = {'G': 'T', 'T': 'CA', 'C' : 'BR', 'A': 'I', 'R': 'B', 'B': 'IS', 'I': 'TG', 'S': 'C'}
L = {}
M = 600
for c in D:
L[c] = [1]*M
for i in range(1,M):
for c in D:
L[c][i] = sum(L[d][i-1] for d in D[c])
print(len(str(L['C'][500])))
def returnstring (c, N, start, end):
if end>=L[c][N]+1:
return 'Error'
if N == 0:
return c
if len(D[c])==1:
return returnstring(D[c], N-1, start, end)
if end<=L[D[c][0]][N-1]:
return returnstring(D[c][0], N-1, start, end)
if start>=L[D[c][0]][N-1]+1:
return returnstring(D[c][1], N-1, start-L[D[c][0]][N-1],end-L[D[c][0]][N-1])
else:
return returnstring(D[c][0], N-1, start, L[D[c][0]][N-1])+returnstring(D[c][1], N-1, 1, end-L[D[c][0]][N-1])
print(returnstring ('R', 500, 10**100+1,10**100+1000))