Käännöt

warning: variable `layer` is assigned to, but never used
  --> input/code.rs:75:13
   |
75 |     let mut layer = 0;
   |             ^^^^^
   |
   = note: consider using `_layer` instead
   = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `prev_child_i`
  --> input/code.rs:82:14
   |
82 |         for (prev_child_i, (edelliset_operaatiot, lista)) in cur_layer_lists.iter().enumerate() {
   |              ^^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_prev_child_i`

warning: 2 warnings emitted

//! Input:
//! 5 3
//! 3 4 1 2 5
//! output:
//! YES
//! 2
//! 2 1

use std::io::stdin;

type IdxLen = usize;
type Value = isize;
type Operaatiot = Vec<IdxLen>;

fn suorita_operaatio(käännön_pituus: IdxLen, operaatio_i: IdxLen, lista: &[Value]) -> Vec<Value> {
    let a = lista.into_iter().take(operaatio_i);
    let b = lista
        .into_iter()
        .skip(operaatio_i)
        .take(käännön_pituus)
        .rev();
    let c = lista.into_iter().skip(operaatio_i + käännön_pituus);
    a.chain(b).chain(c).copied().collect()
}

#[cfg(test)]
#[test]
fn test_tee_operaatio() {
    fn f(käännön_pituus: IdxLen, operaatio_i: IdxLen, expected: &[Value]) {
        let lista = &[1, 2, 3, 4, 5];
        assert_eq!(suorita_operaatio(käännön_pituus, operaatio_i, lista), expected);
    }
    f(0, 0, &[1, 2, 3, 4, 5]);
    f(2, 0, &[2, 1, 3, 4, 5]);
    f(3, 0, &[3, 2, 1, 4, 5]);
    f(3, 1, &[1, 4, 3, 2, 5]);
    f(3, 2, &[1, 2, 5, 4, 3]);
}

/*fn cmp_sorted(sorted: &[Value], new: &[Value]) -> usize {
    let mut n = 0;
    assert_eq!(sorted.len(), new.len());
    for (i, sorted_el) in sorted.into_iter().enumerate() {
        if new[i] == *sorted_el {
            n += 1;
        } else {
            break;
        }
    }
    n
}

#[cfg(test)]
#[test]
fn test_cmp_sorted() {
    fn f(list: &[Value], n: usize) {
        let mut sorted = list.to_owned();
        sorted.sort();
        assert_eq!(cmp_sorted(&sorted, list), n);
    }
    f(&[2, 1, 3, 4, 5], 0);
    f(&[1, 3, 2, 4, 5], 1);
    f(&[1, 2, 3, 4, 5], 5);
}*/


#[allow(dead_code)]
fn käännä3(
    käännön_pituus: IdxLen,
    #[allow(unused_variables)]
    järjestetty_lista: &[Value],
    alkuperäinen_lista: &[Value],
) -> Option<Operaatiot> {
    //eprintln!("\x1b[32m==+ doing\x1b[34m");
    let mut layer = 0;
    let mut layer_lists: Vec<(Operaatiot, Vec<Value>)> = vec![
        (Vec::new(), alkuperäinen_lista.to_owned())
    ];
    loop {
        let cur_layer_lists = layer_lists.clone();
        layer_lists = Vec::new();
        for (prev_child_i, (edelliset_operaatiot, lista)) in cur_layer_lists.iter().enumerate() {
            //eprintln!("{}layer={layer}.{prev_child_i}", "  ".repeat(layer));
            for (i, _luku) in lista.iter().enumerate() {
                let mut operaatiot = edelliset_operaatiot.clone();
                operaatiot.push(i);
                let res = suorita_operaatio(käännön_pituus, i, &lista);
                //eprintln!("  {}operaatiot={operaatiot:?}", "  ".repeat(layer));
                if res == järjestetty_lista {
                    //eprintln!("\x1b[31m==- done\x1b[0m: {:?}", res);
                    return Some(operaatiot);
                }
                layer_lists.push((
                    operaatiot,
                    res
                ));
            }
        }
        layer += 1;
    }
}

/*fn käännä(
    käännön_pituus: IdxLen,
    järjestetty_lista: &[Value],
    alkuperäinen_lista: &[Value],
) -> Option<Operaatiot> {
    let mut lista = alkuperäinen_lista.to_owned();
    let mut operaatiot = Vec::new();
    let mut prev_cmp = 0;
    let max_iters = lista.len() - käännön_pituus + 1; // is +1 necessary?
    let to_visit: Vec<Operaatiot> = Vec::new();

    for iter in 0..max_iters {
        for operaatio_i in 0..(lista.len() - käännön_pituus) {
            println!("sub-iter {operaatio_i} of {iter}");
            let uusi_lista = suorita_operaatio(käännön_pituus, operaatio_i, &lista);
            if järjestetty_lista == uusi_lista {
                operaatiot.push(operaatio_i);
                return Some(operaatiot);
            }



            let cmp = cmp_sorted(järjestetty_lista, &uusi_lista);
            // FIXME: doesn't work for multi-step
            if cmp > prev_cmp {
                // better than previous, good to go for next iter
                lista = uusi_lista;
                prev_cmp = cmp;
                break;
            } else {
                println!("continuing at sub-iter {operaatio_i} of {iter}: {cmp} >= {prev_cmp}");
            }
        }
        eprintln!("= top-level iter {iter}: max_iters={max_iters}, operaatiot={operaatiot:?}");
    }
    None
}*/

#[cfg(test)]
#[test]
fn test_käännä() {
    fn f(käännön_pituus: IdxLen, lista: &[Value], expected: &[IdxLen]) {
        let mut järjestetty = lista.to_owned();
        järjestetty.sort();
        assert_eq!(käännä3(käännön_pituus, &järjestetty, lista).unwrap(), expected);
    }
    eprintln!("-=-=- one step");
    f(2, &[2, 1, 3, 4, 5], &[0]);
    f(2, &[1, 3, 2, 4, 5], &[1]);
    eprintln!("-=-=- two steps");
    f(2, &[2, 3, 1, 4, 5], &[1, 0]);
    f(3, &[3, 4, 1, 2, 5], &[0, 1]); // or 2, 1 for descending
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut lines = stdin().lines();
    let ensimmäinen_rivi = lines
        .next()
        .unwrap()?
        .split_ascii_whitespace()
        .map(str::parse)
        .collect::<Result<Vec<usize>, _>>()?;

    // n, k
    let (listan_pituus, käännön_pituus) = (ensimmäinen_rivi[0], ensimmäinen_rivi[1]);

    // Jokainen luku 1,2,\dots,n esiintyy listassa täsmälleen kerran.
    let lista = lines
        .next()
        .unwrap()?
        .split_ascii_whitespace()
        .map(str::parse)
        .collect::<Result<Vec<Value>, _>>()?;
    assert_eq!(listan_pituus, lista.len());

    let mut järjestetty_lista = lista.clone();
    järjestetty_lista.sort();
    //järjestetty_lista.reverse();

    if let Some(operaatiot) = käännä3(käännön_pituus, &järjestetty_lista, &lista) {
        println!("YES");
        println!("{}", operaatiot.len());
        //let str_ops: Vec<_> = operaatiot.iter().map(ToString::to_string).collect();
        let str_ops: Vec<_> = operaatiot.iter().map(|op| (op + 1).to_string()).rev().collect();
        println!("{}", str_ops.join(" "));
    } else {
        println!("NO");
    }
    Ok(())
}

Test 1

Group: 1

Verdict: WRONG ANSWER

Test 2

Group: 1

Verdict: ACCEPTED

Test 3

Group: 1

Verdict: RUNTIME ERROR

Test 4

Group: 1

Verdict: RUNTIME ERROR

Test 5

Group: 1

Verdict: RUNTIME ERROR

Test 6

Group: 2

Verdict: WRONG ANSWER

Test 7

Group: 2

Verdict: WRONG ANSWER

Test 8

Group: 2

Verdict: WRONG ANSWER

Test 9

Group: 2

Verdict: RUNTIME ERROR

Test 10

Group: 2

Verdict: RUNTIME ERROR

Test 11

Group: 2

Verdict: RUNTIME ERROR

Test 12

Group: 2

Verdict: RUNTIME ERROR

Test 13

Group: 2

Verdict: RUNTIME ERROR

Test 14

Group: 2

Verdict: RUNTIME ERROR

Test 15

Group: 2

Verdict: RUNTIME ERROR

Test 16

Group: 2

Verdict: RUNTIME ERROR

Test 17

Group: 3

Verdict: WRONG ANSWER

Test 18

Group: 3

Verdict: WRONG ANSWER

Test 19

Group: 3

Verdict: RUNTIME ERROR

Test 20

Group: 3

Verdict: RUNTIME ERROR

Test 21

Group: 3

Verdict: RUNTIME ERROR

Test 22

Group: 3

Verdict: RUNTIME ERROR

Test 23

Group: 3

Verdict: RUNTIME ERROR

Test 24

Group: 3

Verdict: RUNTIME ERROR

Test 25

Group: 3

Verdict: RUNTIME ERROR

Test 26

Group: 4

Verdict: WRONG ANSWER

Test 27

Group: 4

Verdict: ACCEPTED

Test 28

Group: 4

Verdict: RUNTIME ERROR

Test 29

Group: 4

Verdict: RUNTIME ERROR

Test 30

Group: 4

Verdict: RUNTIME ERROR

Test 31

Group: 4

Verdict: RUNTIME ERROR

Test 32

Group: 4

Verdict: RUNTIME ERROR

Test 33

Group: 4

Verdict: RUNTIME ERROR

Test 34

Group: 4

Verdict: RUNTIME ERROR