小编Pri*_*usa的帖子

result = False
def permute(a,l,r,b):
    global result
    if l==r:
        if a==b:
            result = True
    else:
        for i in range(l, r+1):
            a[l], a[i] = a[i], a[l]
            permute(a, l+1, r, b)
            a[l], a[i] = a[i], a[l]

string1 = list("abc")
string2 = list("ggg")
permute(string1, 0, len(string1)-1, string2)

所以基本上我认为找到每个排列需要n ^ 2步(时间一些常数)并找到所有排列应该取n!脚步.那么这会使它成为O(n ^ 2*n!)？如果是这样的话!接管,只做O(n!)？

谢谢

编辑:这个算法对于找到排列似乎很奇怪,这是因为我也用它来测试两个字符串之间的字谜.我还没有重命名这个方法但抱歉

注意：我使用的是discord.py 0.16.12

我想知道是否有任何方法可以让机器人在代码中加入服务器。就像有一个命令是这样的：

@client.command(pass_context=True)
async def join(ctx, invite):
    client.join(invite)

我已经尝试过了

@client.command()
async def joinserver(mahlink):
    await client.accept_invite(mahlink)

这不起作用。这是我在谷歌上能找到的关于这个的唯一信息

另外，运行会accept_invite给出以下结果：

Discord.errors.Forbidden：FORBIDDEN（状态代码：403）：机器人无法使用此端点

我希望在比较两种树结构时找到差异。

节点将是字符串。我想捕获它发生在树的哪个级别。

例如找出这两棵树之间的差异：

我正在做这个竞争性编程任务，即使我认为我有一个渐近最优的解决方案，但我仍然超出了时间限制。需要注册账号才能看到问题说明并提交，这里我再重申一遍：

给定一个范围 [L, R]，找出该范围内具有奇数个奇数除数的整数的数量。

约束是 1 <= L <= R < 10^18，并且最多有 10^5 个这样的查询。

例子：

的解[1, 18]是 7，因为在该范围内有 7 个具有奇数个奇数除数的数字：

1 - (1)
2 - (1, 2)
4 - (1, 2, 4)
8 - (1, 2, 4, 8)
9 - (1, 3, 9)
16 - (1, 2, 4, 8, 16)
18 - (1, 2, 3, 6, 9, 18)

我的代码和想法：

我们知道除数是成对出现的，因此任何具有奇数个除数的奇数都必须是平方数。任何具有奇数除数的偶数都必须有一些奇数的“底数”，该“底数”具有奇数个除数，而要使这个“底数”做到这一点，它必须是前面讨论过的平方数。

本质上，我们正在寻找形式为 的数字O^2 * 2^N，其中O是一些奇数。我将解决方案[L, R]视为[1, R] - [1, L) …

我正在学习深度学习，并试图理解下面给出的 pytorch 代码。我正在努力理解概率计算是如何工作的。可以以某种方式将其分解为外行人的术语。万分感谢。

ps = model.forward(图像[0,:])

# Hyperparameters for our network
input_size = 784
hidden_sizes = [128, 64]
output_size = 10

# Build a feed-forward network
model = nn.Sequential(nn.Linear(input_size, hidden_sizes[0]),
                      nn.ReLU(),
                      nn.Linear(hidden_sizes[0], hidden_sizes[1]),
                      nn.ReLU(),
                      nn.Linear(hidden_sizes[1], output_size),
                      nn.Softmax(dim=1))
print(model)

# Forward pass through the network and display output
images, labels = next(iter(trainloader))
images.resize_(images.shape[0], 1, 784)
print(images.shape)
ps = model.forward(images[0,:])

我想知道以下代码如何更快。目前，它似乎异常缓慢，我怀疑我可能使用了 autograd API 错误。我期望的输出是timeline在 f 的雅可比计算的每个元素，我确实得到了，但需要很长时间：

import numpy as np
from autograd import jacobian


def f(params):
    mu_, log_sigma_ = params
    Z = timeline * mu_ / log_sigma_
    return Z


timeline = np.linspace(1, 100, 40000)

gradient_at_mle = jacobian(f)(np.array([1.0, 1.0]))

我希望以下内容：

1. jacobian(f) 返回一个表示带参数的梯度向量的函数。
2. jacobian(f)(np.array([1.0, 1.0]))是在点 (1, 1) 计算的雅可比行列式。对我来说，这应该像一个矢量化的 numpy 函数，所以它应该执行得非常快，即使对于 40k 长度的数组也是如此。然而，这不是正在发生的事情。

即使像下面这样的东西也有同样糟糕的表现：

import numpy as np
from autograd import jacobian


def f(params, t):
    mu_, log_sigma_ = params
    Z = t * mu_ / log_sigma_
    return Z


timeline = …

为什么这个数据集会尝试遍历最后一个元素

from torch.utils.data.dataset import Dataset
class DumbDataset(Dataset):
    def __init__(self, dct):
        self.dct = dct
        self.mapping = dict(enumerate(dct))
    def __getitem__(self, index):
        return self.dct[self.mapping[index]]

    def __len__(self):
        print('called')
        return len(self.dct)

ds = DumbDataset({'a': 'aword', 'b': 'another_words'})

for k in ds: print(k)

这引发了 KeyError: 2，我不明白，因为对象的长度是 2。迭代器用完后不应该得到 StopIteration 吗？

我创建了一个函数convert()，它将 pdf 转换为 html 并将 html 作为字符串输出。当我做 ：

print(convert())

它有效，但是当我尝试将结果写入文件时：

f.write(convert())

我得到：

UnicodeEncodeError: 'charmap' codec can't encode character '\ufb01' in position 978: character maps to <undefined>

在pycharm我的项目中编码器设置为 UTF-8，并且我有一个

# -*- encoding: utf-8 -*-

在文件的开头。关于为什么我收到此错误的任何想法？

我注意到在keras文档中有许多不同类型的Conv层，即Conv1D, Conv2D, Conv3D.

它们都具有其他层中不存在的参数，例如filters、kernel_size、strides和。paddingkeras

我见过像这样“可视化”Conv图层的图像，

但我不明白从一层过渡到下一层的过程中发生了什么。

改变上述参数和我们Conv层的维度如何影响模型中发生的事情？

以此示例对象为例:

class myObj:

    def __init__(self):
        self.a = 1
        self.b = 2
        self.c = 3
a = myObj()

我可以使用vars(a),我将获得{'a': 1, 'b': 2, 'c': 3}或dir(a)获取属性的列表以及a中的所有函数.我可以看到存储在其中的所有内容a.

但是,列表中有一个不同的故事.var([])抛出错误并dir([1, 2, 3])仅列出列表中实现的函数.从哪里__getitem__获取列表中的项目？

我在leetcode上看到了以下解决方案:

class Solution:
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """

        if root is None:
            return []

        q, res = [root], []
        q1 = []
        while q:
            res.append([node.val for node in q])
            q = [child for node in q for child in node.children]

        return res

[child for node in q for child in node.children]工作怎么样？当你把它放在for循环语句之前时,孩子的意思是什么？