#503242 (Rust) No.1096 Range Sums

• 問題: No.1096 Range Sums
• ユーザー: kaki
• 提出日時: 2020-06-26 22:01:31
• 言語: Rust (1.93.0 + proconio + num + itertools)
• 結果: AC
• 実行時間: 10 ms / 2,000 ms
• コード長: 2,639 bytes
• コンパイル時間: 13,899 ms
• コンパイル使用メモリ: 197,120 KB
• 実行使用メモリ: 6,272 KB
• 最終ジャッジ日時: 2026-03-26 04:14:46
• 合計ジャッジ時間: 5,019 ms
• ジャッジサーバーID （参考情報）: judge2_0 / judge3_0

ファイルパターン	結果
sample	AC * 3
other	AC * 12

コンパイルメッセージ

warning: unexpected `cfg` condition name: `local`
  --> src/main.rs:20:17
   |
20 |         if cfg!(local) {
   |                 ^^^^^
...
49 |         self.safe_get_token().unwrap_or_else(|| exit!())
   |                                                 ------- in this macro invocation
   |
   = help: expected names are: `docsrs`, `feature`, and `test` and 31 more
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(local)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(local)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: `#[warn(unexpected_cfgs)]` on by default
   = note: this warning originates in the macro `exit` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `local`
  --> src/main.rs:20:17
   |
20 |         if cfg!(local) {
   |                 ^^^^^
...
53 |         self.token().parse::<T>().unwrap_or_else(|_| exit!())
   |                                                      ------- in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(local)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(local)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `exit` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `

ソースコード

#![allow(non_snake_case)]
#![allow(dead_code)]
#![allow(unused_macros)]
#![allow(unused_imports)]

use std::str::FromStr;
use std::io::*;
use std::collections::*;
use std::cmp::*;

struct Scanner<I: Iterator<Item = char>> {
    iter: std::iter::Peekable<I>,
}

macro_rules! exit {
    () => {{
        exit!(0)
    }};
    ($code:expr) => {{
        if cfg!(local) {
            writeln!(std::io::stderr(), "===== Terminated =====")
                .expect("failed printing to stderr");
        }
        std::process::exit($code);
    }}
}

impl<I: Iterator<Item = char>> Scanner<I> {
    pub fn new(iter: I) -> Scanner<I> {
        Scanner {
            iter: iter.peekable(),
        }
    }

    pub fn safe_get_token(&mut self) -> Option<String> {
        let token = self.iter
            .by_ref()
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect::<String>();
        if token.is_empty() {
            None
        } else {
            Some(token)
        }
    }

    pub fn token(&mut self) -> String {
        self.safe_get_token().unwrap_or_else(|| exit!())
    }

    pub fn get<T: FromStr>(&mut self) -> T {
        self.token().parse::<T>().unwrap_or_else(|_| exit!())
    }

    pub fn vec<T: FromStr>(&mut self, len: usize) -> Vec<T> {
        (0..len).map(|_| self.get()).collect()
    }

    pub fn mat<T: FromStr>(&mut self, row: usize, col: usize) -> Vec<Vec<T>> {
        (0..row).map(|_| self.vec(col)).collect()
    }

    pub fn char(&mut self) -> char {
        self.iter.next().unwrap_or_else(|| exit!())
    }

    pub fn chars(&mut self) -> Vec<char> {
        self.get::<String>().chars().collect()
    }

    pub fn mat_chars(&mut self, row: usize) -> Vec<Vec<char>> {
        (0..row).map(|_| self.chars()).collect()
    }

    pub fn line(&mut self) -> String {
        if self.peek().is_some() {
            self.iter
                .by_ref()
                .take_while(|&c| !(c == '\n' || c == '\r'))
                .collect::<String>()
        } else {
            exit!();
        }
    }

    pub fn peek(&mut self) -> Option<&char> {
        self.iter.peek()
    }
}

fn main() {
    let cin = stdin();
    let cin = cin.lock();
    let mut sc = Scanner::new(cin.bytes().map(|c| c.unwrap() as char));
    let N: usize = sc.get();
    let A: Vec<i64> = sc.vec(N);
    let mut cum = vec![0; N+1];
    for i in 0..N {
        cum[i+1] = cum[i] + A[i];
    }
    let mut ans = 0;
    for r in 0..N+1 {
        ans += cum[r] * r as i64;
    }
    for l in 0..N {
        ans -= cum[l] * (N - l) as i64;
    }
    println!("{}", ans);
}