Funnily enough, I came here because of the same link, having noticed that the code doesn't use this approach.

Here is how I implemented the algorithm, if someone wants to use it as a base for a pull request (However I see that you also already submitted a pull request for this - doing much more than just this code, so feel free to ignore):

trait SetBits {
    fn get_set_bits(&self) -> Bit_Iterator;
}

impl SetBits for usize {
    fn get_set_bits(&self) -> Bit_Iterator {
        Bit_Iterator { remaining: *self, bit_index: 0 }
    }
}

#[derive(Debug)]
struct Bit_Iterator {
    remaining: usize,
    bit_index: usize,
}

impl Iterator for Bit_Iterator {
    type Item = usize;
    fn next(&mut self) -> Option<Self::Item> {
        let mut index = 0;
        if self.remaining == 0 {
            return None;
        }
        let least_significant_bit = (self.remaining as isize & -(self.remaining as isize)) as usize;
        index = self.remaining.trailing_zeros() as usize;
        self.remaining ^= least_significant_bit;
        Some(index)
    }
}

Implement ones using trailing_zeros #17

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

Implement `ones` using `trailing_zeros` #17