Блог

Я пытаюсь получить длину (количество цифр при интерпретации в десятичном формате) int в rust. Я нашел способ сделать это, однако ищу метод, который исходит из самого примитива. Это то, что у меня есть:

 let num = 90.to_string();
println!("num: {}", num.chars().count())
// num: 2
 

Я смотрю на https://docs.rs/digits/0.3.3/digits/struct.Метод Digits.html#.длина. это хороший кандидат? Как мне его использовать? Или есть другие ящики, которые делают это за меня?

Один лайнер с меньшим преобразованием типов-идеальное решение, которое я ищу.

Вы можете сделать цикл и проверить, как часто вы можете делить число на 10, прежде чем оно превратится в одну цифру. Или в другом направлении (поскольку деление происходит медленнее, чем умножение), проверьте, как часто вы можете умножать 10*10*...*10 , пока не достигнете нужного числа:

 fn length(n: u32, base: u32) -> u32 {
    let mut power = base;
    let mut count = 1;
    while n >= power {
        count  = 1;
        if let Some(new_power) = power.checked_mul(base) {
            power = new_power;
        } else {
            break;
        }
    }
    count
}
 

С ночной ржавчиной (или в будущем, когда int_log функция стабилизируется) вы можете использовать:

 #![feature(int_log)]

n.checked_log10().unwrap_or(0)   1
 

Вот однострочный, который не требует строк или плавающей запятой:

 println!("num: {}", successors(Some(n), |amp;n| (n >= 10).then(|| n / 10)).count());
 

Он просто подсчитывает, сколько раз начальное число нужно разделить на 10, чтобы достичь 0.

РЕДАКТИРОВАТЬ: первая версия этого ответа использовалась iterate из (превосходного и настоятельно рекомендуемого) itertools ящика, но @trentcl указал, что successors из stdlib делает то же самое. Для справки, вот версия с использованием iterate :

 println!("num: {}", iterate(n, |amp;n| n / 10).take_while(|amp;n| n > 0).count().max(1));
 

Вот (едва ли) однострочный текст, который быстрее, чем преобразование строк с использованием std::iter:

 let some_int = 9834;
let decimal_places = (0..).take_while(|i| 10u64.pow(*i) <= some_int).count();
 

Первый метод, приведенный ниже, основан на следующей формуле, где a и b являются логарифмическими основаниями.

 log<a>( x ) = log<b>( x ) / log<b>( a )

log<a>( x ) = log<2>( x ) / log<2>( a )  // Substituting 2 for `b`.
 

Следующая функция может быть применена для определения количества цифр для оснований, которые имеют степень 2. Этот подход очень быстрый.

 fn num_digits_base_pow2(n: u64, b: u32) -> u32
{
    (63 - n.leading_zeros()) / (31 - b.leading_zeros())   1
}
 

Биты подсчитываются как n для (числа, которое мы хотим представить), так и b для (базы), чтобы найти их значения уровня log2. Затем скорректированное соотношение этих значений дает значение журнала потолка в нужной базе.

Для подхода общего назначения к нахождению количества цифр для произвольных оснований должно быть достаточно следующего.

 fn num_digits(n: u64, b: u32) -> u32
{
    (n as f64).log(b as f64).ceil() as u32
}
 

Хорошее свойство чисел, которое всегда полезно иметь в виду, состоит в том, что количество цифр, необходимых для записи числа $x$ в базе $n$, на самом деле равно $lceil log_n(x 1) rceil$.

Поэтому можно просто написать следующую функцию (обратите внимание на приведение от u32 к f32 , так как целые числа не имеют функции журнала).

 fn length(n: u32, base: u32) -> u32 {
    let n = (n 1) as f32;
    n.log(base as f32).ceil() as u32
}
 

Вы можете легко адаптировать его для отрицательных чисел. Для чисел с плавающей запятой это может быть немного (т. Е. Намного) сложнее.

Чтобы принять во внимание комментарий Даниэля о патологических случаях, возникающих при использовании f32, обратите внимание, что в случае ночной ржавчины целые числа имеют метод логарифма. (Обратите внимание, что, имо, это детали реализации, и вам следует больше сосредоточиться на понимании алгоритма, чем на реализации.):

 #![feature(int_log)]

fn length(n: u32, base: u32) -> u32 {
    n.log(base)   1
}