小编TLW*_*TLW的帖子

C标准的哪个版本(如果有的话)是如何明确定义的？

void foo(void) {
    char *nullPtr = NULL;
    &*nullPtr;
}

请注意,我没有将结果分配给任何东西 - 第二行是一个简单的语句.

这应该是一个有明显答案的问题,但是(就像在这些问题上看似经常发生的那样)我听到的同样有很多人说答案"明显未定义"为"明确定义".

在一个相当相关的说明,以下是什么？应该foo产生一个c？

extern volatile char c;

void bar(void) {
    volatile char *nonnullptr = &c;
    &*nonnullptr;
}

(相同问题的C++版本:在C++中是否&*NULL定义良好？)

如何合理有效地找到通过重复应用替换输入序列给出的最短可能输出？我相信(如果我错了,请纠正我),这是最坏情况下的指数时间,但由于下面的第二个限制,我不确定.天真的方法当然是.

我尝试编写天真的方法(对于所有可能的替换,对于所有有效位置,在该位置应用替换后递归输入的副本.返回所有有效递归中的最短和输入,并在函数上使用缓存捕获等效的替换序列),但它(不可行)缓慢,我很确定这是一个算法问题而不是实现.

可能(或可能不)产生影响的一些事情:

• 令牌是枚举类型.
• 地图中每个条目的输出长度严格小于条目的输入.
• 我并不需要做了哪里,只是结果序列什么替代品.

所以,作为一个例子,每个字符都是一个标记(为了简单起见),如果我有替换地图为aaba- > a,aaa- > ab和aba- > bb,我应用minimalString('aaaaa'),我想得到'a ".

实际的方法签名大致如下:

List<Token> getMinimalAfterReplacements(List<Token> inputList, Map<List<Token>, List<Token>> replacements) {
    ?
}

有比蛮力更好的方法吗？如果没有,例如,是否有可以利用的SAT库或类似物？是否有任何地图预处理可以通过不同的令牌列表多次调用但使用相同的替换映射来使其更快？

所以,我有一个可重复的3元组,懒得生成.我试图找出如何将其转换为3个迭代,分别由元组的第一,第二和第三个元素组成.但是,我希望这可以懒得做.

因此,举例来说,我希望[(1, 2, 3), (4, 5, 6), (7, 8, 9)]将变成[1, 4, 7],[2, 5, 8],[3, 6, 9].(除非我想要iterables而不是列表.)

标准zip(*data)习惯用法不起作用,因为参数解包扩展了整个迭代.(您可以通过注意zip(*((x, x+1, x+2) for x in itertools.count(step=3)))挂起来验证这一点.)

到目前为止,我提出的最好的是以下内容:

def transpose(iterable_of_three_tuples):
    teed = itertools.tee(iterable_of_three_tuples, 3)
    return map(lambda e: e[0], teed[0]), map(lambda e: e[1], teed[1]), map(lambda e: e[2], teed[2])

这似乎有效.但它似乎不像干净的代码.而且它做了很多看似不必要的工作.

C++标准的哪个版本(如果有的话)是以下定义明确的？

void foo(void) {
    char *nullPtr = NULL;
    &*nullPtr;
}

请注意,我在&*nullPtr这里特别询问.我知道这只是*nullPtr未定义的 - 但这是一个单独的问题,因此当前链接的"重复"不是重复的.

请注意,我没有将结果分配给任何东西 - 第二行是一个简单的语句.

这应该是一个有明显答案的问题,但是(就像在这些问题上看似经常发生的那样)我听到的同样有很多人说答案"明显未定义"为"明确定义".

在一个相当相关的说明,以下是什么？应该foo产生一个c？

extern volatile char c;

void bar(void) {
    volatile char *nonnullptr = &c;
    &*nonnullptr;
}

(相同问题的C版本:C中的&*NULL定义良好吗？)

我试图将使用struct hack转换为使用灵活的数组成员,只是遇到以下错误消息:

错误:使用灵活数组成员的结构无效

(GCC 4.8.1,gnu99,MinGW)

在尝试追踪消息的原因之后,我将其提炼到以下相对最小的情况:

struct a {
    union {
        struct {
            int b;
            int c[];
        } d;
    } e;
};

换句话说,具有灵活数组成员的结构看不到能够放入结构中的并集内,即使联合是结构的最后一个成员.

(请注意,将一个灵活的数组成员直接放在联合内部似乎确实有效.)

现在:除了恢复结构黑客(将c声明为长度为1的数组)之外,还有什么方法可以解决这个问题吗？指向联合内部结构的指针可以工作,但是会遇到额外的间接层.

我正在寻找以下原子版:

import os

def tryMakeFile(filename):
    try:
        with open(filename) as _:
            return False
    except FileNotFoundError:
        with open(filename, mode='a') as _:
            return True

(请不要在这里评论文体问题 - 我知道这个代码在很多方面都很糟糕,但它足以说明我的问题.)

换句话说,我正在寻找一种方法来检查文件是否存在,如果不存在则创建它,在Python中,以我知道发生了哪种方式.但是这样做的方式是在多个进程之间没有竞争条件(在我给出的示例代码中,两个进程都可以认为他们创建了文件,如果第二个进程运行,而第一个进程在第一个和第二个进程之间暂停调用).

或者,换句话说,我正在寻找与Java的Files.createFile调用相当的Python .

编辑:请注意,当我说"Python"时,我的意思是"便携式Python".说"使用这个库*(*这个库只在Windows上可用,或者不在Windows上,或者仅在蓝月亮后的第二个星期二)"并不是我想要的.我正在寻找明确原子的东西,标准库和/或内置的一部分,并且它可以在通用平台上使用.

有没有一种相对便宜的方法将存储在 a 中的 16x16 位矩阵的四个边（第 0 行和第 15 行，以及第 0 行和第 15 列）提取到 a__m256i的四个 16b 通道中__m256i？我不关心输出到哪个通道，或者寄存器的其余部分是否有垃圾。轻度偏好所有这些都处于下半部分，但只是轻度。

提取“顶部”和“底部”很容易 - 只需向量的第一个和最后 16b 个元素即可完成 - 但侧面是另一回事。您需要每个 16b 元素的第一位和最后一位，这会变得很复杂。

您可以使用完整的位转置来完成此操作，如下所示：

// Full bit-transpose of input viewed as a 16x16 bitmatrix.
extern __m256i transpose(__m256i m);

__m256i get_edges(__m256i m) {
    __m256i t = transpose(m);
    // We only care about first and last u16 of each
    // m = [abcdefghijklmnop]
    // t = [ABCDEFGHIJKLMNOP]
    m = _mm256_permutevar8x32_epi32(m, _mm256_set_epi32(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, …

假设有一个快速且无偏的输入 PRNG，是否有一种高性能方法可以生成无偏 64b 随机整数，而无需连续设置 3 个位？我不关心输入源的“浪费位”。

也就是说，比简单的拒绝抽样方法更好：

uint64_t r;
do {
    r = get_rand_64();
} while (r & (r >> 1) & (r >> 2));

...它“有效”，但非常慢。看起来平均迭代次数约为 187 倍左右。

我探索过的一种可能性大致是：

bool p2 = get_rand_bit();
bool p1 = get_rand_bit();
uint64_t r = (p1 << 1) | p2;
for (int i = 2; i < 64; i++) {
    bool p0 = (p1 && p2) ? false : get_rand_bit();
    r |= p0 << i;
    p2 = p1;
    p1 = p0;
}

...但是，这仍然很慢。主要是因为使用这种方法整个计算是位串行的。编辑：这也是有偏见的。最容易看出的是 …

我一直在玩一种简单的基于堆栈的语言，我发现自己反复做的一件事就是手动优化代码块。

我想“嘿，这看起来很像计算机可以做的事情！具有明确目标和语义的重复工作。”。但是环顾四周，我找不到关于优化堆栈机器代码的任何内容。注册机器，是的。但不是基于堆栈的语言。这似乎是对“您如何优化堆栈机器代码？”的普遍回应。是“不要”。

那么：如何优化堆栈机器码？除了简单的窥孔优化之外，还有其他通用方法吗？有没有自动生成窥视孔优化的方法？

是否有一种亚 O(n) 方法¹可以在 IEEE 754 算术中复制浮点值的重复求和？

也就是说，是否有一种更快的方法可以精确^复制以下伪代码的结果：

f64 notQuiteFMA(f64 acc, f64 f, bigint n) {
    for (bigint i = 0; i < n; i++) {
        acc = acc + f;
    }
    return acc;
}

？³

在实际算术中，答案很简单——return acc + f*n就足够了。然而，在有限精度下，答案要复杂得多。作为一个例子，请注意notQuiteFMA(0, 1, 1 << 256)大约是⁴ 2^53，而不是人们期望的无限精度的 2^256。（这个例子还说明了为什么加快计算速度可能是可取的 - 计数到 2^256 是相当不切实际的。）

1. 我知道这整个事情在技术上可以在 O(1) 时间⁵内完成，使用 2^128 条目查找表，每个条目都有一个 2^64 元素的数组；请忽略此类银河算法。acc（鸽巢原理 - 在进入循环之前，重复加法不能进行超过 2^64 步 - 因此“只需”为和的每个初始值存储整个前缀和最终循环中的步数f。）
2. 给定当前舍入模式的位精确（至少忽略非信号 …