一些有趣的问题

1. 不用比较操作(if, >, <)实现max/min
(1)        max=(abs(a-b)+a+b)/2 min=(a+b)-max=((a+b)-abs(a-b))/2
(2)        int Max(int a, int b)
        {
            int ret[2] = { a, b };
            int d = a - b;
            int f = d >> 31;
            f &= 0x1;
            // 如若不使用ret的额外空间，可以组合结果为： a * (1 - f) + b * f，即a + (b - a) * f
            return ret[f];
        }
        
2. 用位运算求绝对值的方法
        int d = a - b;
        int f = d >> 31;
        int absD = (d ^ f) - f;
    这里有点妙，d如果为负数，那么f则为-1.我们知道求负数的绝对值，就是~x+1或~(x-1).
    而(d ^ f) - f正好执行~d+1.如果d为正数，那么f为0，对整个式子不会有影响。
        
3. 有一组数字，从1到n，中减少了一个数，顺序也被打乱，放在一个n-1的数组里,请找出丢失的数字，最好能有程序，最好算法比较快
    扩展问题，如果丢失了2个数字呢？
        
第一问：对于丢失一个数的情况：
1）用1+2+...+n减去当前输入数据的总和。时间复杂度：O(n) 空间复杂度：O(1) 【容易溢出】
2）用12...*n除以当前输入数据的总积。时间复杂度：O(n) 空间复杂度：O(1) 【容易溢出】
3）用1^2^...^n的结果在逐个异或当前输入数据。时间复杂度：O(n) 空间复杂度：O(1)
4）对输入数据排序，然后从头到尾遍历一次。时间复杂度O(nlogn) 空间复杂度O(1)
5) 对输入数据进行Hash，然后从头到尾遍历一次。时间复杂度O(n) 空间复杂度O(n)
第二问：对于丢失两个数的情况：
设丢失的两个数为x和y。
1）用1+2+...+n减去当前输入数据的总和可以得到x+y；用1^2+2^2+...+n^2减去当前输入数据的平方和可以得到x^2+y^2。联立两个方程可以得到x和y。时间复杂度：O(n) 空间复杂度：O(1) 【容易溢出】
2）用1+2+...+n减去当前输入数据的总和可以得到x+y；用12...n除以当前输入数据的总积可以得到xy。联立两个方程可以得到x和y。时间复杂度：O(n) 空间复杂度：O(1) 【容易溢出】
3）对输入数据排序，然后从头到尾遍历一次。时间复杂度O(nlogn) 空间复杂度O(1)
4）对输入数据进行Hash，然后从头到尾遍历一次。时间复杂度O(n) 空间复杂度O(n)
5) 使用位图：n个数字那就需要(n+1)/8个元素的unsigned char数组，如此扫描一遍原始数据更新相应的位，再扫描一遍char数组即可得到结果，如此不管是缺几个数，或者是对付有重复的数，均可迎刃而解。


4.题目：
   1. 给你n个数，其中有且仅有一个数出现了奇数次，其余的数都出现了偶数次。用线性时间常数空间找出出现了奇数次的那一个数。
   2. 给你n个数，其中有且仅有两个数出现了奇数次，其余的数都出现了偶数次。用线性时间常数空间找出出现了奇数次的那两个数。

答案：
   1.
      从头到尾异或一遍，最后得到的那个数就是出现了奇数次的数。这是因为异或有一个神奇的性质：两次异或同一个数，结果不变。再考虑到异或运算满足交换律，先异或和后异或都是一样的，因此这个算法显然正确。
   2.
      从头到尾异或一遍，你就得到了需要求的两个数异或后的值。这两个数显然不相等，异或出来的结果不为0。我们可以据此找出两个数的二进制表达中不同的一位，然后把所有这n个数分成两类，在那一位上是0的分成一类，在那一位上是1的分到另一类。对每一类分别使用前一个问题的算法。

5. 一个大小为n的数组，请设计算法在n + log n次比较运算后找出第二小的数字。
    
答案：先构建胜者树找出最小的元素，然后顺着最小的元素所在路径找出次小的数。败者树也可以。

6. 求两长度不等的有序数组的中位数。
下面有两种思路，其实有一点小差别，自己看吧。
有人如是说：根据比较结果可以从两个数组各排除一半数字，当然要保证每次去掉总数量为偶数。”其实这里去掉的长度小的那个数组的一半，两个数组都如是
1）思路分析：
It is easy to find the median of each array in O(1) time.
Assume the median of array A is m and the median of array B is n.
Then,
1' If m=n, then clearly the median after merging is also m, the algorithm holds.
2' If m<n, then reserve the half of sequence A in which all numbers are greater than
   m, also reserve the half of sequence B in which all numbers are smaller than n.
   Run the algorithm on the two new arrays.
3' If m>n, then reserve the half of sequence A in which all numbers are smaller than
   m, also reserve the half of sequence B in which all numbers are larger than n.
   Run the algorithm on the two new arrays.
Time complexity: O(logn)

2）不失一般性，我们假定B数组比A数组长一点。A的长度为n, B的长度为m。比较A[n/2]和B[m/2] 时候。类似的，我们还是分成几种情况来讨论：
a. 如果A[n/2] == B[m/2]，那么很显然，我们的讨论结束了。A[n/2]就已经是中位数，这个和他们各自的长度是奇数或者偶数无关。
b. 如果A[n/2] <   B[m/2]，那么，我们可以知道这个中位数肯定不在[A[0],A[n/2])这个区间内，同时也不在[B[m/2],B[m]]这个区间里面。这个时候，我们不能冲动地把[A[0],A[n/2])和[B[m/2],B[m]]全部扔掉。我们只能把[B[m-n/2],B[m]]和 [A[0],A[n/2])扔掉就可以了。这样我们就把我们的问题成功转换成了如何在A[n/2]->A[n]这个长度为 n/2的数组和B[1]-B[m-n/2]这个长度为m-n/2的数组里面找中位数了。问题复杂度即可下降了。
c. 只剩下A[n/2] > B[m/2]，和b类似的，我们可以把A[n/2]->A[n]这块以及B[1]->B[n/2]这块扔掉了就行,然后继续递归。


7. 在一个盒子里面有N根绳子，这个N根绳子的中间部分放在盒子里面，不可见，但是这个N根绳子的两端露在盒子外面，所以我们能看到2N个绳头。
随机选取2个绳头并打结，直到所有的绳头都打上结。最后这些打结的绳子会形成许多环。请问环数目的期望值是多少？


8. 设想这样一个计算机系统，它只支持以下几个操作：
    1. 定义变量、给变量赋值；
    2. 变量自身加一；
    3. 令一段语句循环执行指定的次数。
  这个系统只处理且只能处理0和正整数。系统不存在“溢出”的问题。
  注意这个系统没有比较运算，事实上它甚至不存在Boolean值和判断语句。
  循环语句也不是FOR i=a TO b DO的形式，只能是LOOP n的形式。

  在这个系统上实现加法很容易，让a自增b次即可。现在的问题是，你能在这个系统上实现减法吗？

  问题的关键在于如何实现自减一操作。
  本来让-1自增n次即可实现n的自减的，但系统偏偏又不支持负数。
  网友Dingding给出了一个答案：
    dec（int n){
        tmp = 0
        result = 0
        loop(n) {
           result = tmp
           tmp++
        }
    }
  这段代码执行后，result的值将变为n-1。注意到这段代码在自增时是如何巧妙地延迟了一步的。
  现在，我们相当于有了自减一的函数dec。实现a-b只需要令a自减b次即可：
    result = a
    loop(b) {
       dec(result)
    }
    
    
9. 有这么一个计算机：
   1. 存储量为N bytes，包含了内存、Cache，等等所有表示状态的东东
   2. CPU为M赫兹
如果在这上面运行一个一定可以结束的程序，这个程序最多可以运行多久？

   1. 一个byte是8个bit，这是8的bit，N个byte，就是8N个bit，代表着 2^8N 种状态
   2. 不论怎么编码，当程序终止的时候，已经是某一个状态，而且这个状态之前没有经过过（否则早就终止了）
   3. 在任意一个时刻，这些所有表示状态的东东，都不会出现重复，也就是说：已经够经过的状态不会再在后面出现了，否则，你已经猜到了，那就是死循环
   4. 所以最厉害的程序最多跑遍2^8N种状态
   5. CPU是M赫兹，也就是一秒会切换M个状态
    所以结果就是 (2^8N)/M