小编qwr*_*qwr的帖子

我使用大量坐标向量编写了一个迷宫程序。测试100x100的网格，当我使用vector<int>该程序时花了383秒，但当我使用时pair<int,int>只花了13秒。这种戏剧性的加速从何而来？

代码如下：（还有待完善）

#include <iostream>
#include <vector>
#include <stdlib.h>
#include <time.h>
#include <string>
#include <algorithm>
#include <utility>
using namespace std;

const int HEIGHT = 100, WIDTH = 100;

bool in_bounds(int x, int y)
{
    // Cells (0,0) to (WIDTH-1, HEIGHT -1)
    return (x >= 0 && x < WIDTH && y >= 0 && y < HEIGHT);
}

bool in_vector(int x, int y, vector<pair<int,int> > v)
{
    return find(v.begin(), v.end(), pair<int,int>(x,y)) != v.end();
}

vector<string> get_dir(int x, …

GMPY2(或GMP)有一个powmod功能,但除了python的原生之外我找不到任何常规取幂pow.mpz整数是否存在这样的函数？

GNU grep 的基本 (BRE) 和扩展 (ERE) 语法记录在https://www.gnu.org/software/grep/manual/html_node/Regular-Expressions.html，PCRE 总结在man pcresyntax，但没有明确的比较。GNU grep 的基本/扩展正则表达式和 PCRE ( ) 正则表达式有什么区别-P？

在 Python 3 中，bytes需要一个编码：

bytes(s, encoding="utf-8")

有没有办法设置默认编码，所以bytes总是用 UTF-8 编码？

我想象的最简单的方法是

def bytes_utf8(s):
    return bytes(s, encoding="utf-8") 

在这个高尔夫答案中，我看到了一个技巧，其中返回值是未传入的第二个参数。

int f(i, j) 
{
    j = i;   
}

int main() 
{
    return f(3);
}

从gcc 的汇编输出来看，当代码复制时，j = i它存储的结果eax恰好是返回值。

f:
        pushq   %rbp
        movq    %rsp, %rbp
        movl    %edi, -4(%rbp)
        movl    %esi, -8(%rbp)
        movl    -4(%rbp), %eax
        movl    %eax, -8(%rbp)
        nop
        popq    %rbp
        ret
main:
        pushq   %rbp
        movq    %rsp, %rbp
        movl    $3, %edi
        movl    $0, %eax
        call    f
        popq    %rbp
        ret 

那么，这一切仅仅是因为幸运吗？gcc 对此有记录吗？它只适用于，但它适用于我尝试过-O0的一堆值，以及一堆不同版本的 GCC。i-m32

该程序遍历1到400的4个数字的每个组合,并查看可以从产品中制作多少个唯一数字.我相信unordered_set用来保存已经检查的数字太大了,因此它退出了; 任务经理告诉我它是1.5 GB.

有什么方法可以让这个代码运行？我认为可能会拆分该组或以某种方式找到更有效的公式.

注意:根据评论,我想再说一遍,我没有存储所有250亿个数字.我只存储~100,000,000个号码.问题有RANGE400,但我正在寻找一个全面的解决方案,可以处理500,甚至1000没有内存问题.

#include <iostream>
#include <unordered_set>
using namespace std;

const int RANGE = 400;

int main(){

    unordered_set<long long> nums;

    for(long long a=1; a<=RANGE; a++)
    {
        for(long long b=a; b<=RANGE; b++)
        {
            for(long long c=b; c<=RANGE; c++)
            {
                for(long long d=c; d<=RANGE; d++)
                {
                    unordered_set<long long>::const_iterator got = nums.find(a*b*c*d);
                    if (got == nums.end())
                    {
                        nums.insert(a*b*c*d);
                    }
                }
            }
        }
        cout << a << endl;
    }

    cout << nums.size() << endl;

    return 0;
}

我知道已经有一个与此类似的问题，但我想使用 GMPY2（或与 GMP 类似的东西）加快速度。这是我当前的代码，它很不错，但可以更好吗？

编辑：新代码，检查除数 2 和 3

def factors(n):
    result = set()
    result |= {mpz(1), mpz(n)}


    def all_multiples(result, n, factor):
        z = mpz(n)
        while gmpy2.f_mod(mpz(z), factor) == 0:
            z = gmpy2.divexact(z, factor)
            result |= {mpz(factor), z}
        return result

    result = all_multiples(result, n, 2)
    result = all_multiples(result, n, 3)

    for i in range(1, gmpy2.isqrt(n) + 1, 6):
        i1 = mpz(i) + 1
        i2 = mpz(i) + 5
        div1, mod1 = gmpy2.f_divmod(n, i1)
        div2, mod2 = gmpy2.f_divmod(n, i2)
        if mod1 == …

据我所知,GMPY2支持GMP库,而numpy拥有快速数值库.我想知道速度与用GMP实际编写C(或C++)代码相比如何.由于Python是一种脚本语言,我认为它不会像编译语言一样快,但我之前对这些概括我错了.

我不能让GMP在我的电脑上工作,所以我不能进行任何测试.如果可以,只需要一般数学,如加法,也许还有一些触发功能.我稍后会弄清楚GMP.

我发现python的乌龟实现速度非常慢.我预计会有一些延迟,但不会等待相对简单的分形(5次迭代的Koch曲线).

即使设置后turtle.speed(0)它仍然很慢.也许有一个错误,因为它不像文档中声称的那样瞬间？

这个答案建议通过隐藏窗口来重新实施海龟.类似的问题没有答案.我错过了什么,或者正在重新实施的方式去？

这是我的精简代码(l系统的创建几乎是瞬间的):

import turtle

def l_system(V, w, P, n):
    current = w

    for i in range(n):
        current = [P[x] if x in P else x for x in list(current)]
        current = ''.join(current)

    return current

def run_turtle(var, start, rules, iters, angle, size, scale):
    terry = turtle.Turtle()
    terry.pensize(1)
    terry.pencolor("blue")
    terry.speed(0)

    dist = size / ((iters + 1) ** scale)
    positions = []
    angles = []

    instructions = l_system(var, start, rules, iters)

    for instr in …

据我所知，使用 objdump，使用 gas

.section .text

和

.text

是等价的。这是真的？

来自气体手册.section name：

使用该.section指令将以下代码组装到名为name的节中。

来自气体手册.text小节：

告诉as将以下语句组合到编号为subsection的文本小节的末尾，这是一个绝对表达式。如果第被省略，则使用分段数为零。

我的问题也适用于.data.

我目前正在使用PhotoImage和tkinter逐像素地绘制Mandelbrot.我基本上使用的算法没有任何修改.有没有办法让计算更快？也许快速填充大面积的颜色,或预先计算常数？

部分代码:

ITERATIONS = 50
WIDTH, HEIGHT = 600, 600
CENTER = (-.5, 0)
DIAMETER = 2.5

def mandel(c):
    z = 0
    for i in range(ITERATIONS):
        z = z**2 + c
        if abs(z) > 2:
            return i     
    return ITERATIONS

root = Tk()
canvas = Canvas(root, width=WIDTH,height=HEIGHT)
canvas.pack()
img = PhotoImage(width=WIDTH, height=HEIGHT)
canvas.create_image((WIDTH/2, HEIGHT/2), image=img, state="normal")


real = CENTER[0] - 0.5 * DIAMETER
imag = CENTER[1] - 0.5 * DIAMETER

def color(i):
    colors = ("#0000AA", "#88DDFF", "#FF8800", "#000000")
    if i == …

verilog 中的$display与$strobe与$monitor 有什么区别？当在事件队列中时，每个都适用，语句如何交互？任何声明都可以抑制另一个声明吗？

CSS规则header不适用于Chrome或Firefox,但section确实适用于JSFiddle.

HTML:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
<div id="header">
    <h1>Test</h1>
</div>

<div id="section">
    <p>test</p>
</div>
</body>
</html> 

style.css中:

<style>
#header {
    background-color: #f0fff0;
    color: #262626;
    text-align: center;
}
#section {
    text-align: center;
}
</style>

小提琴