Kortit I

use std::{
    fmt::Display,
    io::{stdin, BufRead, BufReader},
};

#[derive(PartialEq, Eq, Debug)]
struct GameScores {
    cardcount: u32,
    score_a: u32,
    score_b: u32,
}

impl GameScores {
    fn test(&self) -> GameResult {
        match self.test_viability() {
            true => {
                let cards_b = (1..self.cardcount + 1).collect::<Vec<u32>>();
                let cards_a = self.create_game_b();

                let result = Self::run_game(&cards_a, &cards_b);

                if self == &result {
                    GameResult::Possible { cards_a, cards_b }
                } else {
                    GameResult::Impossible
                }
            }
            false => GameResult::Impossible,
        }
    }

    fn test_viability(&self) -> bool {
        match self.score_a + self.score_b {
            0 => true,
            x => {
                if x <= self.cardcount {
                    true
                } else {
                    false
                }
            }
        }
    }

    fn run_game(cards_a: &Vec<u32>, cards_b: &Vec<u32>) -> GameScores {
        let mut score_a = 0;
        let mut score_b = 0;

        for i in 0..cards_a.len() {
            match cards_a[i].cmp(&cards_b[i]) {
                std::cmp::Ordering::Less => score_b += 1,
                std::cmp::Ordering::Equal => (),
                std::cmp::Ordering::Greater => score_a += 1,
            }
        }

        GameScores {
            cardcount: cards_a.len() as u32,
            score_a,
            score_b,
        }
    }

    fn create_game_b(&self) -> Vec<u32> {
        let sub_game_length = self.score_a + self.score_b;

        if sub_game_length == 0 {
            return (1..self.cardcount + 1).collect();
        }

        let mut game = Vec::new();
        game.reserve(self.cardcount as usize);

        game.append(&mut Self::create_rotated_list(
            self.score_b,
            sub_game_length,
        ));

        for i in sub_game_length + 1..=self.cardcount {
            game.push(i);
        }

        game
    }

    fn create_rotated_list(rotation: u32, length: u32) -> Vec<u32> {
        let mut result = Vec::new();
        result.reserve(length as usize);

        for i in rotation + 1..length + 1 {
            result.push(i);
        }
        for i in 1..=rotation {
            result.push(i);
        }

        result
    }
}

enum GameResult {
    Possible {
        cards_a: Vec<u32>,
        cards_b: Vec<u32>,
    },
    Impossible,
}

impl Display for GameResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            GameResult::Possible { cards_a, cards_b } => {
                writeln!(f, "YES")?;
                for i in cards_a {
                    write!(f, "{} ", i)?;
                }

                write!(f, "\n")?;

                for i in cards_b {
                    write!(f, "{} ", i)?;
                }

                Ok(())
            }
            GameResult::Impossible => write!(f, "NO"),
        }
    }
}

fn main() {
    let mut reader = BufReader::new(stdin());
    let mut line = String::new();

    reader.read_line(&mut line).expect("Failed to read line");

    let game_count: u32 = line.strip_suffix('\n').unwrap().parse().unwrap();

    for _ in 0..game_count {
        line.clear();

        reader.read_line(&mut line).expect("Failed to read line");

        let mut game_data = line
            .strip_suffix('\n')
            .unwrap()
            .split(' ')
            .map(|x| x.parse::<u32>().unwrap());

        let game = GameScores {
            cardcount: game_data.next().unwrap(),
            score_a: game_data.next().unwrap(),
            score_b: game_data.next().unwrap(),
        };

        println!("{}", game.test());
    }
}

Test 1

Group: 1, 2, 3

Verdict: ACCEPTED

Test 2

Group: 2, 3

Verdict: ACCEPTED

Test 3

Group: 3

Verdict: ACCEPTED

Test 4

Group: 3

Verdict: ACCEPTED

Test 5

Group: 3

Verdict: ACCEPTED

Test 6

Group: 3

Verdict: ACCEPTED

Test 7

Group: 3

Verdict: ACCEPTED

Test 8

Group: 3

Verdict: ACCEPTED

Test 9

Group: 3

Verdict: ACCEPTED

Test 10

Group: 3

Verdict: ACCEPTED

Test 11

Group: 3

Verdict: ACCEPTED

Test 12

Group: 3

Verdict: ACCEPTED

Test 13

Group: 3

Verdict: ACCEPTED

Test 14

Group: 3

Verdict: ACCEPTED

Test 15

Group: 3

Verdict: ACCEPTED

Test 16

Group: 3

Verdict: ACCEPTED

Test 17

Group: 3

Verdict: ACCEPTED

Test 18

Group: 3

Verdict: ACCEPTED

Test 19

Group: 3

Verdict: ACCEPTED

Test 20

Group: 3

Verdict: ACCEPTED