我有这段代码，我想知道第一个输入和第二个输入的执行时间之间存在差异的原因。我认为它应该花费相同的时间，因为我正在调用相同的方法，但它在两个对象中不执行任何操作。但是 input1 （这是 2 个实例的交替）在我的计算机上花费了 5 秒。input2（这是两个实例之间的任意选择）在我的计算机上花费了 17 秒。
public class Program {
private static final Runnable FIRST_INSTANCE = () -> {};
private static final Runnable SECOND_INSTANCE = () -> {};
private static Runnable[] input1() {
Runnable[] array = new Runnable[10000];
for (int i = 0; i < array.length; i++) {
array[i] = i % 2 == 0 ? FIRST_INSTANCE : SECOND_INSTANCE;
}
return array;
}
private static Runnable[] input2() {
Random rnd = new Random(0);
Runnable[] array = new …所以“新（旧）大事”是 C++ 中的“无原始循环”。我正在尝试以这种方式编写代码，但似乎效率很低。是的，有些 STL 算法可以做任何事情，但它们似乎效率不高。
例如，我有一种情况，我想要一个指向节点数组中得分最高的节点的指针。确定该分数是一项代价高昂的浮点运算。所以我实现了STL算法版本并将其与原始循环进行了比较：
#include <cfloat>
#include <iostream>
#include <array>
#include <algorithm>
#include <numeric>
static int counter;
class Node {
public:
auto Score() const -> double {
std::cout << "complex calculation\n";
counter++;
return 1;
}
};
int main()
{
std::array<Node, 10> nodes;
counter = 0;
Node const* nodePtr = std::max_element(std::cbegin(nodes), std::cend(nodes),
[](Node const& node1, Node const& node2) {
return node1.Score() < node2.Score();
});
std::cout << "algorithm count " << counter << std::endl;
counter = 0;
double maxScore = …我有一本类似这样的字典：
{
'firstName': 'abc',
'lastName': 'xyz',
'favoriteMovies': ['Star Wars', 'The lone ranger'],
'favoriteCountries': [
{'country': 'China', 'capitalCity': 'Beiging'},
{'country': 'India', 'capitalCity': 'New Delhi'}
]
}
我想将其转换为snake_case，如下所示
{
'first_name': 'abc',
'last_name': 'xyz',
'favorite_movies': ['Star Wars', 'The lone ranger'],
'favorite_countries': [
{'country': 'China', 'capital_city': 'Beiging'},
{'country': 'India', 'capital_city': 'New Delhi'}
]
}
字典可以是任何长度深度。
我目前的解决方案是
import re
def convert_snake_case_to_camel_case(data):
required_dict = {}
for key, value in data.items():
if type(value) == str:
new_key = re.sub("([a-z0-9])([A-Z])", r"\1_\2", key).lower()
required_dict[new_key] = value
elif type(value) == list …我对辅助空间复杂性有点迷失。
在我参加的讲座中，讲师指出字符串的空间复杂度为 O(n)，因为字符串的长度 (n) 会有所不同。但诸如数字、布尔值、未定义等原语具有恒定的空间复杂度 O(1)。
我很困惑，因为如果字符串的空间长度不同，那么数字也不一样吗？因为它们也会有不同的“长度”？
我确实理解布尔值和未定义的复杂度是 O(1)，我的意思是真/假、未定义和 null 是与长度无关的实例。
如果有人能为我澄清这一点，我将不胜感激。
在我的项目中，我被要求在我们正在使用的数据库上实现文本查询服务；PostgreSQL。我使用过 Postgresql 全文搜索功能，它在时间方面工作得相当好。全文搜索的一个问题是，它不具有模糊搜索能力。另一方面，有一个名为pgtrgm的扩展 ，提供用于确定字母数字文本相似度的函数和运算符。还有几个使用 pgtrgm 进行文本搜索的示例，例如：
select actor
from products
where actor % 'tomy';
如您所知，postgres FTS 的示例也在这里；
SELECT title
FROM pgweb
WHERE to_tsvector(body) @@ to_tsquery('friend');
那么，主要问题是，这两种搜索策略有什么区别？哪种方式更适合搜索文本？可以将它们混合吗？我还需要说的是，性能也是一个重要的问题。提前致谢！
我要这个：
def compare_list(old, new):
new_set = set(new)
old_set = set(old)
return new_set - old_set, old_set - new_set, new_set & old_set
old = [1, 2, 3]
new = [5, 4, 2, 3]
added, deleted, unchanged = compare_list(old, new)
print("added: ", added)
print("deleted: ", deleted)
print("unchanged: ", unchanged)
added: {4, 5}
deleted: {1}
unchanged: {2, 3}
但这对我来说似乎效率很低。所以我想知道还有什么更有效的解决方案吗？或内置功能？
我有一个元组列表，如下所示：
[(1, 'Red'), (2, 'Yellow'), (6, 'Pink'), (7, 'Blue'), (8, 'Green')]
元组中的数字代表索引。但是，由于我的输入文件中缺少一些索引，因此我需要在列表中插入一些元组，并使列表如下所示：
[(1, 'Red'), (2, 'Yellow'), (3, None), (4, None), (5, None), (6, 'Pink'), (7, 'Blue'), (8, 'Green')]
如果你们中的一些人有任何想法，如果您花时间发表评论，我将非常感激。
LPS（最长正确前缀，也是后缀）算法如下：
public static int[] constructLPSArray(String s) {
int n = s.length();
int[] arr = new int[n];
int j = 0;
for (int i = 1; i < n; ) {
if (s.charAt(i) == s.charAt(j)) {
arr[i] = j + 1;
i++;
j++;
} else {
if (j != 0) {
j = arr[j - 1];
} else {
i++;
}
}
}
return arr;
}
部分if (s.charAt(i) == s.charAt(j))看起来很清楚，但else部分却不清楚。我们为什么这样做：
if (j != 0) {
j = …尝试了解 Codility NailingPlanks 的解决方案。
\n\n问题链接：\n https://app.codility.com/programmers/lessons/14-binary_search_algorithm/nailing_planks/
\n\n\n\n\n给定两个由 N 个整数组成的非空数组 A 和 B。\n 这些数组代表 N 个木板。更准确地说，A[K] 是第 K\xe2\x88\x92 个木板的起点，\n B[K] 是终点。
\n\n接下来，给出一个由 M 个整数组成的非空数组 C。该数组代表 M 个钉子。更准确地说，C[I] 是您可以敲入第 I\xe2\x88\x92 个钉子的位置。
\n\n如果存在钉子 C[I]\n 使得 A[K] \xe2\x89\xa4 C[I] \xe2\x89\ ，我们说木板 (A[K], B[K]) 被钉住xa4 B[K]。
\n\n目标是找到必须使用的最少钉子数量，直到钉完所有木板。换句话说，您应该找到一个值 J，使得仅使用前 J 个钉子后即可钉好所有木板。更准确地说，对于每个木板 (A[K], B[K]) 使得 0 \xe2\x89\xa4 K\n < N，应该存在一个钉子 C[I] 使得 I < J 且 A[K ] \xe2\x89\xa4 C[I] \xe2\x89\xa4\n B[K]。
\n
解决方案链接：\n https://github.com/ZRonchy/Codility/blob/master/Lesson12/NailingPlanks.java
\n\nimport java.util.Arrays;\n\nclass Solution {\n …我有两个随机排序的 2d 点的大型 numpy 数组，假设它们是 A 和 B。我需要做的是找到两个数组之间“匹配”的数量，其中匹配是 A 中的一个点（称之为A'）在某个给定半径 R 内，并且 B 中的一个点（称为 B'）。这意味着 A 中的每个点都必须与 B 中的 1 个点匹配或没有点匹配。返回两个数组之间匹配的列表索引也很好，但这不是必需的。由于在这个半径R内可以有很多点，所以似乎最好找到B中距离A'最近的点，然后检查它是否在半径R内。这可以简单地用距离公式来测试dx^2 + dy^2。显然，有一个遍历两个数组的强力 O(n^2) 解决方案，但我需要更快的东西，希望 O(n log n) 。
我所看到的是，Voronoi 图可以用于解决这样的问题，但是我不确定这是如何实现的。我不熟悉 Voronoi 图，所以我用 生成它scipy.spatial.Voronoi。是否有使用这些图来解决此问题的快速算法，或者还有其他算法吗？