Как в Java вы возвращаете первую цифру целого числа.?
то есть.
345
Возвращает int из 3.
Возвращает первую цифру целого числа
Ответ 1
Самый простой способ - использовать String.valueOf(Math.abs((long)x)).charAt(0) -, который даст вам как char 1. Чтобы получить это как целочисленное значение, вы можете просто вычесть "0" (как в Юникоде, "0" - "9" смежны).
Это несколько расточительно, конечно. Альтернативой было бы просто принять абсолютное значение, затем округлить раунд на 10, пока номер не окажется в диапазоне 0-9. Если это домашнее задание, то ответ, который я бы дал. Тем не менее, я не собираюсь предоставлять код для него, потому что я думаю, что это может быть домашняя работа. Однако, если вы предоставите комментарии и отредактируете свой ответ, чтобы объяснить, как вы это делаете, и с какими проблемами вы сталкиваетесь, мы можем помочь.
1 Следует отметить, что абсолютное значение Integer.MIN_VALUE не может быть представлено как int - поэтому вы можете сначала преобразовать в long, а затем использовать Math.abs, тогда сделайте арифметику. Вот почему там есть бросок.
Ответ 2
Еще один способ:
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))));
}
Ответ 3
public static int firstDigit(int n) {
while (n < -9 || 9 < n) n /= 10;
return Math.abs(n);
}
Должны также обрабатывать отрицательные числа. В этом случае вернет отрицательную первую цифру.
Ответ 4
Игнорирование отрицательных значений приводит к:
(""+345).charAt(0);
Ответ 5
Отсутствующее рекурсивное решение:
int getFirstInt(int input) {
if (input > 0 ? input < 10 : input > -10) {
return input > 0 ? input : -input;
}
return getFirstInt(input / 10);
}
Я бы не использовал тройной оператор в реальной жизни, но... разве это не красиво?;)
Ответ 6
Обновлено: для обработки 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;
}
Оригинальный ответ:
return Math.abs(i);
} public static int getFirstDigit(int i) {
while (Math.abs(i) >= 10 ) {
i = i / 10;
}
return Math.abs(i);
}
Ответ 7
Я считаю это еще проще:
int firstDigit(int num)
{
if(num/10 == 0)
return num;
return firstDigit(num/10);
}
- Вход: 123 = > Выход: 1
- Вход: -123 = > Выход: -1
Ответ 8
Домашнее задание Совет. Преобразуйте его в строку и верните первый символ.
Ответ 9
Самый быстрый способ:
- Вычислить журнал абс (x), затем получить слово. Позвольте называть его n.
- Разделите число с помощью 10 ^ n
Ответ 10
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;
}
Ответ 11
int a = 354;
int b = (int)(a / Math.Pow(10, (int)Math.Log10(a))); // 3
Ответ 12
Глядя на поставляемый код, кажется, что это немного усложняет все это, вот простое решение...
int number = 4085;
int firstDigit = number;
while (firstDigit > 9)
{
firstDigit = firstDigit / 10;
}
System.out.println("The First Digit is " + firstDigit);
Ответ 13
Предположим, что число - это тип 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));
или другим способом является изменение строки в 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
Ответ 14
Отрегулируйте мой предыдущий ответ, чтобы обрабатывать Integer.MIN_VALUE и удерживать актерский состав вдалеке от вмешательства:
public static int getFirstDigit(int i) {
if (Math.abs((long)i) >= 10 ) {
i = i / 10;
while (Math.abs(i) >= 10 ) {
i = i / 10;
}
}
return Math.abs(i);
}
Ответ 15
Я думаю, что это может быть хорошим способом сделать это:
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, например. и так далее...
Ответ 16
private int main(int num){
StringBuilder stringBuilder = new StringBuilder(String.valueof(num));
return Integer.parseInt(stringBuilder.charAt(0).toString());
}
Ответ 17
Это 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))
3groovy > println (firstNum (3452))
3groovy > println (firstNum (-112))
1groovy > println (firstNum (9999))
9groovy > println (firstNum (Integer.MAX_VALUE))
2groovy > println (firstNum (Integer.MIN_VALUE + 1))
2
Ответ 18
Здесь очень простой способ получения первой и второй цифр целого числа отдельно, но это будет работать только для двух цифр!
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 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 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;
Ответ 19
//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
Ответ 20
int firstNumber(int x){
int firstN = x;
while(firstN > 9){
firstN = (firstN - (firstN%10))/10;
}
return firstN;
}
Ответ 21
Ниже приведена меньшая версия для получения цифр всех позиций, она работает с отрицательным значением (не десятичным).
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));
}
Ответ 22
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
Ответ 23
Чтобы разделить цифры целого числа слева направо, я использую 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//
Ответ 24
Я думаю, что проще сделать:
int firstDigit = i-(i/10)*10 // i is an integer or long value, positive or negative.
Ответ 25
Этот способ работал у меня просто отлично, но он включает преобразование из int в строку и обратно в int.
Integer.parseInt(String.valueOf(x).substring(0,1));