我无法解决这个问题。我们需要创建一个函数 getUsersNamesInAgeRange(users, sex) 来返回相同性别用户的平均年龄。目前我只能这样写，但结果是错误的：
function getUsersNamesInAgeRange(users, gender) {
const filteredGender = users.filter((user) => {
return user.gender === gender;
});
const ageSum = users.reduce((sum, user) => {
return sum + user.age
}, 0);
return ageSum / users.length
}
告诉我，我做错了什么？预先感谢您的回答！
在 fs 中使用 Promise API 时，首先我必须打开文件描述符，然后才能访问我需要的方法，在我的例子中是 createReadStream
const fileHandle = await fs.open(filePath, 'r')
const readableStream = fileHandle.createReadStream(opt)
我怎样才能通过promise正确使用这个方法呢？最重要的是，如何正确且优雅地关闭文件描述符，因为当将await fileHandle?.close() 行插入finally 块时，文件没有时间被读取并立即关闭，这就是我尝试的方法。
const fs = require("fs/promises");
async function foo() {
const fileHandle = await fs.open("text.txt", "r");
const readableStream = fileHandle.createReadStream();
try {
return new Promise((resolve, reject) => {
let data = "";
readableStream .on("data", (chunk) => {
data += chunk;
});
readableStream .on("end", () => {
resolve(data);
});
readableStream .on("end", reject);
});
} catch (err) {
console.log(err);
} finally {
await fileHandle?.close();
}
}
foo().then((data) => console.log(data));
建议代码：
using namespace std;
int main(int argc, char* argv[]) {
srand(time(0));
const int array_size = 200000; // 1
int a[array_size];
for (int counter = 0; counter < array_size; counter++) { // 2
a[counter] = rand() % 50 - rand() % 50; // 3
cout << a[counter] << " ";
}
int min = a[0]; // 4
for (int counter = 1; counter < array_size; counter++) { // 5
if (min > a[counter]) {
min = a[counter]; // 6
}
}
cout << "\nmin = " << min << endl;
cout << "runtime = " << clock() / 1000.0 << endl;
system("pause");
return 0;
}
我得到以下信息：
不过，我并不完全确定，因为……就霍尔斯特德度量而言，过程和函数名称是运算符，函数是操作数，我无法弄清楚给定程序中什么是函数以及什么是函数名称。
static int
list_resize(PyListObject *self, Py_ssize_t newsize)
{
PyObject **items;
size_t new_allocated, num_allocated_bytes;
Py_ssize_t allocated = self->allocated;
/* Bypass realloc() when a previous overallocation is large enough
to accommodate the newsize. If the newsize falls lower than half
the allocated size, then proceed with the realloc() to shrink the list.
*/
if (allocated >= newsize && newsize >= (allocated >> 1)) {
assert(self->ob_item != NULL || newsize == 0);
Py_SIZE(self) = newsize;
return 0;
}
/* This over-allocates proportional to the list size, making room
* for additional growth. The over-allocation is mild, but is
* enough to give linear-time amortized behavior over a long
* sequence of appends() in the presence of a poorly-performing
* system realloc().
* The growth pattern is: 0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...
* Note: new_allocated won't overflow because the largest possible value
* is PY_SSIZE_T_MAX * (9 / 8) + 6 which always fits in a size_t.
*/
new_allocated = (size_t)newsize + (newsize >> 3) + (newsize < 9 ? 3 : 6);
if (new_allocated > (size_t)PY_SSIZE_T_MAX / sizeof(PyObject *)) {
PyErr_NoMemory();
return -1;
}
if (newsize == 0)
new_allocated = 0;
num_allocated_bytes = new_allocated * sizeof(PyObject *);
items = (PyObject **)PyMem_Realloc(self->ob_item, num_allocated_bytes);
if (items == NULL) {
PyErr_NoMemory();
return -1;
}
self->ob_item = items;
Py_SIZE(self) = newsize;
self->allocated = new_allocated;
return 0;
}
查看CPython方法的源代码append（上面列出），我发现append只要数组中有空闲空间，复杂度就是O(1)，否则Python以指数方式增加新的大小（+3/+6固定量）列表的内存）并将现有元素复制到新数组中。事实证明，由于分配的数组大小呈指数增长，随着列表的增长，重新分配的次数会减少。因此，例如：
lst = []
for i in range(10):
lst.append(i)
第一次重新分配时，复制 1 个元素，第二次复制 4 个元素，第三次复制 10 个元素，依此类推，理论上给出了以下形式的几何级数：1+4+10+⋯≤O(n)。据我了解，随着每次后续迭代，重新分配之间的操作数量线性增长，并且 n 加法的重新分配总数以 O(logn) 的形式减少。那么，在这种情况下，为什么对于 n 个附加序列，总复杂度是 O(n)，而不是 O(n logn)？
int test;
这是一个变量声明
test = 5;
这是她的初始化
int test2 = 5;
这是什么？就好像同时有一个公告和初始化。是否有单独的名称？
还有几个问题（与上面的部分无关）：初始化是第一次给变量赋值，以后只是赋值，我理解正确吗？是不是可以说定义而不是挪用，这不重要？我只是到处看到不同的名字，因此我的头很困惑。