Question

以下是我要解决的problem。

编写一个接受整数参数n的方法evenDigits 返回通过从n中删除奇数位形成的整数。该下表显示了几个调用及其预期的返回值：

Call    Valued Returned
evenDigits(8342116);    8426
evenDigits(4109);   40
evenDigits(8);  8
evenDigits(-34512); -42
evenDigits(-163505);    -60
evenDigits(3052);   2
evenDigits(7010496);    46
evenDigits(35179);  0
evenDigits(5307);   0
evenDigits(7);  0

如果向方法传递了偶数为0的偶数的负数，则结果也应为负数，如上所示，当传递-34512时。

结果中的前导零应该被忽略，如果数字中没有0以外的偶数，则该方法应该返回0，如最后三个输出所示。

到目前为止，我有这个 -

public static int evenDigits(int n) {
    if (n != 0) { 
        int new_x = 0;
        int temp = 0;
        String subS = "";
    String x_str = Integer.toString(n);
        if (x_str.substring(0, 1).equals("-")) {
             temp = Integer.parseInt(x_str.substring(0, 2));
             subS = x_str.substring(2);
        } else {
             temp = Integer.parseInt(x_str.substring(0, 1));
             subS = x_str.substring(1);
        }

        if (subS.length() != 0) {
             new_x = Integer.parseInt(x_str.substring(1));
        }
        
        if (temp % 2 == 0) {
             return Integer.parseInt((Integer.toString(temp) + evenDigits(new_x)));
        } else {
            return evenDigits(new_x);
        }
    }
    return 0;
}

Answer 1

为什么人们似乎总是希望转换为String来处理数字？ Java具有完美的算术原语来处理作业。例如：

public static int evenDigits(int n) {
    int rev = 0;
    int digitCount = 0;

    // handle negative arguments
    if (n < 0) return -evenDigits(-n);

    // Extract the even digits to variable rev
    while (n != 0) {
        if (n % 2 == 0) {
            rev = rev * 10 + n % 10;
            digitCount += 1;
        }
        n /= 10;
    }

    // The digits were extracted in reverse order; reverse them again
    while (digitCount > 0) {
        n = n * 10 + rev % 10;
        rev /= 10;
        digitCount -= 1;
    }

    // The result is in n
    return n;
}

虽然对于像这样的简单学术练习没有任何区别，但是通过算术单独处理工作可能比任何涉及转换为String的工作都要好。

Answer 2

通常使用递归解决方案更容易，然后再回到迭代（如果必须）：

public static int evenDigits(int n) {
    if (n < 0) {
        return -evenDigits(-n);
    } else if (n == 0) {
        return 0;
    } else if (n % 2 == 1) {
        return evenDigits(n / 10);
    } else {
        return 10 * evenDigits(n / 10) + (n % 10);
    }
}

Answer 3

int n = 8342116;

StringBuilder sb = new StringBuilder();
Integer.toString(n).chars()
                   .filter(x -> x % 2 == 0)
                   .mapToObj(i -> (char) i)
                   .forEachOrdered(sb::append);
int result = Integer.valueOf(sb.toString());

System.out.println(result);   // 8426

Answer 4

public int evenDigits(int n) {
    int r = 0;
    boolean neg = false;
    String evenDigits = "";

    if (n < 0) { neg = true; n = abs(n); }

    // keep dividing n until n = 0
    while (n > 0) {
        r = n % 10;
        n = n / 10;         // int division
        if (r % 2 == 0) { evenDigits = Integer.toString(r) + evenDigits; }
    }

    int result = Integer.parseInt(evenDigits);
    if (neg) { result -= 2 * result; }

    return result;
}

这或多或少是伪代码，但我认为你理解了我的想法。我之前使用过这个方法来解决同样的问题。

Answer 5

基于String s：

的外行解决方案

public static int evenDigits(int n) {

    StringBuilder evenDigitsBuffer = new StringBuilder();

    for (char digitChar : String.valueOf(n).toCharArray()) {
        int digit = Character.getNumericValue(digitChar);
        if (digit % 2 == 0) {
            evenDigitsBuffer.append(digit);
        }
    }

    return evenDigitsBuffer.length() > 0 
            ? Integer.signum(n) * Integer.parseInt(evenDigitsBuffer.toString())
            : 0;
}

从int中提取偶数

5 个答案: