Hash maps

def bucket_for(key, size):
    return sum(ord(c) for c in key) % size


def put(buckets, key, value):
    chain = buckets[bucket_for(key, len(buckets))]
    for i, (k, _) in enumerate(chain):
        if k == key:
            chain[i] = (key, value)
            return
    chain.append((key, value))


def get(buckets, key):
    for k, v in buckets[bucket_for(key, len(buckets))]:
        if k == key:
            return v
    return None

function bucketFor(key, size) {
  let sum = 0;
  for (const c of key) sum += c.charCodeAt(0);
  return sum % size;
}

function put(buckets, key, value) {
  const chain = buckets[bucketFor(key, buckets.length)];
  for (const entry of chain) {
    if (entry[0] === key) {
      entry[1] = value;
      return;
    }
  }
  chain.push([key, value]);
}

function get(buckets, key) {
  for (const [k, v] of buckets[bucketFor(key, buckets.length)]) {
    if (k === key) return v;
  }
  return undefined;
}

type entry struct {
	key   string
	value int
}

func bucketFor(key string, size int) int {
	sum := 0
	for _, c := range key {
		sum += int(c)
	}
	return sum % size
}

func put(buckets [][]entry, key string, value int) {
	b := bucketFor(key, len(buckets))
	for i := range buckets[b] {
		if buckets[b][i].key == key {
			buckets[b][i].value = value
			return
		}
	}
	buckets[b] = append(buckets[b], entry{key, value})
}

func get(buckets [][]entry, key string) (int, bool) {
	for _, e := range buckets[bucketFor(key, len(buckets))] {
		if e.key == key {
			return e.value, true
		}
	}
	return 0, false
}

fn bucket_for(key: &str, size: usize) -> usize {
    let sum: usize = key.chars().map(|c| c as usize).sum();
    sum % size
}

fn put(buckets: &mut [Vec<(String, i32)>], key: &str, value: i32) {
    let b = bucket_for(key, buckets.len());
    for entry in buckets[b].iter_mut() {
        if entry.0 == key {
            entry.1 = value;
            return;
        }
    }
    buckets[b].push((key.to_string(), value));
}

fn get(buckets: &[Vec<(String, i32)>], key: &str) -> Option<i32> {
    buckets[bucket_for(key, buckets.len())]
        .iter()
        .find(|(k, _)| k == key)
        .map(|(_, v)| *v)
}