Question

我无法在函数中计算 Knuth的箭头符号，即↑并且可以找到here。我到目前为止所做的是：

int arrowCount = (int)arrowNum.Value; // Part of
BigInteger a = (int)aNum.Value;       // the input I
BigInteger b = (int)bNum.Value;       // already have
BigInteger result = a;
BigInteger temp = a;
for(int i = 0; i < arrowCount; i++)
{
    result = Power(temp, b);
    temp = r;
    b = a;
}

有权力

BigInteger Power(BigInteger Base, BigInteger Pow)
    {
        BigInteger x = Base;
        for(int i = 0; i < (Pow-1); i++)
        {
            x *= Base;
        }
        return x;
    }

但它的价值不正确，我无法找到解决问题的方法。它可以处理1个箭头问题，如 3↑3 （ 3 ^ 3 = 9 ），但它无法处理任何问题箭头多于那个。

我需要一种方法来找出更多箭头，例如 3↑↑3 ，

应该是 7625597484987（3 ^ 27） ，我得到 19683（27 ^ 3） 。如果你能帮我弄清楚如何得到正确的输出并解释我做错了什么，我将不胜感激。

Answer 1

我在java中编写它，并使用double作为输入参数：

    private static double knuthArrowMath(double a, double b, int arrowNum)
{
    if( arrowNum == 1)
        return Math.pow(a, b);
    double result = a;
    for (int i = 0; i < b - 1; i++)
    {
        result = knuthArrowMath(a, result, arrowNum - 1);
    }
    return result;
}

Answer 2

如果你期望7625597484987（3 ^ 27 ）但得到19683（ 27 ^ 3），那么它是不是一个简单的交换参数的问题打电话给你的电源功能？

查看您的Power功能，您的代码段似乎以 temp 为基础， b 为权力调用Power：

int arrowCount = (int)arrowNum.Value; // Part of
BigInteger a = (int)aNum.Value;       // the input I
BigInteger b = (int)bNum.Value;       // already have
BigInteger result = a;
BigInteger temp = a;
for(int i = 0; i < arrowCount; i++)
{
    result = Power(temp, b);
    temp = result;
    b = a;
}

不应该交换b，以便获得result = Power(b, temp)以获得所需的结果吗？

因此，传递1个结果调用Power(3, 3)会产生temp = 27并传递2个调用Power(3, 27)。它现在仅适用于单箭头的原因是因为第一个Power(base, power)调用的交换参数并不重要。

正如你在答案中指出的那样，这并不能涵盖所有情况。根据您提供的示例，我创建了这个小控制台应用程序：

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Arrow(3, 3));
            Console.WriteLine(Arrow(4, 4, 1));
            Console.WriteLine(Arrow(3, 4, 1));
            Console.ReadKey();
        }

        private static BigInteger Arrow(BigInteger baseNumber, BigInteger arrows)
        {
            return Arrow(baseNumber, baseNumber, arrows-1);
        }

        private static int Arrow(BigInteger baseNumber, BigInteger currentPower, BigInteger arrows)
        {
            Console.WriteLine("{0}^{1}", baseNumber, currentPower);
            var result = Power(baseNumber, currentPower);

            if (arrows == 1)
            {
                return result;
            }
            else
            {
                return Arrow(baseNumber, result, arrows - 1);
            }
        }

        private static BigInteger Power(BigInteger number, BigInteger power)
        {
            int x = number;
            for (int i = 0; i < (power - 1); i++)
            {
                x *= number;
            }
            return x;
        }
    }

Answer 3

我想出了一种使用BigInteger.Pow()函数的方法。这可能看起来有些奇怪，但这是因为C＃BigInterger.Pow(x, y)仅接受y的整数，并且确定具有巨大的指数。在这种情况下，我必须“翻转脚本”并转换x ^ y = y ^ x。我没有添加任何错误检查，它希望所有数字均为正整数。

我知道，它适用于x ^^ 2和x ^^ 3。我也知道它适用于2 ^^ 4和2 ^^ 5。我没有计算能力/内存/数学知识，无法确定它是否适用于其他任何数字。我只能检查和测试2 ^^ 4和2 ^^ 5。可能适用于其他数字，但我无法确认。

int baseNum = 4;
int exp = 3;
// this example is 4^^3
BigInteger bigAnswer = tetration(baseNum, exp);

// Here is what the method that "does the work" looks like.  

    // This looks a little odd but that is because I am using BigInteger.Pow(x,y)
    // Unfortunately, y can only be an int.  Tetrations have huge exponents, so I had to figure out a
    // way to have x^y work as y^x for this specific application
    // no error checking in here, and it expects positive ints only
    // I *know* this works for x^^2, x^^3, but I don't know if it works for
    // any other number than 2 at ^^4 or higher
    public static BigInteger tetration(int baseNum, int exp)
    {
        if (exp > 2)
        {
            exp = (int)Math.Pow(baseNum, (exp - 3));
        }
        else
        {
            exp = exp - 2;
        }

        Func<BigInteger, int, BigInteger> bigPowHelper = (x, y) => BigInteger.Pow(x, y);
        BigInteger bigAnswer = baseNum;

        for (int i = 0; i < Math.Pow(baseNum, exp); i++)
        {
            bigAnswer = bigPowHelper(bigAnswer, baseNum);
        }
        return bigAnswer;
    }

在函数

3 个答案: