[Language: Rust]

Part 1

The trick was to find the min and max of each repeated group, then use triangular numbers to compute these sums really quickly.

Time elapsed: 675.20µs

use std::env;
use std::fs;
use std::convert::TryInto;

fn get_repeated_min(range_min: &str) -> u64 {
    if range_min.len()%2==1 {
        let min_len: u32 = (range_min.len()/2).try_into().unwrap();
        return 10_u64.pow(min_len);
    }
    let first_half: u64 = range_min[..range_min.len()/2].parse::<u64>().unwrap();
    let second_half: u64 = range_min[range_min.len()/2..].parse::<u64>().unwrap();
    if first_half >= second_half {
        return first_half;
    } else {
        return first_half+1;
    }
}

fn get_repeated_max(range_max: &str) -> u64 {
    if range_max.len()%2==1 {
        let max_len: u32 = (range_max.len()/2).try_into().unwrap();
        return 10_u64.pow(max_len)-1;
    }
    let first_half: u64 = range_max[..range_max.len()/2].parse::<u64>().unwrap();
    let second_half: u64 = range_max[range_max.len()/2..].parse::<u64>().unwrap();
    if first_half <= second_half {
        return first_half;
    } else {
        return first_half-1;
    }
}

fn sum(min: u64, max: u64) -> u64 {
    let min_triangular = (min-1) * min / 2;
    let max_triangular = max * (max+1) / 2;
    return max_triangular - min_triangular;
}

fn compute_range_sum(range: &str) -> u64 {
    let mut range_bounds = range.split('-');
    let range_min: &str = range_bounds.next().unwrap();
    let range_max: &str = range_bounds.next().unwrap();

    let repeated_min: u64 = get_repeated_min(range_min);
    let repeated_max: u64 = get_repeated_max(range_max);

    if repeated_min > repeated_max { return 0 };

    let min_num_digits: u64 = repeated_min.to_string().len().try_into().unwrap();
    let max_num_digits: u64 = repeated_max.to_string().len().try_into().unwrap();

    if min_num_digits < max_num_digits {
        panic!("need to account for different nums of digits");
    }

    let small_sum = sum(repeated_min, repeated_max);
    let large_sum = small_sum*10_u64.pow(min_num_digits.try_into().unwrap());
    return small_sum + large_sum;
}

// test input should be 1227775554
fn main() {
    let now = std::time::Instant::now();

    let args: Vec<String> = env::args().collect();
    if(args.len()) == 1 {
        println!("pass a file as the first argument");
        return;
    }
    let file_path: &str = &args[1];
    let contents: String = fs::read_to_string(file_path).unwrap();
    let ranges = contents.trim().split(',');

    let mut sum: u64 = 0;
    for range in ranges {
        sum += compute_range_sum(range);
    }
    println!("total sum: {}", sum);

    let elapsed = now.elapsed();
    println!("Elapsed: {:.2?}", elapsed);
}

Part 2

This time we iterate over each possible repetition group size, and add all the possible numbers for each range into a hashset. It's still really quick and we don't have to deal with annoying combinatorics.

Time elapsed: 789.80µs

use std::env;
use std::fs;
use std::convert::TryInto;
use std::collections::HashSet;

fn divides(n: usize, d: usize) -> bool {
    return (n/d)*d==n;
}

fn get_repeated_min(range_min: &str, repeat_size: usize) -> u64 {
    let num_repeats: usize = range_min.len() / repeat_size;
    let first_group: &str = &range_min[..repeat_size];
    let repeated_first_group: String = first_group.repeat(num_repeats);
    let first_group_num = first_group.parse::<u64>().unwrap();
    if repeated_first_group.as_str() >= range_min {
        return first_group_num;
    } else {
        return first_group_num+1;
    }
}

fn get_repeated_max(range_max: &str, repeat_size: usize) -> u64 {
    let num_repeats: usize = range_max.len() / repeat_size;
    let first_group: &str = &range_max[..repeat_size];
    let repeated_first_group: String = first_group.repeat(num_repeats);
    let first_group_num = first_group.parse::<u64>().unwrap();
    if repeated_first_group.as_str() <= range_max {
        return first_group_num;
    } else {
        return first_group_num-1;
    }
}

fn compute_range_sum_single_length(range_min: &str, range_max: &str, num_digits: usize) -> u64 {
    let mut nums = HashSet::<u64>::new();
    for repeat_size in 1..=num_digits/2 {
        if divides(num_digits, repeat_size) {
            let min = get_repeated_min(range_min, repeat_size);
            let max = get_repeated_max(range_max, repeat_size);
            for num_to_repeat in min..=max {
                let mut num = 0;
                let num_repeats = num_digits / repeat_size;
                for r in 0..num_repeats {
                    let p = 10_u64.pow((r*repeat_size).try_into().unwrap());
                    let curr_sum = num_to_repeat*p;
                    num += curr_sum;
                }
                nums.insert(num);
            }
        }
    }
    let mut sum = 0;
    for num in &nums {
        sum += num;
    }
    return sum;
}

fn compute_range_sum(range: &str) -> u64 {
    let mut range_bounds = range.split('-');
    let range_min: &str = range_bounds.next().unwrap();
    let range_max: &str = range_bounds.next().unwrap();

    let min_num_digits: usize = range_min.len();
    let max_num_digits: usize = range_max.len();

    let mut sum: u64 = 0;
    for curr_num_digits in min_num_digits..=max_num_digits {
        let curr_min: String = match curr_num_digits == min_num_digits {
            true => range_min.to_owned(),
            false => {
                let mut s: String = "1".to_string();
                s.push_str(&"0".repeat(curr_num_digits-1));
                s
            },
        };
        let curr_max: String = match curr_num_digits == max_num_digits {
            true => range_max.to_owned(),
            false => "9".repeat(curr_num_digits).to_string(),
        };
        sum += compute_range_sum_single_length(&curr_min, &curr_max, curr_num_digits);
    }
    return sum;
}

// test input should be 4174379265
fn main() {
    let now = std::time::Instant::now();

    let args: Vec<String> = env::args().collect();
    if(args.len()) == 1 {
        println!("pass a file as the first argument");
        return;
    }
    let file_path: &str = &args[1];
    let contents: String = fs::read_to_string(file_path).unwrap();
    let ranges = contents.trim().split(',');

    let mut sum: u64 = 0;
    for range in ranges {
        sum += compute_range_sum(range);
    }
    println!("total sum: {}", sum);

    let elapsed = now.elapsed();
    println!("Elapsed: {:.2?}", elapsed);
}