Program to convert one list identical to other with sublist sum operation in Python

Given two lists, we need to make them identical by repeatedly choosing a sublist and replacing it with its sum. The goal is to find the maximum possible length of the resulting identical lists, or return -1 if no solution exists.

The key insight is to work backwards from the end of both lists, comparing elements and merging adjacent elements when needed.

Algorithm Approach

We use a greedy approach starting from the end of both lists ?

• Compare elements from the end of both lists
• If elements match, move to the previous elements
• If one element is smaller, merge it with its previous element
• Continue until both lists are fully processed or no solution is possible

Example Walkthrough

Let's trace through the example with l1 = [1, 4, 7, 1, 2, 10] and l2 = [5, 6, 1, 3, 10] ?

• Both end with 10 ? match, move left
• l1 has 2, l2 has 3 ? merge l1: [1, 4, 7, 3, 10]
• Both have 3 ? match, move left
• l1 has 7, l2 has 1 ? merge l2: [5, 7, 3, 10]
• Both have 7 ? match, move left
• l1 has 4, l2 has 5 ? merge l1: [5, 7, 3, 10]
• Both have 5 ? match, final result length = 4

Implementation

def solve_lists(l1, l2):
    # Work with copies to avoid modifying original lists
    list1 = l1.copy()
    list2 = l2.copy()
    
    i, j, result = len(list1) - 1, len(list2) - 1, 0
    
    while i >= 0 and j >= 0:
        if list1[i] == list2[j]:
            result += 1
            i -= 1
            j -= 1
        elif list1[i] < list2[j]:
            if i > 0:
                list1[i - 1] += list1[i]
            i -= 1
        else:  # list1[i] > list2[j]
            if j > 0:
                list2[j - 1] += list2[j]
            j -= 1
    
    return result if i == -1 and j == -1 else -1

# Test with the example
l1 = [1, 4, 7, 1, 2, 10]
l2 = [5, 6, 1, 3, 10]
print(f"Maximum length: {solve_lists(l1, l2)}")

Maximum length: 4

Step-by-Step Execution

def solve_with_steps(l1, l2):
    list1 = l1.copy()
    list2 = l2.copy()
    
    i, j, result = len(list1) - 1, len(list2) - 1, 0
    step = 1
    
    print(f"Initial: list1 = {list1}, list2 = {list2}")
    
    while i >= 0 and j >= 0:
        print(f"\nStep {step}: Comparing list1[{i}]={list1[i]} with list2[{j}]={list2[j]}")
        
        if list1[i] == list2[j]:
            result += 1
            i -= 1
            j -= 1
            print(f"Match found! Result = {result}")
        elif list1[i] < list2[j]:
            if i > 0:
                list1[i - 1] += list1[i]
                print(f"Merged in list1: {list1}")
            i -= 1
        else:
            if j > 0:
                list2[j - 1] += list2[j]
                print(f"Merged in list2: {list2}")
            j -= 1
        
        step += 1
    
    final_result = result if i == -1 and j == -1 else -1
    print(f"\nFinal result: {final_result}")
    return final_result

# Demonstrate with example
l1 = [1, 4, 7, 1, 2, 10]
l2 = [5, 6, 1, 3, 10]
solve_with_steps(l1, l2)

Initial: list1 = [1, 4, 7, 1, 2, 10], list2 = [5, 6, 1, 3, 10]

Step 1: Comparing list1[5]=10 with list2[4]=10
Match found! Result = 1

Step 2: Comparing list1[4]=2 with list2[3]=3
Merged in list1: [1, 4, 7, 3, 10]

Step 3: Comparing list1[3]=3 with list2[3]=3
Match found! Result = 2

Step 4: Comparing list1[2]=7 with list2[2]=1
Merged in list2: [5, 7, 3, 10]

Step 5: Comparing list1[2]=7 with list2[1]=7
Match found! Result = 3

Step 6: Comparing list1[1]=4 with list2[0]=5
Merged in list1: [5, 7, 3, 10]

Step 7: Comparing list1[0]=5 with list2[0]=5
Match found! Result = 4

Final result: 4

Edge Cases

# Test edge cases
test_cases = [
    ([1, 2, 3], [6]),           # Can be made equal
    ([1, 2], [4]),              # Cannot be made equal  
    ([5], [5]),                 # Already equal
    ([1, 2, 3], [2, 4])         # Different sums
]

for i, (list1, list2) in enumerate(test_cases, 1):
    result = solve_lists(list1, list2)
    print(f"Test {i}: {list1} and {list2} ? {result}")

Test 1: [1, 2, 3] and [6] ? 1
Test 2: [1, 2] and [4] ? -1
Test 3: [5] and [5] ? 1
Test 4: [1, 2, 3] and [2, 4] ? 1

Conclusion

This greedy algorithm works backwards from both lists, merging adjacent elements when needed to maximize the length of identical resulting lists. The time complexity is O(n + m) where n and m are the lengths of the input lists.