Skip to content

Commit 0bb6180

Browse files
nojimanojima
committed
feat(atcoder): Add practice_1
1 parent 24a6b2e commit 0bb6180

File tree

15 files changed

+578
-2
lines changed

15 files changed

+578
-2
lines changed

‎.gitignore

+2
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
*.iml
2+
target/

‎atcoder/practice_1/Cargo.lock

+4
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎atcoder/practice_1/Cargo.toml

+6
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
[package]
2+
name = "practice_1"
3+
version = "0.1.0"
4+
authors = ["Yusuke Nojima <[email protected]>"]
5+
6+
[dependencies]

‎atcoder/practice_1/a.rs ‎atcoder/practice_1/src/a.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -7,8 +7,8 @@ struct StdinReader<'a> {
77
}
88

99
impl<'a> StdinReader<'a> {
10-
pub fn new(reader: StdinLock<'a>) -> Self {
11-
Self { reader: reader }
10+
pub fn new(reader: StdinLock<'a>) -> StdinReader {
11+
StdinReader { reader: reader }
1212
}
1313

1414
pub fn read<T: FromStr>(&mut self) -> T {

‎atcoder/practice_1/src/b.rs

+42
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
use std::io::{Read, StdinLock};
2+
use std::str::{from_utf8, FromStr};
3+
use std::vec::Vec;
4+
5+
struct StdinReader<'a> {
6+
reader: StdinLock<'a>,
7+
}
8+
9+
impl<'a> StdinReader<'a> {
10+
pub fn new(reader: StdinLock<'a>) -> StdinReader {
11+
StdinReader { reader: reader }
12+
}
13+
14+
pub fn read<T: FromStr>(&mut self) -> T {
15+
fn is_whitespace(ch: u8) -> bool {
16+
ch == 0x20 || ch == 0x0a || ch == 0x0d
17+
}
18+
19+
let token: Vec<u8> = self.reader
20+
.by_ref()
21+
.bytes()
22+
.map(|ch| ch.expect("failed to read a byte"))
23+
.skip_while(|ch| is_whitespace(*ch))
24+
.take_while(|ch| !is_whitespace(*ch))
25+
.collect();
26+
let token_str = from_utf8(&token)
27+
.unwrap_or_else(|_| panic!(format!("invalid utf8 sequence: {:?}", token)));
28+
token_str
29+
.parse()
30+
.unwrap_or_else(|_| panic!(format!("failed to parse input: {}", token_str)))
31+
}
32+
}
33+
34+
fn main() {
35+
let stdin = std::io::stdin();
36+
let mut reader = StdinReader::new(stdin.lock());
37+
38+
let a: i64 = reader.read();
39+
let b: i64 = reader.read();
40+
41+
println!("{}", if (a * b) % 2 == 0 { "Even" } else { "Odd" })
42+
}

‎atcoder/practice_1/src/c.rs

+42
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
use std::io::{Read, StdinLock};
2+
use std::str::{from_utf8, FromStr};
3+
use std::vec::Vec;
4+
5+
struct StdinReader<'a> {
6+
reader: StdinLock<'a>,
7+
}
8+
9+
impl<'a> StdinReader<'a> {
10+
pub fn new(reader: StdinLock<'a>) -> StdinReader {
11+
StdinReader { reader: reader }
12+
}
13+
14+
pub fn read<T: FromStr>(&mut self) -> T {
15+
fn is_whitespace(ch: u8) -> bool {
16+
ch == 0x20 || ch == 0x0a || ch == 0x0d
17+
}
18+
19+
let token: Vec<u8> = self.reader
20+
.by_ref()
21+
.bytes()
22+
.map(|ch| ch.expect("failed to read a byte"))
23+
.skip_while(|ch| is_whitespace(*ch))
24+
.take_while(|ch| !is_whitespace(*ch))
25+
.collect();
26+
let token_str = from_utf8(&token)
27+
.unwrap_or_else(|_| panic!(format!("invalid utf8 sequence: {:?}", token)));
28+
token_str
29+
.parse()
30+
.unwrap_or_else(|_| panic!(format!("failed to parse input: {}", token_str)))
31+
}
32+
}
33+
34+
fn main() {
35+
let stdin = std::io::stdin();
36+
let mut reader = StdinReader::new(stdin.lock());
37+
38+
let s: String = reader.read();
39+
let c = s.chars().filter(|c| *c == '1').count();
40+
41+
println!("{}", c);
42+
}

‎atcoder/practice_1/src/d.rs

+55
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,55 @@
1+
use std::cmp::min;
2+
use std::io::{Read, StdinLock};
3+
use std::str::{from_utf8, FromStr};
4+
use std::vec::Vec;
5+
6+
struct StdinReader<'a> {
7+
reader: StdinLock<'a>,
8+
}
9+
10+
impl<'a> StdinReader<'a> {
11+
pub fn new(reader: StdinLock<'a>) -> StdinReader {
12+
StdinReader { reader: reader }
13+
}
14+
15+
pub fn read<T: FromStr>(&mut self) -> T {
16+
fn is_whitespace(ch: u8) -> bool {
17+
ch == 0x20 || ch == 0x0a || ch == 0x0d
18+
}
19+
20+
let token: Vec<u8> = self.reader
21+
.by_ref()
22+
.bytes()
23+
.map(|ch| ch.expect("failed to read a byte"))
24+
.skip_while(|ch| is_whitespace(*ch))
25+
.take_while(|ch| !is_whitespace(*ch))
26+
.collect();
27+
let token_str = from_utf8(&token)
28+
.unwrap_or_else(|_| panic!(format!("invalid utf8 sequence: {:?}", token)));
29+
token_str
30+
.parse()
31+
.unwrap_or_else(|_| panic!(format!("failed to parse input: {}", token_str)))
32+
}
33+
}
34+
35+
fn main() {
36+
let stdin = std::io::stdin();
37+
let mut reader = StdinReader::new(stdin.lock());
38+
39+
let mut min_shift_count = 100;
40+
41+
let n: usize = reader.read();
42+
for _i in 0..n {
43+
let mut a: i32 = reader.read();
44+
45+
let mut shift_count = 0;
46+
while a % 2 == 0 {
47+
a /= 2;
48+
shift_count += 1;
49+
}
50+
51+
min_shift_count = min(min_shift_count, shift_count);
52+
}
53+
54+
println!("{}", min_shift_count);
55+
}

‎atcoder/practice_1/src/e.rs

+72
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,72 @@
1+
use std::io::{Read, StdinLock};
2+
use std::str::{from_utf8, FromStr};
3+
use std::vec::Vec;
4+
5+
struct StdinReader<'a> {
6+
reader: StdinLock<'a>,
7+
}
8+
9+
impl<'a> StdinReader<'a> {
10+
pub fn new(reader: StdinLock<'a>) -> StdinReader {
11+
StdinReader { reader: reader }
12+
}
13+
14+
pub fn read<T: FromStr>(&mut self) -> T {
15+
fn is_whitespace(ch: u8) -> bool {
16+
ch == 0x20 || ch == 0x0a || ch == 0x0d
17+
}
18+
19+
let token: Vec<u8> = self.reader
20+
.by_ref()
21+
.bytes()
22+
.map(|ch| ch.expect("failed to read a byte"))
23+
.skip_while(|ch| is_whitespace(*ch))
24+
.take_while(|ch| !is_whitespace(*ch))
25+
.collect();
26+
let token_str = from_utf8(&token)
27+
.unwrap_or_else(|_| panic!(format!("invalid utf8 sequence: {:?}", token)));
28+
token_str
29+
.parse()
30+
.unwrap_or_else(|_| panic!(format!("failed to parse input: {}", token_str)))
31+
}
32+
}
33+
34+
fn f_50(c: i32, x: i32) -> i64 {
35+
if c * 50 >= x {
36+
1
37+
} else {
38+
0
39+
}
40+
}
41+
42+
fn f_100(b: i32, c: i32, x: i32) -> i64 {
43+
let mut sum: i64 = 0;
44+
for i in 0..(b + 1) {
45+
if x - i * 100 >= 0 {
46+
sum += f_50(c, x - i * 100);
47+
}
48+
}
49+
sum
50+
}
51+
52+
fn f_500(a: i32, b: i32, c: i32, x: i32) -> i64 {
53+
let mut sum: i64 = 0;
54+
for i in 0..(a + 1) {
55+
if x - i * 500 >= 0 {
56+
sum += f_100(b, c, x - i * 500);
57+
}
58+
}
59+
sum
60+
}
61+
62+
fn main() {
63+
let stdin = std::io::stdin();
64+
let mut reader = StdinReader::new(stdin.lock());
65+
66+
let a: i32 = reader.read();
67+
let b: i32 = reader.read();
68+
let c: i32 = reader.read();
69+
let x: i32 = reader.read();
70+
71+
println!("{}", f_500(a, b, c, x));
72+
}

‎atcoder/practice_1/src/f.rs

+61
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,61 @@
1+
use std::io::{Read, StdinLock};
2+
use std::str::{from_utf8, FromStr};
3+
use std::vec::Vec;
4+
5+
struct StdinReader<'a> {
6+
reader: StdinLock<'a>,
7+
}
8+
9+
impl<'a> StdinReader<'a> {
10+
pub fn new(reader: StdinLock<'a>) -> StdinReader {
11+
StdinReader { reader: reader }
12+
}
13+
14+
pub fn read<T: FromStr>(&mut self) -> T {
15+
fn is_whitespace(ch: u8) -> bool {
16+
ch == 0x20 || ch == 0x0a || ch == 0x0d
17+
}
18+
19+
let token: Vec<u8> = self.reader
20+
.by_ref()
21+
.bytes()
22+
.map(|ch| ch.expect("failed to read a byte"))
23+
.skip_while(|ch| is_whitespace(*ch))
24+
.take_while(|ch| !is_whitespace(*ch))
25+
.collect();
26+
let token_str = from_utf8(&token)
27+
.unwrap_or_else(|_| panic!(format!("invalid utf8 sequence: {:?}", token)));
28+
token_str
29+
.parse()
30+
.unwrap_or_else(|_| panic!(format!("failed to parse input: {}", token_str)))
31+
}
32+
}
33+
34+
fn sum_digits(n: i32) -> i32 {
35+
let mut sum = 0;
36+
let mut m = n;
37+
while m > 0 {
38+
sum += m % 10;
39+
m /= 10;
40+
}
41+
return sum;
42+
}
43+
44+
fn main() {
45+
let stdin = std::io::stdin();
46+
let mut reader = StdinReader::new(stdin.lock());
47+
48+
let n: i32 = reader.read();
49+
let a: i32 = reader.read();
50+
let b: i32 = reader.read();
51+
52+
let mut sum = 0;
53+
for i in 1..(n + 1) {
54+
let s = sum_digits(i);
55+
if a <= s && s <= b {
56+
sum += i;
57+
}
58+
}
59+
60+
println!("{}", sum);
61+
}

‎atcoder/practice_1/src/g.rs

+59
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,59 @@
1+
use std::io::{Read, StdinLock};
2+
use std::str::{from_utf8, FromStr};
3+
use std::vec::Vec;
4+
5+
struct StdinReader<'a> {
6+
reader: StdinLock<'a>,
7+
}
8+
9+
impl<'a> StdinReader<'a> {
10+
pub fn new(reader: StdinLock<'a>) -> StdinReader {
11+
StdinReader { reader: reader }
12+
}
13+
14+
pub fn read<T: FromStr>(&mut self) -> T {
15+
fn is_whitespace(ch: u8) -> bool {
16+
ch == 0x20 || ch == 0x0a || ch == 0x0d
17+
}
18+
19+
let token: Vec<u8> = self.reader
20+
.by_ref()
21+
.bytes()
22+
.map(|ch| ch.expect("failed to read a byte"))
23+
.skip_while(|ch| is_whitespace(*ch))
24+
.take_while(|ch| !is_whitespace(*ch))
25+
.collect();
26+
let token_str = from_utf8(&token)
27+
.unwrap_or_else(|_| panic!(format!("invalid utf8 sequence: {:?}", token)));
28+
token_str
29+
.parse()
30+
.unwrap_or_else(|_| panic!(format!("failed to parse input: {}", token_str)))
31+
}
32+
33+
pub fn read_array<T: FromStr>(&mut self, n: usize) -> Vec<T> {
34+
(0..n).map(|_| self.read()).collect()
35+
}
36+
}
37+
38+
fn main() {
39+
let stdin = std::io::stdin();
40+
let mut reader = StdinReader::new(stdin.lock());
41+
42+
let n: usize = reader.read();
43+
let mut a: Vec<i32> = reader.read_array(n);
44+
45+
a.sort();
46+
a.reverse();
47+
48+
let mut alice = 0;
49+
let mut bob = 0;
50+
for (i, v) in a.iter().enumerate() {
51+
if i % 2 == 0 {
52+
alice += *v;
53+
} else {
54+
bob += *v;
55+
}
56+
}
57+
58+
println!("{}", alice - bob);
59+
}

0 commit comments

Comments
 (0)