任何精通低级代码优化的人都知道分支的危险，无论将其实现为if语句，循环还是select语句，分支错误预测的可能性都是一件很浪费时钟的事情。

使用简单的算法可以更好地解决简单的问题，所以让我们这样做。

对于以下问题，所有变量都是32位无符号整数，并且唯一允许的代码是仅包含以下运算符的纯集语句：

+ addition
- subtraction
* multiplication
/ integer division, rounds down, division by 0 not allowed
% modulo
& binary and
| binary or
^ binary exclusive or
>> bitshift right
<< bitshift left

Logic operators, return 1 if the expression is true and 0 if it is false.
== equal
!= not equal
< less than
<= less than or equal
> greater than
>= greater than or equal

Set operator
=

每行必须包含一个变量标识符，后跟一个集合运算符，后跟一个表达式。

表达式可以不包含其他集合运算符，但可以包含变量标识符，文字数字和括号。

高尔夫球得分仅计入操作员人数。

例：

myvar = ( ( ( foo + 5 ) * bar ) % 7 ) == 3

拥有5位操作员的分数。

一个解决方案可以包含作者认为合适的变量。
未设置的变量具有value 0。
溢和下溢是允许的，所有的负数下溢，所以3 - 5是4294967294，即使作为一个更大的语句的一部分。

任务1：最大

程序终止时，作用域中存在两个值A和B，使RESULT变量包含这些值中的最大值。

任务2：中位数

三个值，A，B和C，在存在的范围中，进行RESULT可变包含那些值当程序终止时的中位数。

任务3：平方根

一个价值 A在程序终止时，作用域中存在使RESULT变量包含的平方根A，四舍五入。

可以仅对一个或两个问题发布答案，对某些人来说，找到有效的解决方案将是一个挑战。

任务3，操作23

x = (A >> 16) + A / ((A >> 13) + 511) + 15
x = (x + A/x) >> 1
x = (x + A/x) >> 1
x = (x + A/x) >> 1
RESULT = x - (x > A/x)

与其他解决方案一样，使用牛顿方法，并且选择的种子更加机智。第一位A >> 16使范围的顶部保持快乐，第二位A / ((A >> 13) + 511)使范围的中间保持快乐，最后一位15使底部保持快乐，并且还防止除以零误差（15是可能的最大值，允许0正确收敛-减半三倍减去校正等于零）。对于输入值225, 275625, 82137969, 2908768489（和附近的值），初始种子是精确的。该范围上的所有边缘情况（完美的正方形，完美的正方形+ 1和完美的正方形-1）0 .. 2**32-1均已测试并且正确。

关于规则的一些注释：
允许上溢和下溢，所有负数都下溢，因此3-5是4294967294，即使作为较大语句的一部分。

最后一点证明是创新杀手。我最初尝试使用Halley方法的广义形式的解决方案，但意识到鉴于上述限制，该方法无效。迭代（应用于平方根）是这样的：

x = x * (3*A + x*x) / (A + 3*x*x)

此迭代具有牛顿所没有的良好品质。它三次收敛（而不是二次收敛），它从上方或下方收敛（而不是从上方收敛），并且对选择不好的种子不那么敏感（如果提供的牛顿迭代值太低，它将大大超出收敛点，然后需要逐步降低）。

牛顿方法还存在一个问题（至少在处理整数时），它经常会到达一个x，使得A / x-x = 2-在这种情况下，它将收敛到比适当的整数根大一个的值，需要纠正的；哈雷的方法不需要这种校正。但不幸的是，的值3*A + x*x通常会大于允许的32位整数空间。

还有许多其他通用的^第 n ^个根算法，但是它们都有相同的特征：

x = x + x*(v - x**n)/(v*n)
x = (x*(n+1) - x**(n+1)/v)/n
x = ((n-2)*x + (4*v*x)/(v + x**n))/n
x = x*((n+2)*v + (n-2)*x**n)/(v + x**n)/n
x = ((n-2)*x + (n*x*v)/(v + (n-1)*x**n))/(n-1)
x = ((n-2)*x + x*((n*2-1)*v + x**n)/(v + (n*2-1)*x**n))/(n-1)

x = x + 2*x*(v - x**n)/(v + x**n)/n
x = x + x*31*(v - x**n)/(10*v + 21*x**n)/n
x = x + x*561*(v - x**n)/(181*v + 380*x**n)/n
x = x + x*1153*(v - x**n)/(372*v + 781*x**n)/n

等。大多数显示三次或二次收敛。后四个是四次收敛的一系列迭代的一部分。但实际上，除非您需要计算数百位数字，否则牛顿方法将通过较少的操作为您提供所需的信息。

65（61）次行动（5 + 13 + 47（43））

任务1-最大值（A，B）

RESULT = A + (B - A) * (A <= B)

这是显而易见的解决方案。您需要分配，需要比较，需要将比较与某物相乘，被乘数不能是变量之一，乘积不能是结果。

任务2-中（A，B，C）

RESULT = A                               \
       + (B - A) * (A > B) ^ (B <= C)    \
       + (C - A) * (A > C) ^ (C <  B)

这是对我之前的15步解决方案的改进，后者解决了所有三个变量的问题-节省了两个减法，但是引入了另一个中心性测试。测试本身很简单：一个元素位于中间，而两个元素中的另一个恰好在上面。

任务3 -sqrt（A）

X1     = 1024 + A / 2048
X2     = (X1  + A / X1 ) / 2
...
X10    = (X9 + A / X9 ) / 2
RESULT = X16 - (X16 * X16 > A)

十一轮牛顿逼近。魔法常数1024已被击败WolframW（在a = 2 ** 32收敛之前512使a = 0除以零），但是如果我们可以将0/0定义为零，那么十次迭代将使用起始值512。我确实承认我对十次迭代的主张并不完全清楚，但是我仍然在括号中主张它们。 但是，我将调查是否有九种可能。WolframH的解决方案是九次迭代。

1：5个运算符

RESULT = B ^ (A ^ B)*(A > B)

2：13位操作员

RESULT = B ^ (A ^ B)*(A > B) ^ (A ^ C)*(A > C) ^ (B ^ C)*(B > C)

3：27位操作员

g = 47|((0x00ffffff & A)>>10)|(A>>14)
r = (g + A/g)/3
r = (r + A/r)>>1
r = (r + A/r)>>1
r = (r + A/r)>>1
RESULT = r - (r*r-1>=A)

任务3，39次操作

编辑：更改了最后一行；看评论。

这是Newthon方法的实现。使用所有正平方以及正平方减去1以及100万个随机数（范围为0到2 ^ 32-1）进行测试。看似有趣的起始值是的缩写(1022 + A/1022) / 2，它需要最少的迭代次数（我认为），并且也使RESULTfor为A=0对（1024不是代替1022）。

r = (511 + A/2044)
r = (r + A/r) / 2
r = (r + A/r) / 2
r = (r + A/r) / 2
r = (r + A/r) / 2
r = (r + A/r) / 2
r = (r + A/r) / 2
r = (r + A/r) / 2
r = (r + A/r) / 2
RESULT = r - (r > A/r)