Repeated DNA Sequences solution and explanation

def findRepeatedDnaSequences(s):
    seen, repeated = set(), set()
    for i in range(len(s) - 9):
        seq = s[i:i + 10]
        if seq in seen:
            repeated.add(seq)
        else:
            seen.add(seq)
    return list(repeated)

function findRepeatedDnaSequences(s) {
    const seen = new Set();
    const repeated = new Set();
    for (let i = 0; i <= s.length - 10; i++) {
        const seq = s.substring(i, i + 10);
        if (seen.has(seq)) {
            repeated.add(seq);
        } else {
            seen.add(seq);
        }
    }
    return Array.from(repeated);
}

#include <vector>
#include <string>
#include <unordered_set>

std::vector<std::string> findRepeatedDnaSequences(std::string s) {
    std::unordered_set<int> seen, repeated;
    std::vector<std::string> result;
    int map[128] = {0};
    map['A'] = 0;
    map['C'] = 1;
    map['G'] = 2;
    map['T'] = 3;

    int num = 0;
    for (int i = 0; i < s.size(); ++i) {
        num = ((num << 2) & 0xFFFFF) | map[s[i]];
        if (i < 9) continue;
        if (seen.count(num) && !repeated.count(num)) {
            result.push_back(s.substr(i - 9, 10));
            repeated.insert(num);
        }
        seen.insert(num);
    }
    return result;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char** findRepeatedDnaSequences(char* s, int* returnSize) {
    int seen[1 << 20] = {0};
    int repeated[1 << 20] = {0};
    char** result = malloc(100 * sizeof(char*));
    *returnSize = 0;

    int num = 0;
    for (int i = 0; i < strlen(s); i++) {
        num = ((num << 2) & ((1 << 20) - 1)) | (s[i] & 3);
        if (i < 9) continue;
        if (seen[num] == 1 && !repeated[num]) {
            result[*returnSize] = strndup(s + i - 9, 10);
            repeated[num] = 1;
            (*returnSize)++;
        }
        seen[num] = 1;
    }
    return result;
}

class Solution {
    public List<String> findRepeatedDnaSequences(String s) {
        Map<String, Integer> cnt = new HashMap<>();
        List<String> ans = new ArrayList<>();
        for (int i = 0; i < s.length() - 10 + 1; ++i) {
            String t = s.substring(i, i + 10);
            if (cnt.merge(t, 1, Integer::sum) == 2) {
                ans.add(t);
            }
        }
        return ans;
    }
}

function findRepeatedDnaSequences(s: string): string[] {
    const n = s.length;
    const cnt: Map<string, number> = new Map();
    const ans: string[] = [];
    for (let i = 0; i <= n - 10; ++i) {
        const t = s.slice(i, i + 10);
        cnt.set(t, (cnt.get(t) ?? 0) + 1);
        if (cnt.get(t) === 2) {
            ans.push(t);
        }
    }
    return ans;
}

public class Solution {
    public IList<string> FindRepeatedDnaSequences(string s) {
        var cnt = new Dictionary<string, int>();
        var ans = new List<string>();
        for (int i = 0; i < s.Length - 10 + 1; ++i) {
            var t = s.Substring(i, 10);
            if (!cnt.ContainsKey(t)) {
                cnt[t] = 0;
            }
            if (++cnt[t] == 2) {
                ans.Add(t);
            }
        }
        return ans;
    }
}

func findRepeatedDnaSequences(s string) (ans []string) {
	cnt := map[string]int{}
	for i := 0; i < len(s)-10+1; i++ {
		t := s[i : i+10]
		cnt[t]++
		if cnt[t] == 2 {
			ans = append(ans, t)
		}
	}
	return
}

use std::collections::HashMap;

impl Solution {
    pub fn find_repeated_dna_sequences(s: String) -> Vec<String> {
        if s.len() < 10 {
            return vec![];
        }
        let mut cnt = HashMap::new();
        let mut ans = Vec::new();
        for i in 0..s.len() - 9 {
            let t = &s[i..i + 10];
            let count = cnt.entry(t).or_insert(0);
            *count += 1;
            if *count == 2 {
                ans.push(t.to_string());
            }
        }
        ans
    }
}

func findRepeatedDnaSequences(s string) []string {
	hashCode := map[byte]int{'A': 0, 'C': 1, 'G': 2, 'T': 3}
	ans, cnt, left, right := []string{}, map[int]int{}, 0, 0

	sha, multi := 0, int(math.Pow(4, 9))
	for ; right < len(s); right++ {
		sha = sha*4 + hashCode[s[right]]
		if right-left+1 < 10 {
			continue
		}
		cnt[sha]++
		if cnt[sha] == 2 {
			ans = append(ans, s[left:right+1])
		}
		sha, left = sha-multi*hashCode[s[left]], left+1
	}
	return ans
}