AtCoder Beginner Contest 379 E

https://atcoder.jp/contests/abc379/tasks/abc379_e

これは和を取る順序を変える問題ですね。より具体的には各数字がどの桁で何回使うかを調べます。例えば123だと1は123なら100、12なら10、1なら1となるので、1は111になります。
ちゃんと書くと、k桁の数字をと書いて、

jとkの和の順序を変えて、

iとkの和の順序を変えて、



これを計算すればよいです。

// Sum of All Substrings
#![allow(non_snake_case)]


//////////////////// library ////////////////////

fn read<T: std::str::FromStr>() -> T {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).ok();
    line.trim().parse().ok().unwrap()
}


//////////////////// BigInteger ////////////////////

struct BigInteger {
    ds: Vec<i64>
}

impl BigInteger {
    fn add(&mut self, mut n: i64, mut k: usize) {
        let mut carry: i64 = 0;
        while n > 0 || carry > 0 {
            let d = n % 10;
            n /= 10;
            while k >= self.ds.len() {
                self.ds.push(0)
            }
            let m = d + self.ds[k] + carry;
            let r = m % 10;
            self.ds[k] = r;
            carry = m / 10;
            k += 1
        }
    }
    
    fn sub(&mut self, mut n: i64) {
        let mut k: usize = 0;
        let mut borrowing: i64 = 0;
        while n > 0 || borrowing > 0 {
            let d = n % 10;
            n /= 10;
            if d + borrowing > self.ds[k] {
                self.ds[k] += 10 - (d + borrowing);
                borrowing = 1
            }
            else {
                self.ds[k] -= d + borrowing;
                borrowing = 0
            }
            k += 1
        }
    }
    
    fn div(&self, d: i64) -> BigInteger {
        let mut rev_ds: Vec<i64> = vec![];
        let mut carry: i64 = 0;
        for &n in self.ds.iter().rev() {
            let m = carry * 10 + n;
            let q = m / d;
            if !rev_ds.is_empty() || q != 0 {
                rev_ds.push(q)
            }
            carry = m % d
        }
        let ds: Vec<i64> = rev_ds.into_iter().rev().collect();
        BigInteger { ds }
    }
    
    fn to_string(&self) -> String {
        self.ds.iter().rev().map(|&d| d.to_string()).
                                collect::<Vec<_>>().join("")
    }
    
    fn create_from_String(S: String) -> BigInteger {
        let ds: Vec<i64> = S.as_bytes().iter().rev().
                                map(|&c| ((c - ('0' as u8)) as i64)).collect();
        BigInteger { ds }
    }
}


//////////////////// process ////////////////////

fn read_input() -> String {
    let _N: usize = read();
    let S: String = read();
    S
}


fn F(S: String) -> String {
    let N = S.len();
    let n = BigInteger::create_from_String(S);
    let mut n1 = BigInteger { ds: vec![] };
    for k in 1..N+1 {
        n1.add((N - k + 1) as i64 * n.ds[k-1], k)
    }
    let s = (1..N+1).map(|k| (N - k + 1) as i64 * n.ds[k-1]).sum::<i64>();
    n1.sub(s);
    let n2 = n1.div(9);
    n2.to_string()
}

fn main() {
    let S = read_input();
    println!("{}", F(S))
}