Check if all people can vote on two machines in Python

Suppose we have n people and two identical voting machines. We have an array called time where time[i] represents the total time needed by the i-th person to vote on any machine. Only one person can use each machine at a time. Given a maximum allowable time x for which machines are operational, we need to check whether all people can vote within this time limit.

For example, if n = 3, x = 7, and time = [3, 5, 3], the answer is True. At time t0, person 0 uses machine 1 and person 1 uses machine 2. At time t3, machine 1 becomes free and person 2 starts voting. At time t5, machine 2 becomes free, and at time t6, machine 1 becomes free. All people have voted within the time limit.

Algorithm

To solve this problem, we follow these steps −

• Calculate the total sum of all voting times
• If total sum ? x, return True (single machine can handle all votes)
• Sort the time array to try different distributions
• Create a prefix sum array to calculate cumulative times
• Try all possible ways to distribute people between two machines
• Check if both machines can complete their assigned votes within time x

Example

def solve(n, x, time):
    total_sum = sum(time)
    
    # If total time fits in x, single machine can handle all
    if total_sum <= x:
        return True
    
    # Sort times to try different distributions
    time.sort()
    
    # Create prefix sum array
    prefix_sum = [0] * len(time)
    prefix_sum[0] = time[0]
    
    for i in range(1, len(prefix_sum)):
        prefix_sum[i] = prefix_sum[i - 1] + time[i]
    
    # Try all possible distributions between two machines
    for i in range(len(prefix_sum)):
        for j in range(i + 1, len(prefix_sum)):
            # Machine 1 gets people from 0 to i and j+1 to end
            machine1_time = prefix_sum[i] + (total_sum - prefix_sum[j])
            # Machine 2 gets people from i+1 to j
            machine2_time = total_sum - machine1_time
            
            if machine1_time <= x and machine2_time <= x:
                return True
    
    return False

# Test the function
n = 3
x = 7
time = [3, 5, 3]
print(solve(n, x, time))

True

How It Works

The algorithm first checks if all people can vote on a single machine. If not, it tries different ways to distribute people between two machines. The key insight is to use a sorted array and prefix sums to efficiently calculate the total time for different distributions.

For the example [3, 5, 3] with x = 7 −

• Total sum = 11 (exceeds x = 7, so need both machines)
• After sorting: [3, 3, 5]
• One valid distribution: Machine 1 gets [3, 5] (total = 8 > 7), Machine 2 gets [3] (total = 3 ? 7)
• Another valid distribution: Machine 1 gets [3] (total = 3 ? 7), Machine 2 gets [3, 5] (total = 8 > 7)
• The algorithm finds a distribution where both machines finish within time x

Conclusion

This solution efficiently determines if all people can vote using two machines within a given time limit. It uses sorting and prefix sums to explore different distributions and find a valid assignment of people to machines.