全部问题

大家好。任何人都可以帮助完成任务吗？有两个解决方案，第一个是我的，它没有通过测试时间：coins=[186, 419, 83, 408]，amount=6249。我注意到的第二件事是决策。

实际上，它们唯一的区别在于 dp 中的数据类型，在我的解决方案中它是 int，在第二个中有指向 int 的指针。第一个在时间限制下失败，第二个成功通过，上述测试的速度差异很大。第一个解决方案需要 30 秒以上，第二个解决方案需要 30 秒以上。我不明白为什么速度会有这么大的差异。我将感谢你的帮助

第一的：

func coinChange(coins []int, amount int) int {
 dp := make([]int, amount+1)
 for i := range dp {
  dp[i] = math.MaxInt32
 }
 var r func(need int) int
 r = func(need int) int {
  if need < 0 {
   return math.MaxInt32
  }
  if need == 0 {
   return 0
  }
  if dp[need] != math.MaxInt32 {
   return dp[need]
  }
  needCoins := math.MaxInt32
  for _, c := range coins {
   needCoins = min(needCoins, 1+r(need-c))
  }
  dp[need] = needCoins
  return needCoins
 }

 ans := r(amount)
 if ans == math.MaxInt32 {
  return -1
 }
 return ans
}

第二：

func coinChange(coins []int, amount int) int {
 dp := make([]*int, amount+1)
 var r func(need int) int
 r = func(need int) int {
  if need < 0 {
   return math.MaxInt32
  }
  if need == 0 {
   return 0
  }
  if dp[need] != nil {
   return *dp[need]
  }
  needCoins := math.MaxInt32
  for _, c := range coins {
   needCoins = min(needCoins, 1+r(need-c))
  }
  dp[need] = &needCoins
  return needCoins
 }

 ans := r(amount)
 if ans == math.MaxInt32 {
  return -1
 }
 return ans
}

尝试了解元组中列表的 += 和 .append() 方法之间的差异。提出这个问题是为了了解“内部厨房”，而不是为了寻找实际应用。示例代码：

def add_func():
    a = (1, 2, [1, 2])
    a[-1] += [3] # в список значение добавится, но потом падает ошибка

第二个版本：

 def append_func(): 
    a = (1, 2, [1, 2])
    a[-1].append(3) # в данном случае всё корректно отработает 

查看字节码后，我发现有些行有所不同：

print(dis.dis(add_func))
print('--------------')
print(dis.dis(append_func))

  4           0 LOAD_CONST               1 (1)
              2 LOAD_CONST               2 (2)
              4 LOAD_CONST               1 (1)
              6 LOAD_CONST               2 (2)
              8 BUILD_LIST               2
             10 BUILD_TUPLE              3
             12 STORE_FAST               0 (a)

  5          14 LOAD_FAST                0 (a)
             16 LOAD_CONST               3 (-1)
             18 DUP_TOP_TWO
             20 BINARY_SUBSCR
             22 LOAD_CONST               4 (3)
             24 BUILD_LIST               1
             26 INPLACE_ADD              # Кажется, это "отголоски" __iadd__
             28 ROT_THREE
             30 STORE_SUBSCR
             32 LOAD_CONST               0 (None)
             34 RETURN_VALUE
--------------
  8           0 LOAD_CONST               1 (1)
              2 LOAD_CONST               2 (2)
              4 LOAD_CONST               1 (1)
              6 LOAD_CONST               2 (2)
              8 BUILD_LIST               2
             10 BUILD_TUPLE              3
             12 STORE_FAST               0 (a)

  9          14 LOAD_FAST                0 (a)
             16 LOAD_CONST               3 (-1)
             18 BINARY_SUBSCR
             20 LOAD_METHOD              0 (append)
             22 LOAD_CONST               4 (3)
             24 CALL_METHOD              1
             26 POP_TOP
             28 LOAD_CONST               0 (None)
             30 RETURN_VALUE

字节码的差异让我认为我理解了这个问题，但在那之后我决定阅读SO。
引用这个问题：

+= 是一个赋值。当你使用它时，你实际上是在说“some_list2= some_list2+['something']”。分配涉及重新绑定，因此：

同时他们__iadd__ 在这里写到：

从 API 的角度来看，iadd应该用于就地修改可变对象（返回已变异的对象），而add应该返回某个新的实例。

还有L. Ramalho 的书《Python - to the heights of mastery》中的一句话：

如果左侧的变量与不可变对象关联，并且可以就地修改可变对象，则复合赋值（运算符 +=、*= 等）会创建一个新对象。

坦白说，我对此感到困惑，并发现其中有很多矛盾。如果+=“就地”更改对象，为什么会发生错误？

PS我也不太理解STORE_FAST文档中字节码中的一行：

将 STACK.pop() 存储到本地 co_varnames[var_num] 中。

我看了《三体》系列。

我查了一下维基百科，他们说没有简单公式形式的解决方案，但如果你每纳秒计算所有力的影响并将它们加在一起，就可以简单地模拟。

而且据我了解，现在的计算机可以提前一百年计算出三个物体的轨迹，而不会出现特别大的误差？或者这不是真的吗？

为什么这段代码会抛出错误：

const MSG: &str = "Hello";

fn one_of(_first: &str, _second: &str) -> &str {
    MSG
}

我向我的铁杆朋友（gpt-4-1106-preview）问了这个问题，他回答说：

该代码会抛出错误，因为 Rust 无法保证引用的字符串的生存MSG时间足够长，足以安全地使用函数返回的引用one_of

好吧，好吧，那么为什么这个函数不会导致错误：

const MSG: &str = "Hello";

fn one(_first: &str) -> &str {
    MSG
}

我朋友回复：

当声明函数时one未显式指定返回引用的生存期时，编译器将使用生存期推断并发现返回值MSG具有静态生存期。因此，编译器假定该函数返回具有静态生命周期的引用，并且此推论与输入参数的生命周期兼容（在本例中忽略该参数，因为它不用于确定返回值的生命周期） ）。

我的合理反对：

但是在 one_of 的情况下，编译器可以自动为该函数分配静态生命周期，就像在 one 的情况下一样，为什么您所说的有关 one 的所有内容在 one_of 函数的情况下都无效？

我的朋友终于崩溃了，开始为“造成的混乱”道歉，并表示这两个函数不应该导致错误（即使它们没有）。

我们需要生物神经网络的帮助，那就是你，亲爱的皮革和骨头朋友！解释一下主题

我想在输出处看到 6 行和 2 列的 DF（因为 2**3 = 6）。但结果只有3：

import pandas as pd
def get_series(name_column: str, size:int=2):
    return pd.Series([i for i in range(size)], name=name_column)


def get_df():
    return pd.concat([get_series('col1'), get_series('col2', 3)], axis=1)
print(get_df())

结果：

   col1  col2
0   0.0     0
1   1.0     1
2   NaN     2

当然，您可以使用Python工具使用double for来实现这一点，但我想知道这是否可以通过Pandas实现？