列表元素权重分配及随机合并新元素的技术实现问询

Great question! Let's break this down into the two parts you mentioned, with practical, actionable code examples that fit your needs.

To track weights for each element, the cleanest approach is to use a dictionary that maps each element to its weight. For your initial state where all weights are 1, this is straightforward:

l = ['x1', 'x2', 'x3', 'x4']
# Initialize all elements with weight 1
element_weights = {elem: 1 for elem in l}

If you prefer keeping elements and their weights paired directly in a single structure, you can use a list of tuples instead:

weighted_elements = [(elem, 1) for elem in l]

Both methods work well—use the dictionary if you need fast lookups by element name, or the tuple list if you want to keep everything in one collection.

Your goal is to pick two random elements, merge them into a new element with weight 2, and update the list. Let's build this out with the dictionary approach first, since it's easy to manage weights separately.

Basic Single Merge Function #

This function takes your element list and weight dictionary, performs one merge, and returns the updated list and weights:

import random

def rand_merge(elements: list, weights: dict) -> tuple[list, dict]:
    # Ensure we have at least two elements to merge
    if len(elements) < 2:
        raise ValueError("Need at least two elements to perform a merge")
    
    # Pick two distinct random elements from the list
    elem1, elem2 = random.sample(elements, 2)
    
    # Create a new element (adjust naming logic to your preference)
    # Option 1: Combine the names of merged elements
    new_elem = f"{elem1}+{elem2}"
    # Option 2: Use sequential numbering like x5, x6, etc.
    # new_elem = f"x{len(elements)+1}"
    
    # Update the element list and weights
    updated_elements = elements.copy()
    updated_elements.append(new_elem)
    
    updated_weights = weights.copy()
    updated_weights[new_elem] = 2  # New element gets weight 2
    
    return updated_elements, updated_weights

How to Use It #

# Initial setup
l = ['x1', 'x2', 'x3', 'x4']
element_weights = {elem: 1 for elem in l}

# Perform one merge
updated_list, updated_weights = rand_merge(l, element_weights)

print(updated_list)
# Example output: ['x1', 'x2', 'x3', 'x4', 'x1+x3']
print(updated_weights)
# Output: {'x1': 1, 'x2': 1, 'x3': 1, 'x4': 1, 'x1+x3': 2}

Handling Multiple Merges (Using Your count Parameter) #

If you want to perform count number of merges in one go, modify the function to loop through the requested number of times:

def rand_merge_multiple(elements: list, weights: dict, count: int) -> tuple[list, dict]:
    updated_elements = elements.copy()
    updated_weights = weights.copy()
    
    for _ in range(count):
        if len(updated_elements) < 2:
            break  # Stop if we can't merge anymore
        
        elem1, elem2 = random.sample(updated_elements, 2)
        new_elem = f"x{len(updated_elements)+1}"  # Sequential naming
        updated_elements.append(new_elem)
        updated_weights[new_elem] = 2
    
    return updated_elements, updated_weights

Using the Tuple List Approach #

If you prefer keeping elements and weights paired together, here's a version that works with the tuple list structure:

def rand_merge_weighted_list(weighted_list: list[tuple[str, int]]) -> list[tuple[str, int]]:
    if len(weighted_list) < 2:
        raise ValueError("Need at least two elements to merge")
    
    # Extract just the element names to pick from
    elements = [elem for elem, _ in weighted_list]
    elem1, elem2 = random.sample(elements, 2)
    
    new_elem = f"x{len(weighted_list)+1}"
    weighted_list.append((new_elem, 2))
    
    return weighted_list

内容的提问来源于stack exchange，提问作者user8650813