Google Foobar挑战级别2“嘿，我已经做到了”

Question

我需要帮助来解决Google的Foobar挑战的第二阶段。

指挥官Lambda使用自动算法将小兵随机分配给任务，以使小兵保持脚尖。但是您已经注意到该算法的一个缺陷-它最终会自行循环，因此，它不会像迭代那样分配新的奴才，而是陷入了一个值循环中，从而使相同的奴隶最终可以完成并执行相同的任务。再次。您认为向Lambda指挥官证明这一点将为您的下一次晋升提供依据。

您已经确定该算法具有以下过程：

1]以随机小号ID n开头，它是基数b中长度为k的非负整数2）将x和y定义为长度为k的整数。 x具有降序的n位数，而y具有升序的n位数3）定义z = x-y。如果需要，在z上添加前导零以保持长度k4）分配n = z以获得下一个奴才ID，然后返回步骤2

例如，假设给定的奴才ID n = 1211，k = 4，b = 10，然后x = 2111，y = 1112和z = 2111-1112 =0999。那么下一个奴才ID将为n = 0999，算法再次迭代：x = 9990，y = 0999和z = 9990-0999 = 8991，依此类推。

取决于n，k（从n得出）和b的值，在某些时候，算法会达到一个周期，例如达到恒定值。例如，从n = 210022开始，k = 6，b = 3，该算法将达到值[210111、122221、102212]的周期，并且无论继续重复多少次，算法都将停留在该周期中。从n = 1211开始，例程将达到整数6174，并且由于7641-1467为6174，因此无论迭代多少次，该例程都将保持该值。

给出一个minion ID作为字符串n，该字符串n在基数b中表示长度为k的非负整数，其中2 <= k <= 9并且2 <= b <= 10，编写一个函数solution（n，b），该函数返回上面以n开头的算法结束循环的长度。例如，在上面的示例中，solution（210022，3）将返回3，因为在基数3中完成时在102212上进行的迭代将返回210111。如果算法达到常数，例如0，则长度为1。 >

测试用例：Solution.solution（“ 1211”，10）返回1Solution.solution（“ 210022”，3）返回3

这是我的代码：

import java.util.ArrayList;
import java.util.Arrays;

public class Solution {

    public static int solution(String n, int b) {
        int k = n.length();
        String m = n;
        ArrayList<String> minionID = new ArrayList<>();

        while (!minionID.contains(m)) {
            minionID.add(m);
            char[] s = m.toCharArray();
            Arrays.sort(s);
            int y = Integer.parseInt(toString(s));
            int x = Integer.parseInt(reverseString(s));
            if (b == 10) {
                int intM = x - y;
                m = Integer.toString(intM);
            } else {
                int intM10 = ((int) Integer.parseInt(toBase10(x,b))) - ((int) Integer.parseInt(toBase10(y, b)));
                m = toBaseN(intM10, b);
            }

            m = addLeadingZeros(k, m);
        }
        System.out.println(minionID);
        return minionID.size() - minionID.indexOf(m);
    }

    private static String toBaseN (int intBase10, int b) {
        int residual = intBase10;
        ArrayList<String> digitsBaseN = new ArrayList<>();

        while (residual >= b) {
            int r = residual % b;
            digitsBaseN.add(Integer.toString(residual));
            residual = (residual - r) / b;
        }
        digitsBaseN.add(Integer.toString(residual));

        StringBuilder reverseDigits = new StringBuilder();
        for (int i = digitsBaseN.size() -1; i >= 0; i--) {
            reverseDigits.append(digitsBaseN.get(i));
        }
        return reverseDigits.toString();
    }

    private static String toBase10 (int intBaseN, int b) {
        int[] xArr = new int[Integer.toString(intBaseN).length()];
        int count = 0;
        for (int i = xArr.length - 1; i >= 0; i--) {
            xArr[count] = Integer.toString(intBaseN).charAt(i) - '0';
            count++;
        }

        int yBase10 = 0;

        for(int i = 0; i < xArr.length; i++) {
            yBase10 += xArr[i] * (Math.pow(b, i));
        }
        return Integer.toString(yBase10);
    }

    public static String toString(char[] arr) {
        StringBuilder newString = new StringBuilder();
        for (char c : arr) {
            newString.append(c);
        }
        if (newString.toString().contains("-")) {
            newString.deleteCharAt(0);
        }
        return newString.toString();
    }

    public static String reverseString(char[] arr) {
        StringBuilder newString = new StringBuilder();
        for (int i = arr.length - 1; i >= 0; i--) {
            newString.append(arr[i]);
        }
        if (newString.toString().contains("-")) {
            newString.deleteCharAt(newString.length()-1);
        }
        return newString.toString();
    }

    public static String addLeadingZeros(int k, String z) {
        if (k > z.length()) {
            String zeros = "";
            for (int i = 0; i < (k - z.length()); i++) {
                zeros += "0";
            }
            zeros += z;
            return zeros;
        }
        return z;
    }
仅适用于十个测试用例中的三个

我需要帮助来解决Google Foobar挑战的第二阶段。指挥官Lambda使用自动算法将小兵随机分配给任务，以使小兵保持脚尖。 ...

Answer 1

def答案（n，b）：