Strings Mix

Strings MixCodewars

Approach

Solve the problem

collectData function

1. getting lowercase character via RegExp

2. iterest each character with initial value Map

   1. if key exist in map add value with 'arraySequence'. (arraySequence is for identifier for distinguish. because we need calculate rank)

   2. set max value for format (in this case arraySequence will '1', '2',)

   3. set comparision result (1 || 2 || '=')

3. return map

mix function

1. call collectData function with two input

2. convert process-1 to array

3. sorting

   1. if a.max < b.max return 1 (change) because ordering DESC

   2. if a.max equal with b.max

      1. if a.greater > b.greater should be change because when max value same sequence 1 should be first. *and the reason use parseInt(a[1].greater) || 3 because when trying parseInt if greater is '=' should be go to last

      2. if a,b greater same ordering lexicographically

4. filtering process-3 who less than 1

5. iterate process-4 and convert to format

6. Convert process-5 to one string

Solution

JavaScript

const collectData = (map, str, arraySequence) => {
  str.match(/[a-z]/g)
    .forEach((v) => {
      const format = map.get(v) || {};
      format[arraySequence] = (format[arraySequence] || 0) + 1;
      format.max = Math.max(format[1] || 0, format[2] || 0);
      
      if (format[1] === format[2]) {
        format.greater = '=';
      } else {
        format.greater = (format[1] || 0) > (format[2] || 0) ? 1 : 2;
      }
      
      map.set(v, format);
    });
  return map;
};

const mix = (s1, s2) => {
  let map = collectData(new Map(), s1, 1);
  map = collectData(map, s2, 2);
 
  const sortedResult = [...map.entries()].sort((a, b) => {
    if (a[1].max < b[1].max) {
      return 1;
    }
    
    if (a[1].max === b[1].max) {
      if ((parseInt(a[1].greater) || 3) > (parseInt(b[1].greater) || 3)) {
        return 1;
      }
      
      if (a[1].greater === b[1].greater) {
        return a[0].localeCompare(b[0]);
      }
    }
    
    return -1;
  }).filter((v) => v[1].max > 1);
  
  return sortedResult.map((v) => `${v[1].greater}:${v[0].repeat(v[1].max)}`)
    .join('/');
};