CODEWITHSUNDEEP
javarecursion
user11340251
user11340251

Reputation:

Remove all numbers except the first using recursion

Basically what I have to do is to remove all digits and leave the first one. If it's a number under 10 keep that number.

I already made some code but instead of removing all digits following the first, I removed the first digit.

My code:

public static int keepFirstDigit(int num) {
  // Can't change anything besides the following code
  if(num==0){
    return 0;
  }
  if(num>0){
    return num % (int) Math.pow(10, (int) Math.log10(num));
  }
  return num;
}

If the number is 5, the output should be 5.
If the number is 23 the output should be 2.
If the number is 62363456 the output should be 6.

Upvotes: 1

Views: 1212

Answers (5)

Pankaj Singh
Pankaj Singh

Reputation: 1178

First, you need to understand what is recursion and how it works. Recursion means function/method call itself. in below program removeDigit method calling itself if n is greater than 10 with n = n/10.

try this one.

public class Main {
    public static void main(String[] args) {
            System.out.println(removeDigit(23219));
    }

    public static int removeDigit(int n) {
        if (Math.abs(n) < 10) {
            return n;
        } 
        return removeDigit(n/10);
    }
}

for n = 23219

iteration 1

23219 > 10 call removeDigit with n = 23219/10 = 2321

iteration 2

2321 > 10 call removeDigit with n = 2321/10 = 232

iteration 3

232 > 10 call removeDigit with n = 232/10 = 23

iteration 4

23 > 10 call removeDigit with n = 23/10 = 2

iteration 5

2 < 10 So return 2

Upvotes: 1

Michał Krzywański
Michał Krzywański

Reputation: 16910

I am not sure if recursion is the best tool to do it however this should work :

    public static int keepFirstDigit(int num) {


        //Can't change anything besides the following code
       if(num < 10) {
           return num;
       } else {
           return keepFirstDigit(num / 10);
       }
    }

If num is less then 10 we jest return it. Otherwise we divide num by 10 without the remainder and pass it to recursive method call.

For negative numbers we could change the negative number to positive as this does not affect first digit :

    public static int keepFirstDigit(int num) {

        num = Math.abs(num);

       if(num < 10) {
           return num;
       } else {
           return keepFirstDigit(num / 10);
       }
    }

We could also do the abs before calling this method and pass it as parameter.

Upvotes: 1

el-teedee
el-teedee

Reputation: 1341

Based on @Pankaj Singh and @michalk answer, here is a working, verifiable solution in Javascript.
It also handle negative and null values.
Run it to see output and results.
(Probably not the fastest, shortest way though)

Result for 0 -> 0
Result for 10 -> 1
Result for -10 -> -1
Result for 9.9999 -> 9
Result for 1.57 -> 1
Result for 23 -> 2
Result for 34.5 -> 3
Result for 5678848 -> 5
Result for -3.14159 -> -3
Result for -28.123 -> -2


// Define a function doing the job
// Take an object as argument, not a number (for updating purpose)
const getFirstDigit = (obj) => {
  // Ensure argument is valid
  if (!obj || !obj.count) {
    return;
  }
  if ((obj.count >= 0 && obj.count < 10) 
    /* handle negatives */
    || (obj.count <= 0 && obj.count > -10)) {
    // Ensure it is an integer
    obj.count = parseInt(obj.count);
  } else {
    // Divide by ten: update obj.count
    obj.count = parseInt(obj.count / 10);
    // Recursion: call again since number is greater or equals than 10
    getFirstDigit(obj);
  }
}
// At the end of recursion stack, obj.count will be an integer < 10 == the first digit of initial number

// Give some inputs (and negative values)
let numbers = [0, 10, -10, 9.9999, 1.57, 23, 34.50, 5678848, -3.14159, -28.123];

for (index in numbers) {
  let input = numbers[index];
  // Prepare an object to hold our number
  let object = { count: input };
  // Call the method by passing an object
  // Passing an object rather a primitive Number allow the function to update the object by reference
  getFirstDigit(object)
  // Retrieve object updated (or not) number
  let output = object.count;
  console.log(`Result for ${input} -> ${output}`);
}

Upvotes: 0

Peter
Peter

Reputation: 11

This can also be achieved using Strings, maybe think of this:

public static int keepFirstDigit(int num) {
   //Can't change anything besides the following code
   return Integer.parseInt((num+"").charAt(0)+"");
}

Upvotes: 0

sassy_rog
sassy_rog

Reputation: 1097

I'm not sure if you need to do it recursiveley but if you don't, I'd do it like this

public static int keepFirstDigit(int num) {
  String tempNum = String.valueOf(num).substring(0,1);
  return((int) Integer.parseInt(tempNum));
}

but if you do, just use the other examples that have already been posted

Upvotes: 0

Related Questions