1. 循环列表，构建一个 hashtable, 初始 T[item] = 0;
2. 循环列表，T[item] += 1
3. 按值排序 T, 方法具体找找 stackoverflow

现用 XZ2，感觉挺好的，流畅，不怎么发热，我不怎么玩儿手机所以待机时间也不错。

锻炼，跑起来。不想跑步找人打球，拼个输赢的运动还是很 high 的

xbox1x

布地奈德喷剂和生理盐水洗鼻子。不严重的话大约 15 天能好。

21 天精通 C++
21 天精通 Java
21 天精通 PHP
21 天精通 C 语言
21 天精通素描
21 天精通攻防策略

要是读数据的话可以试试 pandas
import pandas as pd
f = pd.read_csv(<file_name>, chunksize =10000, ...)
更多参数看 https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html
然后
for chunk in f:
do_sth(chunk)

EDIT:
1. [ (i, j) for i,x in enumerate(a) for j,y in enumerate(a) if i<j and x + y == target ]
2. [ idxes for idxes in ( (i, binary_search(a, target - x, i+1, n-1) ) for i, x in enumerate(a) ) if idxes[1] != -1 ]


def binary_search(arr, hkey, start, end):
....while start <= end:
........mid = start + (end - start) // 2
........if arr[mid] < hkey:
............start = mid + 1
........elif arr[mid] > hkey:
............end = mid - 1
........else:
............return mid
....return -1

假定数组是 a，长度是 n, [ (i, j) for i,x in enumerate(a) for j,y in enumerate(a) if x + y == target and i<j ] 比较直观，复杂度是 O(n^2)，大致看了下，至少你的 a!=i 就不允许列表中出现重复元素；并且最后也少放了另一个元素 a 的标号在结果里。

第二个就是用 binary_search，当然，假定你的数组 a 是排好序的：

[ idxes for idxes in ( (i, binary_search(target - x, i+1, n)) for i, x in enumerate(a) ) if idxes[1] != -1 ]，比如用楼上那个失败返回 -1 的 binary_search，这样是 O(nlog(n))

np.vstack([a, b]).T

@takato 一般只是在弥补白天开着篇文献就一直在看剧刷新闻的羞耻心。。。

In [1]: a = np.array([ 0, 1, 2, 3, 6, 7, 8, 9, 10, 12, 14, 15, 16, 17, 18, 19, 23, 24, 27, 28, 29, 30])

In [2]: np.split(a,np.argwhere(np.diff(a-np.arange(a.shape[0]))!=0).flatten()+1)
Out[2]:
[array([0, 1, 2, 3]),
array([ 6, 7, 8, 9, 10]),
array([12]),
array([14, 15, 16, 17, 18, 19]),
array([23, 24]),
array([27, 28, 29, 30])]

学古典拉丁语。TTC latin 101，资料比较好搜。看到 20 几节课的时候买本韦洛克。我已经走出阴影，顺带着多了一门很装逼的技能，现在打算再好好学学意大利语，用手机的多邻国应用。学一阵会感觉多很多自信，在有时间空余和寂寞的时候也有个可以思考的目标，目前感觉工作什么都顺利了很多。

A = np.array([[1,1,0,0],[0,0,1,-1],[1,0,1,0],[0,1,0,1]])
b = np.array([8,6,13,8])
np.linalg.sovle(A,b)

你是想写程序把这个方程的 A，b 求出来吗？

嗯……也许可以更 numpy 一点:
Cij = Cij[:, np.argsort(p)]
p = p[np.argsort(p)] # 价格和接受能力从低到高排序
d = (Cij - p) >0
sum([p[_][-1] for _ in d]) #每个客户都买可接受的最贵产品。如果允许一个客户重复购买，不允许多个客户重复购买某商品是不是没意义……我有点脑残。

先对价格排序，然后从最大价格商品起（不应该是 Cij >= Pj 才买么……），对 Ci 进行遍历，如果商品能重复卖出，那么所有能承受最大价格的都买下最大价格的商品，然后价格第二大的商品……
s=0
for p in sorted(P)[::-1]:
....for i,c in enumerate(Cij):
........if (p<=c).any():
............s += p
............Cij[i]=-1 # 买过一次就不能再买
............break # 如果商品也不能重复

方法笨了点，我自己生成了几个好像可以……用的是 numpy 数组的写法。

有意思。我的解决方案是先算不定方程，求出来所有可能组合，然后对每个组合算全排列(distin with duplicate)……也就是 112 的排列只有 112,121,211 这样。这个排列很耗时……