如何从 4 位数字列表中找到最常见的渐进数字

Question

我是 Python 编程的新手。从 4 位数字列表中找到最常见的渐进数字的有效且 Pyhtonic 方法是什么？

假设我有以下列表：[6111, 7111, 6112, 6121, 6115, 6123]。

逻辑是观察第一个数字 6 是最常见的。我可以删除数字 7111 以供下一个考虑。

对于第二个数字，我考虑了新的候选者[6111, 6112, 6121, 6115, 6123]，我观察到 1 是最常见的数字，依此类推。

在算法结束时，我将只剩下列表中的 1 个数字。

如果有 2 个或更多数字出现相同的数字，我可以在所有数字之间随机选择较小的一个。

一种简单的方法是将列表转换为 Nx4 矩阵，并为每一列考虑最常见的数字。这可以工作，但我找到了一种非常愚蠢和低效的方法来解决这个问题。有人可以帮忙吗？

编辑：此解决方案的代码（注意：此代码并不总是有效，有些地方是错误的。有关此问题的解决方案，请参阅@MadPhysicist ANSWER）

import numpy as np
import pandas as pd
from collections import Counter



numbers_list = [6111, 7111, 6112, 6121, 6115, 6123]

my_list = []

for number in numbers_list:
    digit_list = []
    for c in str(number):
       digit_list.append(c)
    my_list.append(digit_list)


matrix = np.array(my_list)

matrix0 = matrix

my_counter = Counter(matrix.T[0]).most_common(1)
i=0
for digit0 in matrix.T[0]:
    if digit0 != my_counter[0][0]:
        matrix0 = np.delete(matrix, i, 0)
    i += 1
matrix = matrix0

matrix1 = matrix
my_counter = Counter(matrix.T[1]).most_common(1)
i=0
for digit1 in matrix.T[1]:
    if digit1 != my_counter[0][0]:
        matrix1 = np.delete(matrix, i, 0)
    i += 1
matrix = matrix1

matrix2 = matrix
my_counter = Counter(matrix.T[2]).most_common(1)
i=0
for digit2 in matrix.T[2]:
    if digit2 != my_counter[0][0]:
        matrix2 = np.delete(matrix, i, 0)
    i += 1

matrix = matrix2

matrix3 = matrix
my_counter = Counter(matrix.T[3]).most_common(1)
i=0
for digit3 in matrix.T[3]:
    if digit3 != my_counter[0][0]:
        matrix3 = np.delete(matrix, i, 0)
    i += 1
matrix = matrix3

print (matrix[0])

Answer 1

您转换为 numpy 数组的想法是可靠的。您不需要预先拆分它。一系列掩码和直方图将很快减少数组。

z = np.array([6111, 7111, 6112, 6121, 6115, 6123])

第 n 个数字（从零开始）可以通过类似的方式获得

nth = (z // 10**n) % 10

使用np.bincount 可以快速完成最频繁的计数，如图所示here：

frequentest = np.argmax(np.bincount(nth))

您可以简单地选择在第 n 位具有该数字的元素

mask = nth == frequentest

所以现在在n 上循环运行它（向后）：

# Input array
z = np.array([6111, 7111, 6112, 6121, 6115, 6123])

# Compute the maximum number of decimal digits in the list.
# You can just manually set this to 4 if you prefer
n = int(np.ceil(np.log10(z + 1).max()))

# Empty output array
output = np.empty(n, dtype=int)

# Loop over the number of digits in reverse.
# In this case, i will be 3, 2, 1, 0.
for i in range(n - 1, -1, -1):

    # Get the ith digit from each element of z
    # The operators //, ** and % are vectorized: they operate
    # on each element of an array to return an array
    ith = (z // 10**i) % 10

    # Count the number of occurrences of each number 0-9 in the ith digit
    # Bincount returns an array of 10 elements. counts[0] is the number of 0s,
    # counts[1] is the number of 1s, ..., counts[9] is the number of 9s
    counts = np.bincount(ith)

    # argmax finds the index of the maximum element: the digit with the
    # highest count
    output[i] = np.argmax(counts)

    # Trim down the array to numbers that have the requested digit in the
    # right place. ith == output[i] is a boolean mask. It is 1 where ith
    # is the most common digit and 0 where it is not. Indexing with such a
    # mask selects the elements at locations that are non-zero.
    z = z[ith == output[i]]

如果有多个可用，np.argmax 将返回第一个最大计数的索引，这意味着它将始终选择最小的数字。

您可以通过类似的方式从output 恢复号码

>>> output
array([1, 1, 1, 6])
>>> (output * 10**np.arange(output.size)).sum()
6111

你也可以只获取z的剩余元素：

>>> z[0]
6111