結果

問題 No.2560 A_1 < A_2 < ... < A_N
ユーザー ぱるま
提出日時 2023-12-02 14:59:06
言語 Rust
(1.83.0 + proconio)
結果
AC  
実行時間 131 ms / 2,000 ms
コード長 6,319 bytes
コンパイル時間 14,569 ms
コンパイル使用メモリ 378,568 KB
実行使用メモリ 10,240 KB
最終ジャッジ日時 2024-09-26 17:48:34
合計ジャッジ時間 16,792 ms
ジャッジサーバーID
(参考情報)
judge4 / judge2
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
sample AC * 1
other AC * 15
権限があれば一括ダウンロードができます
コンパイルメッセージ
warning: field `n_case` is never read
  --> src/main.rs:24:5
   |
23 | struct Problem {
   |        ------- field in this struct
24 |     n_case: usize,
   |     ^^^^^^
   |
   = note: `#[warn(dead_code)]` on by default

ソースコード

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

use std::io::stdin;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct TestCase{
n: usize,
x: i64,
}
impl TestCase{
fn solve(&self) -> Option<Vec<i64>> {
let n = self.n as i64;
let x = self.x;
let min_sum = n * ( n +1 )/2;
if x < min_sum{
None
}else{
let ret = (1..n).chain(std::iter::once(x - n * (n-1)/2)).collect();
Some(ret)
}
}
}
struct Problem {
n_case: usize,
test_cases: Vec<TestCase>,
}
impl Problem {
fn read<R: IProconReader>(mut r: R) -> Problem {
let n_case = r.read_usize_1();
let test_cases = (0..n_case).map(|_| {
let (n, x) = r.read_i64_2();
let n = n as usize;
TestCase { n, x }
}).collect();
Problem { n_case, test_cases }
}
fn solve(&self) -> Answer {
let ans = self.test_cases.iter().copied().map(|test_case| {
test_case.solve()
}).collect();
Answer { ans }
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
struct Answer {
ans: Vec<Option<Vec<i64>>>,
}
impl Answer {
fn print(&self) {
for row in &self.ans{
if let Some(row) = row{
print_vec_1line(row);
}else{
println!("-1");
}
}
}
}
pub fn print_vec_1line<T: std::fmt::Debug>(arr: &[T]) {
let msg = arr.iter().map(|x| format!("{:?}", x)).collect::<Vec<_>>().join(" ");
println!("{}", msg);
}
fn main() {
Problem::read(ProconReader::new(stdin().lock())).solve().print();
}
#[cfg(test)]
mod tests {
use super::*;
#[allow(dead_code)]
fn check(input: &str, expected: Answer) {
let actual = Problem::read(ProconReader::new(input.as_bytes())).solve();
assert_eq!(expected, actual);
}
#[test]
fn test_problem() {
let _input = "
3
4
"
.trim();
// check(_input, Answer { ans: 7 });
}
}
// ====== snippet ======
#[allow(unused_imports)]
use myio::*;
pub mod myio {
use std::io::BufRead;
pub trait IProconReader {
fn read_line(&mut self) -> String;
fn read_bytes(&mut self) -> Vec<u8> {
self.read_line().as_bytes().to_vec()
}
fn read_any_1<T>(&mut self) -> T
where
T: std::str::FromStr,
T::Err: std::fmt::Debug,
{
let buf = self.read_line();
buf.parse::<T>().unwrap()
}
fn read_any_2<T0, T1>(&mut self) -> (T0, T1)
where
T0: std::str::FromStr,
T0::Err: std::fmt::Debug,
T1: std::str::FromStr,
T1::Err: std::fmt::Debug,
{
let buf = self.read_line();
let splitted = buf.trim().split(' ').collect::<Vec<_>>();
let a0 = splitted[0].parse::<T0>().unwrap();
let a1 = splitted[1].parse::<T1>().unwrap();
(a0, a1)
}
fn read_any_3<T0, T1, T2>(&mut self) -> (T0, T1, T2)
where
T0: std::str::FromStr,
T0::Err: std::fmt::Debug,
T1: std::str::FromStr,
T1::Err: std::fmt::Debug,
T2: std::str::FromStr,
T2::Err: std::fmt::Debug,
{
let buf = self.read_line();
let splitted = buf.trim().split(' ').collect::<Vec<_>>();
let a0 = splitted[0].parse::<T0>().unwrap();
let a1 = splitted[1].parse::<T1>().unwrap();
let a2 = splitted[2].parse::<T2>().unwrap();
(a0, a1, a2)
}
fn read_any_4<T0, T1, T2, T3>(&mut self) -> (T0, T1, T2, T3)
where
T0: std::str::FromStr,
T0::Err: std::fmt::Debug,
T1: std::str::FromStr,
T1::Err: std::fmt::Debug,
T2: std::str::FromStr,
T2::Err: std::fmt::Debug,
T3: std::str::FromStr,
T3::Err: std::fmt::Debug,
{
let buf = self.read_line();
let splitted = buf.trim().split(' ').collect::<Vec<_>>();
let a0 = splitted[0].parse::<T0>().unwrap();
let a1 = splitted[1].parse::<T1>().unwrap();
let a2 = splitted[2].parse::<T2>().unwrap();
let a3 = splitted[3].parse::<T3>().unwrap();
(a0, a1, a2, a3)
}
fn read_vec_any<T>(&mut self) -> Vec<T>
where
T: std::str::FromStr,
T::Err: std::fmt::Debug,
{
let buf = self.read_line();
buf.trim().split(' ').map(|s| s.parse::<T>().unwrap()).collect::<Vec<T>>()
}
fn read_vec_i64(&mut self) -> Vec<i64> {
self.read_vec_any::<i64>()
}
fn read_vec_usize(&mut self) -> Vec<usize> {
self.read_vec_any::<usize>()
}
fn read_vec_str(&mut self) -> Vec<String> {
self.read_vec_any::<String>()
}
fn read_i64_1(&mut self) -> i64 {
self.read_any_1::<i64>()
}
fn read_i64_2(&mut self) -> (i64, i64) {
self.read_any_2::<i64, i64>()
}
fn read_i64_3(&mut self) -> (i64, i64, i64) {
self.read_any_3::<i64, i64, i64>()
}
fn read_i64_4(&mut self) -> (i64, i64, i64, i64) {
self.read_any_4::<i64, i64, i64, i64>()
}
fn read_usize_1(&mut self) -> usize {
self.read_any_1::<usize>()
}
fn read_usize_2(&mut self) -> (usize, usize) {
self.read_any_2::<usize, usize>()
}
fn read_usize_3(&mut self) -> (usize, usize, usize) {
self.read_any_3::<usize, usize, usize>()
}
fn read_usize_4(&mut self) -> (usize, usize, usize, usize) {
self.read_any_4::<usize, usize, usize, usize>()
}
}
pub struct ProconReader<R: BufRead> {
buf_read: R,
}
impl<R: BufRead> ProconReader<R> {
pub fn new(buf_read: R) -> ProconReader<R> {
ProconReader { buf_read }
}
}
impl<R: BufRead> IProconReader for ProconReader<R> {
fn read_line(&mut self) -> String {
let mut buffer = String::new();
self.buf_read.read_line(&mut buffer).unwrap();
buffer.trim().to_string()
}
}
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0