array_num_count.rs

//  Программа для подсчета количества одинаковых чисел в массиве
use std::io::BufRead;
use std::io::BufReader;
use std::fs::OpenOptions;
use std::str::FromStr;  //  Для преобразования чисел из строк
use std::collections::BTreeMap; //  Для нашего хранилища

static  APP_NAME:   &str  = "array_num_count";
static  BUF_SIZE:   usize = 0x10000;
static  DELIM:  &str = "#--------------------------------";

//-------------------------------------------------------------------
//  Начало программы
fn  main()
{
    //  Породим вектор с аргументами командной строки
    let argv:Vec<String> = std::env::args().collect();

    if  argv.len() > 1
    {
        for i in 1..argv.len()
        {
            //  Попробуем открыть на чтение файл с именем,
            //  содержащимся в векторе argv по индексу i
            match   OpenOptions::new().read(true).open(&argv[i])
            {
                Ok( f ) =>
                {
                    println!( "{}", DELIM );
                    println!( "Обрабатываем файл '{}':",
                        &argv[i] );
                    //  Обработаем файл
                    process_file( &f );
                    println!( "{}", DELIM );
                },
                Err( err ) =>
                {
                    eprintln!( "Ошибка открытия {}: {}",
                         &argv[i], err );
                }
            }
        }
    }
    else
    {
        println!( "Использование:" );
        println!( "{} <файл1> ... <файлN>", APP_NAME );
    }
}
//-------------------------------------------------------------------
fn  process_file( file : &std::fs::File )
{
    //  Породим BufReader
    let reader = BufReader::with_capacity( BUF_SIZE, file );
    //  Хранилище информации о числе цифр в массиве
    //  Ключом является число из массива типа i64, значением - счетчик
    //  таких чисел типа u64
    let mut storage : BTreeMap<i64,u64> = BTreeMap::new();

    //  Построчное считывание файла
    for (n,line) in reader.lines().enumerate()
    {
        match   line
        {
            Ok( l ) =>
            {
                //  Произведем разбор считанной строки
                process_array_line( &l, &mut storage );
            },
            Err( err ) =>
            {
                eprintln!( "Ошибка считывания строки {}: {}",
                    n, err );
            }
        }
    }

    println!( "Частота встречи чисел в массиве:" );
    for (num,count) in &storage
    {
        println!( "Частота встречи числа {} в массиве: {} раза", num, count );
    }
}
//-------------------------------------------------------------------
fn  process_array_line( line: &std::string::String,
        map: &mut BTreeMap<i64,u64> )
{
    //  Превратим строку чисел, разделенных пробелами и табуляцией
    //  в вектор из отедльных полей
    let num_str : Vec<&str> = line.split_whitespace().collect();

    for ns in num_str
    {
        //  Попробуем преобразовать каждый элемент вектора
        //  из строки в число
        match   i64::from_str( ns )
        {
            //  Перборазование удалось?
            Ok( val ) =>
            {
                //  Найдем в хранилище элемент с ключом,
                //  равным текущему числу или добавим
                //  такой ключ со счетчиком, равным 0,
                //  если его еще не существует
                let entry = map.entry( val ).or_insert( 0 );
                //  Увеличим счетчик количества чисел в
                //  массиве для данного числа на единицу
                *entry += 1;
            },
            //  Не, не удалось, надо вывести сообщение об ошибке
            Err( err ) =>
            {
                eprintln!( "Ошибка преобразования '{}' в i64: {}",
                    ns, err );
            },
        }
    }

}
//-------------------------------------------------------------------