5 Best Ways to Find the Most Occurring Number in a String Using Regex in Python

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

The defaultdict initializes any new key with a default integer value of 0, eliminating the need to check for key existence before incrementing the count. The rest of the process is similar to Method 2.

Method 4: Using Regex Finditer and Max

Here we harness the iterative power of re.finditer() to scan through the string for number patterns, while tracking the counts to determine the most common number using the max() function for comparison.

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

re.finditer() is a memory-efficient method that returns an iterator yielding MatchObject instances over all non-overlapping matches for the regex pattern in the string. The rest of the counting and collating logic is akin to the previous methods.

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

This one-liner finds all sequences of digits and feeds them directly into the Counter constructor, which then immediately applies the most_common() method to identify the high-frequency numbers, all in a single line of code.

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

This code uses re.findall() to gather the numbers and a dictionary to keep count. It then iterates over the dictionary to find the maximum frequency and returns a list of numbers that match this frequency.

Method 3: Using Regex, Collections Defaultdict

A slight modification to method 2, this technique uses a collections.defaultdict to automatically handle new numbers without needing to check if they’re already in the dictionary, providing a cleaner code.

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re
from collections import Counter

def most_common_number(string):
    numbers = re.findall(r'\d+', string)
    counts = Counter(numbers)
    return counts.most_common(1)

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [(‘7′, 2), (’12’, 2)]

In the snippet above, the re.findall() function extracts all sequences of digits, which are then tallied by the Counter. The most_common() method is then used to retrieve the numbers with the highest frequency.

Method 2: Using Regex and Manual Counting

Instead of using an external library, this approach manually counts the frequency of each number after they have been extracted by a regular expression. This introduces more custom code but avoids importing the Counter class.

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re
from collections import Counter

def most_common_number(string):
    numbers = re.findall(r'\d+', string)
    counts = Counter(numbers)
    return counts.most_common(1)

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [(‘7′, 2), (’12’, 2)]

Method 2: Using Regex and Manual Counting

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re
from collections import Counter

def most_common_number(string):
    numbers = re.findall(r'\d+', string)
    counts = Counter(numbers)
    return counts.most_common(1)

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [(‘7′, 2), (’12’, 2)]

Method 2: Using Regex and Manual Counting

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re
from collections import Counter

def most_common_number(string):
    numbers = re.findall(r'\d+', string)
    counts = Counter(numbers)
    return counts.most_common(1)

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [(‘7′, 2), (’12’, 2)]

Method 2: Using Regex and Manual Counting

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re
from collections import Counter

def most_common_number(string):
    numbers = re.findall(r'\d+', string)
    counts = Counter(numbers)
    return counts.most_common(1)

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [(‘7′, 2), (’12’, 2)]

Method 2: Using Regex and Manual Counting

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re
from collections import Counter

def most_common_number(string):
    numbers = re.findall(r'\d+', string)
    counts = Counter(numbers)
    return counts.most_common(1)

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [(‘7′, 2), (’12’, 2)]

Method 2: Using Regex and Manual Counting

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re
from collections import Counter

def most_common_number(string):
    numbers = re.findall(r'\d+', string)
    counts = Counter(numbers)
    return counts.most_common(1)

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [(‘7′, 2), (’12’, 2)]

Method 2: Using Regex and Manual Counting

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

💡 Problem Formulation: In data processing, a common task involves identifying the most frequently occurring number within a string. This could mean searching through a log file for the most common error code or analyzing text for recurring numeric patterns. For instance, given the string “7 apples, 12 oranges, 7 bananas, and 12 cherries”, the desired output should indicate that the numbers ‘7’ and ’12’ appear most frequently (2 times each).

Method 1: Using Collections Counter and Regex

This method utilizes the collections.Counter class to count the frequency of each number after extracting all the numbers from the string using a regular expression pattern. The function re.findall() is employed to find all non-overlapping matches of the pattern, which should be a sequence of digits.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.

import re
from collections import Counter

def most_common_number(string):
    numbers = re.findall(r'\d+', string)
    counts = Counter(numbers)
    return counts.most_common(1)

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [(‘7′, 2), (’12’, 2)]

Method 2: Using Regex and Manual Counting

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        if num in num_freq:
            num_freq[num] += 1
        else:
            num_freq[num] = 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 3: Using Regex, Collections Defaultdict

Here’s an example:

import re
from collections import defaultdict

def most_common_number(string):
    num_freq = defaultdict(int)
    numbers = re.findall(r'\d+', string)
    for num in numbers:
        num_freq[num] += 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Method 4: Using Regex Finditer and Max

Here’s an example:

import re

def most_common_number(string):
    num_freq = {}
    for match in re.finditer(r'\d+', string):
        num = match.group()
        num_freq[num] = num_freq.get(num, 0) + 1
    max_freq = max(num_freq.values())
    return [num for num, freq in num_freq.items() if freq == max_freq]

# Example usage
input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(most_common_number(input_string))

Output: [‘7′, ’12’]

Bonus One-Liner Method 5: Using Regex, Collections Counter, and a Generator Expression

When aiming for conciseness, a one-liner can combine regex searching with immediate counting and selection of the most common numbers, leveraging the generator expression alongside Counter.

Here’s an example:

import re
from collections import Counter

input_string = "7 apples, 12 oranges, 7 bananas, and 12 cherries"
print(Counter(re.findall(r'\d+', input_string)).most_common(1))

Output: [(‘7′, 2), (’12’, 2)]

Summary/Discussion

Method 1: Collections Counter and Regex. Effective and concise. Utilizes built-in libraries for quick counting and retrieval. However, it may be too high-level for simple tasks or when external libraries should be avoided.
Method 2: Regex and Manual Counting. Does not rely on external libraries other than regex. Offers more control over the counting process. However, the code is more verbose and may be less efficient than using built-in functionalities.
Method 3: Regex and Collections Defaultdict. A more elegant variant of method 2. Defaultdict simplifies the counting logic. The drawback is largely the same as Method 1, requiring an additional import.
Method 4: Regex Finditer and Max. Offers fine-grained control over the matching process and is memory efficient for large strings. This method, however, might be slower and more complex than necessary for simple cases.
Method 5: One-Liner with Regex, Counter, and Generator. The epitome of concise code. Excellent for one-off scripts or condensed code blocks. Lack of clarity can be a downside for those unfamiliar with Python’s more advanced constructs.