1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
use std::cell::RefCell;
use std::fmt::Debug;
use std::io::BufRead;
use std::str::{self, FromStr};

thread_local! {
    static READ_ITEM_BUF: RefCell<Vec<u8>> = const { RefCell::new(Vec::new()) }
}

fn fill_until_whitespace(input: &mut impl BufRead, buf: &mut Vec<u8>) {
    buf.clear();
    loop {
        let mut chunk = input
            .fill_buf()
            .expect("EOF before encountering whitespace");
        let skipped_white = if buf.is_empty() {
            let before_skipped = chunk.len();
            chunk = chunk.trim_ascii_start();
            before_skipped - chunk.len()
        } else {
            0
        };
        let white_pos = chunk
            .iter()
            .position(|b| (*b as char).is_ascii_whitespace());
        let found = white_pos.is_some();
        let white_pos = white_pos.unwrap_or(chunk.len());
        buf.extend_from_slice(&chunk[..white_pos]);
        input.consume(skipped_white + white_pos);
        if found {
            return;
        }
    }
}

fn read_item<T>(input: &mut impl BufRead) -> T
where
    T: FromStr,
    T::Err: Debug,
{
    READ_ITEM_BUF.with_borrow_mut(|buf| {
        fill_until_whitespace(input, buf);
        T::from_str(str::from_utf8(buf).expect("not a utf-8 string")).expect("failed to parse")
    })
}

fn shuffle_nums_algosia(a: u32, b: u32) -> (u32, u32) {
    assert!(a >= 1);
    assert!(a <= 1000);
    assert!(b >= 1);
    assert!(b <= 1000);
    assert_ne!(a, b);

    if a > b {
        let (d, c) = shuffle_nums_algosia(b, a);
        return (c, d);
    }

    if a + b != 1001 {
        (1001 - b, 1001 - a)
    } else if a != 1 {
        (a - 1, b + 1)
    } else {
        (500, 501)
    }
}

fn shuffle_nums_bajtek(a: u32, b: u32) -> (u32, u32) {
    assert!(a >= 1);
    assert!(a <= 1000);
    assert!(b >= 1);
    assert!(b <= 1000);
    assert_ne!(a, b);

    if a > b {
        let (d, c) = shuffle_nums_bajtek(b, a);
        return (c, d);
    }

    if a + b != 1001 {
        (1001 - b, 1001 - a)
    } else if a != 500 {
        (a + 1, b - 1)
    } else {
        (1, 1000)
    }
}

fn main() {
    let mut stdin = std::io::stdin().lock();
    let mode: String = read_item(&mut stdin);
    let a: u32 = read_item(&mut stdin);
    let b: u32 = read_item(&mut stdin);
    std::mem::drop(stdin);

    assert!(mode == "Algosia" || mode == "Bajtek");

    let (c, d) = if mode == "Algosia" {
        shuffle_nums_algosia(a, b)
    } else {
        shuffle_nums_bajtek(a, b)
    };

    println!("{} {}", c, d);
}

#[test]
fn test_all_cases() {
    for a in 1..=1000 {
        for b in 1..=1000 {
            if a != b {
                let (c, d) = shuffle_nums_algosia(a, b);
                assert!(c >= 1);
                assert!(c <= 1000);
                assert!(d >= 1);
                assert!(d <= 1000);
                assert_ne!(a, b);
                assert_ne!(c, d);
                assert_ne!(a, c);
                assert_ne!(a, d);
                assert_ne!(b, c);
                assert_ne!(b, d);

                let (aa, bb) = shuffle_nums_bajtek(c, d);
                assert_eq!(a, aa);
                assert_eq!(b, bb);
            }
        }
    }
}