Rating:

The file looks like this:


183 183 0
548 3000548 5
91 8000091 5
41 2000041 8
95 1000095 1
296 296 4
625 625 2
399 4000399 6
904 6000904 7
386 8000386 8
...


The following script can calculate the code:

python
import re
import time

with open('/tmp/Given_File.txt', 'r') as f:

l = [0 for i in range(10**7)]

for line in lines:
m = re.search(r'^(\d+) (\d+) (\d+)$', line) if(m): a = int(m.group(1)) b = int(m.group(2)) c = int(m.group(3)) for i in range(a,b): l[i-1] = (l[i-1] + c) % 10 else: print("Bad line: '{}'".format(line)) p = 1 for x in l: if(x != 0): p = p * x % 999999937 print(p)  However, executing it on the original file would take much too long. We need to optimise the number codes first. First, we are reducing redundancy by aggregating lines with the same a and b values (100 100 1 and 100 100 2 can be aggregated to 100 100 3): python import re with open('/tmp/sorted.txt', 'r') as f: lines = f.readlines() opt = {} n=0 ts1 = time.time() for line in lines: n += 1 m = re.search(r'^(\d+) (\d+) (\d+)$', line)
if(m):
a = int(m.group(1))
b = int(m.group(2))
c = int(m.group(3))
if( (a,b) in opt):
opt[(a,b)] += c
else:
opt[(a,b)] = c
else:

for key in opt:
a,b = key
print('{} {} {}'.format(a, b, opt[key]))


With those optimisations, the running time of the script would still be a few hours. We can do some better, by removing some overlapping intervals:

python
import re

with open('/tmp/optimized.txt', 'r') as f:

def optimize(d:dict):
for a in d:
bs = list(d[a].keys())
list.sort(bs, reverse=True)
if(bs[-1] == a):
bs.remove(a)
if(len(bs) > 1):

b = bs[0]
c = d[a][b]
nextb = bs[1]
if(not nextb in d[a]):
d[a][nextb] = 0
d[a][nextb] += c
if(not nextb in d):
d[nextb] = {}
if(not b in d[nextb]):
d[nextb][b] = 0
d[nextb][b] += c
del d[a][b]
return d, True

return d, False

opt = {}
n=0
ts1 = time.time()
for line in lines:
n += 1
m = re.search(r'^(\d+) (\d+) (\d+)\$', line)
if(m):
a = int(m.group(1))
b = int(m.group(2))
c = int(m.group(3))
if(not a in opt):
opt[a] = {}
opt[a][b] = c

opt2, optimized = optimize(opt)
while optimized:
opt2, optimized = optimize(opt2)

for a in opt2:
for b in opt2[a]:
c = opt2[a][b]
print('{} {} {}'.format(a, b, c))


After this (still not perfect) optimisation, the script spits out the code after ~40 minutes:

Flag: **HackTM{585778044}**