def find_eligible_purchases_brute_force(users, items): 
    eligible_purchases = []

    for user in users:
        for item in items:
            # Check eligibility for each user-item pair
            if is_eligible_to_purchase(user, item):

                # Only add if user is eligible.
                eligible_purchases.append((user, item))

    return eligible_purchases

def is_eligible_to_purchase(user, item): 
    # Dummy logic - replace with actual rules
    # This is where the eligibility logic goes
    user_location = user.get('location')
    item_location = item.get('available_location')

    if item_location == "global" or user_location == item_location:
        user_age = user.get('age')

        # Adding age check
        if user_age is not None and user_age >= item.get('min_age', 0):
            return True

    return False

# Example usage (for demonstration purposes)
if __name__ == '__main__':
    users = [
        {'user_id': 1, 'location': 'USA', 'age': 25},
        {'user_id': 2, 'location': 'Canada', 'age': 17},
        {'user_id': 3, 'location': 'USA', 'age': 30}
    ]
    items = [
        {'item_id': 101, 'available_location': 'USA', 'min_age': 18},
        {'item_id': 102, 'available_location': 'Canada', 'min_age': 21},
        {'item_id': 103, 'available_location': 'global', 'min_age': 0}
    ]

    eligible = find_eligible_purchases_brute_force(users, items)
    for user, item in eligible:
        print(f"User {user['user_id']} is eligible to purchase item {item['item_id']}")

def find_frequent_purchase_patterns(purchase_records):
    user_purchase_sequences = {}
    for user, time, platform in purchase_records:
        if user not in user_purchase_sequences:
            user_purchase_sequences[user] = []
        user_purchase_sequences[user].append((time, platform))

    platform_sequences = []
    for user, purchases in user_purchase_sequences.items():
        # Sort purchases by time.
        purchases.sort()
        platforms = [platform for _, platform in purchases]

        # Create sequences of platforms for each user.
        for i in range(len(platforms) - 1):
            sequence = tuple(platforms[i:i+2])
            platform_sequences.append(sequence)

    sequence_counts = {}
    # Count the frequency of each platform sequence.
    for sequence in platform_sequences:
        if sequence not in sequence_counts:
            sequence_counts[sequence] = 0
        sequence_counts[sequence] += 1

    # Find the most frequent platform sequences.
    sorted_sequences = sorted(sequence_counts.items(), key=lambda item: item[1], reverse=True)

    most_frequent_sequences = []
    if sorted_sequences:
        max_frequency = sorted_sequences[0][1]
        for sequence, frequency in sorted_sequences:
            if frequency == max_frequency:
                most_frequent_sequences.append((sequence, frequency))
            else:
                break

    return most_frequent_sequences