CODEWITHSUNDEEP
stringvectorrust
Jared Mackey
Jared Mackey

Reputation: 4158

Convert int to a vector of strings

I am trying to convert long numbers to a string vector. For example, 17562 would become ["1", "7", "5", "6", "2"]. I have seen a lot of examples of converting ints to strings, but no ints to string vectors. I want to iterate over each digit individually.

Here is what I have so far, but it isn't working. 

fn main() {
    let x = 42;
    let values: Vec<&str> = x.to_string().split(|c: char| c.is_alphabetic()).collect();
    println!("{:?}", values);     
}

Gives me the compiler error of :

<anon>:3:29: 3:42 error: borrowed value does not live long enough
<anon>:3     let values: Vec<&str> = x.to_string().split(|c: char| c.is_alphabetic()).collect();

<anon>:3:88: 6:2 note: reference must be valid for the block suffix following statement 1 at 3:87...
<anon>:3     let values: Vec<&str> = x.to_string().split(|c: char| c.is_alphabetic()).collect();
<anon>:4     println!("{:?}", values);
<anon>:5     
<anon>:6 }
<anon>:3:5: 3:88 note: ...but borrowed value is only valid for the statement at 3:4
<anon>:3     let values: Vec<&str> = x.to_string().split(|c: char| c.is_alphabetic()).collect();

<anon>:3:5: 3:88 help: consider using a `let` binding to increase its lifetime
<anon>:3     let values: Vec<&str> = x.to_string().split(|c: char| c.is_alphabetic()).collect();

The equivalent of what I am trying to do in python would be x = 42; x = list(str(x)); print(x)

Upvotes: 1

Views: 176

Answers (3)

Johan Larsson
Johan Larsson

Reputation: 17580

What about:

let ss = value.to_string()
              .chars()
              .map(|c| c.to_string())
              .collect::<Vec<_>>();

Demo

Not the greatest perf but reads well.

Upvotes: 1

DK.
DK.

Reputation: 58975

Ok, the first problem is that you don't store the result of x.to_string() anywhere. As such, it will cease to exist at the end of the expression, meaning that values will be trying to reference a value that no longer exists. Hence the error. The simplest solution is to just store the temporary string somewhere so that it continues to exist:

fn main() {
    let x = 42;
    let x_str = x.to_string();
    let values: Vec<&str> = x_str.split(|c: char| c.is_alphabetic()).collect();
    println!("{:?}", values);     
}

Second problem: this outputs ["42"] because you told it to split on letters. You probably meant to use is_numeric:

fn main() {
    let x = 42;
    let x_str = x.to_string();
    let values: Vec<&str> = x_str.split(|c: char| c.is_numeric()).collect();
    println!("{:?}", values);     
}

Third problem: this outputs ["", "", ""], because those are the three strings between numeric characters. Split's argument is the separator. Thus, the third problem is that you're using entirely the wrong method to begin with.

The closest direct equivalent to the Python code you listed would be:

fn main() {
    let x = 42;
    let values: Vec<String> = x.to_string().chars().map(|c| c.to_string()).collect();
    println!("{:?}", values);     
}

At last, it outputs: ["4", "2"].

But, this is horribly inefficient: this takes the integer, allocates an intermediate buffer, prints the integer to it, turns it into a string. It takes each code point in that string, allocates an intermediate buffer, prints the code point to it, turns it into a string. Then it collects all these strings into a Vec, possibly reallocating more than once.

It works, but is a bit wasteful. If you don't care about waste, you can stop reading now.

You can make things a bit less wasteful by collecting code points instead of strings:

fn main() {
    let x = 42;
    let values: Vec<char> = x.to_string().chars().collect();
    println!("{:?}", values);     
}

This outputs: ['4', '2']. Note the different quotes because we're using char instead of String.

We can remove the intermediate allocations from Vec resizing by pre-allocating its storage, which gives us this version:

fn main() {
    let x = 42u32; // no negatives!
    let values = {
        if x == 0 {
            vec!['0']
        } else {
            // pre-allocate Vec so there's no resizing
            let digits = 1 + (x as f64).log10() as u32;
            let mut cs = Vec::with_capacity(digits as usize);
            let mut div = 10u32.pow(digits - 1);
            while div > 0 {
                cs.push((b'0' + ((x / div) % 10) as u8) as char);
                div /= 10;
            }
            cs
        }
    };
    println!("{:?}", values);     
}

Unless you're doing this in a loop, I'd just stick to the correct, wasteful version.

Upvotes: 6

Shepmaster
Shepmaster

Reputation: 430426

If you are looking for a performant version, I'd just use this

fn digits(mut val: u64) -> Vec<u8> {
    // An unsigned 64-bit number can have 20 digits
    let mut result = Vec::with_capacity(20);

    loop {
        let digit = val % 10;
        val = val / 10;
        result.push(digit as u8);

        if val == 0 { break }
    }

    result.reverse();
    result
}

fn main() {
    println!("{:?}", digits(0));
    println!("{:?}", digits(1));
    println!("{:?}", digits(9));
    println!("{:?}", digits(10));
    println!("{:?}", digits(11));
    println!("{:?}", digits(1234567890));
    println!("{:?}", digits(0xFFFFFFFFFFFFFFFF));
}

This may over allocate by a few bytes, but 20 bytes total is small unless you are doing this a whole bunch. It also leaves each value as a number, which you can convert to a string as needed.

Upvotes: 3

Related Questions