int의 자리수를 얻는 방법?
이 방법보다 더 정확한 방법으로 int의 자리수를 얻을 수 있을까요?
int numDigits = String.valueOf(1000).length();
String 기반 솔루션은 문제없이 사용할 수 있습니다.수학적으로 숫자에는 길이도 자리도 없다는 것을 깨달아야 합니다.길이와 숫자는 모두 특정 기본(예: 문자열)에 있는 숫자를 물리적으로 표현하는 속성입니다.
로그 기반 솔루션은 String 기반 솔루션과 내부적으로 동일한 작업(일부)을 수행하며, 길이만 생성되고 숫자는 무시되기 때문에 (중요하게) 더 빠르게 수행될 수 있습니다.하지만 나는 실제로 그것이 더 명확한 의도라고 생각하지 않을 것이다 - 그리고 그것이 가장 중요한 요소이다.
로그는 당신의 친구입니다.
int n = 1000;
int length = (int)(Math.log10(n)+1);
NB: n > 0에만 유효합니다.
가장 빠른 접근법: 분열과 정복.
지정할 수 있는 범위가 0 ~MAX_INT라고 가정하면 1 ~10자리입니다이 간격은 분할과 정복으로 접근할 수 있습니다.각 입력당 최대 4개의 비교가 가능합니다.먼저 [1]을 나눕니다.10]을 [1..5]와 [6]으로 변환합니다.한 번의 비교를 거쳐 각 길이 5 간격을 하나의 비교를 사용하여 길이 3과 길이 2의 간격으로 나눕니다.길이 2 간격은 1회 더 비교(총 3회 비교)가 필요하며 길이 3 간격은 길이 1 간격(솔루션)과 길이 2 간격으로 나눌 수 있습니다.그래서 비교가 3, 4개 필요해요.
나눗셈, 부동소수점 연산, 값비싼 로그 없이 정수 비교만 가능합니다.
코드(긴 길이지만 빠름):
if (n < 100000) {
// 5 or less
if (n < 100){
// 1 or 2
if (n < 10)
return 1;
else
return 2;
} else {
// 3 or 4 or 5
if (n < 1000)
return 3;
else {
// 4 or 5
if (n < 10000)
return 4;
else
return 5;
}
}
} else {
// 6 or more
if (n < 10000000) {
// 6 or 7
if (n < 1000000)
return 6;
else
return 7;
} else {
// 8 to 10
if (n < 100000000)
return 8;
else {
// 9 or 10
if (n < 1000000000)
return 9;
else
return 10;
}
}
}
벤치마크(JVM 예열 후) - 벤치마크 실행 방법을 보려면 아래 코드를 참조하십시오.
- 베이스라인 메서드(String.length 사용): 2145ms
- log10 메서드: 711ms = 베이스라인의 3.02배 속도
- 반복 분할: 2797ms = 베이스라인의 0.77배 속도
- 나눗셈: =99초
의
풀코드:
public static void main(String[] args) throws Exception {
// validate methods:
for (int i = 0; i < 1000; i++)
if (method1(i) != method2(i))
System.out.println(i);
for (int i = 0; i < 1000; i++)
if (method1(i) != method3(i))
System.out.println(i + " " + method1(i) + " " + method3(i));
for (int i = 333; i < 2000000000; i += 1000)
if (method1(i) != method3(i))
System.out.println(i + " " + method1(i) + " " + method3(i));
for (int i = 0; i < 1000; i++)
if (method1(i) != method4(i))
System.out.println(i + " " + method1(i) + " " + method4(i));
for (int i = 333; i < 2000000000; i += 1000)
if (method1(i) != method4(i))
System.out.println(i + " " + method1(i) + " " + method4(i));
// work-up the JVM - make sure everything will be run in hot-spot mode
allMethod1();
allMethod2();
allMethod3();
allMethod4();
// run benchmark
Chronometer c;
c = new Chronometer(true);
allMethod1();
c.stop();
long baseline = c.getValue();
System.out.println(c);
c = new Chronometer(true);
allMethod2();
c.stop();
System.out.println(c + " = " + StringTools.formatDouble((double)baseline / c.getValue() , "0.00") + " times as fast as baseline");
c = new Chronometer(true);
allMethod3();
c.stop();
System.out.println(c + " = " + StringTools.formatDouble((double)baseline / c.getValue() , "0.00") + " times as fast as baseline");
c = new Chronometer(true);
allMethod4();
c.stop();
System.out.println(c + " = " + StringTools.formatDouble((double)baseline / c.getValue() , "0.00") + " times as fast as baseline");
}
private static int method1(int n) {
return Integer.toString(n).length();
}
private static int method2(int n) {
if (n == 0)
return 1;
return (int)(Math.log10(n) + 1);
}
private static int method3(int n) {
if (n == 0)
return 1;
int l;
for (l = 0 ; n > 0 ;++l)
n /= 10;
return l;
}
private static int method4(int n) {
if (n < 100000) {
// 5 or less
if (n < 100) {
// 1 or 2
if (n < 10)
return 1;
else
return 2;
} else {
// 3 or 4 or 5
if (n < 1000)
return 3;
else {
// 4 or 5
if (n < 10000)
return 4;
else
return 5;
}
}
} else {
// 6 or more
if (n < 10000000) {
// 6 or 7
if (n < 1000000)
return 6;
else
return 7;
} else {
// 8 to 10
if (n < 100000000)
return 8;
else {
// 9 or 10
if (n < 1000000000)
return 9;
else
return 10;
}
}
}
}
private static int allMethod1() {
int x = 0;
for (int i = 0; i < 1000; i++)
x = method1(i);
for (int i = 1000; i < 100000; i += 10)
x = method1(i);
for (int i = 100000; i < 1000000; i += 100)
x = method1(i);
for (int i = 1000000; i < 2000000000; i += 200)
x = method1(i);
return x;
}
private static int allMethod2() {
int x = 0;
for (int i = 0; i < 1000; i++)
x = method2(i);
for (int i = 1000; i < 100000; i += 10)
x = method2(i);
for (int i = 100000; i < 1000000; i += 100)
x = method2(i);
for (int i = 1000000; i < 2000000000; i += 200)
x = method2(i);
return x;
}
private static int allMethod3() {
int x = 0;
for (int i = 0; i < 1000; i++)
x = method3(i);
for (int i = 1000; i < 100000; i += 10)
x = method3(i);
for (int i = 100000; i < 1000000; i += 100)
x = method3(i);
for (int i = 1000000; i < 2000000000; i += 200)
x = method3(i);
return x;
}
private static int allMethod4() {
int x = 0;
for (int i = 0; i < 1000; i++)
x = method4(i);
for (int i = 1000; i < 100000; i += 10)
x = method4(i);
for (int i = 100000; i < 1000000; i += 100)
x = method4(i);
for (int i = 1000000; i < 2000000000; i += 200)
x = method4(i);
return x;
}
다시 벤치마크:
- 베이스라인 메서드(String.length 사용): 2145ms
- log10 메서드: 711ms = 베이스라인의 3.02배 속도
- 반복 분할: 2797ms = 베이스라인의 0.77배 속도
- 분할 및 분할: 74ms = 베이스라인의 28.99배 속도
편집
벤치마크 작성 후 Java 6에서 Integer.toString으로 슬쩍 피크를 설정해 보니 다음 항목이 사용되고 있습니다.
final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
99999999, 999999999, Integer.MAX_VALUE };
// Requires positive x
static int stringSize(int x) {
for (int i=0; ; i++)
if (x <= sizeTable[i])
return i+1;
}
나는 그것을 divide-and-conquer 솔루션과 비교해서 벤치마킹했다.
- 분할 및 분리: 104 ms
- Java 6 솔루션 - 반복 및 비교: 406ms
내 것은 Java 6 솔루션보다 약 4배 빠릅니다.
벤치마크에 대한 두 가지 코멘트: Java는 복잡한 환경입니다.Just-In-Time 컴파일이나 가비지 수집 등이 있기 때문에 공정한 비교를 위해 벤치마크를 실행할 때마다 (a) 2개의 테스트를 시퀀스 5번 또는 10번 실행하는 루프로 묶습니다.루프를 통과하는 두 번째 경로의 실행 시간이 첫 번째 경로와 상당히 다른 경우가 많습니다.(b) 각 "접근" 후 System.gc()를 실행하여 가비지 컬렉션을 트리거합니다.그렇지 않으면 첫 번째 접근 방식에서는 다수의 개체가 생성될 수 있지만 가비지 수집을 강제할 정도는 아닙니다.다음으로 두 번째 접근 방식에서는 몇 개의 개체가 생성되고 힙이 모두 사용되며 가비지 수집이 실행됩니다.그리고 두 번째 접근법은 첫 번째 접근법에 의해 남겨진 쓰레기를 줍는 것에 대해 "과금"된다.너무 불공평해!
그러나 이 예에서는 위의 어느 것도 큰 차이를 보이지 않았다.
그런 수정을 했든 안 했든 간에, 저는 당신과 매우 다른 결과를 얻었습니다.실행 시 toString 접근법은 6400~6600밀리인 반면 로그는 topok 20,000~20,400밀리인 것으로 나타났습니다.나는 약간 빠른 대신 로그 접근 속도가 3배 느렸다.
두 가지 접근 방식은 비용이 매우 많이 들기 때문에 이는 그다지 충격적이지 않습니다.toString 접근법은 정리해야 하는 많은 임시 객체를 생성하는 반면 로그 접근법은 더 많은 계산을 필요로 합니다.따라서 메모리가 적은 시스템에서는 toString이 더 많은 가비지 수집 라운드를 필요로 하는 반면 프로세서가 느린 시스템에서는 로그의 추가 계산이 더 어려워질 수 있습니다.
세 번째 접근도 시도했습니다.제가 쓴 함수는 다음과 같습니다.
static int numlength(int n)
{
if (n == 0) return 1;
int l;
n=Math.abs(n);
for (l=0;n>0;++l)
n/=10;
return l;
}
1600밀리초에서 1900밀리초 사이에 실행되었습니다.이것은, ToString 어프로치의 1/3미만, 로그 어프로치의 1/10 미만입니다.
폭넓은 수의 경우 1,000 또는 1,000,000으로 나누어 루프를 통과하는 횟수를 줄임으로써 속도를 높일 수 있습니다.난 그걸 가지고 놀지 않았어.
아직 댓글을 달 수 없기 때문에 따로 댓글로 올리도록 하겠습니다.
로그 기반 솔루션은 다음과 같이 매우 큰 긴 정수에 대해 정확한 자릿수를 계산하지 않습니다.
long n = 99999999999999999L;
// correct answer: 17
int numberOfDigits = String.valueOf(n).length();
// incorrect answer: 18
int wrongNumberOfDigits = (int) (Math.log10(n) + 1);
로그 기반 솔루션은 큰 정수의 잘못된 자릿수를 계산합니다.
Java 사용
int nDigits = Math.floor(Math.log10(Math.abs(the_integer))) + 1;
import java.lang.Math.*;
C 사용
int nDigits = floor(log10(abs(the_integer))) + 1;
inclue math.h
정수의 밑수 10 자리수는 1 + truncate(log10(number))에 불과하므로 다음 작업을 수행할 수 있습니다.
public class Test {
public static void main(String[] args) {
final int number = 1234;
final int digits = 1 + (int)Math.floor(Math.log10(number));
System.out.println(digits);
}
}
지난 번 편집으로 코드 예가 수정되었지만 설명은 수정되지 않았기 때문에 편집되었습니다.
다른 스트링 어프로치.sweet - 의 정수인 - Sweetn.
int length = ("" + n).length();
Maryan의 솔루션은, 카피앤페이스트 하는 경우에 대비해, 긴 타입의 번호(최대 9,223,372,036,854,775,807)에 대응하고 있습니다.프로그램에서는 10000까지의 숫자에 대해 작성했을 가능성이 매우 높기 때문에 특정 브랜치를 작성했습니다.어쨌든 큰 차이는 없을 것이다.
public static int numberOfDigits (long n) {
// Guessing 4 digit numbers will be more probable.
// They are set in the first branch.
if (n < 10000L) { // from 1 to 4
if (n < 100L) { // 1 or 2
if (n < 10L) {
return 1;
} else {
return 2;
}
} else { // 3 or 4
if (n < 1000L) {
return 3;
} else {
return 4;
}
}
} else { // from 5 a 20 (albeit longs can't have more than 18 or 19)
if (n < 1000000000000L) { // from 5 to 12
if (n < 100000000L) { // from 5 to 8
if (n < 1000000L) { // 5 or 6
if (n < 100000L) {
return 5;
} else {
return 6;
}
} else { // 7 u 8
if (n < 10000000L) {
return 7;
} else {
return 8;
}
}
} else { // from 9 to 12
if (n < 10000000000L) { // 9 or 10
if (n < 1000000000L) {
return 9;
} else {
return 10;
}
} else { // 11 or 12
if (n < 100000000000L) {
return 11;
} else {
return 12;
}
}
}
} else { // from 13 to ... (18 or 20)
if (n < 10000000000000000L) { // from 13 to 16
if (n < 100000000000000L) { // 13 or 14
if (n < 10000000000000L) {
return 13;
} else {
return 14;
}
} else { // 15 or 16
if (n < 1000000000000000L) {
return 15;
} else {
return 16;
}
}
} else { // from 17 to ...¿20?
if (n < 1000000000000000000L) { // 17 or 18
if (n < 100000000000000000L) {
return 17;
} else {
return 18;
}
} else { // 19? Can it be?
// 10000000000000000000L is'nt a valid long.
return 19;
}
}
}
}
}
평범한 옛날 수학은 어때?0이 될 때까지 10으로 나누세요.
public static int getSize(long number) {
int count = 0;
while (number > 0) {
count += 1;
number = (number / 10);
}
return count;
}
해봐도 될까요?;)
Dirk의 솔루션에 근거해
final int digits = number==0?1:(1 + (int)Math.floor(Math.log10(Math.abs(number))));
Marian's Solution, Ternary와 함께합니다.
public int len(int n){
return (n<100000)?((n<100)?((n<10)?1:2):(n<1000)?3:((n<10000)?4:5)):((n<10000000)?((n<1000000)?6:7):((n<100000000)?8:((n<1000000000)?9:10)));
}
할 수 있으니까.
String API, utils, type 변환 없이 순수 Java 반복만 가능 ->
public static int getNumberOfDigits(int input) {
int numOfDigits = 1;
int base = 1;
while (input >= base * 10) {
base = base * 10;
numOfDigits++;
}
return numOfDigits;
}
괜찮으시다면 더 큰 가치를 추구하실 수 있습니다.
String 라이브러리를 사용하거나 Integer 클래스를 사용하는 사람도 있습니다.그건 문제될 게 없지만 자리수를 구하는 알고리즘은 그렇게 복잡하지 않아요.이 예에서는 long을 사용하고 있습니다만, int에서도 정상적으로 동작합니다.
private static int getLength(long num) {
int count = 1;
while (num >= 10) {
num = num / 10;
count++;
}
return count;
}
궁금해서 벤치마크를 해봤는데...
import org.junit.Test;
import static org.junit.Assert.*;
public class TestStack1306727 {
@Test
public void bench(){
int number=1000;
int a= String.valueOf(number).length();
int b= 1 + (int)Math.floor(Math.log10(number));
assertEquals(a,b);
int i=0;
int s=0;
long startTime = System.currentTimeMillis();
for(i=0, s=0; i< 100000000; i++){
a= String.valueOf(number).length();
s+=a;
}
long stopTime = System.currentTimeMillis();
long runTime = stopTime - startTime;
System.out.println("Run time 1: " + runTime);
System.out.println("s: "+s);
startTime = System.currentTimeMillis();
for(i=0,s=0; i< 100000000; i++){
b= number==0?1:(1 + (int)Math.floor(Math.log10(Math.abs(number))));
s+=b;
}
stopTime = System.currentTimeMillis();
runTime = stopTime - startTime;
System.out.println("Run time 2: " + runTime);
System.out.println("s: "+s);
assertEquals(a,b);
}
}
결과는 다음과 같습니다.
실행시간 1: 6765s: 400000000실행시간 2: 6000s: 400000000
벤치마크 자체가 여러 번 실행되어도 일관된 결과(밀리초 이내의 변화)를 얻을 수 있을지 의문입니다.이것을 최적화하려고 해도 소용없을 것 같습니다.
edit: ptomli의 코멘트에 따라 위의 코드에서 'number'를 'i'로 대체하고 벤치를 5회 실행한 결과 다음과 같은 결과를 얻었습니다.
실행시간 1: 11500s: 7888890실행시간 2: 8547s: 7888890 실행시간 1: 11485s: 7888890실행시간 2: 8547s: 7888890 실행시간 1: 11469s: 7888890실행시간 2: 8547s: 7888890 실행시간 1: 11500s: 7888890실행시간 2: 8547s: 7888890 실행시간 1: 11484s: 7888890실행시간 2: 8547s: 7888890
설계(문제 기반)이것은 divide-and-conquer의 대체 수단입니다.먼저 열거형을 정의합니다(부호가 없는 int에 대해서만 고려).
public enum IntegerLength {
One((byte)1,10),
Two((byte)2,100),
Three((byte)3,1000),
Four((byte)4,10000),
Five((byte)5,100000),
Six((byte)6,1000000),
Seven((byte)7,10000000),
Eight((byte)8,100000000),
Nine((byte)9,1000000000);
byte length;
int value;
IntegerLength(byte len,int value) {
this.length = len;
this.value = value;
}
public byte getLenght() {
return length;
}
public int getValue() {
return value;
}
}
이제 enum 값을 통과하는 클래스를 정의하고 적절한 길이를 비교 및 반환합니다.
public class IntegerLenght {
public static byte calculateIntLenght(int num) {
for(IntegerLength v : IntegerLength.values()) {
if(num < v.getValue()){
return v.getLenght();
}
}
return 0;
}
}
이 솔루션의 실행 시간은 divide-and-conquer 접근 방식과 동일합니다.
이 재귀적 방법은 어떻습니까?
private static int length = 0;
public static int length(int n) {
length++;
if((n / 10) < 10) {
length++;
} else {
length(n / 10);
}
return length;
}
심플한 솔루션:
public class long_length {
long x,l=1,n;
for (n=10;n<x;n*=10){
if (x/n!=0){
l++;
}
}
System.out.print(l);
}
매우 심플한 솔루션:
public int numLength(int n) {
for (int length = 1; n % Math.pow(10, length) != n; length++) {}
return length;
}
또는 원하는 숫자보다 숫자가 큰지 작은지 확인할 수 있습니다.
public void createCard(int cardNumber, int cardStatus, int customerId) throws SQLException {
if(cardDao.checkIfCardExists(cardNumber) == false) {
if(cardDao.createCard(cardNumber, cardStatus, customerId) == true) {
System.out.println("Card created successfully");
} else {
}
} else {
System.out.println("Card already exists, try with another Card Number");
do {
System.out.println("Enter your new Card Number: ");
scan = new Scanner(System.in);
int inputCardNumber = scan.nextInt();
cardNumber = inputCardNumber;
} while(cardNumber < 95000000);
cardDao.createCard(cardNumber, cardStatus, customerId);
}
}
}
곱셈 기반의 솔루션은 아직 본 적이 없습니다., 은 수백만 사례에 다소 수 , ', 눗, 눗, 눗, 눗, -, -, -, -, -, -, -, -, -, -, -, -, -, -, -, -, -, -, -, -, -에 대한 이 있습니다.이러한 테스트 사례를 다음에 제시하겠습니다.ints:
/**
* Returns the number of digits needed to represents an {@code int} value in
* the given radix, disregarding any sign.
*/
public static int len(int n, int radix) {
radixCheck(radix);
// if you want to establish some limitation other than radix > 2
n = Math.abs(n);
int len = 1;
long min = radix - 1;
while (n > min) {
n -= min;
min *= radix;
len++;
}
return len;
}
베이스 10에서는 n이 본질적으로 9, 99, 999와 비교되기 때문에 이것이 동작합니다.9살, 90살, 900살...그리고 n은 9, 90, 900을 뺀다.
이것은 할 수 .long의 모든 하는 것만으로int오버플로우 때문에한편, 2번 베이스와 10번 베이스에서는 동작합니다(단, 다른 베이스의 대부분은 실패).오버플로우 포인트에 대한 룩업 테이블(또는 나눗셈 테스트...)이 필요합니다.으으으)
/**
* For radices 2 &le r &le Character.MAX_VALUE (36)
*/
private static long[] overflowpt = {-1, -1, 4611686018427387904L,
8105110306037952534L, 3458764513820540928L, 5960464477539062500L,
3948651115268014080L, 3351275184499704042L, 8070450532247928832L,
1200757082375992968L, 9000000000000000000L, 5054470284992937710L,
2033726847845400576L, 7984999310198158092L, 2022385242251558912L,
6130514465332031250L, 1080863910568919040L, 2694045224950414864L,
6371827248895377408L, 756953702320627062L, 1556480000000000000L,
3089447554782389220L, 5939011215544737792L, 482121737504447062L,
839967991029301248L, 1430511474609375000L, 2385723916542054400L,
3902460517721977146L, 6269893157408735232L, 341614273439763212L,
513726300000000000L, 762254306892144930L, 1116892707587883008L,
1617347408439258144L, 2316231840055068672L, 3282671350683593750L,
4606759634479349760L};
public static int len(long n, int radix) {
radixCheck(radix);
n = abs(n);
int len = 1;
long min = radix - 1;
while (n > min) {
len++;
if (min == overflowpt[radix]) break;
n -= min;
min *= radix;
}
return len;
}
이것을 실시하는 것은, 주로 「제시」하고 싶다고 생각하고 있기 때문입니다.즉, 최종적으로, 명시적 또는 암묵적으로 「ToString-ed」(또는 다른 방법으로 변환)를 실시할 필요가 있는 것입니다.그 후에, 제시(예를 들면 인쇄)할 수 있습니다.
이 경우 필요한 "toString"을 명시하고 비트를 카운트합니다.
재귀 루프를 사용하여 이를 달성할 수 있습니다.
public static int digitCount(int numberInput, int i) {
while (numberInput > 0) {
i++;
numberInput = numberInput / 10;
digitCount(numberInput, i);
}
return i;
}
public static void printString() {
int numberInput = 1234567;
int digitCount = digitCount(numberInput, 0);
System.out.println("Count of digit in ["+numberInput+"] is ["+digitCount+"]");
}
는 제가 쓴 입니다.Integer.java소스 코드
private static int stringSize(int x) {
final int[] sizeTable = {9, 99, 999, 9_999, 99_999, 999_999, 9_999_999,
99_999_999, 999_999_999, Integer.MAX_VALUE};
for (int i = 0; ; ++i) {
if (x <= sizeTable[i]) {
return i + 1;
}
}
}
「」의 하는 .int변수는 필요한 수의 조건부 문이 있는 메서드 digits Counter를 정의하는 것입니다.
. 우리는 각 범위를 체크할 것입니다.n숫자 번호는 다음과 같습니다.
0 : 9는Single 번호(표준)
10 : 99는Double 번호(표준)
100 : 999는Triple★★★★★★★★★★★★★★★★★★▼
static int digitsCounter(int N)
{ // N = Math.abs(N); // if `N` is -ve
if (0 <= N && N <= 9) return 1;
if (10 <= N && N <= 99) return 2;
if (100 <= N && N <= 999) return 3;
if (1000 <= N && N <= 9999) return 4;
if (10000 <= N && N <= 99999) return 5;
if (100000 <= N && N <= 999999) return 6;
if (1000000 <= N && N <= 9999999) return 7;
if (10000000 <= N && N <= 99999999) return 8;
if (100000000 <= N && N <= 999999999) return 9;
return 10;
}
더 깔끔한 방법은 순차적으로 진행하면 필요하지 않으므로 하한 검사를 제거하는 것입니다.
static int digitsCounter(int N)
{
N = N < 0 ? -N : N;
if (N <= 9) return 1;
if (N <= 99) return 2;
if (N <= 999) return 3;
if (N <= 9999) return 4;
if (N <= 99999) return 5;
if (N <= 999999) return 6;
if (N <= 9999999) return 7;
if (N <= 99999999) return 8;
if (N <= 999999999) return 9;
return 10; // Max possible digits in an 'int'
}
다음은 모든 숫자에 사용할 수 있는 매우 간단한 방법입니다.
public static int numberLength(int userNumber) {
int numberCounter = 10;
boolean condition = true;
int digitLength = 1;
while (condition) {
int numberRatio = userNumber / numberCounter;
if (numberRatio < 1) {
condition = false;
} else {
digitLength++;
numberCounter *= 10;
}
}
return digitLength;
}
숫자 카운터 변수와 함께 작동하는 방법은 10 = 1자리 공간입니다.예를 들어, .1 = 1/10 => 1자리 공백입니다.그렇기 때문에int number = 103342;6은 0.000001 스페이스와 같기 때문입니다.또, 다른 변수 이름 가지고 계신 분?numberCounter더 좋은 생각이 안 나네요
편집: 더 나은 설명이 생각났어요.기본적으로 이 while loop이 하는 일은 숫자를 10으로 나누어서 1보다 작아질 때까지 하는 것입니다.기본적으로 10으로 나누면 1개의 숫자 공간이 뒤로 이동하기 때문에 숫자 1보다 작은 자릿수가 될 때까지 10으로 나누기만 하면 됩니다.
다음은 10진수로 숫자를 셀 수 있는 다른 버전입니다.
public static int repeatingLength(double decimalNumber) {
int numberCounter = 1;
boolean condition = true;
int digitLength = 1;
while (condition) {
double numberRatio = decimalNumber * numberCounter;
if ((numberRatio - Math.round(numberRatio)) < 0.0000001) {
condition = false;
} else {
digitLength++;
numberCounter *= 10;
}
}
return digitLength - 1;
}
언급URL : https://stackoverflow.com/questions/1306727/way-to-get-number-of-digits-in-an-int
'programing' 카테고리의 다른 글
| 정의와 선언의 차이점은 무엇입니까? (0) | 2022.08.13 |
|---|---|
| Nuxt 가져오기 내에서 Vuex 작업이 "함수가 아님" (0) | 2022.08.13 |
| Vue 템플릿에서 사용자 지정 특성 바인딩이 가능합니까? (0) | 2022.08.13 |
| 계산된 VueJ의 이전 값에 액세스합니다.s (0) | 2022.08.13 |
| Nuxt SSR와 FireBase 통합 (0) | 2022.08.13 |