'''

 merge two configure files, basic file is aFile

 insert the added content of bFile compare to aFile

 for example, 'bbb' is added content

 -----------------------------------------------------------

 a file content  |  b file content  |  c merged file content

     111         |       111        |    111

     aaa         |       bbb        |    aaa

                 |                  |    bbb

     222         |       222        |    222

 ------------------------------------------------------------

 '''

 def mergeFiles(aPath, bPath, cPath):

     with open(aPath, 'r') as f:

         aLines = f.readlines();

         aLines = [ line.strip() + '\n' for line in aLines]

     with open(bPath, 'r') as f:

         bLines = f.readlines();

         bLines = [ line.strip() + '\n' for line in bLines]

     cLines = mergeSequences(aLines, bLines)

     with open(cPath, 'w') as f:

         for line in cLines:

             f.write(line)

 '''

 merge the sequence

 '''

 def mergeSequences(aLines, bLines):

     record = {}

     lcs = findLCS(record, aLines, 0, bLines, 0)

     currA = currB = 0

     merged = []

     for (line, aI, bI) in lcs:

         # add deleted

         if aI > currA:

             merged.extend(aLines[currA:aI])

         currA = aI + 1

         # add added

         if bI > currB:

             merged.extend(bLines[currB:bI])

         currB = bI + 1

         # add common

         merged.append(line)

     if currA < len(aLines):

         merged.extend(aLines[currA:])

     if currB < len(bLines):

         merged.extend(bLines[currB:])

     return merged

 '''

 find Longest common subsequence

 return list of (line, x, y)

 line is common line, x is the index in aLines, y is the index in bLines

 TODO: eliminate recursive invoke, use dynamic algorithm

 '''

 def findLCS(record, aLines, aStart, bLines, bStart):

     key = lcsKey(aStart, bStart)

     if record.has_key(key):

         return record[key]

     aL = aLines[aStart:]

     bL = bLines[bStart:]

     if len(aL) > 0 and len(bL) > 0:

         if aL[0] == bL[0]:

             lsc = [(aL[0], aStart, bStart)]

             lsc.extend(findLCS(record, aLines, aStart + 1, bLines, bStart + 1))

             record[key] = lsc

             return lsc

         else:

             aLsc = findLCS(record, aLines, aStart, bLines, bStart + 1)

             bLsc = findLCS(record, aLines, aStart + 1, bLines, bStart)

             if len(aLsc) > len(bLsc):

                 record[key] = aLsc

                 return aLsc

             else:

                 record[key] = bLsc

                 return bLsc

     else:

         return []

 Code