## 760. Find Anagram Mappings

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 = 1` because the `0`th element of `A` appears at `B`, and `P = 4` because the `1`st element of `A` appears at `B`, and so on.

Note:

1. `A, B` have equal lengths in range `[1, 100]`.
2. `A[i], B[i]` are integers in range `[0, 10^5]`.

## Rust Solution

``````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);
}
``````

Having problems with this solution? Click here to submit an issue on github.