如何实现有序列表重复元素统计与重复项收集功能？

Alright, let's work through this problem to get your duplic function up and running correctly!

First, let's recap what we need to accomplish:

• We have an ordered list where we can add numbers
• We need a duplic function that iterates through the list, appends duplicate elements to a new list called seen, and outputs a specific formatted string showing the list, count of a repeated element, and the duplicates themselves.

Step-by-Step Implementation #

1. Assume the Existing Sorted List Add Function #

You mentioned the add-to-sorted-list functionality is already in place, but here's a quick implementation for context (feel free to swap in your existing code):

def add_to_sorted_list(sorted_list, num):
    # Insert the number in the correct position to maintain order
    for idx, value in enumerate(sorted_list):
        if value >= num:
            sorted_list.insert(idx, num)
            return
    sorted_list.append(num)

2. Implement the duplic Function #

This function will track element occurrences, collect duplicates, and output the required format exactly as you specified:

def duplic(input_list):
    seen = []
    element_tracker = {}

    # Traverse the list to count occurrences and collect duplicates
    for num in input_list:
        if num in element_tracker:
            # This is a duplicate—add it to the seen list
            seen.append(num)
            element_tracker[num] += 1
        else:
            # First time seeing this element, initialize its count
            element_tracker[num] = 1

    # Generate the formatted output (using the first duplicate element as shown in your example)
    if element_tracker:
        # Find the first element that has duplicates
        repeated_num = next((k for k, v in element_tracker.items() if v > 1), None)
        if repeated_num:
            total_count = element_tracker[repeated_num]
            # Filter the seen list to get only instances of this repeated number
            relevant_duplicates = [str(n) for n in seen if n == repeated_num]
            # Format the output string with literal curly braces
            print(f"{input_list} Count of {repeated_num} in list: {total_count} Duplicates in list: {{{','.join(relevant_duplicates)}}}")

    return seen

3. Test the Implementation #

Let's test this with your example scenario to verify it works:

# Initialize our sorted list
mylist = [10, 23, 23]
# Add another 23 to the list
add_to_sorted_list(mylist, 23)
# Run the duplic function
duplic(mylist)

Expected Output:

[10, 23, 23, 23] Count of 23 in list: 3 Duplicates in list: {23,23}

Key Notes #

• The seen list collects every duplicate occurrence (so if an element appears 3 times, seen will have 2 entries of that element, matching your example).
• If you need to output all repeated elements instead of just the first, you can loop through element_tracker and print a line for each element with duplicates.
• We use escaped curly braces ({{ and }}) in the f-string to get literal {} in the final output.

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