月度归档:2016年05月

javascript数组完全随机排列(洗牌算法、shuffle算法)

关于错误算法的前言:(可以当做废话跳过,不谢)

  • 采用javascript的sort方法实现的随机洗牌算法是错误的。
  • 基于冒泡排序、插入排序等常规排序算法实现的随机洗牌算法是错误的。

采用排序实现的随机洗牌算法具体错误原理本文就不描述了,尔等可以用结尾的测试代码自行实验。大体来讲最终排序的结果是受排序前的状态影响,可以理解为排序前是正叙的话,结果也整体偏向于正序,排序前是倒序的话,结果也偏向于倒序。

进入主题:

随机算法代码:

时间复杂度为O(n).

function shuffle(array) {
  var m = array.length, t, i;

  // 处理余下待随机排序的元素…
  while (m) {

    // 取到一个带排序的元素…
    i = Math.floor(Math.random() * m--);

    // 把它和当前剩余元素序列的最后一个元素交换位置.
    t = array[m];
    array[m] = array[i];
    array[i] = t;
  }

  return array;
}

在上面的算法里,我们每一次循环从前 len – i 个元素里随机一个位置,将这个元素和第 len – i 个元素进行交换,迭代直到 i = len – 1 为止。

洗牌算法、shuffle算法 洗牌算法、shuffle算法 洗牌算法、shuffle算法 洗牌算法、shuffle算法 洗牌算法、shuffle算法

为了证明这个算法的正确性,我们设计一个测试的方法。假定这个排序算法是正确的,那么,将这个算法用于随机数组 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],如果算法正确,那么每个数字在每一位出现的概率均等。因此,将数组重复洗牌足够多次,然后将每次的结果在每一位相加,最后对每一位的结果取平均值,这个平均值应该约等于 (0 + 9) / 2 = 4.5,测试次数越多次,每一位上的平均值就都应该越接近于 4.5。所以我们简单实现测试代码如下:

function shuffle(array) {
  var m = array.length, t, i;

  // 处理余下待随机排序的元素…
  while (m) {

    // 取到一个带排序的元素…
    i = Math.floor(Math.random() * m--);

    // 把它和当前剩余元素序列的最后一个元素交换位置.
    t = array[m];
    array[m] = array[i];
    array[i] = t;
  }

  return array;
}

var arr = [0,1,2,3,4,5,6,7,8,9]; 
var res = [0,0,0,0,0,0,0,0,0,0]; 

var t = 10000; 
for(var i = 0; i < t; i++) { 
  var sorted = shuffle(arr.slice(0));
  sorted.forEach(function(o,i){ res[i] += o; }); 
}

res = res.map(function(o) { 
  return o / t; 
});

console.log(res);

测试结果:

40E72288-BCAE-4FA7-959E-7F5873EF6C5C

随机性的数学归纳法证明

对 n 个数进行随机:

  1. 首先我们考虑 n = 2 的情况,根据算法,显然有 1/2 的概率两个数交换,有 1/2 的概率两个数不交换,因此对 n = 2 的情况,元素出现在每个位置的概率都是 1/2,满足随机性要求。
  2. 假设有 i 个数, i >= 2 时,算法随机性符合要求,即每个数出现在 i 个位置上每个位置的概率都是 1/i。
  3. 对于 i + 1 个数,按照我们的算法,在第一次循环时,每个数都有 1/(i+1) 的概率被交换到最末尾,所以每个元素出现在最末一位的概率都是 1/(i+1) 。而每个数也都有 i/(i+1) 的概率不被交换到最末尾,如果不被交换,从第二次循环开始还原成 i 个数随机,根据 2. 的假设,它们出现在 i 个位置的概率是 1/i。因此每个数出现在前 i 位任意一位的概率是 (i/(i+1)) * (1/i) = 1/(i+1),也是 1/(i+1)。
  4. 综合 1. 2. 3. 得出,对于任意 n >= 2,经过这个算法,每个元素出现在 n 个位置任意一个位置的概率都是 1/n。

参考文章:

  • https://bost.ocks.org/mike/shuffle/
  • https://www.h5jun.com/post/array-shuffle.html

李彦宏内部信:强调用户至上 牺牲收入在所不惜

今天上午,百度公司董事长兼CEO李彦宏今日面向全员发出内部信,信中表示:强调用户至上,牺牲收入在所不惜。

李彦宏:用户至上

以下为李彦宏内部信全文:

勿忘初心  不负梦想

各位百度同学:

一月份的贴吧事件、四月份的魏则西事件引起了网民对百度的广泛批评和质疑。其愤怒之情,超过了以往百度经历的任何危机。

这些天,每当夜深人静的时候,我就会想:为什么很多每天都在使用百度的用户不再热爱我们?为什么我们不再为自己的产品感到骄傲了?问题到底出在哪里?

还记得创业初期的百度,那时我们主要在跟谷歌等竞争对手抢用户,但我更怕的是它去高价挖我们的人才,谷歌完全有实力给百度的工程师们开出三倍以上的工资待遇来。后来他们进来了,却几乎没有挖动我们什么人。细想起来,那个时候大家都憋着一股气,要做最好的中文搜索引擎。我们每个人每天都为自己做的事情感到特别自豪。那时候我们的招聘海报经常用一个名人的头像,在下面配一句简练的文字。比如用鲁迅的头像,下面配的文字就是:“是翻译,还是用创作寻找中国意义?”用钱学森,文字就是:“是在海外住别墅还是回中国做导弹之父?”用毛泽东,文字就是“是投降,还是比敌人更强”……一直到今天,每当我把这些词句说给后来人听时,都会几近哽咽。在这些梦想的感召下,我们去倾听用户的声音,去了解用户的需求,在实力相差极为悬殊的情况下,一点点地赢得了中国市场。是我们坚守用户至上的价值观为我们赢得了用户,也正是这些用户在贴吧里盖楼、在知道里回答问题、在百科里编写词条,他们创造的内容、贡献的信息,让我们区别于竞争对手,成就了百度的辉煌。

然而今天呢?我更多地会听到不同部门为了KPI分配而争吵不休,会看到一些高级工程师在平衡商业利益和用户体验之间纠结甚至妥协。用户也因此开始质疑我们商业推广的公平性和客观性,吐槽我们产品的安装策略,反对我们贴吧、百科等产品的过度商业化……因为从管理层到员工对短期KPI的追逐,我们的价值观被挤压变形了,业绩增长凌驾于用户体验,简单经营替代了简单可依赖,我们与用户渐行渐远,我们与创业初期坚守的使命和价值观渐行渐远。如果失去了用户的支持,失去了对价值观的坚守,百度离破产就真的只有30天!

今天,百度能影响的人比以往任何时候都更多,信息的流动比以往任何时候都更快,市场的环境比以往任何时候都更复杂,好的,坏的,美的,丑的,真的,假的,在网上都有。每天有无数的人会根据在百度搜到的结果去做决策,这也对我们的产品理念,行为准则提出了更高的要求。我们要与时俱进,为用户负责!

网民希望我们做的事儿,我们要顺应民心和民意,积极承担社会责任。哪些钱可以赚,怎么赚,关键时刻高管和员工如何选择,这些问题时刻考验着我们的商业道德和行为规范。我们在接下来的时间必须集中力量做好几件事:

首先,是重新审视公司所有产品的商业模式,是否因变现而影响用户体验,对于不尊重用户体验的行为要彻底整改。我们要建立起用户体验审核的一票否决制度,由专门的部门负责监督,违背用户体验原则的做法,一票否决,任何人都不许干涉。

其次,要完善我们的用户反馈机制,倾听用户的声音,让用户的意见能快速反映到产品的设计和更新中,让用户对产品和服务的评价成为搜索排名的关键因素。

最后,要继续完善现有的先行赔付等网民权益保障机制,增设10亿元保障基金,充分保障网民权益。

这些个措施,也许对公司的收入有负面影响,但我们有壮士断腕的决心,因为我相信,这是正确的做法!是长远的做法!是顺天应时的做法!

十年前,我们以搜索为基础,创立了贴吧、知道、百科等新产品;今天,我希望我们以人工智能为基础,把语音搜索、自动翻译、无人车做成影响人们日常生活的新产品。百度要跑完从大企业到伟大企业的长距离,要有拓展业务的“体力”,更要有坚守简单可依赖文化的“意志”。让我们坚守用户至上的价值观,为实现让人们平等便捷获取信息找到所求的使命努力拼搏,让我们的后人为我们所做的事情感到骄傲和自豪!

Robin

2016-5-10

计算机科学中最重要的32个算法

奥地利符号计算研究所(Research Institute for Symbolic Computation,简称RISC)的Christoph Koutschan博士在自己的页面上发布了一篇文章,提到他做了一个调查,参与者大多数是计算机科学家,他请这些科学家投票选出最重要的算法,以下是这次调查的结果,按照英文名称字母顺序排序。

  1. A* 搜索算法——图形搜索算法,从给定起点到给定终点计算出路径。其中使用了一种启发式的估算,为每个节点估算通过该节点的最佳路径,并以之为各个地点排定次序。算法以得到的次序访问这些节点。因此,A*搜索算法是最佳优先搜索的范例。
  2. 集束搜索(又名定向搜索,Beam Search)——最佳优先搜索算法的优化。使用启发式函数评估它检查的每个节点的能力。不过,集束搜索只能在每个深度中发现最前面的m个最符合条件的节点,m是固定数字——集束的宽度。
  3. 二分查找(Binary Search)——在线性数组中找特定值的算法,每个步骤去掉一半不符合要求的数据。
  4. 分支界定算法(Branch and Bound)——在多种最优化问题中寻找特定最优化解决方案的算法,特别是针对离散、组合的最优化。
  5. Buchberger算法——一种数学算法,可将其视为针对单变量最大公约数求解的欧几里得算法和线性系统中高斯消元法的泛化。
  6. 数据压缩——采取特定编码方案,使用更少的字节数(或是其他信息承载单元)对信息编码的过程,又叫来源编码。
  7. Diffie-Hellman密钥交换算法——一种加密协议,允许双方在事先不了解对方的情况下,在不安全的通信信道中,共同建立共享密钥。该密钥以后可与一个对称密码一起,加密后续通讯。
  8. Dijkstra算法——针对没有负值权重边的有向图,计算其中的单一起点最短算法。
  9. 离散微分算法(Discrete differentiation)
  10. 动态规划算法(Dynamic Programming)——展示互相覆盖的子问题和最优子架构算法
  11. 欧几里得算法(Euclidean algorithm)——计算两个整数的最大公约数。最古老的算法之一,出现在公元前300前欧几里得的《几何原本》。
  12. 期望-最大算法(Expectation-maximization algorithm,又名EM-Training)——在统计计算中,期望-最大算法在概率模型中寻找可能性最大的参数估算值,其中模型依赖于未发现的潜在变量。EM在两个步骤中交替计算,第一步是计算期望,利用对隐藏变量的现有估计值,计算其最大可能估计值;第二步是最大化,最大化在第一步上求得的最大可能值来计算参数的值。
  13. 快速傅里叶变换(Fast Fourier transform,FFT)——计算离散的傅里叶变换(DFT)及其反转。该算法应用范围很广,从数字信号处理到解决偏微分方程,到快速计算大整数乘积。
  14. 梯度下降(Gradient descent)——一种数学上的最优化算法。
  15. 哈希算法(Hashing)
  16. 堆排序(Heaps)
  17. Karatsuba乘法——需要完成上千位整数的乘法的系统中使用,比如计算机代数系统和大数程序库,如果使用长乘法,速度太慢。该算法发现于1962年。
  18. LLL算法(Lenstra-Lenstra-Lovasz  lattice reduction)——以格规约(lattice)基数为输入,输出短正交向量基数。LLL算法在以下公共密钥加密方法中有大量使用:背包加密系统(knapsack)、有特定设置的RSA加密等等。
  19. 最大流量算法(Maximum flow)——该算法试图从一个流量网络中找到最大的流。它优势被定义为找到这样一个流的值。最大流问题可以看作更复杂的网络流问题的特定情况。最大流与网络中的界面有关,这就是最大流-最小截定理(Max-flow min-cut theorem)。Ford-Fulkerson 能找到一个流网络中的最大流。
  20. 合并排序(Merge Sort)
  21. 牛顿法(Newton’s method)——求非线性方程(组)零点的一种重要的迭代法。
  22. Q-learning学习算法——这是一种通过学习动作值函数(action-value function)完成的强化学习算法,函数采取在给定状态的给定动作,并计算出期望的效用价值,在此后遵循固定的策略。Q-leanring的优势是,在不需要环境模型的情况下,可以对比可采纳行动的期望效用。
  23. 两次筛法(Quadratic Sieve)——现代整数因子分解算法,在实践中,是目前已知第二快的此类算法(仅次于数域筛法Number Field Sieve)。对于110位以下的十位整数,它仍是最快的,而且都认为它比数域筛法更简单。
  24. RANSAC——是“RANdom SAmple Consensus”的缩写。该算法根据一系列观察得到的数据,数据中包含异常值,估算一个数学模型的参数值。其基本假设是:数据包含非异化值,也就是能够通过某些模型参数解释的值,异化值就是那些不符合模型的数据点。
  25. RSA——公钥加密算法。首个适用于以签名作为加密的算法。RSA在电商行业中仍大规模使用,大家也相信它有足够安全长度的公钥。
  26. Schönhage-Strassen算法——在数学中,Schönhage-Strassen算法是用来完成大整数的乘法的快速渐近算法。其算法复杂度为:O(N log(N) log(log(N))),该算法使用了傅里叶变换。
  27. 单纯型算法(Simplex Algorithm)——在数学的优化理论中,单纯型算法是常用的技术,用来找到线性规划问题的数值解。线性规划问题包括在一组实变量上的一系列线性不等式组,以及一个等待最大化(或最小化)的固定线性函数。
  28. 奇异值分解(Singular value decomposition,简称SVD)——在线性代数中,SVD是重要的实数或复数矩阵的分解方法,在信号处理和统计中有多种应用,比如计算矩阵的伪逆矩阵(以求解最小二乘法问题)、解决超定线性系统(overdetermined linear systems)、矩阵逼近、数值天气预报等等。
  29. 求解线性方程组(Solving a system of linear equations)——线性方程组是数学中最古老的问题,它们有很多应用,比如在数字信号处理、线性规划中的估算和预测、数值分析中的非线性问题逼近等等。求解线性方程组,可以使用高斯—约当消去法(Gauss-Jordan elimination),或是柯列斯基分解( Cholesky decomposition)。
  30. Strukturtensor算法——应用于模式识别领域,为所有像素找出一种计算方法,看看该像素是否处于同质区域( homogenous region),看看它是否属于边缘,还是是一个顶点。
  31. 合并查找算法(Union-find)——给定一组元素,该算法常常用来把这些元素分为多个分离的、彼此不重合的组。不相交集(disjoint-set)的数据结构可以跟踪这样的切分方法。合并查找算法可以在此种数据结构上完成两个有用的操作:
      • 查找:判断某特定元素属于哪个组。
      • 合并:联合或合并两个组为一个组。
  32. 维特比算法(Viterbi algorithm)——寻找隐藏状态最有可能序列的动态规划算法,这种序列被称为维特比路径,其结果是一系列可以观察到的事件,特别是在隐藏的Markov模型中。

转载自:http://www.infoq.com/cn/news/2012/08/32-most-important-algorithms

彻底理解0.1 + 0.2不等于0.3的原理

抛两个著名的js运算坑:

  1. 0.1 + 0.2 === 0.30000000000000004
  2. 1000000000000000128 === 1000000000000000129

IEEE 754 Floating-point

众所周知JS仅有Number这个数值类型,而Number采用的时IEEE 754 64位双精度浮点数编码。而浮点数表示方式具有以下特点:

  1. 浮点数可表示的值范围比同等位数的整数表示方式的值范围要大得多;
  2. 浮点数无法精确表示其值范围内的所有数值,而有符号和无符号整数则是精确表示其值范围内的每个数值;
  3. 浮点数只能精确表示m*2e的数值;
  4. 当biased-exponent为2e-1-1时,浮点数能精确表示该范围内的各整数值;
  5. 当biased-exponent不为2e-1-1时,浮点数不能精确表示该范围内的各整数值。

由于部分数值无法精确表示(存储),于是在运算统计后偏差会愈见明显。

想了解更多浮点数的知识可参考以下文章:

Why 0.1 + 0.2 === 0.30000000000000004?

在浮点数运算中产生误差值的示例中,最出名应该是0.1 + 0.2 === 0.30000000000000004了,到底有多有名?看看这个网站就知道了http://0.30000000000000004.com/。也就是说不仅是JavaScript会产生这种问题,只要是采用IEEE 754 Floating-point的浮点数编码方式来表示浮点数时,则会产生这类问题。下面我们来分析整个运算过程。

  1. 0.1 的二进制表示为 1.1001100110011001100110011001100110011001100110011001 1(0011)+ * 2^-4;
  2. 当64bit的存储空间无法存储完整的无限循环小数,而IEEE 754 Floating-point采用round to nearest, tie to even的舍入模式,因此0.1实际存储时的位模式是0-01111111011-1001100110011001100110011001100110011001100110011010;
  3. 0.2 的二进制表示为 1.1001100110011001100110011001100110011001100110011001 1(0011)+ * 2^-3;
  4. 当64bit的存储空间无法存储完整的无限循环小数,而IEEE 754 Floating-point采用round to nearest, tie to even的舍入模式,因此0.2实际存储时的位模式是0-01111111100-1001100110011001100110011001100110011001100110011010;
  5. 实际存储的位模式作为操作数进行浮点数加法,得到 0-01111111101-0011001100110011001100110011001100110011001100110100。转换为十进制即为0.30000000000000004。

Why 0.7 * 180===125.99999999998?

  1. 0.7实际存储时的位模式是0-01111111110-0110011001100110011001100110011001100110011001100110;
  2. 180实际存储时的位模式是0-10000000110-0110100000000000000000000000000000000000000000000000;
  3. 实际存储的位模式作为操作数进行浮点数乘法,得到0-10000000101-1111011111111111111111111111111111111111101010000001。转换为十进制即为125.99999999998。

Why 1000000000000000128 === 1000000000000000129?

  1. 1000000000000000128实际存储时的位模式是0-10000111010-1011110000010110110101100111010011101100100000000001;
  2. 1000000000000000129实际存储时的位模式是0-10000111010-1011110000010110110101100111010011101100100000000001;
  3. 因此1000000000000000128和1000000000000000129的实际存储的位模式是一样的。

Solution

到这里我们都理解只要采取IEEE 754 FP的浮点数编码的语言均会出现上述问题,只是它们的标准类库已经为我们提供了解决方案而已。而JS呢?显然没有。坏处自然是掉坑了,而好处恰恰也是掉坑了:)

针对不同的应用需求,我们有不同的实现方式。

Solution 0x00 – Simple implementation

对于小数和小整数的简单运算可用如下方式

function numAdd(num1/*:String*/, num2/*:String*/) { 
    var baseNum, baseNum1, baseNum2; 
    try { 
        baseNum1 = num1.split(".")[1].length; 
    } catch (e) { 
        baseNum1 = 0; 
    } 
    try { 
        baseNum2 = num2.split(".")[1].length; 
    } catch (e) { 
        baseNum2 = 0;
    } 
    baseNum = Math.pow(10, Math.max(baseNum1, baseNum2)); 
    return (num1 * baseNum + num2 * baseNum) / baseNum; 
};

Solution 0x01 – math.js

若需要复杂且全面的运算功能那必须上math.js,其内部引用了decimal.js和fraction.js。功能异常强大,用于生产环境上妥妥的!

Solution 0x02 – D.js

D.js算是我的练手项目吧,截止本文发表时D.js版本为V0.2.0,仅实现了加、减、乘和整除运算而已,bug是一堆堆的,但至少解决了0.1+0.2的问题了。

var sum = D.add(0.1, 0.2)
console.log(sum + '') // 0.3

var product = D.mul("1e-2", "2e-4")
console.log(product + '') // 0.000002

var quotient = D.div(-3, 2)
console.log(quotient + '') // -(1+1/2)

解题思路:

  1. 由于仅位于Number.MIN_SAFE_INTEGER和Number.MAX_SAFE_INTEGER间的整数才能被精准地表示,也就是只要保证运算过程的操作数和结果均落在这个阀值内,那么运算结果就是精准无误的;
  2. 问题的关键落在如何将小数和极大数转换或拆分为Number.MIN_SAFE_INTEGER至Number.MAX_SAFE_INTEGER阀值间的数了;
  3. 小数转换为整数,自然就是通过科学计数法表示,并通过右移小数点,减小幂的方式处理;(如0.000123 等价于 123 * 10-6)
  4. 而极大数则需要拆分,拆分的规则是多样的。
    1. 按因式拆分:假设对12345进行拆分得到 5 * 2469;
    2. 按位拆分:假设以3个数值为一组对12345进行拆分得到345和12,而实际值为12*1000 + 345。
      就我而言,1 的拆分规则结构不稳定,而且不直观;而 2 的规则直观,且拆分和恢复的公式固定。
  5. 余数由符号位、分子和分母组成,而符号与整数部分一致,因此只需考虑如何表示分子和分母即可。
  6. 无限循环数则仅需考虑如何表示循环数段即可。(如10.2343434则分成10.23 和循环数34和34的权重即可)

得到编码规则后,那就剩下基于指定编码如何实现各种运算的问题了。

  1. 基于上述的数值编码规则如何实现加、减运算呢?
  2. 基于上述的数值编码规则如何实现乘、除运算呢?(其实只要加、减运算解决了,乘除必然可解,就是效率问题而已)
  3. 基于上述的数值编码规则如何实现其它如sin、tan、%等数学运算呢?

另外由于涉及数学运算,那么将作为add、sub、mul和div等入参的变量保持如同数学公式运算数般纯净(Persistent/Immutable Data Structure)是必须的,那是否还要引入immutable.js呢?(D.js现在采用按需生成副本的方式,可预见随着代码量的增加,这种方式会导致整体代码无法维护)

Conclusion

依照我的尿性,D.js将采取不定期持续更新的策略(待我理解Persistent/Immutable Data Structure后吧:))。欢迎各位指教!

尊重原创,转载请注明来自:http://www.cnblogs.com/fsjohnhuang/p/5115672.html ^_^肥子John