CODEWITHSUNDEEP
java
Dylan
Dylan

Reputation: 491

Extracting even digits from int

Here is the problem that I am solving.

Write a method evenDigits that accepts an integer parameter n and that returns the integer formed by removing the odd digits from n. The following table shows several calls and their expected return values:

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

If a negative number with even digits other than 0 is passed to the method, the result should also be negative, as shown above when -34512 is passed.

Leading zeros in the result should be ignored and if there are no even digits other than 0 in the number, the method should return 0, as shown in the last three outputs.

I have this so far - 

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;
}

Upvotes: 1

Views: 5685

Answers (5)

Mick Mnemonic
Mick Mnemonic

Reputation: 7956

A layman's solution that's based on Strings:

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;
}

Upvotes: 0

John Bollinger
John Bollinger

Reputation: 180286

Why do people seem always to want to convert to String to deal with digits? Java has perfectly good arithmetic primitives for handling the job. For example:

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;
}

Although it makes no difference for a simple academic exercise such as this one, handling the job via arithmetic alone can be expected to perform better than anything involving converting to String.

Upvotes: 2

Misha
Misha

Reputation: 28133

It's often easier to start with a recursive solution and then work you way back to iterative (if you must):

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);
    }
}

Upvotes: 1

lightbringer
lightbringer

Reputation: 835

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;
}

This is more or less a pseudo code, but I think you get my idea. I have used this method for the same problem before.

Upvotes: 0

Olivier Croisier
Olivier Croisier

Reputation: 6149

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

Upvotes: 0

Related Questions