Given two lists `A`

and `B`

, and `B`

is an anagram of `A`

. `B`

is an anagram of `A`

means `B`

is made by randomizing the order of the elements in `A`

.

We want to find an *index mapping* `P`

, from `A`

to `B`

. A mapping `P[i] = j`

means the `i`

th element in `A`

appears in `B`

at index `j`

.

These lists `A`

and `B`

may contain duplicates. If there are multiple answers, output any of them.

For example, given

A = [12, 28, 46, 32, 50] B = [50, 12, 32, 46, 28]We should return

[1, 4, 3, 2, 0]as

`P[0] = 1`

because the `0`

th element of `A`

appears at `B[1]`

,
and `P[1] = 4`

because the `1`

st element of `A`

appears at `B[4]`

,
and so on.
**Note:**

`A, B`

have equal lengths in range`[1, 100]`

.`A[i], B[i]`

are integers in range`[0, 10^5]`

.

```
struct Solution;
use std::collections::HashMap;
impl Solution {
fn anagram_mappings(a: Vec<i32>, b: Vec<i32>) -> Vec<i32> {
let mut hs: HashMap<i32, Vec<i32>> = HashMap::new();
let n = a.len();
for (i, &x) in b.iter().enumerate() {
let indexes = hs.entry(x).or_default();
indexes.push(i as i32);
}
let mut res: Vec<i32> = vec![0; n];
for (i, &x) in a.iter().enumerate() {
let indexes = hs.entry(x).or_default();
res[i] = indexes.pop().unwrap();
}
res
}
}
#[test]
fn test() {
let a = vec![12, 28, 46, 32, 50];
let b = vec![50, 12, 32, 46, 28];
let res = vec![1, 4, 3, 2, 0];
assert_eq!(Solution::anagram_mappings(a, b), res);
}
```