Read lines in pairs from stdin in rust

Question

My input data is structured as follows:

label_1
value_1
label_2
value_2
...

And my end goal is to read that data into a HashMap

My current working approach is to put even and odd lines in two separate vectors and then read from both vectors to add to Hashmap.

use std::io;
use std::io::prelude::*;
use std::collections::HashMap;

fn main() {
    
    let mut labels: Vec<String> = Vec::new();
    let mut values: Vec<String> = Vec::new();
     
    let stdin = io::stdin();

    /* Read lines piped from stdin*/
    for (i, line) in stdin.lock().lines().enumerate() {
    
        if i % 2 == 0 {
            /* store labels (even lines) in labels vector */
            labels.push(line.unwrap());

        } else {
            /* Store values (odd lines) in values vector */
            values.push(line.unwrap());
        }
    }

    println!("number of labels: {}", labels.len());
    println!("number of values: {}", values.len());
    


    /* Zip labels and values into one iterator */
    let double_iter = labels.iter().zip(values.iter());

    /* insert (label: value) pairs into hashmap */
    let mut records: HashMap<&String, &String> = HashMap::new();
    for (label, value) in double_iter {
        records.insert(label, value);
    }
}

I would like ask how to achieve this result without going though an intermediary step with vectors ?

kmdreko · Accepted Answer · 2020-12-14T09:09:40.370

3

You can use .tuples() from the itertools crate:

use itertools::Itertools;
use std::io::{stdin, BufRead};

fn main() {
    for (label, value) in stdin().lock().lines().tuples() {
        println!("{}: {}", label.unwrap(), value.unwrap());
    }
}

See also:

This answer on "Are there equivalents to slice::chunks/windows for iterators to loop over pairs, triplets etc?"

edited Dec 14 '20 at 09:09

answered Dec 14 '20 at 07:48

kmdreko

42,554
6
57
106

Note that this fails silently when there is an unpaired line, unlike the [next answer](https://stackoverflow.com/a/65283641/617159). – Lambda Fairy Dec 14 '20 at 21:26

score 2 · Answer 2 · answered Dec 14 '20 at 04:33

You can manually advance an iterator with .next()

use std::io;
use std::io::prelude::*;
use std::collections::HashMap;

fn main() {
    let stdin = io::stdin();
    let mut lines = stdin.lock().lines();
    let mut records = HashMap::new();

    while let Some(label) = lines.next() {
        let value = lines.next().expect("No value for label");
        records.insert(label.unwrap(), value.unwrap());
    }
}

Playground

score 0 · Answer 3 · answered Dec 14 '20 at 04:02

0

How about:

fn main() {
    let lines = vec![1,2,3,4,5,6];
    let mut records = std::collections::HashMap::new();

    for i in (0..lines.len()).step_by(2) {
        // make sure the `i+1` is existed
        println!("{}{}", lines[i], lines[i + 1]);
        records.insert(lines[i], lines[i + 1]);
    }
}

answered Dec 14 '20 at 04:02

AurevoirXavier

2,543
2
17
25

1

If you already have a vector, then you may as well use [`.chunks(2)`](https://doc.rust-lang.org/std/primitive.slice.html#method.chunks) instead. – Lambda Fairy Dec 14 '20 at 04:51

Read lines in pairs from stdin in rust

3 Answers3