返回整数的第一个数字答案

【问题标题】：Return first digit of an integer返回整数的第一个数字
【发布时间】：2011-01-04 08:11:15
【问题描述】：

在 Java 中如何返回整数的第一个数字？

即

345

返回一个 3 的整数。

【问题讨论】：

如果没有字符串，您可以使用模运算提取它。 (345/10)%10 = 4 , (345/100)%10 = 5

标签： java int

【解决方案1】：

如果您只需要第一个数字/一个特定数字，那么它比任何解决方案都更容易：

int temp = 345%100 //temp = 45
int firstDigit = (345 -temp)/100 //fisrtDigit= 300/100 = 3

如果您还需要检查第二个数字，那么您需要重复第一步

 int tempHuns = 345%100 //tempHuns = 45  
 tempTens = tempHuns %10 // tempTens= 5
 int secondDigit = (tempHuns - tempTens)/10 //fisrtDigit= 40/10 = 4

【讨论】：

正如目前所写，您的答案尚不清楚。请edit 添加其他详细信息，以帮助其他人了解这如何解决所提出的问题。你可以找到更多关于如何写好答案的信息in the help center。

【解决方案2】：

更新：log10 解决方案：

log10 解决方案的一种变体，没有除法。：

public int getFirstDigit(int x) {
    double e = Math.log10(Math.abs((long) x));
    return Double.valueOf(Math.pow(10.0, e - Math.floor(e))).intValue());
}

它在做什么？

将 int 转换为 long（以处理 MIN_VALUE 问题）
获取绝对值
计算log10
计算 log10 的地板
从 log10 中减去底（差将是分数）
差值加十，得到第一位数字的值。

while循环解决方案：

处理 Integer.MIN_VALUE 并将 Math.abs() 和强制转换保持在循环之外：

public static int getFirstDigit(int i) {
    i = Math.abs(i / (Math.abs((long)i) >= 10 ) ? 10 : 1);
    while (i >= 10 ) 
        i /= 10;
    return i;
}

【讨论】：

【解决方案3】：

我觉得做起来更简单：

int firstDigit = i-(i/10)*10 // i is an integer or long value, positive or negative.

【讨论】：

我想如果你在 123 上测试这个，你会得到 3 而不是 1。
没有先生... 123 - 120 = 3
感谢您的确认。我相信 123 的第一个数字是 1。

【解决方案4】：

为了从左到右分隔整数的数字，我使用了 2 种不同的方法，第一种方法是计算整数由多少位组成，然后通过将整数除以 10 将它们从左到右拆分为位数减1的幂。

//method to separate digits of an integer from left to right
private static void separateDigits(int num){
    int numOfDigits = countNumberOfDigits(num);
    for (int numOfZeros = numOfDigits-1; numOfZeros >= 0 ; --numOfZeros){
        int divisor = (int) Math.pow(10, numOfZeros);
        System.out.print( Math.abs(num) / divisor + " // " );
        num %= divisor;
    }
}

//method to count number of digits
private static int countNumberOfDigits(int num){
    int numOfDigits=0;
    //using absolute value of num allows method to work even with negative integers
    while(Math.abs(num) > 0){ 
        num = num / 10;
        numOfDigits++; //this counts the number of times the "while" loops
    }
    return numOfDigits;
}

不使用数组或递归方法，只使用“/”和“%”进行简单除法。

调用方法：

public static void main(String args[]) {

separateDigits( -123456789 );

}

收益： 1 // 2 // 3 // 4 // 5 // 6 // 7 // 8 // 9 //

【讨论】：

【解决方案5】：

public static void firstDigit(int number){      
    while(number != 0){
        if (number < 10){
            System.out.println("The first digit is " + number);
        }
            number = number/10;

        }
    }

当您调用它时，您可以使用 Maths.abs 以使其适用于负数：

firstDigit(Math.abs(9584578));

这会返回 9

【讨论】：

【解决方案6】：

这是一个较小的版本，用于获取所有位置的数字，它适用于负值（不是小数）。

int number = -23456;

int length = (int) Math.log10(Math.abs(number)) + 1; //This gets the length of the number of digits used
//Math.abs to change negative int to positive

System.out.println("Digit at pos " + 1 + " is :- " + (int)(Math.abs(number)/Math.pow(10,(length-1))));

for (int i = 2; i <= length; i++){
    System.out.println("Digit at pos " + i + " is :- " + (int)(Math.abs(number)/Math.pow(10,(length-i))%10));
}

【讨论】：

【解决方案7】：

这种方式对我来说效果很好，但它确实涉及从 int 转换为 string 并返回到 int。

Integer.parseInt(String.valueOf(x).substring(0,1));

【讨论】：

如果是负数会怎样？
为了使其正常工作，您必须添加Abs 调用：Integer.parseInt(String.valueOf(Math.abs(x)).substring(0,1));
好的。幸运的是，我的应用程序只有正整数，但我仍会进行此更改。谢谢！

【解决方案8】：

假设数字是int类型

因此，

int number = 352
// Change the int into String format
String numberString = Integer.toString(number);
// We can know the first digit of that String with substring method directly
Integer.parseInt(numberString.substring(0,1));

或者另一种方式是将String改成char并从char中获取数值

例如

int number = 352;
String numberString = Integer.toString(number);
Character.getNumericValue(String.valueOf(target).charAt(0)); 
// 0 means the first digit of the number

【讨论】：

【解决方案9】：

int firstNumber(int x){
     int firstN = x;
     while(firstN > 9){
          firstN = (firstN - (firstN%10))/10;
     }
     return firstN;   
 }

【讨论】：

【解决方案10】：

//Try this one.
Scanner input = new Scanner(System.in);
System.out.println("enter first 9 digits: ");
String x = input.nextLine();
String x1 = x.substring(0,1);
int d1 = Integer.parseInt(x1);
System.out.println(d1);
// the substring gives the position of extraction. method dont seem to work for letters though

【讨论】：

【解决方案11】：

这是一个非常简单的分别获取整数的第一位和第二位数字的方法，但这仅适用于恰好两位数！

    int firstDigit = number / 10;
    int secondDigit = number % 10;

对于用户可能输入更多或更少数字但您可能不知道有多少的情况，您可以尝试这种方法，但其他答案对于这种情况有更好的解决方案。我刚刚编写了这个完整的程序，您可以将其粘贴到编译器中并运行。看到模式后，您可以检查任意数量的数字，然后捕获大于您想要接受的长度：

package testingdigits;

import java.util.Scanner;

public class TestingDigits {


Scanner keyboard = new Scanner(System.in);    

public static void main(String[] args) 
{

Scanner keyboard = new Scanner(System.in);

System.out.printf("\nEnter a number to test:");
int number = keyboard.nextInt();

int length = (int) Math.log10(number) + 1; //This gets the length of the number of digits used 

//Initializing variables first to prevent error
int firstDigit = 0, secondDigit = 0, thirdDigit = 0, fourthDigit = 0, fifthDigit = 0, sixthDigit = 0;

    if (length == 1)
     {
        firstDigit = number;
        System.out.println("" + firstDigit);
     }
    if (length == 2)
     {
        firstDigit = number / 10; //For example, 89/10 will output 8.9 and show as 8 in this case.
        secondDigit = number % 10;
        System.out.println("" + firstDigit + "" + secondDigit);
     }
    if (length == 3)
     {
        firstDigit = number / 10 / 10; // 123/10/10 is 1.23 and will show as 1
        secondDigit = number / 10 % 10;
        thirdDigit = number % 10;
        System.out.println("" + firstDigit + "" + secondDigit + "" + thirdDigit);
     }
    if (length == 4)
     {
        firstDigit = number / 10 / 10 / 10; 
        secondDigit = number / 10 / 10 % 10;
        thirdDigit = number / 10 % 10;
        fourthDigit = number % 10;
        System.out.println("" + firstDigit + "" + secondDigit + "" + thirdDigit + "" + fourthDigit);
     }
     if (length == 5)
     {
        firstDigit = number / 10 / 10 / 10 / 10; 
        secondDigit = number / 10 / 10 / 10 % 10;
        thirdDigit = number / 10 / 10 % 10;
        fourthDigit = number / 10 % 10;
        fifthDigit = number % 10;
        System.out.println("" + firstDigit + "" + secondDigit + "" + thirdDigit + "" + fourthDigit + "" + fifthDigit);
     }
    //You can probably see the pattern by now. It's not an elegant solution, but is very readable by even beginners:     
    if ((length == 6))
     {
        firstDigit = number / 10 / 10 / 10 / 10 / 10; //The first digit is divided by 10 for however many digits are after it
        secondDigit = number / 10 / 10 / 10 % 10;
        thirdDigit = number / 10 / 10 / 10 % 10;
        fourthDigit = number / 10 / 10 % 10;
        fifthDigit = number / 10 % 10; //The second to last always looks like this
        sixthDigit = number % 10;  //The last digit always looks like this no matter how big you go
        System.out.println("" + firstDigit + "" + secondDigit + "" + thirdDigit + "" + fourthDigit + "" + fifthDigit + "" + sixthDigit);
     }
    if ((length > 6))
     {
        //The main problem with this approach is that you have to define in advance how many digits you are working with
        //So it's simple, but not very elegant, and requires something to catch unexpected input from the user.
        System.out.println("Invalid Input!");
     }

  }

}

作为一个程序，它只输出您输入的数字，但正如您所看到的，它的执行方式表明它能够分隔用户输入的数字，因此您可以将其用作简单的测试程序，但同样，它不如这里的其他一些解决方案，它只是一种适合初学者的可读方法。它也可以接受否定。

另外：如果您以 double 开头，您可以使用以下命令转换为 int 并截断小数：

numberInt = (int)number;

【讨论】：

【解决方案12】：

我认为这可能是一个不错的方法：

public static int length(int number) {
    return (int)Math.log10(Math.abs(number)) + 1;
}

public static int digit(int number, int digit) {
    for (int i = 0; i < digit; i++) {
        number /= 10;
    }
    return Math.abs(number % 10);
}

适用于负数和正数。 digit(345, length(345) - 1) 将返回 3，digit(345, 0) 将返回 5 例如等等……

【讨论】：

【解决方案13】：

我觉得这个更简单：

int firstDigit(int num)
{
    if(num/10 == 0)
        return num;
    return firstDigit(num/10);

}

输入：123 => 输出：1
输入：-123 => 输出：-1

【讨论】：

【解决方案14】：

查看提供的代码似乎有点过于复杂了，这里有一个简单的解决方案...

int number = 4085;
int firstDigit = number;
while (firstDigit > 9)
{
      firstDigit = firstDigit / 10;
}
System.out.println("The First Digit is " + firstDigit);

【讨论】：

【解决方案15】：

int a = 354;
int b = (int)(a / Math.Pow(10, (int)Math.Log10(a))); // 3

【讨论】：

如果数字是负数，Math.Abs() 自然是先。

【解决方案16】：

另一种方式：

public int firstDigit(int x) {
  if (x == 0) return 0;
  x = Math.abs(x);
  return (int) Math.floor(x / Math.pow(10, Math.floor(Math.log10(x))));
}

【讨论】：

我很想知道这是否适用于每个整数。我会担心浮点不准确的蔓延 - 但它可能没问题。很难有效地测试...
有趣的是，对于 0 到 100,000,000 之间的所有整数，此解决方案产生的结果与我的相同。但是，它不会产生负面影响。
如果 x == 0 则需要稍作改动以返回 0，如果 x
@lins314159：谢谢，我为那些 @Jon 添加了检查：我想我会用 haskell 的 QuickCheck 库测试算法，结果很有趣：当我交互式运行测试时，它通过了，当我编译测试代码它在 -1000, 1000 失败。事实证明，log 1000 在编译代码中返回 2.999...，而不是 3。这正是您担心的那种浮点错误。不过，这似乎不会在 Java 中发生（至少不是具有相同的值）。我会看看 haskell 邮件列表是怎么说的。
除数 = (int)(Math.pow(10,(int) Math.log10(rem))); firstdigit = (int) (rem * 1.0 / divisor);

【解决方案17】：

忽略负值会导致：

(""+345).charAt(0);

【讨论】：

【解决方案18】：

最简单的方法是使用String.valueOf(Math.abs((long)x)).charAt(0) - 这会给你一个char¹。要将其作为整数值，您只需减去“0”（在 Unicode 中，“0”到“9”是连续的）。

当然，这有点浪费。另一种方法是取绝对值，然后循环除以 10，直到数字在 0-9 范围内。如果这是家庭作业，这就是我要给出的答案。但是，我不会提供它的代码，因为我认为它可能是家庭作业。但是，如果您提供 cmets 并编辑您的答案以说明您的工作方式和遇到的问题，我们或许可以提供帮助。

¹需要注意的一点是Integer.MIN_VALUE 的绝对值不能表示为int - 所以您可能应该先转换为long，然后使用Math.abs，然后做算术。这就是为什么那里有演员表。

【讨论】：

我不喜欢这个解决方案涉及将数字转换为字符串，但我喜欢它是一个单行器，你得到了我的投票。
这将是“0”。不适用于 Integer.MIN_VALUE。
(1String.valueOf(-Math.abs(x)).charAt(1)` ？还是有点晦涩难懂？)
@Tom：我正在编辑 Integer.MIN_VALUE 问题。使用 longs 会更容易:) 考虑到我第一段的第二句话，不确定你所说的“0”是什么意思。 OP 想要一个字符还是一个整数并不明显。
@Carl：那里只有一个演员表（到long）和三个方法调用（valueOf、abs、charAt）。第二种形式的循环建议仍然需要强制转换（或隐式转换）和abs 来处理Integer.MIN_VALUE。我也不同意它是拜占庭式的——这对我来说似乎很自然。当您从格式化的意义上考虑整数时，它实际上只有一个“第一个数字” - 所以将它转换为字符串并获取第一个字符非常明显，不是吗？其他复杂性只是由于处理负数。

【解决方案19】：

public static int firstDigit(int n) {
  while (n < -9 || 9 < n) n /= 10;
  return Math.abs(n);
}

也应该很好地处理负数。在这种情况下将返回一个负数。

【讨论】：

String generalSolution = carlsSolution.replace("345", "Math.abs(inputValue))";
@Andreas_D：我刚刚意识到我可能错过了选票，因为人们无法实现智力飞跃，所以我明确地利用了它。
@Gennadiy，很抱歉我编辑了我的解决方案，因为您发表了评论，但之前也没有错。任何平方大于 81 的整数值的绝对值都大于 9，因为它是一个整数，这意味着它至少是 10。
@Tom：规范没有说明如何处理负数。是否允许负输入？他们真的想要第一个 digit 还是想要第一个 character (-)？我不愿意为此担心太多。

【解决方案20】：

作业提示：将其转换为字符串并返回第一个字符。

【讨论】：

所以获取绝对值，然后将其转换为字符串，然后返回第一个字符。

【解决方案21】：

这是 Groovy，但它应该很容易转换为 Java：

int firstNum(int x) {
    a = Math.abs(x)
    sig = Math.floor(Math.log10(a))
    return a / Math.pow(10, sig)
}

结果：

groovy> println(firstNum(345))
3

groovy> println(firstNum(3452))
3

groovy> println(firstNum(-112))
1

groovy> println(firstNum(9999))
9

groovy> println(firstNum(Integer.MAX_VALUE))
2

groovy> println(firstNum(Integer.MIN_VALUE + 1))
2

【讨论】：

【解决方案22】：

缺少的递归解决方案：

int getFirstInt(int input) {
  if (input > 0 ? input < 10 : input > -10) {
    return input > 0 ? input : -input;
  }
  return getFirstInt(input / 10);
}

我不会在现实生活中使用三元运算符，但是 - 它不是很漂亮吗？ ;)

【讨论】：

不能处理 Integer.MIN_VALUE，但很高兴看到递归版本。我认为我不会将条件运算符用于if 条件，但我可能会将它用于返回语句 - 至少在 Math.abs 不存在的情况下。
@Jon，之前用 Integer.MIN_VALUE 测试过，结果是 '2'，有没有强制转换成 long……真的有问题吗？
这不是问题，因为您从不尝试否定 MIN_VALUE，而只尝试否定介于 -1 和 -9 之间的值，这些（显然）具有正等值。

【解决方案23】：

最快的方法是：

计算 abs(x) 的日志，然后获取地板。我们就叫它吧。
将数字除以 10^n

【讨论】：

你有多大把握计算一个对数和一个幂然后除一次会比执行多达 9 个整数除以 10 更快？老实说，我不想猜测……或者声称它在所有处理器和 JVM 中普遍适用。
对此我感到相当震惊，但事实证明，与此非常相似的 liwp 的解决方案在其大部分范围内都返回了正确的结果（我在 1 亿之后放弃了）。是运气还是那些先验函数非常适合这个确切的问题，还是什么？公平地说，这里也是 +1。
至于性能...是的。他们可能不会在任何超级计算中心运行这个算法。有关系吗？ ;)

【解决方案24】：

int main(void) {
  int num = 3421;

  while (num*num + 10 - num*(1 + num) <= 0) {
    num *= (num - 0.9*num)/num;
  }

  std::cout << num << std::endl;
}

【讨论】：