标签: memory-efficient

我想知道是否有足够简单的算法来生成 N 个元素的排列，比如说1..N，它使用的O(N)内存少于内存。它不必计算第 n 个排列，但它必须能够计算所有排列。

当然，这个算法应该是某种生成器，或者使用一些O(N)内存不足的内部数据结构，因为将结果作为大小的向量返回N已经违反了对次线性内存的限制。

我很好奇无论解释性如何,以长格式还是宽格式存储数据是否更有效？我已经习惯于object.size()确定内存中的大小,但它们没有显着差异(长度在大小方面稍微有点效率)并且值仅是和估计值.

除了原始大小之外,我还想知道在建模时使用哪种格式更有效.

我有一个嵌入式系统(没有任何操作系统的MCU),最终用户应该能够定义系统的级别(比例:0-100)一年.作为一个例子(时间x天矩阵):

       | 1st Jan | 2nd Jan | 3rd Jan | .. | 31 Dec |
00:30  |  40 (%) | 40      |  45     | .. |   50   |
01:48  |  48     | 47      |  55     | .. |   33   |
02:26  |  64     | 64      |  60     | .. |   68   |
..     |  ..     | ..      |  ..     | .. |   ..   |
22:15  | 79      | 82      |  89     | .. |   100  |
23:37  | 100 …

假设我有两个大小为 M1 和 M2 的 RDD，它们平均分布在 p 个分区中。

我很想知道（理论上/大约）操作过滤器、映射、leftOuterJoin、++、reduceByKey 等的成本是多少。

谢谢您的帮助。

当我们使用 DB API 2.0 获取数据时，cur.execute("select * from db.table")我们会得到一个游标，它看起来像元组列表的生成器对象。

而在 pymongo 中，当我们获取时，我们将其作为字典列表获取。我想实现这样的目标。

我不需要获取元组列表，而是想要字典列表或命名元组。

我相信从效率的角度来看这是有意义的，因为模式已经定义，所以不需要为每条记录发送它。

目前我正在使用的解决方法是：

cur.execute("select * from db.table")
columns = cur.columns_with_types
data = cur.fetchall()
df = pd.DataFrame(data,columns=[tuple[0] for tuple in columns])
data_reqd = df.to_dict('records')

当查询返回大量数据时，此方法的公平性很差。

解决方法 1：使用fetchmany(size=block_size)，但它似乎不是一种优雅的做事方式。

解决方法 2：这似乎是一种更好的处理方式。

cur.execute("select * from db.table")
columns = cur.columns_with_types
for tup in cur:
     row = dict(zip(columns, tup))
    # use row

有什么好的办法处理这个问题吗？对问题的任何改进表示赞赏。

我正在开发一个以 60fps 运行的可视化。该可视化的一部分是根据项目的位置对屏幕上的项目进行排序。我在用着

Array.Sort<T>(T[] array, int index, int length, IComparer<T> comparer)

每秒分配近 1MB 的内存Comparison<T>，这会导致 GC 频繁运行，从而导致帧速率出现问题。

我已经尝试了几种变体Array.Sort，它们都在分配，包括接受的变体Comparison<T>（这也是不够的，因为它缺少index和length参数）。

有没有办法在 C# (.NET 5) 中对数组进行排序而不分配大量内存？

更新：这是一个重现，

using System;
using System.Collections.Generic;

namespace New_folder
{
    public class EmptyClass
    {
        // Empty
    }

    public class EmptyClassComparer : IComparer<EmptyClass>
    {
        public int Compare(EmptyClass x, EmptyClass y)
        {
            return 0;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            EmptyClass[] emptyClasses = new EmptyClass[100];
            for (int …

我有一个关于数据集中两个字符串的子字符串之间非常快速有效的比较的问题，尽管机器非常强大，但它的运行速度不够快。我有data.table2 列和大约 15 亿行，其结构如下：

library(data.table)
library(stringr)
library(stringi)
library(stringdist)

dt <- data.frame(c("002134", "024345", "176234"), c("002003", "024234", "002004"))
colnames(dt) <- c("class1", "class2")
setDT(dt)

我想要的是一个函数，它 (1) 从两个向量的每个字符串中逐行提取前 3 位数字，(2) 比较两个向量之间的子字符串，(3) 创建一个新的布尔变量来报告两个子字符串是否相同是否相等。

所以想要的结果如下：

dt$sameclass <- c(TRUE, TRUE, FALSE)
print(dt)
   class1 class2 sameclass
1: 002134 002003      TRUE
2: 024345 024234      TRUE
3: 176234 002004     FALSE

我已经尝试过stringr和的版本，stringi无论是在data.table功能内还是在功能外。为了比较我使用的子字符串stringdist，因为据我了解可以并行化，这对我的服务器非常有益。然而，瓶颈似乎仍然是子串提取。

#stringi + stringdist without data.table: 
dt$redclass1 <- stri_sub(dt$class1, to = 3)
dt$redclass2 <- stri_sub(dt$class2, to = 3)
dt[, classdist …

内存成本显然取决于模块的大小,但我只是在寻找一个通用的答案:在Python中导入模块通常是昂贵还是便宜？如果我有几十个小脚本可能在整个应用程序期间留在内存中,那么占用多少内存？

只是好奇哪个在 swift 中更有效/更好：

• 创建三个临时常量（使用 let）并使用这些常量定义其他变量
• 创建一个临时变量（使用 var）并使用该变量保存三个不同的值，然后这些值将用于定义其他变量

这也许可以通过一个例子更好地解释：

var one = Object()
var two = Object()
var three = Object()

func firstFunction() {
    let tempVar1 = //calculation1
    one = tempVar1

    let tempVar2 = //calculation2
    two = tempVar2

    let tempVar3 = //calculation3
    three = tempVar3

}

func seconFunction() {
    var tempVar = //calculation1
        one = tempVar

    tempVar = //calculation2
        two = tempVar

    tempVar = //calculation3
        three = tempVar

}

这两个函数哪个更有效？感谢您的时间！

我问这个关于 C++ 的问题，因为我对 C++ 很熟悉，但问题确实可以解释自己：是否有一种语言可以派生一个类并使其在内存中占用的空间比原始类少？

这个问题更像是一个噱头，而不是我试图解决的实际问题，但我可以想象一些真正高性能的代码可以从这种内存优化中受益：

假设我们有：

class Person {
    std::string name;
    unsigned int age;
}

class PersonNamedJared {
}

理论上，我们不需要这个子类中的字段“name”，因为它总是“Jared”，这可以提高内存效率。

通过用我们简单地覆盖以始终返回“Jared”Person的get_name()函数替换“name”字段来实现这一点是唯一的方法PersonNamedJared吗？我们如何仍然在基类中创建 name 变量？

我知道这个例子是非常糟糕的做法，但这是我能想到的最好的做法。我认为实施这种模式是有正当理由的。