function maxOccurence(str) {
    const dict = {}
    for (const char of str) {
        if (char in dict) dict[char]++
        else dict[char] = 1
    }
    let maxchar = [], maxcount = -1
    for (const char in dict)
        if (dict[char] === maxcount) maxchar.push(char)
        else if (dict[char] > maxcount) {
            maxchar = [char]
            maxcount = dict[char]
        }
    return { char: maxchar, count: maxcount }
}

function test(str){
    let _length = 0;
    let word = '';
    let result = []
    let str_list = str.split('');
    let _result = new Set(str_list);
	for(let w of _result){
		let number = str_list.filter(element => element == w).length;
		if(number > _length){
			result = [{
                              _length: number,
                              word: w
                         }]
			_length = number;
		}else if(number == _length){
			result.push({
                             _length: number,
                             word: w
                        })
		}
    }
    return result;
}

function findMaxLetter (str) {
  let maxLetter = ''
  let maxLen = 0
  let key = {}
  str.split('').forEach(item => {
    if (key[item] === undefined) {
      key[item] = 1
    } else {
      key[item]++
    }
    if (key[item] > maxLen) {
      maxLen = key[item]
      maxLetter = item
    }
  })

  return [maxLetter, maxLen]
}

function test (str) {
  let maxLen = 0;
  let char = '';

  for (let i = 0; i < str.length; i++) {
    const d = str[i];
    const len = str.split(d).length - 1;

    if (len > maxLen) {
      maxLen = len;
      char = d;
    }
  }

  return [char, maxLen];
}

/**
 * 写个方法，找出指定字符串中重复最多的字符及其长度
 */
function searchStr (str) {
  const arr = (str.split('').sort().join('').match(/(.)\1+/g) || []).sort((a, b) => a.length - b.length)
  if (arr.length) {
    const last = arr[arr.length - 1]
    const char = last[0]
    const size = last.length
    return {char, size}
  }
  return undefined
}
console.log(searchStr('asdfaaaaccksksks')) // {char: 'a', size: 5}

function test (str) {
  const listData = {}
  const arr = str.split('')

  for (let i of arr) {
    if (listData[i]) {
      listData[i] ++
    } else {
      listData[i] = 1
    }
  }

  let maxValue = 0
  let maxProps = []
  for(let [k, v] of Object.entries(listData)) {
    if (v === maxValue) {
      maxProps.push(k)
    }
    
    if (v > maxValue) {
      maxValue = v
      maxProps = [k]
    }
  }

  console.log('maxProps', maxProps)
  console.log('maxValue', maxValue)
}
test('abcde aafgff')

function searchString(str) {
  let arr = str.split('');
  let max = 0;
  let res = [];
  let list = arr.reduce((prev, cur) => {
    if(prev[cur] == undefined) {
      prev[cur] = 1
    } else {
      prev[cur] += 1;
    }
    return prev;
  }, {});
  for(i in list) {
    if(list[i] > max) {
        max = list[i];
        res = [];
        res.push(i);
    } else if(list[i] == max) {
        res.push(i);
    }
  }
  console.log(list);
  console.log(res);
  console.log(max);
}
searchString('idajweoicjxzkljsaoiuwoeunhdjkashdoaiujewqo');

function findRepeatStr(str) {
	var obj = {}
  
  for (var i in str) {
    if (obj[str[i]]) {
      obj[str[i]]++
    } else {
    	obj[str[i]] = 1
    }
  }
  
  var arr = []
  for (var key in obj) {
  	arr.push({key:key, num: obj[key]})
  }
  
  return arr.sort(function (a,b) {
		return b.num-a.num
  })[0]
}

findRepeatStr('aaaabbbbbbbbaasdasdasaa')

    const str = 'apple, banana';
    function fintMost(str) {
      const obj = {};
      let mostLen = 0;
      let mostStr = '';
      for (let index = 0; index < str.length; index++) {
        if (obj.hasOwnProperty(str[index])) {
          obj[str[index]] += 1;
          continue;
        }
        obj[str[index]] = 1;
      }
      for (const key in obj) {
        if (obj[key] > mostLen) {
          mostLen = obj[key];
          mostStr = key;
        }
      }
      return `最多的字符为${mostStr},次数为${mostLen}`
    }
    const res = fintMost(str);