C＃，无循环
好的，我浏览了其中的一些链接，但是老实说它们有点无聊。我对用哈希表和诸如此类的东西来优化地狱不感兴趣。我为什么要这样？您有一个该死的超级计算机！
地狱，我什至不想打扰循环！此解决方案将遵循无循环规则。
请注意，我将要编写的代码不是很好的代码，也不是我在现实生活中编写的那种代码（以防任何潜在的雇主偶然读到此代码）。该代码强调简洁和在叙述中工作的能力，并且不强调适当的约定，仪式和循环等。
为了演示我在说什么，我们将从一个带有公共字段的令人震惊的类开始，以存储该方程的操作数：
class BealOperands
{
public BigInteger A, B, C, x, y, z;
}
好的，我们将从最困难的挑战开始。我们需要找出一种方法来对这些操作数的每种组合进行置换。毫无疑问，有比检查每个排列更有效的方法，但是我不介意弄清楚它们。我为什么要呢？我们有一个该死的超级计算机！
这是我想出的算法。它效率极低，并且一次又一次地遍历相同的操作数，但是谁在乎呢？超级计算机！
- 将六个操作数视为以2为底的数字，然后对每种组合进行置换。
- 将六个操作数视为以3为底的数字，然后对每种组合进行置换。
- 将六个操作数视为以4为底的数字，并通过每种组合进行置换。
- （...）
如何做到所有这些没有循环？简单！只需实现IEnumerable和相关联IEnumerator即可抽出排列。稍后，我们将使用LINQ进行查询。
class BealOperandGenerator : IEnumerable<BealOperands>
{
// Implementation of IEnumerable<> and IEnumerable -- basically boilerplate to get to BealOperandGeneratorEnumerator.
public IEnumerator<BealOperands> GetEnumerator() { return new BealOperandGeneratorEnumerator(); }
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }
}
class BealOperandGeneratorEnumerator : IEnumerator<BealOperands>
{
public BealOperandGeneratorEnumerator() { Reset(); }
private BealOperands operands;
private BigInteger @base;
public void Reset()
{
// A is set to 0, which is "before" its minimum value, because IEnumerators are supposed to
// point to their first element *after* the first call to MoveNext().
// All other operands are set to their minimum values.
operands = new BealOperands { A = 0, B = 1, C = 1, x = 3, y = 3, z = 3 };
@base = 2;
}
public BealOperands Current
{
get
{
// We need to return a copy, since we'll be manipulating our internal one.
return new BealOperands {
A = operands.A, B = operands.B, C = operands.C,
x = operands.x, y = operands.y, z = operands.z };
}
}
public bool MoveNext()
{
// Increment the lowest "digit" and "carry" as necessary.
operands.A++;
if (operands.A - 1 >= @base)
{
operands.A = 1; operands.B++;
if (operands.B - 1 >= @base)
{
operands.B = 1; operands.C++;
if (operands.C - 1 >= @base)
{
operands.C = 1; operands.x++;
if (operands.x - 3 >= @base)
{
operands.x = 3; operands.y++;
if (operands.y - 3 >= @base)
{
operands.y = 3; operands.z++;
if (operands.z - 3 >= @base)
{
operands.z = 3; @base++;
}
}
}
}
}
}
// There will always be more elements in this sequence.
return true;
}
// More boilerplate
object System.Collections.IEnumerator.Current { get { return Current; } }
public void Dispose() { }
}
现在我们开始营业！我们所需要做的就是枚举BealOperandGeneratorBeal猜想的一个实例并找到一个反例。
我们的下一个大问题是，似乎没有一种将a提升为a BigInteger的幂的内置方法BigInteger。有BigInteger.Pow(BigInteger value, int exponent)和BigInteger.ModPow(BigInteger value, BigInteger exponent, BigInteger modulus)，但没有方法将a提升BigInteger为另一BigInteger模无穷大的幂。
问题的根基啊！看来是要用我们的IEnumerable/ IEnumerator锤子解决！
class BigIntegerPowerEnumerable : IEnumerable<Tuple<BigInteger, BigInteger>>
{
public BigIntegerPowerEnumerable(BigInteger @base, BigInteger exponent) { this.@base = @base; this.exponent = exponent; }
BigInteger @base, exponent;
public IEnumerator<Tuple<BigInteger, BigInteger>> GetEnumerator() { return new BigIntegerPowerEnumerator(@base, exponent); }
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }
}
class BigIntegerPowerEnumerator : IEnumerator<Tuple<BigInteger, BigInteger>>
{
public BigIntegerPowerEnumerator(BigInteger @base, BigInteger exponent)
{
originalBase = @base;
originalExponent = exponent;
Reset();
}
BigInteger originalBase, currentBase, originalExponent, currentExponent;
bool finished;
public void Reset()
{
// IEnumerable.Reset() is a silly method. You're required to implement it when you implement IEnumerable,
// but it isn't used by foreach or LINQ or anything. If you want to re-enumerate the enumerable, just get
// a brand new enumerator.
// In this case it gets in the way. The only reason I'm storing the original values is so I can implement
// this useless method properly. I supposed I could just throw a NotImplementedException or something,
// but it's done now.
currentBase = originalBase;
currentExponent = originalExponent;
finished = false;
}
public bool MoveNext()
{
if (finished) return false;
if (currentExponent <= Int32.MaxValue)
{
currentBase = BigInteger.Pow(currentBase, (Int32)currentExponent);
currentExponent = 1;
finished = true;
}
else
{
currentBase = BigInteger.Pow(currentBase, Int32.MaxValue);
currentExponent -= Int32.MaxValue;
}
return true;
}
public Tuple<BigInteger, BigInteger> Current
{
get { return new Tuple<BigInteger, BigInteger>(currentBase, currentExponent); }
}
object System.Collections.IEnumerator.Current { get { return Current; } }
public void Dispose() { }
}
static class BigIntegerPowExtension
{
public static BigInteger Pow(this BigInteger @base, BigInteger exponent)
{
return new BigIntegerPowerEnumerable(@base, exponent).Last().Item1;
}
}
现在我们有了一个扩展方法Pow，可以在上调用它BigInteger，并采用BigInteger指数且没有模数。
好，让我们退后一步。我们怎么知道一个特定的BealOperands某件事是否是Beal猜想的反例？好吧，有两件事必须是正确的：
- 将操作数插入页面顶部的该公式时，必须形成一个真方程。
- A，B和C不得具有共同的质因数（即，它们的GCD为1）。
我们已经具备了检查第一个条件所需的条件。事实证明，第二种情况比听起来容易得多。BigInteger提供一个可爱的GreatestCommonDivisor方法，它使我们可以方便地回避试图实现无循环的整个噩梦。
因此，我们准备编写一种方法来检查a BealOperands是否是反例。开始...
static class BealOperandsExtensions
{
public static bool IsBealsConjectureCounterExample(this BealOperands o)
{
// If the equation isn't even true, we don't have a counter example unfortunately
if (o.A.Pow(o.x) + o.B.Pow(o.y) != o.C.Pow(o.z))
{
return false;
}
// We have a counterexample if A, B and C are coprime
return BigInteger.GreatestCommonDivisor(o.A, o.B) == 1 &&
BigInteger.GreatestCommonDivisor(o.A, o.C) == 1 &&
BigInteger.GreatestCommonDivisor(o.B, o.C) == 1;
}
}
最后，我们可以使用这种相当巧妙的Main方法将所有内容整合在一起：
static class Program
{
static void Main()
{
var bealOperandGenerator = new BealOperandGenerator();
if (bealOperandGenerator.Any(o => o.IsBealsConjectureCounterExample()))
{
Console.WriteLine("IN YOUR FACE, BEAL!");
}
}
}
A，B，C，x，y和z是x，y，z> 2的正整数，则A，B和C具有共同的质因数。