Check Whether Two Strings are Almost Equivalent solution and explanation

def are_almost_equivalent(word1, word2):
    freq1 = [0] * 26
    freq2 = [0] * 26

    for ch1, ch2 in zip(word1, word2):
        freq1[ord(ch1) - ord('a')] += 1
        freq2[ord(ch2) - ord('a')] += 1

    return all(abs(f1 - f2) <= 3 for f1, f2 in zip(freq1, freq2))

word1 = "abcdeef"
word2 = "abaaacc"
print(are_almost_equivalent(word1, word2))

public class Solution {
    public boolean areAlmostEquivalent(String word1, String word2) {
        int[] freq1 = new int[26];
        int[] freq2 = new int[26];

        int n = word1.length();
        for (int i = 0; i < n; i++) {
            freq1[word1.charAt(i) - 'a']++;
            freq2[word2.charAt(i) - 'a']++;
        }

        for (int i = 0; i < 26; i++) {
            if (Math.abs(freq1[i] - freq2[i]) > 3) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println(sol.areAlmostEquivalent("abcdeef", "abaaacc"));
    }
}

#include <iostream>
#include <vector>
#include <string>
using namespace std;

bool areAlmostEquivalent(string word1, string word2) {
    vector<int> freq1(26, 0), freq2(26, 0);
    int n = word1.length();
    for (int i = 0; i < n; i++) {
        freq1[word1[i] - 'a']++;
        freq2[word2[i] - 'a']++;
    }
    
    for (int i = 0; i < 26; i++) {
        if (abs(freq1[i] - freq2[i]) > 3)
            return false;
    }
    return true;
}

int main() {
    string word1 = "abcdeef";
    string word2 = "abaaacc";
    cout << (areAlmostEquivalent(word1, word2) ? "true" : "false") << endl;
    return 0;
}

function areAlmostEquivalent(word1, word2) {
    const freq1 = Array(26).fill(0);
    const freq2 = Array(26).fill(0);

    for (let i = 0; i < word1.length; i++) {
        freq1[word1.charCodeAt(i) - 97]++;
        freq2[word2.charCodeAt(i) - 97]++;
    }

    for (let i = 0; i < 26; i++) {
        if (Math.abs(freq1[i] - freq2[i]) > 3) {
            return false;
        }
    }
    return true;
}

console.log(areAlmostEquivalent("abcdeef", "abaaacc"));

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

bool areAlmostEquivalent(char *word1, char *word2) {
    int freq1[26] = {0};
    int freq2[26] = {0};
    
    int n = strlen(word1);
    for (int i = 0; i < n; i++) {
        freq1[word1[i] - 'a']++;
        freq2[word2[i] - 'a']++;
    }
    
    for (int i = 0; i < 26; i++) {
        if (abs(freq1[i] - freq2[i]) > 3) {
            return false;
        }
    }
    return true;
}

int main() {
    char *word1 = "abcdeef";
    char *word2 = "abaaacc";
    printf("%s\n", areAlmostEquivalent(word1, word2) ? "true" : "false");
    return 0;
}

using System;

public class Solution {
    public bool AreAlmostEquivalent(string word1, string word2) {
        int[] freq1 = new int[26];
        int[] freq2 = new int[26];

        for (int i = 0; i < word1.Length; i++) {
            freq1[word1[i] - 'a']++;
            freq2[word2[i] - 'a']++;
        }

        for (int i = 0; i < 26; i++) {
            if (Math.Abs(freq1[i] - freq2[i]) > 3) {
                return false;
            }
        }
        return true;
    }

    public static void Main() {
        Solution sol = new Solution();
        Console.WriteLine(sol.AreAlmostEquivalent("abcdeef", "abaaacc"));
    }
}

def are_almost_equivalent(word1, word2):
    from collections import defaultdict
    freq1, freq2 = defaultdict(int), defaultdict(int)

    for ch in word1:
        freq1[ch] += 1
    for ch in word2:
        freq2[ch] += 1

    for ch in 'abcdefghijklmnopqrstuvwxyz':
        if abs(freq1[ch] - freq2[ch]) > 3:
            return False
    return True

print(are_almost_equivalent("abcdeef", "abaaacc"))

import java.util.HashMap;

public class Solution {
    public boolean areAlmostEquivalent(String word1, String word2) {
        HashMap<Character, Integer> freq1 = new HashMap<>();
        HashMap<Character, Integer> freq2 = new HashMap<>();

        for (char c : word1.toCharArray())
            freq1.put(c, freq1.getOrDefault(c, 0) + 1);
        for (char c : word2.toCharArray())
            freq2.put(c, freq2.getOrDefault(c, 0) + 1);

        for (char c = 'a'; c <= 'z'; c++) {
            int count1 = freq1.getOrDefault(c, 0);
            int count2 = freq2.getOrDefault(c, 0);
            if (Math.abs(count1 - count2) > 3) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println(sol.areAlmostEquivalent("abcdeef", "abaaacc"));
    }
}

#include <iostream>
#include <unordered_map>
#include <string>
#include <cmath>
using namespace std;

bool areAlmostEquivalent(string word1, string word2) {
    unordered_map<char, int> freq1, freq2;
    for (char ch : word1) freq1[ch]++;
    for (char ch : word2) freq2[ch]++;
    
    for (char ch = 'a'; ch <= 'z'; ch++) {
        if (abs(freq1[ch] - freq2[ch]) > 3) {
            return false;
        }
    }
    return true;
}

int main() {
    cout << areAlmostEquivalent("abcdeef", "abaaacc") << endl; // Output: 1 (true)
    return 0;
}

function areAlmostEquivalent(word1, word2) {
    const freq1 = new Map();
    const freq2 = new Map();

    for (const char of word1) {
        freq1.set(char, (freq1.get(char) || 0) + 1);
    }
    for (const char of word2) {
        freq2.set(char, (freq2.get(char) || 0) + 1);
    }

    for (let i = 0; i < 26; i++) {
        const char = String.fromCharCode(97 + i);
        const f1 = freq1.get(char) || 0;
        const f2 = freq2.get(char) || 0;
        if (Math.abs(f1 - f2) > 3) {
            return false;
        }
    }
    return true;
}

console.log(areAlmostEquivalent("abcdeef", "abaaacc"));

function checkAlmostEquivalent(word1: string, word2: string): boolean {
    const cnt: number[] = new Array(26).fill(0);
    for (const c of word1) {
        ++cnt[c.charCodeAt(0) - 97];
    }
    for (const c of word2) {
        --cnt[c.charCodeAt(0) - 97];
    }
    return cnt.every(x => Math.abs(x) <= 3);
}

func checkAlmostEquivalent(word1 string, word2 string) bool {
	cnt := [26]int{}
	for _, c := range word1 {
		cnt[c-'a']++
	}
	for _, c := range word2 {
		cnt[c-'a']--
	}
	for _, x := range cnt {
		if x > 3 || x < -3 {
			return false
		}
	}
	return true
}

class Solution {
    /**
     * @param String $word1
     * @param String $word2
     * @return Boolean
     */
    function checkAlmostEquivalent($word1, $word2) {
        for ($i = 0; $i < strlen($word1); $i++) {
            $hashtable[$word1[$i]] += 1;
            $hashtable[$word2[$i]] -= 1;
        }
        $keys = array_keys($hashtable);
        for ($j = 0; $j < count($keys); $j++) {
            if (abs($hashtable[$keys[$j]]) > 3) {
                return false;
            }
        }
        return true;
    }
}