删除字符串中出现次数最少的字符

function deleteStr(line){
  let hash = {}
  for(let i = 0; i<line.length; i++){
    if(!hash[line[i]]){
      hash[line[i]] = 1
    }else{
      hash[line[i]]++
    }
  }
  // 求出hash中元素最少的个数？
  let min = hash[line[0]]
  for(let key in hash){
    if(hash[key] < min){
      min = hash[key]
    }
  }
  // 将个数等于min的字符全部删除
  for(let key in hash){
    if(hash[key] == min) {
      let reg = new RegExp(key,"g")
      line = line.replace(reg,"")
    }
  }
  console.log(line)
}

const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
const lines = [];
rl.on("line", function (line) {
    const lines = [...line]
    const obj={}
    lines.forEach((char) => {
        obj[char] = (obj[char]||0) + 1
    })
    let values = Object.values(obj), min = values[0]
    values.forEach((item)=> {
        min = Math.min(item, min)
    })
    Object.keys(obj).forEach((key)=> {
        if (obj[key] ===min) {
            line = line.replace(new RegExp(key,'g'), '')
        }
    })
    console.log(line)
});

先分解数组
在用对象key value值 计算每个字符次数 key为字符，value为次数
拿出最小次数
然后通过replace替换最小次数字符

const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
const arr = [];
rl.on('line', function (line) {
    if (line === "") {
        rl.close();
    } else {
        arr.push(line);
    }
});

rl.on("close", function() {
    arr.forEach(string => {
        
        // 记录字符和字符出现的次数
        const charArr = [];
        const countArr = [];
        for(char of string) {
            const index = charArr.indexOf(char);
            if (index === -1) {
                charArr.push(char);
                countArr.push(1);
            } else {
                countArr[index]++;
            }
        }
        
        // 计算出现次数最少的字符
        const min = Math.min(...countArr);
        let minChars = "";
        countArr.forEach((count, i) => {
            if (count === min) {
                minChars = minChars + charArr[i];
            }
        });
        
        // 将出现次数最少的字符删除
        const pattern = "[" + minChars + "]";
        const resultStr = string.replace(new RegExp(pattern, "g"), "");
        console.log(resultStr);
    });
});

const readline = require("readline");
const rl = readline.createInterface({
    input:process.stdin,
    output:process.stdout
});

rl.on("line",function(line){
    var list = line.split('');
    //按字典序排序
    list.sort();
    //console.log(list);
    //计算次数
    let obj = {};
    for(let i=0;i<list.length;i++){
        if (obj[list[i]]){
            obj[list[i]]++;
        } else {
            obj[list[i]] = 1;
        }
    }
    //console.log(obj);
    //obj对象转成数组
     var arr=[];
    for(let key in obj){
        arr.push({"key":key,"value":obj[key]});
    }
    //console.log(arr);
    //按次数排序,降序
    arr.sort((a,b)=>{
        return b.value-a.value;
    })
    //console.log(arr);
    //找出所有大于最后一个字符次数的结果集
    var result=[];
    arr.forEach(item=>{
        if(item.value>arr[arr.length-1].value){
            result.push(item);
        }
    });
    //console.log(result);
    //比较输出
    var str="";
    line.split('').forEach(li=>{
        result.forEach(item=>{
        if(li==item.key){
            str+=item.key;
        }
     })
    })
     console.log(str);
   
});

let line
while(line = readline()) {
  let arr = [...new Set(line.split(''))]
  let letter = []
  for(let item of arr) {
    let index = line.split('').filter(e => e === item).length
    letter[index] ? letter[index].push(item) : letter[index] = [item]
  }
  letter = letter.filter(() => true)
  let reg = new RegExp(`[${letter[0].join('')}]`, 'g')
  console.log(line.replace(reg, ''))
}

var readline = require('readline');
const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
});

function delMin(str) {
  const countObj = {}
  const strArr = Array.from(str)
  strArr.forEach(item => {
    if (countObj[item]) {
      countObj[item] += 1
    } else {
      countObj[item] = 1
    }
  })

  const minTime = Math.min(...(Object.keys(countObj)).map(item => {
    return countObj[item]
  }))

  const delFLag = Object.keys(countObj).filter(item => countObj[item] === minTime)

  for (let i = 0; i<strArr.length; i++) {
    if (delFLag.indexOf(strArr[i]) > -1) {
      strArr[i] = ''
    }
  }

  console.log(strArr.join(''))
}

rl.on('line', function(line){
   delMin(line)
});

function deletString(str2){
    arr2=str2.split('');
//reduce求出每个字符对应的个数
var result=arr2.reduce(function(allString,name){     if(name in allString){         allString[name]++;     }     else{         allString[name]=1;     }     return allString;
},{});
//排序取最小值
var arr=Object.keys(result).sort(function(v1,v2){     return result[v1]-result[v2]
})
//将满足条件的最小字符放入一个数组
var arr3=[]
var min=result[arr[0]]
for(var i=0;i<arr.length;i++){     if(result[arr[i]]===min){              arr3.push(arr[i])     }
}

//正则表达式删除最小的元素
for(var i=0;i<arr3.length;i++){     var reg = new RegExp(arr3[i],"g");
    var a=str2.replace(reg,"");     str2=a;
}
return str2;
}
while(line = readline()){
    console.log(deletString(line));
}

function def_str(par){     var arr=par.split("");     var obj={};     var min=99999;     void function(){         for(var i=0, len=arr.length; i<len; i++){         if(obj.hasOwnProperty(arr[i])){             obj[arr[i]]++;         }else{             obj[arr[i]]=1;         }     }     }();     void function(){         for(var key in obj){             if(obj[key]<min){                 min=obj[key];             }         }     }();     void function(){         for(var key in obj){             if(obj[key]===min){                 arr.splice(arr.indexOf(key),1);             }         }     }();     return arr.join("");
}
var line;
while(line=readline()){
    var str=line;
    var res=def_str(str);
    console.log(res);
}

while(line = readline()){
    console.log(deleChar(line));
}

function deleChar(str){
    //hashmap字符对应字符个数
    var obj = {};
    for(var i=0; i<str.length; i++){
        if(str[i] in obj){
            obj[str[i]]++;
        }else{
            obj[str[i]]=1;
        }
    }
    //排序取最小值
    var arr = Object.keys(obj).sort(function(v1,v2){
        return obj[v1]-obj[v2];
    });
    var arr2 = [];
    var cnt = obj[arr[0]];
    //求出满足最小值得字符
    for(var i=0; i<arr.length; i++){
        if(obj[arr[i]] == cnt){
            arr2.push(arr[i]);
        }
    }
    //通过正则表达式删除
    var result = '';
    for(var i=0; i<arr2.length; i++){
        var regx = new RegExp(arr[i], 'g'); 
        result = str.replace(regx, '');
        str = result;
    }
    return str;
}