function mixMine(s1, s2) {
  /** Only lowercase letters */
  const cleanStrings = [s1, s2].map(it => it.replace(/[^a-z]/g, '').split(''));
  
  /** {a: [3,2], b: [0,5], c: [6,6]} */
  const lettersCount = cleanStrings.reduce((acc, arr, index) => {
    for (let i = 0; i < arr.length; i++) {
      const letter = arr[i];
      if (!acc[letter]) {
        acc[letter] = [0, 0];
      }

      acc[letter][index] += 1;
    }
    return acc;
  }, {});

  /** {2: ['1:gg', '2:ee', '2:ff'], 3: ['1:aaa', '1:nnn']} */
  const lengthToArr = {};

  for (const letter in lettersCount) {
    let [first, second] = lettersCount[letter];

    if (first >= 2 || second >= 2) {
      if (first === second) {
        if (!lengthToArr[second]) lengthToArr[second] = [];

        lengthToArr[second].push(`=:${letter.repeat(second)}`)
        lengthToArr[second].sort();
      } else {
        const maxLen = Math.max(first, second);
        if (!lengthToArr[maxLen]) lengthToArr[maxLen] = [];

        lengthToArr[maxLen].push(`${first > second ? 1 : 2}:${letter.repeat(maxLen)}`)
        lengthToArr[maxLen].sort();
      }
    }
  }

  return Object.keys(lengthToArr).sort((a, b) => +b - +a).reduce((acc, it) => {
    acc.push(lengthToArr[it].join('/'));
    return acc;
  }, []).join('/');
}

test(mixMine);

const alphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');

function mixTopSolution(s1, s2) {
  return alphabet
    .map(char => {
      const s1Count = s1.split('').filter(x => x === char).length,
            s2Count = s2.split('').filter(x => x === char).length,
            maxCount = Math.max(s1Count, s2Count);

      return {
        char: char,
        count: maxCount,
        src: maxCount > s1Count ? '2' : maxCount > s2Count ? '1' : '='
      };
    })
    .filter(c => c.count > 1)
    .sort((objA, objB) => objB.count - objA.count || (objA.src + objA.char > objB.src + objB.char ? 1 : -1))
    .map(c => `${c.src}:${c.char.repeat(c.count)}`)
    .join('/');
}

test(mixTopSolution);

function mixSecondToTop(s1, s2) {
  var counter = s => s.replace(/[^a-z]/g,'').split('').sort().reduce((x,y)=> (x[y] = 1 + (x[y]||0), x),{});
  s1 = counter(s1); s2 = counter(s2);
  var res = [], keys = new Set(Object.keys(s1).concat(Object.keys(s2)));
  keys.forEach(key => {
    var c1 = s1[key]||0, c2 = s2[key]||0, count = Math.max(c1, c2);
    if (count>1) {
      var from = [1, '=', 2][Math.sign(c2-c1)+1];
      var str = [...Array(count)].map(_=>key).join('');
      res.push(from+':'+str);
    }
  });
  return res.sort((x, y) => y.length - x.length || (x < y ? -1 : 1)).join('/');}


test(mixSecondToTop)

const sanitise = string => {
  return string
          .split('')
          .filter(Boolean)
          .filter(c => 'abcdefghijklmnopqrstuvwxyz'.indexOf(c) > -1)
          .filter(c => string.match(new RegExp(c, 'g')).length > 1)
          .join('');
}

const group = string => {
  return string.split('').sort().reduce((acc, c, i, arr) => {
    if (!acc[c]) acc[c] = arr.slice(arr.indexOf(c), arr.lastIndexOf(c) + 1).length;
    return acc;
  }, {});
}

const alphaSort = (a, b) => {
  if (a > b) return -1;
  if (a < b) return 1;
  return 0;
}

const sort = (a, b) => {
  const comparator = a.split(':')[1].length - b.split(':')[1].length;
  return comparator !== 0 ? comparator : alphaSort(a, b);
}

const repeat = (c, n) => {
  return Array(n + 1).join(c)
}

function mixLongestSolution(s1, s2) {
  const group1 = group(sanitise(s1));
  const group2 = group(sanitise(s2));
  const keys = [...Object.keys(group1), ...Object.keys(group2)];

  return keys
    .filter((c, i, arr) => arr.indexOf(c) === i)
    .reduce((output, k) => {
      const len1 = group1[k] || 0;
      const len2 = group2[k] || 0;

      if (len1 === len2) {
        return [...output, `=:${repeat(k, len1)}`];
      }
      else if (len1 > len2) {
        return [...output, `1:${repeat(k, len1)}`];
      }
      else {
        return [...output, `2:${repeat(k, len2)}`];
      }
      return output;
    }, [])
    .sort(sort)
    .reverse()
    .join('/');
}

test(mixLongestSolution)

    function compSol(a, b) {
        var r;
        var cp = b.length - a.length;
        if (cp === 0) {
            if (a < b) r = -1; else r = 1;
        } else {
            r = cp;
        }
        return r;
    }
    function mixAuthorSolution(s1, s2) {
      var alpha_s1 = Array(27).join(1).split('').map(function(){return 0;});
      var alpha_s2 = Array(27).join(1).split('').map(function(){return 0;});
      var l1 = s1.length; var l2 = s2.length; var i; var res = ""; var c;
      for(i = 0; i < l1; i++) {
        c = s1.charCodeAt(i);
        if (c >= 97 && c <= 122)
          alpha_s1[c - 97]++;
      }
      for(i = 0; i < l2; i++) {
        c = s2.charCodeAt(i);
        if (c >= 97 && c <= 122)
          alpha_s2[c - 97]++;
      }
      for(i = 0; i < 26; i++) {
        var sm = Math.max(alpha_s1[i], alpha_s2[i]);
        if (sm > 1) {
          if (sm > alpha_s1[i]) {
            res += "2:" + Array(sm+1).join(String.fromCharCode(i + 97)) + "/";
          } else {
            if (sm > alpha_s2[i]) {
              res += "1:" + Array(sm+1).join(String.fromCharCode(i + 97)) + "/";
            } else {
            res += "=:" + Array(sm+1).join(String.fromCharCode(i + 97)) + "/";
            }
          }
        }
      }
      if (res.Length === 0) return "";
      return res.substring(0, res.length - 1).split("/").sort(compSol).join("/");
    }


test(mixAuthorSolution)