一些答案最初有这种排序算法：
\nfor i from 0 to n-1:\n for j from 0 to n-1:\n if A[j] > A[i]:\n swap A[i] and A[j]\n请注意， 和i都j在整个范围内，因此j可以比 更大和更小i，因此它可以使对的顺序正确和错误（实际上它确实两者都做！）。我认为这是一个错误（作者后来这样称呼它），这会使数组变得混乱，但它似乎排序正确。但原因尚不清楚。但代码简单（全方位，并且没有+1像冒泡排序那样）使它变得有趣。
这是对的吗？如果是这样，为什么它有效？它有名字吗？
\nPython 实现与测试：
\nfrom random import shuffle\n\nfor _ in range(3):\n n = 20\n A = list(range(n))\n shuffle(A)\n print(\'before:\', A)\n\n for i in range(n):\n for j in range(n):\n if A[j] > A[i]:\n A[i], A[j] = A[j], …检查列表是否包含奇数的两种类似方法：
any(x % 2 for x in a)
any(True for x in a if x % 2)
计时结果a = [0] * 10000000（每次尝试五次，时间以秒为单位）：
any(x % 2 for x in a)
any(True for x in a if x % 2)
为什么第二种方式几乎快两倍？
我的测试代码：
from timeit import repeat
setup = 'a = [0] * 10000000'
expressions = [
'any(x % 2 for x in a)',
'any(True for x in a if x % 2)',
]
for expression in expressions:
times = sorted(repeat(expression, …简短版本：如果s是字符串，则s = s + \'c\'可以就地修改字符串，但t = s + \'c\'不能。但是操作如何s + \'c\'知道它处于哪种场景呢？
长版：
\nt = s + \'c\'需要创建一个单独的字符串，因为程序随后需要旧字符串 ass和新字符串 as t。
s = s + \'c\'如果是唯一的引用，则可以就地修改字符串s，因为程序只想s成为扩展字符串。如果末尾有多余字符的空间，CPython 实际上会执行此优化。
考虑这些重复添加字符的函数：
\ndef fast(n):\n s = \'\'\n for _ in range(n):\n s = s + \'c\'\n t = s\n del t\n\ndef slow(n):\n s = \'\'\n for _ in range(n):\n t = s …有人刚刚问为什么sum(myfloats)不同sum(reversed(myfloats))。很快就被骗到浮点数学坏了吗？并删除。
但这让我很好奇：仅仅通过以不同的顺序求和，我们可以从很少的浮点数中得到多少个不同的总和？使用三个浮点数，我们可以得到三个不同的总和：
>>> from itertools import permutations
>>> for perm in permutations([0.2, 0.3, 0.4]):
print(perm, sum(perm))
(0.2, 0.3, 0.4) 0.9
(0.2, 0.4, 0.3) 0.9000000000000001
(0.3, 0.2, 0.4) 0.9
(0.3, 0.4, 0.2) 0.8999999999999999
(0.4, 0.2, 0.3) 0.9000000000000001
(0.4, 0.3, 0.2) 0.8999999999999999
我相信加法对于浮点数来说是可交换的（即a + b == b + a）。我们对第一对相加有三个选择，然后对第二个相加有一个“选择”，所以三个和是我们仅用三个值就能得到的最多结果。
我们可以得到三个以上具有四个值的不同总和吗？经过一些实验，我没有发现这样的情况。如果我们不能：为什么不呢？如果可以的话：有多少？五有多少？
正如埃里克刚刚指出的，对于三个以上的值，除了从左到右求和之外，还有不同的可能性，例如(a+b) + (c+d)。我对任何添加数字的方式感兴趣。
注意我说的是 64 位浮点数（我是 Python 爱好者，我知道在其他语言中它们通常被称为双精度浮点数）。
我想检查列表是否是有效的块序列，其中每个块以某个值开始，以下一次出现的相同值结束。例如，这是三个块的有效序列：
lst = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9, 0, 4, 5, 2]
\___________/ \_____/ \_______________________/
这是无效的：
lst = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9, 0, 4]
\___________/ \_____/ \_____ ... missing the 2 to end the chunk
我有一个解决方案，但它很糟糕。你看到更好的东西了吗？
def is_valid(lst):
while lst:
start = lst.pop(0)
if start not in lst:
return False
while lst[0] != start:
lst.pop(0)
lst.remove(start)
return True
# Tests, should …HackerRank 的请求：
\n\n\n如果客户在特定日期的支出金额大于或等于 2\xc3\x97 客户在过去几天的平均支出，他们会向客户发送有关潜在欺诈的通知。银行不会向客户发送任何通知，直到他们至少拥有前几天的交易数据的跟踪数据。
\n给定跟踪天数d和客户在n天期间的每日总支出，确定客户在所有n天内收到通知的次数。
\n
我的代码可以解决问题，但是对于大型测试用例来说有时间限制。我的代码无法通过时间限制要求。我的代码实际上很短：
\nfrom statistics import median\n\nfirst_multiple_input = input().rstrip().split()\nn = int(first_multiple_input[0])\nd = int(first_multiple_input[1])\nexpenditure = list(map(int, input().rstrip().split()))\ncount=0\nfor i in range(len(expenditure)-d):\n if expenditure[d+i] >= 2*median(expenditure[i:d+i]) :\n count+=1\nprint( count)\n请指出造成延误的原因以及如何改善。
\n帮助理解代码的小测试用例：
\n9 5 expenditure[] size n =9, d = 5\n2 3 4 2 3 6 8 4 5 expenditure = [2, 3, 4, 2, 3, 6, 8, 4, 5]\n我觉得这是一个非常简单的问题，但我找不到解决方案。
给定一个真/假值的布尔数组，我需要输出所有值为“假”的索引。我有办法做到这一点：
测试= [真假真真]
test1 = np.where(test)[0]
这将返回 [0,2,3]，换句话说，每个真值的相应索引。现在我需要为 false 获得相同的结果，其中输出为 [1]。有人知道怎么做吗？
当我将相同的float值重新插入我的集合几次时，x in s应该花费恒定时间的检查变得非常缓慢。为什么？
计时输出x in s：
0.06 microseconds
0.09 microseconds
0.16 microseconds
0.56 microseconds
1.00 microseconds
1.58 microseconds
2.55 microseconds
5.98 microseconds
10.50 microseconds
24.54 microseconds
40.39 microseconds
96.60 microseconds
160.24 microseconds
419.08 microseconds
732.27 microseconds
代码（在线试用！）：
from timeit import timeit
s = {float('nan')}
for _ in range(15):
for _ in [*s]:
x = float('nan')
s.add(x)
time = timeit('x in s', number=1000, globals=globals()) * 1e3
print('%7.2f microseconds' % time)
我想用管道“包围”字符串中的所有字符：
'abc' => '|a|b|c|'
'abcde' => '|a|b|c|d|e|'
'x' => '|x|'
'' => '|'
有什么好的方法可以做到这一点，最好是作为单行表达式？这是一种循环方式：
s = 'abcde'
t = '|'
for c in s:
t += c + '|'
print(t) # |a|b|c|d|e|