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);
    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 {
                    println!("{}", [first].iter().cycle().take(size).collect::<String>());
                    return
                }
            }
            '\n' => {
                break;
            }
            _ => panic!(),
        }
    }
    if first != '9' {
        println!("{}", [((first as u8 + 1) as char)].iter().cycle().take(size).collect::<String>());
    } else {
        println!("{}", ['1'].iter().cycle().take(size + 1).collect::<String>());
    }
}
*/

fn jarjesta(a: &mut [usize]) -> bool {
    if a.len() < 5 {
        match a {
            [0, 1, 2, 3] => return true,
            [2, 3, 0, 1] => return true,
            [0, 1, 2] => return true,
            [0, 1] => return true,
            [0] => return true,
            _ => return false,
        }
    }
    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
        }
        if pos + 1 == a.len() {
            if n + 2 >= a.len() {
                //println!("Returning false from b");
                return false;
            }
            // ABC -> CAB
            let tmp = a[pos];
            a[pos] = a[pos - 1];
            a[pos - 1] = a[pos - 2];
            a[pos - 2] = tmp;

            pos = pos - 2;
        }
        if pos == n {
            continue
        }
        if pos == n + 1 {
            if pos + 1 >= a.len() {
                //println!("Returning false from a");
                return false;
            }
            // ABC -> BCA
            let tmp = a[pos - 1];
            a[pos - 1] = a[pos];
            a[pos] = a[pos + 1];
            a[pos + 1] = tmp;
            continue
        }
        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: ACCEPTED

Test 2

Group: 2

Verdict: ACCEPTED

Test 3

Group: 1, 2

Verdict: ACCEPTED

Test 4

Group: 1, 2

Verdict: ACCEPTED