Järjestäminen

use std::io::{self, BufRead};
 
/*
fn suurempi(s: &str) {
    let mut chars = s.chars().enumerate().skip_while(|&(_, x)| x == '0');
    let (size, first) = chars.next().unwrap();
    let size = s.len() - size;
    let mut chars = chars.map(|(_, x)| x);
    let mut exact = true;
    for c in chars {
        match c {
            '0'..='9' => {
                if c as u8 > first as u8 {
                    println!("{}", [((first as u8 + 1) as char)].iter().cycle().take(size).collect::<String>());
                    return;
                } else if (c as u8) < first as u8 {
                    exact = false;
                }
            }
            '\n' => {
                break;
            }
            _ => panic!(),
        }
    }
    if exact && first != '9' {
        println!("{}", [((first as u8 + 1) as char)].iter().cycle().take(size).collect::<String>());
    } else if exact {
        println!("{}", ['1'].iter().cycle().take(size + 1).collect::<String>());
    } else {
        println!("{}", [first].iter().cycle().take(size).collect::<String>());
    }
}
*/
 
fn jarjesta(a: &mut [usize]) -> bool {
    for n in 0..a.len() {
        //println!("State of the array: {:?}", a);
        let mut pos = a.iter().enumerate().find(|(_, &x)| x == n).unwrap().0;
        if pos == n {
            continue
        } else if pos == n + 1 {
            if pos + 3 >= a.len() {
                //println!("Returning false from a");
                return false;
            }
            let tmp = a[pos - 1];
            a[pos - 1] = a[pos + 1];
            a[pos + 1] = tmp;
 
            let tmp = a[pos];
            a[pos] = a[pos + 2];
            a[pos + 2] = tmp;
 
            pos = pos + 2;
        } else if pos + 1 == a.len() {
            if n + 4 >= a.len() {
                //println!("Returning false from b");
                return false;
            }
 
            let tmp = a[pos - 1];
            a[pos - 1] = a[pos - 3];
            a[pos - 3] = tmp;
 
            let tmp = a[pos];
            a[pos] = a[pos - 2];
            a[pos - 2] = tmp;
 
            pos = pos - 2;
        }
        let tmp = a[pos];
        a[pos] = a[n];
        a[n] = tmp;
 
        let tmp = a[pos + 1];
        a[pos + 1] = a[n + 1];
        a[n + 1] = tmp;
    }
    true
}
 
fn main() {
    let stdin = io::stdin();
    let mut lines = stdin.lock().lines();
    let count = lines.next().unwrap().unwrap().parse::<usize>().unwrap();
    let mut ignore = true;
    for line in lines.take(count*2) {
        /*
        suurempi(&line.unwrap());
        */
        if !ignore {
            let mut v : Vec<_> = line.unwrap().split_whitespace().map(|x| x.parse::<usize>().unwrap() - 1).collect();
            if jarjesta(&mut v) {
                println!("YES");
            } else {
                println!("NO");
            }
        }
        ignore = !ignore;
    }
}

Test 1

Group: 1, 2

Verdict: WRONG ANSWER

Test 2

Group: 2

Verdict: WRONG ANSWER

Test 3

Group: 1, 2

Verdict: WRONG ANSWER

Test 4

Group: 1, 2

Verdict: WRONG ANSWER