Question

我最近尝试了3个元素的最高产品的问题。现在我正在尝试为k元素做这件事。让我们从现在开始说它需要4个元素。我试着编写一个泛型函数，以便它可以处理数组中的任何k元素。算法必须在O（n）中，就像有3个元素的算法一样。

 def highest_product_sol(input):

    high = max(input[0],input[1])
    low = min(input[0],input[1])


    max_prod_2 = input[0] * input[1]
    low_prod_2 = input[0] * input[1]
    max_prod_3 = max_prod_2 * input[2]


    prod_2_high = input[0] * input[1]
    prod_2_low = input[0] * input[1]

    for i in range(2,len(input)):
        val = input[i]
        max_prod_3 = max(max_prod_3,max_prod_2*val,low_prod_2*val)

        prod_2_high = high * val
        prod_2_low =  low * val

        max_prod_2 = max(max_prod_2,prod_2_high)

        low_prod_2 = min(low_prod_2,prod_2_high)


        high = max(high,val)

        low = min(low,val)


    return (max_prod_2,low_prod_2,max_prod_3)

def highest_product_num(input,num):


    high = max(input[0:num - 1])
    low = min(input[0:num - 1])


    print("max",high)
    print("min",low)

    prod_high_minus_1 = 1
    prod_low_minus_1 = 1

    for n in range(0,num-1):
        prod_high_minus_1 *= input[n]
        prod_low_minus_1 *= input[n]

    max_prod_n_1 = prod_high_minus_1
    min_prod_n_1 = prod_high_minus_1
    max_prod_n = prod_high_minus_1 * input[num-1]

    for i in range(num,len(input)):
        val = input[i]
        max_prod_n = max(max_prod_n,max_prod_n_1*val,min_prod_n_1*val)

        prod_high_minus_1 = high * val
        prod_low_minus_1 =  low * val

        max_prod_n_1 = max(max_prod_n_1,prod_high_minus_1)

        min_prod_n_1 = min(min_prod_n_1,prod_low_minus_1)


        high = max(high,val)

        low = min(low,val)

    return max_prod_n
test_input = [[1,2,3,4,5,6,7,8],[1,-2,3,4,5,100,2,3,1],[-10,-10,1,3,2][1000,7,-6,2,2]]
print(test_input)

for i in test_input:
    print(highest_product_num(i,4),"\n")

# correct `results`
# 1680
# 6000
# 600

Answer 1

bulk_insert中的O（n）解决方案，在4个示例列表和@Stefan Pochmann的无情自动测试脚本上进行了压力测试。非常感谢Stefan，没有他们的输入，一些严重的错误就会被忽视。

numpy

算法简要说明：

特殊情况k奇数，所有数据负数通过分区找到k最小负值，返回prod，停止
按绝对值划分，在等级k - O（n）最坏情况下用introselect库函数拆分
如果prod top k＆gt; = 0，则停止
如果可能的话，交换最少积极的内部对于大多数负面的外部，存储prod
如果可能的话，交换最少的负面内部最积极的外部，存储prod
返回以上最佳，停止

示例运行：

import numpy as np

def kmaxprod_v2(data, k):
    if len(data) < k:
        return np.nan
    data = np.asanyarray(data)
    # for integer dtypes convert to python ints to have unlimited range for the
    # final product
    dfp = data.astype(object) if data.dtype in (
        int, np.int64, np.int32, np.int16, np.int8) else data
    # np.argpartition raises an exception if len(data) == k, therefore
    if len(data) == k:
        return np.prod(dfp)
    neg = data <= 0
    # if k is odd and there are no positive elements we must settle for the
    # least negative
    if k % 2 == 1 and np.count_nonzero(neg) == len(data):
        return np.prod(-np.partition(-data, k)[:k].astype(dfp.dtype))
    # now n > k and we have at least one positive element
    ap = np.argpartition(-np.absolute(data), k)
    low, high = ap[k:], ap[:k]
    # try multiplying the k with highest absolute value
    greedy = np.prod(dfp[high])
    if greedy >= 0:
        return greedy
    # there are two possible ways of fixing the sign:
    # either swap the worst negative inside for the best positive outside
    # or swap the worst positive inside for the best negative outside
    # compute both and compare
    # bpo in, wni out
    bpo = np.max(dfp[low])
    if bpo <= 0:
        spfn = 0
    else:
        neg_high = np.where(neg[high])[0]
        wni_ind = np.argmax(data[high[neg_high]])
        # translate to index in high
        wni_ind = neg_high[wni_ind]
        spfn = bpo*np.prod(dfp[high[:wni_ind]])*np.prod(dfp[high[wni_ind+1:]])
    # bno in, wno out
    pos_high = np.where(~neg[high])[0]
    if len(pos_high) == 0:
        snfp = 0
    else:
        wpi_ind = np.argmin(data[high[pos_high]])
        wpi_ind = pos_high[wpi_ind]
        bno = np.min(dfp[low])
        snfp = bno*np.prod(dfp[high[:wpi_ind]])*np.prod(dfp[high[wpi_ind+1:]])
    return max(spfn, snfp)

测试脚本，谢谢@Stefan Pochmann

>>> test_input = [[1,2,3,4,5,6,7,8],[1,-2,3,4,5,100,2,3,1],[-10,-10,1,3,2],[1000,7,-6,2,2]]
>>> for t in test_input:
...     kmp.kmaxprod(t,4)
... 
1680
6000
600
28000

Answer 2

from functools import reduce
import operator

def get_largest_product(l,n):
    possible_products = [reduce(operator.mul,c,1) for c in combinations(l, n)]
    return max(possible_products)

print (get_largest_product([232,434,5,4],3))

输出：

如何在n长度的数组中找到k个元素的最高乘积，其中k <1。 ñ

2 个答案: