2022-06-29: x = {a, B, C, D}, y = {e, F, G, H}, the length of the two small arrays X and Y is 4. If yes: a + e = B + F = C + G = D + H

2022-06-29：x = { a, b, c, d },
y = { e, f, g, h },
x、y The length of both small arrays is 4.
If there is : a + e = b + f = c + g = d + h,
So x and y Is a perfect pair .
The title is given N A small array , The length of each small array is K.
Back here N In small arrays , How many are perfect .
From Ali .

answer 2022-06-29：

Look for features , save map, Find the difference between adjacent numbers of the array , Assemble into key,value It's quantity .

The code to use rust To write . The code is as follows ：

use std::collections::HashMap;
fn main() {
    
    let sc: Vec<i32> = vec![5, 3, 2, 11, 21, 19, 10, 1, 20, 11, 1, 6, 15, 24, 18, 27, 36];
    let mut ii: i32 = 0;
    while ii < sc.len() as i32 {
    
        let n = sc[ii as usize];
        ii += 1;
        let m: i32 = sc[ii as usize];
        ii += 1;
        let mut matrix: Vec<Vec<isize>> = vec![];
        for i in 0..n {
    
            matrix.push(vec![]);
            for _ in 0..m {
    
                matrix[i as usize].push(sc[ii as usize] as isize);
                ii += 1;
            }
        }
        println!("matrix = {:?}", matrix);
        let ans = perfect_pairs(&mut matrix);
        println!("ans = {}", ans);
    }
}

fn perfect_pairs(matrix: &mut Vec<Vec<isize>>) -> isize {
    
    let mut ans: isize = 0;
    // key :  character string   features , Difference characteristics  : "_5_-2_6_9"
    let mut counts: HashMap<String, isize> = HashMap::new();
    for arr in matrix.iter() {
    
        let mut self0: String = String::new();
        let mut minus: String = String::new();
        for i in 1..arr.len() as isize {
    
            self0.push_str(
                &(String::from("_") + &format!("{}", arr[i as usize] - arr[(i - 1) as usize])),
            );
            minus.push_str(
                &(String::from("_") + &format!("{}", arr[(i - 1) as usize] - arr[i as usize])),
            );
        }
        ans += match counts.get(&minus) {
    
            Some(v) => *v,
            None => 0,
        };
        counts.insert(
            self0.clone(),
            match counts.get(&self0) {
    
                Some(v) => (*v) + 1,
                None => 1,
            },
        );
    }
    return ans;
}

The results are as follows ：

---

Zuo Shen java Code