unordered_map

C++, Rust, Python, Go

C++ Rust (use std::collections::HashMap) Python ({} Dictionary) Go
Create 
   
unordered_map<string, int> um;
Empty 

let hm:HashMap = HashMap::new()
Key ,value 

let hm:HashMap<i32, Vec<i32>> = HashMap::new();
initialize 

iter(): is called on the array to create
        an iterator over its elements
cloned(): method is used to clone each
            tuple's elements. This is necessary
            because &str is a reference type,
            and we need to create owned values
            to store in the HashMap.
collect(): method consumes the iterator and collects
            the cloned tuples into a HashMap<char, &str>
let hm: HashMap = [
    (2, "abc"),
    (3, "def"),
    (4, "ghi"),
    (5, "jkl"),
    (6, "mno"),
    (7, "pqrs"),
    (8, "tuv"),
    (9, "wxyz"),
]
.iter()
.cloned()
.collect();
                        
                               
#Empty
self.hm = {}

#key,val
self.hm={1:1, 2:2}

#hashmap <key=int, value=vector>
um = {}
value = [1,2,3]
um[10] = value
            
                              
hm := make(map[int]int) //[key]value
OR
var hm map[string[int]]  //key=string, value=int
Delete/Erase 
    
um.erase(key);
Range: um.erase(start,end);
Find 
    
if (um.find("key") != um.end())
OR
value=count(key)
// Smallest Key
  min_element(um.begin(), um.end())
Search 

if let Some(value) = hm.get(&key) {
} else {
}
Mutable 

if let Some(value) = hm.get_mut(&key) {
    value = 1;
} else {
}
value = um[key] 
        
value = hm[key]
if value != nil {
    //Found
}
Insert 
   
vec.insert(v.begin() + 2, 7)

//Count occurences
for (auto&i:vec)
  um[i]++
Method Code
Insert 

hm.insert(key, value);
Count occurences
method code
get_mut 

for i in 0..nums.len() {
    if let Some(val) = hm.get_mut(&nums[i]) {
        *val += 1;
    } else {
        hm.insert(nums[i],1);
    }
}
entry 

// entry() returns enum{Occupied, Vacant}
*hm.entry(nums[i]).or_insert(0) += 1;
                    
    
# Count number of occurences
um = {}
nums = [1,2,3,1,2]
for i in nums:
  if i in um:
    um[i] += 1
  else:
    um[i] = 1
            
    
hm["test"] = 1

//Count number of occurences
for i:=0; i<len(nums);i++ {
    hm[nums[i]]++
}
Iterate over elements 
                   
for (const auto& [key, value] : um) {
    out += value*(value-1)/2;
}
iter 

for (key, value) in hm.iter() {
    println!("Key: {}, Value: {}", *key, *value);
}
&hm 

for (key, value) in &hm {
    println!("Key: {}, Value: {}", key, value);
}
                        
                 
for key,value in um.items():
  
            
                   
for key, value := range hm {
    out += (value-1)*value/2
}