Question

基本上，我要做的是删除所有数字并保留第一个数字。如果数字小于10，请保留该数字。

我已经编写了一些代码，但是我没有删除第一位之后的所有数字，而是删除了第一位。

我的代码：

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

如果数字为5，则输出应为5。
如果数字为23，则输出应为2。
如果数字为62363456，则输出应为6。

Answer 1

首先，您需要了解什么是递归及其工作方式。递归表示函数/方法本身。在下面的程序中，如果n = n / 10时n大于10，则调用removeDigit方法本身。

尝试这个。

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

n = 23219

迭代1

23219> 10 用n = 23219/10 = 2321致电removeDigit

迭代2

2321> 10 用n = 2321/10 = 232调用removeDigit

迭代3

232> 10 致电removeDigit，n = 232/10 = 23

迭代4

23> 10 调用removeDigit，n = 23/10 = 2

迭代5

2 <10 所以返回2

Answer 2

我不确定递归是否是最好的工具，但这应该可行：

    public static int keepFirstDigit(int num) {


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

如果num小于10，则我们将其退回。否则，我们将num除以10，然后除以余数，并将其传递给递归方法调用。

对于负数，我们可以将负数更改为正数，因为这不会影响第一位数字：

    public static int keepFirstDigit(int num) {

        num = Math.abs(num);

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

我们还可以在调用此方法并将其作为参数传递之前进行abs。

Answer 3

我不确定是否需要递归进行，但如果不需要，我会这样做

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

但是，如果这样做，请使用已经发布的其他示例

Answer 4

这也可以使用字符串来实现，也许可以考虑一下：

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

Answer 5

基于@Pankaj Singh和@michalk答案，这是一个有效的Java验证解决方案。
它还处理负值和空值。
运行它以查看输出和结果。
（虽然可能不是最快，最短的方法）

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

删除除第一个使用递归之外的所有数字

5 个答案: