結果

問題 No.2203 POWER!!!!!
ユーザー tonyu0
提出日時 2023-02-03 22:54:57
言語 Rust
(1.83.0 + proconio)
結果
AC  
実行時間 11 ms / 2,000 ms
コード長 5,090 bytes
コンパイル時間 14,237 ms
コンパイル使用メモリ 382,840 KB
実行使用メモリ 5,376 KB
最終ジャッジ日時 2024-07-02 20:59:33
合計ジャッジ時間 14,472 ms
ジャッジサーバーID
(参考情報)
judge5 / judge1
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
sample AC * 3
other AC * 18
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

#![allow(dead_code, unused_imports, unused_macros)]
use std::{
cell::UnsafeCell,
cmp::{max, min},
collections::{HashMap, VecDeque},
io::{BufWriter, Read, Stdin, Stdout, Write},
mem::swap,
str::FromStr,
};
fn main() {
let n = read!(usize);
let a = read_vec::<usize>(n);
let mut b = vec![0; 9];
for &x in a.iter() {
b[x] += 1;
}
let mut ans = 0usize;
for i in 1..=8usize {
let mut pans = 0;
let mut base = i;
for j in 1..=8usize {
pans += base * b[j];
base *= i;
}
ans += pans * b[i];
}
println!("{}", ans);
out_flush();
}
const IO_BUF_SIZE: usize = 1 << 16;
type Input = Scanner<Stdin>;
type Output = BufWriter<Stdout>;
fn _init_input() -> Input {
Scanner::new(std::io::stdin())
}
fn _init_output() -> Output {
BufWriter::with_capacity(IO_BUF_SIZE, std::io::stdout())
}
#[repr(transparent)]
struct Unsync<T>(T);
unsafe impl<T> Sync for Unsync<T> {}
type BadLazy<T> = Unsync<UnsafeCell<Option<T>>>;
impl<T> BadLazy<T> {
const fn new() -> Self {
Self(UnsafeCell::new(None))
}
}
static INPUT: BadLazy<Input> = BadLazy::new();
static OUTPUT: BadLazy<Output> = BadLazy::new();
fn inp<F: FnOnce(&mut Input) -> R, R>(f: F) -> R {
unsafe { f((&mut *INPUT.0.get()).get_or_insert_with(_init_input)) }
}
fn out<F: FnOnce(&mut Output) -> R, R>(f: F) -> R {
unsafe { f((&mut *OUTPUT.0.get()).get_or_insert_with(_init_output)) }
}
#[macro_export]
macro_rules! read {
() => { read() };
($t: ty) => { read::<$t>() };
($t: ty, $($tt: ty),*) => { (read::<$t>(), $(read::<$tt>(),)*) };
[$t: ty; $n: expr] => { read_vec::<$t>($n) };
}
#[macro_export]
macro_rules! println {
() => { out(|x| { let _ = writeln!(x); }) };
($exp: expr) => { out(|x| { let _ = writeln!(x, "{}", $exp); }) };
($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = writeln!(x, $fmt, $($arg)*); }) }
}
#[macro_export]
macro_rules! print {
($exp: expr) => { out(|x| { let _ = write!(x, "{}", $exp); }) };
($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = write!(x, $fmt, $($arg)*); }) }
}
fn out_flush() {
out(|x| {
let _ = x.flush();
});
}
fn input_is_eof() -> bool {
inp(|x| x.eof())
}
fn read_byte() -> u8 {
inp(|x| x.byte())
}
fn read_bytes_no_skip(n: usize) -> Vec<u8> {
inp(|x| x.bytes_no_skip(n))
}
fn read_bytes(n: usize) -> Vec<u8> {
inp(|x| x.bytes(n))
}
fn read_bytes2(n: usize, m: usize) -> Vec<Vec<u8>> {
inp(|x| x.bytes2(n, m))
}
fn read_token() -> Vec<u8> {
inp(|x| x.token_bytes())
}
fn read_token_str() -> String {
unsafe { String::from_utf8_unchecked(read_token()) }
}
fn read_line() -> Vec<u8> {
inp(|x| x.line_bytes())
}
fn read_line_str() -> String {
unsafe { String::from_utf8_unchecked(read_line()) }
}
fn read<T: FromStr>() -> T {
read_token_str().parse::<T>().ok().expect("failed parse")
}
fn read_vec<T: FromStr>(n: usize) -> Vec<T> {
(0..n).map(|_| read()).collect()
}
fn read_vec2<T: FromStr>(n: usize, m: usize) -> Vec<Vec<T>> {
(0..n).map(|_| read_vec(m)).collect()
}
struct Scanner<R: Read> {
src: R,
_buf: Vec<u8>,
_pt: usize, // pointer
_rd: usize, // bytes read
}
impl<R: Read> Scanner<R> {
fn new(src: R) -> Scanner<R> {
Scanner {
src,
_buf: vec![0; IO_BUF_SIZE],
_pt: 1,
_rd: 1,
}
}
fn _check_buf(&mut self) {
if self._pt == self._rd {
self._rd = self.src.read(&mut self._buf).unwrap_or(0);
self._pt = (self._rd == 0) as usize;
}
}
// returns true if end of file
fn eof(&mut self) -> bool {
self._check_buf();
self._rd == 0
}
// filters \r, returns \0 if eof
fn byte(&mut self) -> u8 {
loop {
self._check_buf();
if self._rd == 0 {
return 0;
}
let res = self._buf[self._pt];
self._pt += 1;
if res != b'\r' {
return res;
}
}
}
fn bytes_no_skip(&mut self, n: usize) -> Vec<u8> {
(0..n).map(|_| self.byte()).collect()
}
fn bytes(&mut self, n: usize) -> Vec<u8> {
let res = self.bytes_no_skip(n);
self.byte();
res
}
fn bytes2(&mut self, n: usize, m: usize) -> Vec<Vec<u8>> {
(0..n).map(|_| self.bytes(m)).collect()
}
fn token_bytes(&mut self) -> Vec<u8> {
let mut res = Vec::new();
let mut c = self.byte();
while c <= b' ' {
if c == b'\0' {
return res;
}
c = self.byte();
}
loop {
res.push(c);
c = self.byte();
if c <= b' ' {
return res;
}
}
}
fn line_bytes(&mut self) -> Vec<u8> {
let mut res = Vec::new();
let mut c = self.byte();
while c != b'\n' && c != b'\0' {
res.push(c);
c = self.byte();
}
res
}
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0