相关疑难解决方法(0)

昨天我把干净的洗衣店的袜子配对,弄清楚我做的方式效率不高.我正在做一个天真的搜索 - 挑选一个袜子并"迭代"堆,以找到它的对.这需要迭代在n/2*N/4 = N ² /8上平均的袜子.

作为一名计算机科学家,我在想我能做什么？当然,为了实现O(NlogN)解决方案,我们会想到排序(根据大小/颜色/ ...).

哈希或其他非就地解决方案不是一种选择,因为我无法复制我的袜子(尽管如果可能的话可能会很好).

所以,问题基本上是:

给出一堆n袜子,包含2n元素(假设每个袜子只有一对匹配),有效配对多达对数额外空间的最佳方法是什么？(我相信如果需要的话我会记住那些信息.)

我将感谢一个解决以下方面的答案:

• 大量袜子的一般理论解决方案.
• 袜子的实际数量并不是那么大,我不相信我的配偶和我有超过30双.(并且很容易区分我的袜子和她的袜子;这也可以使用吗？)
• 它是否等同于元素清晰度问题？

我生成了两个1000x 矩阵1000:

第一矩阵:O和#.
第二个矩阵:O和B.

使用以下代码,第一个矩阵需要8.52秒才能完成:

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        if(r.nextInt(4) == 0) {
            System.out.print("O");
        } else {
            System.out.print("#");
        }
    }

   System.out.println("");
 }

使用此代码,第二个矩阵需要259.152秒才能完成:

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) …

如何在C/C++中设置,清除和切换？

如何在C#中生成随机整数？

我一直在寻找最快的方法来处理popcount大数据.我遇到了一个很奇怪的效果:改变从循环变量unsigned至uint64_t50%在我的电脑上所做的性能下降.

基准

#include <iostream>
#include <chrono>
#include <x86intrin.h>

int main(int argc, char* argv[]) {

    using namespace std;
    if (argc != 2) {
       cerr << "usage: array_size in MB" << endl;
       return -1;
    }

    uint64_t size = atol(argv[1])<<20;
    uint64_t* buffer = new uint64_t[size/8];
    char* charbuffer = reinterpret_cast<char*>(buffer);
    for (unsigned i=0; i<size; ++i)
        charbuffer[i] = rand()%256;

    uint64_t count,duration;
    chrono::time_point<chrono::system_clock> startP,endP;
    {
        startP = chrono::system_clock::now();
        count = 0;
        for( unsigned k = 0; k < …

我正在尝试各种方法来实现一个顺序给出pi数字的程序.我尝试了泰勒系列方法,但事实证明它非常缓慢地收敛(当我在一段时间后将我的结果与在线值进行比较时).无论如何,我正在尝试更好的算法.

因此,在编写程序时,我遇到了问题,就像所有算法一样:我怎么知道n我计算的数字是准确的？

" 缓存不友好代码 "和" 缓存友好 "代码之间有什么区别？

如何确保编写高效缓存代码？

请参阅相关的.NET问题

我正在寻找一种快速简便的方法来完成与分裂完全相反的方式,以便它 ["a","b","c"]能够成为"a,b,c"

迭代数组需要添加条件(如果这不是最后一个元素,添加分隔符)或使用子字符串删除最后一个分隔符.

我确信有一种经过认证的有效方法(Apache Commons？)

您更喜欢在项目中做到这一点？

我在2009年首先注意到GCC(至少在我的项目和我的机器上)如果我优化尺寸(-Os)而不是速度(-O2或-O3),则会产生明显更快的代码,我一直想知道为什么.

我设法创建(相当愚蠢)代码,显示这种令人惊讶的行为,并且足够小,无法在此处发布.

const int LOOP_BOUND = 200000000;

__attribute__((noinline))
static int add(const int& x, const int& y) {
    return x + y;
}

__attribute__((noinline))
static int work(int xval, int yval) {
    int sum(0);
    for (int i=0; i<LOOP_BOUND; ++i) {
        int x(xval+sum);
        int y(yval+sum);
        int z = add(x, y);
        sum += z;
    }
    return sum;
}

int main(int , char* argv[]) {
    int result = work(*argv[1], *argv[2]);
    return result;
}

如果我用-Os它编译它,执行这个程序需要0.38秒,如果用-O2 …

我正在用Java编写一些代码,在某些时候,程序的流程是由两个int变量"a"和"b"是否为非零来确定的(注意:a和b从不是负数,并且从不在整数溢出范围内).

我可以评估它

if (a != 0 && b != 0) { /* Some code */ }

或者

if (a*b != 0) { /* Some code */ }

因为我希望每段代码运行数百万次,所以我想知道哪一段会更快.我通过在一个巨大的随机生成的数组上进行比较来做实验,我也很想知道数组的稀疏性(数据的分数= 0)会如何影响结果:

long time;
final int len = 50000000;
int arbitrary = 0;
int[][] nums = new int[2][len];

for (double fraction = 0 ; fraction <= 0.9 ; fraction += 0.0078125) {
    for(int i = 0 ; i < 2 ; i++) {
        for(int j = 0 ; j < len ; j++) …