Problem:
Problem C: Dial Lock A dial lock is a kind of lock which has some dials with printed numbers. It has a special sequence of
numbers, namely an unlocking sequence, to be opened. You are working at a manufacturer of dial locks. Your job is to verify that every manufactured lock is
unlocked by its unlocking sequence. In other words, you have to rotate many dials of many many locks. It’s a very hard and boring task. You want to reduce time to open the locks.
It’s a good idea to rotate multiple dials at one time. It is, however, a difficult problem to find steps to open
a given lock with the fewest rotations. So you decided to write a program to find such steps for given
initial and unlocking sequences. Your company’s dial locks are composed of vertically stacked k (1 ≤ k ≤ 10) cylindrical dials. Every dial
has 10 numbers, from 0 to 9, along the side of the cylindrical shape from the left to the right in sequence.
The neighbor on the right of 9 is 0. A dial points one number at a certain position. If you rotate a dial to the left by i digits, the dial newly
points the i -th right number. In contrast, if you rotate a dial to the right by i digits, it points the i -th left
number. For example, if you rotate a dial pointing 8 to the left by 3 digits, the dial newly points 1. You can rotate more than one adjacent dial at one time. For example, consider a lock with 5 dials. You
can rotate just the 2nd dial. You can rotate the 3rd, 4th and 5th dials at the same time. But you cannot
rotate the 1st and 3rd dials at one time without rotating the 2nd dial. When you rotate multiple dials, you
have to rotate them to the same direction by the same digits. Your program is to calculate the fewest number of rotations to unlock, for given initial and unlocking
sequences. Rotating one or more adjacent dials to the same direction by the same digits is counted as one
rotation. Input The input consists of multiple datasets. 

Each datset consists of two lines. The first line contains an integer k. The second lines contain two strings,
separated by a space, which indicate the initial and unlocking sequences. The last dataset is followed by a line containing one zero. This line is not a part of any dataset and should not be processed. Output For each dataset, print the minimum number of rotations in one line. Sample Input 4
1357 4680
6
777777 003330
0 Output for the Sample Input 1
2

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


def main():
    rr = []

    def f(n):
        a,b = LS()
        if a == b:
            return 0
        a = [int(c) for c in a]
        b = [int(c) for c in b]
        aa = [a]
        ad = set()
        ad.add(tuple(a))
        r = 0
        while True:
            r += 1
            na = []
            for a in aa:
                ti = 0
                for i in range(r-1,n):
                    if a[i] != b[i]:
                        ti = i
                        break
                sa = b[ti] - a[ti]
                for j in range(ti+1, n+1):
                    t = [(a[i] + sa) % 10 if ti <= i < j else a[i] for i in range(n)]
                    k = tuple(t)
                    if k in ad:
                        continue
                    if t == b:
                        return r
                    ad.add(k)
                    na.append(t)
            aa = na

    while True:
        n = I()
        if n == 0:
            break
        rr.append(f(n))

    return '\n'.join(map(str,rr))


print(main())

Solution (Python):
def solve():
    def bfs(k):
        start, goal = file_input.readline().split()
        
        if start == goal:
            return 0
        
        start = map(int, start)
        goal = map(int, goal)
        diff = [(g - s) % 10 for g, s in zip(goal, start)]
        
        q = [diff]
        checked = {tuple(diff): True}
        ans = 0
        
        while q:
            ans += 1
            t_q = []
            for d in q:
                for i, r in enumerate(d):
                    if r != 0:
                        break
                for j in range(i, k):
                    d[j] -= r
                    d[j] %= 10
                    key = tuple(d)
                    if key in checked:
                        continue
                    if sum(d) == 0:
                        return ans
                    checked[key] = True
                    t_q.append(d[:])
                q = t_q

    from sys import stdin
    file_input = stdin
    
    while True:
        k = int(file_input.readline())
        if k == 0:
            break
        print(bfs(k))

solve()