Kortit I

use std::{io, mem};

fn main() {
    let stdin = io::stdin();

    let t: i32 = {
        let mut input: String = String::new();
        stdin.read_line(&mut input).unwrap();
        input.trim().parse().unwrap()
    };

    for _ in 0..t {
        let values: Vec<i32> = {
            let mut input: String = String::new();
            stdin.read_line(&mut input).unwrap();
            input.trim().split_whitespace().map(|x| x.parse::<i32>().unwrap()).collect()
        };

        let answer = generate_answer(values[0], values[1], values[2]);
        if answer.is_none() {
            println!("NO");
        } else {
            println!("YES");
            for row in answer.unwrap() {
                println!("{}", row.iter().map(|x| x.to_string()).collect::<Vec<String>>().join(" "));
            }
        }
    }
}

fn generate_answer(total_cards: i32, mut a_points: i32, mut b_points: i32) -> Option<[Vec<i32>; 2]> {
    let total_points = a_points + b_points;


    if total_points > total_cards {
        return None;
    }
    if total_points > 0 && (a_points >= total_points || b_points >= total_points) {
        return None;
    }

    let mut a_plays = Vec::new();
    let mut b_plays = Vec::new();

    if a_points == 1 && b_points == 1 {
        a_plays.push(1);
        b_plays.push(2);

        a_plays.push(2);
        b_plays.push(1);
    } else if total_points > 0 {
        // Dealing with A = 1 is a pain, but it works with B, so let's be hacky and swap them.
        let mut swapped = false;
        if a_points == 1 {
            swapped = true;
            mem::swap(&mut a_points, &mut b_points);
            mem::swap(&mut a_plays, &mut b_plays);
        }

        let temp_a_points = a_points + if b_points == 1 { 1 } else { 0 };
        for i in 1..=(temp_a_points - 1) {
            a_plays.push(i + 1);
            b_plays.push(i);
        }

        if temp_a_points > 1 {
            // Balancing (win for B)
            a_plays.push(1); // first B play
            b_plays.push(temp_a_points); // last A play so far or hardcoded
        }
        // Now both have played [1, a_points].

        for i in (a_points + 1)..=(a_points + b_points - 1) {
            a_plays.push(i);
            b_plays.push(i + 1);
        }

        if a_points > 1 && b_points > 1 {
            // Balancing (win for A)
            a_plays.push(a_points + b_points);  // last B play
            b_plays.push(a_points + 1); // first A play after last balancing or hardcoded
        }

        // Now both have also played [a_points + 1, a_points + b_points].

        if swapped {
            mem::swap(&mut a_points, &mut b_points);
            mem::swap(&mut a_plays, &mut b_plays);
        }
    }

    // Play all remaining draws.
    for i in (a_points + b_points + 1)..=total_cards {
        a_plays.push(i);
        b_plays.push(i);
    }

    return Some([a_plays, b_plays]);
}

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