前端基础知识与常见面试题(七)

实现删除字符串中出现次数最少的字符，若出现次数最少的字符有多个，则把出现次数最少的字符都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。

数据范围：输入的字符串长度满足 1 \le n \le 20 \ 1≤n≤20  ，保证输入的字符串中仅出现小写字母
法一：
let str=readline().split('')
let c={}
let og=[]
 
    for(var i=0;i<str.length;i++){
      if(c[str[i]]){
         c[str[i]]++
      } else{
           c[str[i]]=1
      }      
    }
  
  for(var k in c){
     og.push(c[k])
  }
let min=og.sort(function(a,b){return a-b})[0]
    for(var k in c){
        if(c[k]==min){
            while(str.indexOf(k)!==-1){
                str.splice(str.indexOf(k),1)
               
            }
        }
    }
 console.log(str.join(''))
法二：
let str = readline().split('');
let obj = {};
        str.map((item) => {
            if (!obj[item]) {
                obj[item] = 1;
            } else {
                obj[item] +=1;
            }
        });
        // 将obj中所有字母的次数取出来,算出最小次数
        const min = Object.values(obj).sort((a,b)=>a-b)[0];
        // 遍历obj找到字符，在str中删除
        for(let key in obj){
            if(obj[key]==min){
                while(str.includes(key)){
                    str.splice(str.indexOf(key),1);
                }
            }
        }
        console.log(str.join(''));
————————————————————————————————
描述
原理：ip地址的每段可以看成是一个0-255的整数，把每段拆分成一个二进制形式组合起来，然后把这个二进制数转变成
一个长整数。
举例：一个ip地址为10.0.3.193
每段数字             相对应的二进制数
10                   00001010
0                    00000000
3                    00000011
193                  11000001

组合起来即为：00001010 00000000 00000011 11000001,转换为10进制数就是：167773121，即该IP地址转换后的数字就是它了。

数据范围：保证输入的是合法的 IP 序列

输入描述：
输入 
1 输入IP地址
2 输入10进制型的IP地址

输出描述：
输出
1 输出转换成10进制的IP地址
2 输出转换后的IP地址

示例1
输入：
10.0.3.193
167969729
复制
输出：
167773121
10.3.3.193
解：let str=readline().split('.')
let sum=""
for(var i=0;i<str.length;i++){
 let n=Number(str[i]).toString(2)
 while(n.length<8){
     n='0'+`${n}`
 }
   sum+=n
}
console.log(parseInt(sum,2))
let str0=readline()
let n=Number(str0).toString(2).split('').reverse()
let arr=[]
for(var i=0;i<n.length;i+=8){
  let og= n.slice(i,i+8).reverse().join("")
  arr.push(og)
}
let res=arr.reverse()
let end=''
for(var i=0;i<res.length;i++){
  let hh= parseInt(res[i],2) 
  if(i==res.length-1){end+=hh}else{end+=`${hh}.`}
  
}

console.log(end)
————————————————————
描述
输入整型数组和排序标识，对其元素按照升序或降序进行排序

数据范围： 1 \le n \le 1000 \ 1≤n≤1000  ，元素大小满足 0 \le val \le 100000 \ 0≤val≤100000 
输入描述：
第一行输入数组元素个数
第二行输入待排序的数组，每个数用空格隔开
第三行输入一个整数0或1。0代表升序排序，1代表降序排序

输出描述：
输出排好序的数字

示例1
输入：
8
1 2 4 9 3 55 64 25
0
复制
输出：
1 2 3 4 9 25 55 64
复制
示例2
输入：
5
1 2 3 4 5
1
复制
输出：
5 4 3 2 1
解：let str1=readline()

let str2=readline().split(' ')
 
let str3=readline()
if(str3==0){
    console.log(str2.sort((a,b)=>a-b).join(' '))
}else{
    console.log(str2.sort((a,b)=>b-a).join(' '))
}
——————————————————————————
描述
数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。

提示:
0 <= index <= 11111111
1 <= value <= 100000

输入描述：
先输入键值对的个数n（1 <= n <= 500）
接下来n行每行输入成对的index和value值，以空格隔开

输出描述：
输出合并后的键值对（多行）

示例1
输入：
4
0 1
0 2
1 2
3 4
复制
输出：
0 3
1 2
3 4
复制
示例2
输入：
3
0 1
0 2
8 9
复制
输出：
0 3
8 9
解：let str=readline()
let num=""
let obj={}
while(num=readline()){
    let n=num.split(' ')
    if(obj[n[0]]){
        obj[n[0]]+=n[1]*1
    }else{
        obj[n[0]]=n[1]*1
    }
}
for(var k in obj){
    console.log(k,obj[k])
}
——————————————————————
描述
给定 n 个字符串，请对 n 个字符串按照字典序排列。

数据范围： 1 \le n \le 1000 \ 1≤n≤1000  ，字符串长度满足 1 \le len \le 100 \ 1≤len≤100 
输入描述：
输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
输出描述：
数据输出n行，输出结果为按照字典序排列的字符串。
示例1
输入：
9
cap
to
cat
card
two
too
up
boat
boot
复制
输出：
boat
boot
cap
card
cat
to
too
two
up
解：let num = readline()
let arr = []
while(line = readline()) {
    arr.push(line)
}
arr.sort()
for(let i=0;i<arr.length;i++) {
    console.log(arr[i])
}
————————————————————————
描述
给出一组区间，请合并所有重叠的区间。
请保证合并后的区间按区间起点升序排列。

数据范围：区间组数 0 \le n \le 2 \times 10^50≤n≤2×10 
5
 ，区间内 的值都满足 0 \le val \le 2 \times 10^50≤val≤2×10 
5
 
要求：空间复杂度 O(n)O(n)，时间复杂度 O(nlogn)O(nlogn)
进阶：空间复杂度 O(val)O(val)，时间复杂度O(val)O(val)
示例1
输入：
[[10,30],[20,60],[80,100],[150,180]]
复制
返回值：
[[10,60],[80,100],[150,180]]
复制
示例2
输入：
[[0,10],[10,20]]
复制
返回值：
[[0,20]]
解： * function Interval(a, b){
 *   this.start = a || 0;
 *   this.end = b || 0;
 * }
 */

/**
 * 
 * @param intervals Interval类一维数组 
 * @return Interval类一维数组
 */
function merge( intervals ) {
    // write code here
    let len = intervals.length;
    let arr = [];
    let j = 0;
    intervals.sort(function(a,b){return a.start - b.start});
    while(j < len){
        while(j < len - 1 && intervals[j].end >= intervals[j + 1].start){
            j++;
            intervals[j].start = intervals[j - 1].start;
            if(intervals[j].end < intervals[j - 1].end){
                intervals[j].end = intervals[j - 1].end;
            }
        }
        arr.push(intervals[j]);
        j++;
    }
    return arr;
}
module.exports = {
    merge : merge
};
——————————————————
描述
给定一些同学的信息（名字，成绩）序列，请你将他们的信息按照成绩从高到低或从低到高的排列,相同成绩

都按先录入排列在前的规则处理。

例示：
jack      70
peter     96
Tom       70
smith     67

从高到低  成绩 
peter     96 
jack      70 
Tom       70 
smith     67

从低到高

smith     67

jack      70

Tom       70 
peter     96

注：0代表从高到低，1代表从低到高

数据范围：人数：1\le n \le 200\ 1≤n≤200 
进阶：时间复杂度：O(nlogn)\ O(nlogn) ，空间复杂度：O(n)\ O(n) 
输入描述：
第一行输入要排序的人的个数n，第二行输入一个整数表示排序的方式，之后n行分别输入他们的名字和成绩，以一个空格隔开

输出描述：
按照指定方式输出名字和成绩，名字和成绩之间以一个空格隔开
解：let num=readline()
let px=readline()
const arr=[]
let student=""
let xu=0
while(student=readline()){
    const obj={}
  let n=  student.split(' ')
   obj.name=n[0]
    obj.fen=n[1]
    xu+=1
    obj.id=xu
    arr.push(obj)
}
arr.sort((a,b)=>{
   if(a.fen==b.fen){
       return a.id-b.id
   }else if(px==1){
       return a.fen-b.fen
   }else if(px==0){
       return b.fen-a.fen
   }         
}).forEach(i=>console.log(i.name,i.fen))
————————————————————————
描述
给出一个仅包含字符'(',')','{','}','['和']',的字符串，判断给出的字符串是否是合法的括号序列
括号必须以正确的顺序关闭，"()"和"()[]{}"都是合法的括号序列，但"(]"和"([)]"不合法。

数据范围：字符串长度 0\le n \le 100000≤n≤10000
要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n)
示例1
输入：
"()[]{}"
返回值：
true

示例2
输入：
"[]"

返回值：
true

示例3
输入：
"([)]"

返回值：
false
解：/**
  * 
  * @param s string字符串 
  * @return bool布尔型
  */
//简单暴力
function isValid( s ) {
    let arr = [];
    for(let i = 0; i < s.length; i++){
if((arr[arr.length - 1] == '(' && s[i] == ')') || (arr[arr.length - 1] == '[' && s[i] == ']' ) || (arr[arr.length - 1] == '{' && s[i] == '}'))
            arr.pop();
        else
            arr.push(s[i]);
    }
    if(arr.length == 0)
        return true;
    else
        return false;
}
module.exports = {
    isValid : isValid
};
——————————————————————————
描述
对于长度为n的一个字符串A（仅包含数字，大小写英文字母），请设计一个高效算法，计算其中最长回文子串的长度。

输入："ababc"

返回值：3

说明：
最长的回文子串为"aba"与"bab"，长度都为3  

输入："abbba"

返回值：5

输入："b"
返回值：1
解：遍历每个字符，以该字符为中心，不断向两边扩展，求回文字符串的最大长度

注意分为奇偶，比如xyzabbaxyz，b为中心的时候分为b和bb
function getLongestPalindrome( A ) {
   
  function getLength(begin,end){
    while(begin>=0 && end<A.length && A[begin]==A[end]){
      begin--;
      end++;
    }
    return end-begin-1;//返回长度
  }
   
  let maxLen = 1;
  for(let i=0; i<A.length-1; i++){//以每个点为中心
    maxLen = Math.max( maxLen, getLength(i,i), getLength(i,i+1) );
  }
  return maxLen;
}