小编use*_*317的帖子

问题类似于硬币变化问题,但有点不同.

问题表述为:你有一组硬币,你知道硬币的价值和每种硬币的数量.您想知道您可以从这些硬币的非空分组中获得多少不同的总和.

因此,例如coins = [1, 2, 3]和数量= [1, 2, 2],有11个可能的总和,基本上所有数字从1到11.

阵列硬币的长度最多只能达到20,但数量[x]最多可达10 ^ 5.

什么是有效的算法解决方案.收集如此大量的所有可能组合将需要永远.有没有可以确定答案的数学公式？我不知道它会如何工作,特别是它需要不同的总和.

我正在考虑根据硬币及其数量生成阵列.基本上是它的倍数:

[ [1],
  [2, 4],
  [3, 6]]

然后必须从每个阵列中选择1或不选.

1
1,2
1,4
1,3
...
1,4,6

我似乎无法想出一个好的算法来执行它.嵌套循环可能太慢,因为可能有20个不同的硬币,每个硬币可能有大量.

另一种可能的解决方案是循环1到最大值.最大值是所有硬币的总和乘以其相关数量.但问题在于确定是否存在将等于该数字的子集.我知道有一个动态编程算法(子集和)来确定是否存在将加起来某个值的子集,但是数组是什么？

对于这个例子它工作正常,列表为[1,2,4,3,6],目标总和为11然后计数DP中的'真'将得到11.但是例如coins = [10,50,100]和quantity = [1,2,1].答案是9可能的总和,但如果使用子集和DP算法将得到21'真'.如果根据[[10],[50,100],[100]提供的清单是[10,50,100,100]或[10,50,100]]

python解决方案将是首选,但不是必需的.

下面是我目前的代码,[10,50,100]硬币示例得到21.

def possibleSums(coins, quantity):
    def subsetSum(arr,s):
        dp = [False] * (s + 1)  
        dp[0] = True

        for num in sorted(arr):  
            for i in range(1, len(dp)):  
                if num <= i:  
                    dp[i] = dp[i] or dp[i - num]  
        return …

如何使用 argparse 从一组选择中提供参数列表。例如，假设我想要类似的东西：

python sample.py --p1 ['a','b'] --p2 ['x','y']

其中p1只能是列表中的任何或全部'a', 'b', 'c'并且p2只能是列表中的任何或全部'x', 'y', 'z'

假设每个节点都有self.left,self.right和self.data，从每个级别给出数字的列表中构造二叉树而不是二叉搜索树（BST）的最佳方法是什么。其中第一个数字是级别 1，接下来的 2 是级别 2，接下来的 4 是级别 3，依此类推。例如

input: [3,5,2,1,4,6,7,8,9,10,11,12,13,14] 

构造一棵树：

          3
       /     \
     5         2
    /\         /\
   1  4       6   7
  /\  /\     /\   /\
 8 9 10 11 12 13 14

一种解决方案是：

for node at index i,
left child index = 2i+1
right child index = 2i+2

想知道是否还有其他可能的方法

问题表述为:给定一个仅包含数字0-9和目标值的字符串,返回通过在数字之间添加一些二元运算符(+, - 或*)创建的所有表达式,以便它们计算为目标值.在某些情况下,可能没有任何二进制运算符会创建有效的表达式,在这种情况下,该函数应返回一个空数组.新表达式中的数字不应包含前导零.

该函数应返回所有评估为目标的有效表达式,按字典顺序排序.

例如:

digits = "123"和target = 6,应该返回: ["1*2*3", "1+2+3"]

我目前的算法如下.它有点慢,所以我正在寻找一种更有效的方法来解决问题.我目前的算法产生操作数和运算符的所有组合.对于上面的例子,它产生了

操作数:

[['1', '2', '3'], ['1', '23'], ['12', '3'], ['123']]

运营商:

{0: [()], 1: [('+',), ('-',), ('*',)], 2: [('+', '+'), ('+', '-'), ('+', '*'), ('-', '+'), ('-', '-'), ('-', '*'), ('*', '+'), ('*', '-'), ('*', '*')]}

然后它结合了操作数和运算符的所有可能组合并评估每个.

数字有一个约束,2 ? digits.length ? 10. 所以它并没有那么糟糕,但是这个算法对于一个长度为10的数字需要大约4.3秒,其中它应该只需要4秒(最大值).

我还尝试使用以下替代方法加速eval()函数:

if eval(temp) == target:

要么

exp_as_func = eval('lambda: ' + temp)
if exp_as_func() == target:

要么

compiled = compile(temp, '<string>', 'eval') …

我读到 numpy 在四舍五入方面是无偏见的，并且它的工作方式是按照其设计的方式工作的。“如果你总是将 0.5 舍入到下一个最大的数字，那么一组舍入数字的平均值可能会略大于未舍入数字的平均值：这种偏差或漂移会对某些数值算法产生非常不利的影响，并且让他们变得不准确。”

无视这些信息并假设我总是想四舍五入，我该如何在 numpy 中做到这一点？假设我的数组可能很大。

为简单起见，假设我有数组：

import numpy as np

A = [ [10, 15, 30], [25, 134, 41], [134, 413, 51]]
A = np.array(A, dtype=np.int16)

decimal = A * .1
whole = np.round(decimal)

十进制看起来像：

[[  1.    1.5   3. ]
 [  2.5  13.4   4.1]
 [ 13.4  41.3   5.1]]

整体看起来像：

[[  1.   2.   3.]
 [  2.  13.   4.]
 [ 13.  41.   5.]]

如您所见，1.5 四舍五入为 2，2.5 也四舍五入为 2。如何强制始终获得 XX.5 的舍入答案？我知道我可以遍历数组并使用 python round() 但这肯定会慢得多。想知道是否有办法使用 numpy 函数来做到这一点

想知道是否有更好的方法来获得 2D numpy 数组的概率。也许使用一些 numpy 的内置函数。

为简单起见，假设我们有一个示例数组：

[['apple','pie'],
['apple','juice'],
['orange','pie'],
['strawberry','cream'],
['strawberry','candy']]

想得到这样的概率：

['apple' 'juice'] --> 0.4 * 0.5 = 0.2
['apple' 'pie']  --> 0.4 * 0.5 = 0.2
['orange' 'pie'] --> 0.2 * 1.0 = 0.2
['strawberry' 'candy'] --> 0.4 * 0.5 = 0.2
['strawberry' 'cream'] --> 0.4 * 0.5 = 0.2

其中“果汁”作为第二个词的概率为 0.2。由于苹果的概率为 2/5 * 1/2（果汁）。

另一方面，'pie' 作为第二个词的概率为 0.4。'apple' 和 'orange' 的概率组合。

我处理这个问题的方法是向数组添加 3 个新列，分别是第一列、第二列和最终概率的概率。将数组按第一列分组，然后按第二列分组并相应地更新概率。

下面是我的代码：

a = np.array([['apple','pie'],['apple','juice'],['orange','pie'],['strawberry','cream'],['strawberry','candy']])

ans = []
unique, counts = np.unique(a.T[0], return_counts=True)                      ## …

我有一个有序的字典,我试图以相反的顺序通过它,基本上从插入的最后一个(键,值)开始.

dicts = OrderedDict()
...
for key, value in reversed(dicts.items()):

当我在Python 3.5.1中使用PyCharm时,上面的代码工作正常,但是当我将它放在codefights上时,使用他们的Python 3解释器(不知道确切的版本),我得到for循环实现的下面的错误:

TypeError: argument to reversed() must be a sequence

为什么会发生此错误,我该如何解决？

您如何索引超出范围的环绕的numpy数组？

例如，我有3x3数组：

import numpy as np

matrix = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])

## 
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]]

说我想索引值所在的索引（2,4）周围的值15。我想用值返回数组：

[[9,  10, 6]
 [14, 15, 11]
 [4,  5,  1]]

基本上所有15左右的值都返回了，假设它回绕了

不确定这个问题的最佳标题是什么，但基本上我想根据提供的位置和指定的距离用一个值填充现有的 numpy 数组。假设对角线是无效的。

例如，假设我们有一个只有 0 的数组。

[[0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]]

如果我想要 (2,2) 作为距离为 1 的位置，它将用值 1 填充矩阵，在与提供的位置距离为 1 的位置（包括其自身）。因此矩阵看起来像：

[[0 0 0 0 0]
 [0 0 1 0 0]
 [0 1 1 1 0]
 [0 0 1 0 0]
 [0 0 0 0 0]]

如果我提供 2 的距离，它看起来像：

[[0 0 1 0 0]
 [0 1 1 1 0]
 [1 1 …

如何创建单行数据作为pandas.core.frame.Pandas object？

因此，当您使用 迭代数据帧 (df) 时for row in df.itertuples()，每一行都将是一个pandas.core.frame.Pandas对象。我想创建一个该类型的对象。

例如：

import pandas as pd

d = [{'a': 1, 'b': 2}]
df = pd.DataFrame(d)
print(type(df))
print("a", df.a)

for row in df.itertuples():
    print(type(row))
    print("a", row.a)


myrow = None
df = pd.DataFrame(d)
for row in df.itertuples():
    myrow = row
print(type(myrow))
print("a", myrow.a)

其输出为：

<class 'pandas.core.frame.DataFrame'>
a 0    1
Name: a, dtype: int64
<class 'pandas.core.frame.Pandas'>
a 1
<class 'pandas.core.frame.Pandas'>
a 1

正如您所看到的，pandas.core.frame.DataFrame的行为与预期不同pandas.core.frame.Pandas。

我真的不想myrow …