每日2道算法题

leetcode整数反转

let x = -123;
// number->string->array->string->number->judge
let reverse = function(x) {
    let res = [];
    let str = x.toString();
    //字符串也有length属性
    for(let i = str.length - 1; i > 0; i --){
        res.push(str[i]);
    }
    if(str[0] === '-'){
        res.unshift(str[0]);
    }else{
        res.push(str[0]);
    }
    //join()是把数组里的每个元素合并成字符串了
    let reverseNumber = parseInt(res.join(""));
    if(reverseNumber < Math.pow(-2,31) || reverseNumber > (Math.pow(2,31) - 1)){
        return 0;
    }else
        return reverseNumber;
};
console.log(reverse(x));

leetcode两数之和

let nums = [2,7,4,11],target = 9;
var twoSum = function(nums, target) {
 for(let i = 0; i < nums.length; i ++){
     for(let j = i+1; j < nums.length; j ++){
         if(nums[j] == target - nums[i])
             return [i,j];
     }
 } 
};
console.log(twoSum(nums,target));

回文数：

//先将'-121'变成['-','1','2','1']然后变成['1','2','1','-']然后变成'121-',最后比较'-121'和'121-'
function f(x) {
    let str = x.toString();
    let arr = str.split('').reverse();//split()可以把字符串变成数组
    let result = arr.join('');//join()可以把数组变成字符串
    if(str === result){
        return true;
    }else{
        return false;
    }
}
let x = -121;
f(x);

最长公共前缀：

let str = ['flower','flow','flight'];
var longestCommonPrefix = function(strs) {
    if (strs.length === 0) {
        return '';
    }
    let a = strs[0];
    for(let i = 0; i < a.length; i++) {
        for(let j = 1; j < strs.length; j++) {
            if (a[i] !== strs[j][i]) {//比较独特的数组访问方式，要记住
                return a.substring(0, i);//不接受负数,提取子字符串,从0号位置开始提取,提取到i-1的位置
            }
        }
    }
    return a;
};
console.log(longestCommonPrefix(str));

有效的括号：

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function (s) {
    let map = {
        '{':'}',
        '[':']',
        '(':')'
    };
    const arr = ['{','[','('];
    const stack = [];//这个栈为啥是const型的
    for(let item in s) {
        const v = s[item];
        if(arr.indexOf(v) !== -1){
            stack.push(v);
        }else{
            const peak = stack.pop();
            if(v !== map[peak])
                return false;
        }
    }
    
    if(stack.length !== 0) return false;
    else return true;
};
let str = "{[()]}";
console.log(isValid(str));

26:删除排序数组中的重复项

下面这种方法的前提：有序数组

方法的思路：采用双指针

• 开始时这两个指针都指向第一个数组元素；

• 如果两个指针指的数组元素相同，则快指针向前走一步；

• 如果不同，则两个指针都向前走一步，并将慢指针指向的数组元素替换为快指针指向的数组元素；

• 当快指针走完整个数组后，慢指针当前的坐标加1就是数组中不同元素的个数

/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function(nums) {
    const size = nums.length;
    let slowP = 0;
    for (let fastP = 0; fastP < size; fastP++) {
        if (nums[fastP] !== nums[slowP]) {
            slowP++;
            nums[slowP] = nums[fastP]
        }   
    }
    return slowP + 1;
};

27：移除元素

方法思路：

当 nums[j] 与给定的值相等时，递增 j 以跳过该元素。只要 nums[j]  !== val ，我们就复制 nums[j] 到 nums[i] 并同时递增两个索引。重复这一过程，直到 j 到达数组的末尾，该数组的新长度为 i。（其实是变相的替换操作）

var removeElement = function(nums, val) {
    let i = 0;
    for(let j = 0; j < nums.length; j++){
        if(nums[j] !== val){
            nums[i] = nums[j];
            i++;
        }
    }
    return i;
};

28.翻转字符串中的单词

代码：

var reverseWords = function (s) {
    if(s.length === 0) return "";
    let [index,len] = [0,s.length];
    let result = "";
    let storge = "";
    while(index < len) {
        while(index < len && s.charAt(index) === ' ') {
            index ++;
        }
        while(index < len && s.charAt(index) !== ' ') {
            storge = `${storge}${s.charAt(index)}`;
            index ++;
        }
        result  = storge + " " + result;
        storge = ""
    }
    return result.trim();
}
console.log(reverseWords("  Hello   World   "));

思路：

 1）跳过句子前所有空格(让索引一步一步往前走,用一个变量把非空格字符存起来)
 2）借助变量反转单词,每遍历到一个字符,在遇到下一个空格之前,为一个完整单词。
 3）遇到空格之后,将单词进行倒序拼接
 4）消除头部尾部的空格（trim()）

29.实现一个RGB到１６进制的转换函数

代码：

let testColor = "rgb(20, 20, 20)";
const rgbToHex = (color) => {
    let arr = color.split(',');

    let r = +arr[0].split('(')[1];
    let g = +arr[1];
    let b = +arr[2].split(')')[0];
    let value = (1 << 24) + r * (1 << 16) + g * (1 << 8) + b;
    value = value.toString(16);
    console.log(value);
    return '#' + value.slice(1);
};
console.log(rgbToHex(testColor)); // #141414
console.log(rgbToHex('rgb(255, 255, 255)')) // #fffff

Q: 找出一个字符串中出现最多的字母，并判断出现的次数 

let arr = []
let str = "success"
for(let i =0; i < str.length; i++) {
    let index = -1;
    let j = 0;
    do {
        index = str.indexOf(str[i],index+1)
        if(index != -1) {
            j++;//记录每个字符出现的次数
        }
    } while (index != -1)
    arr[j] = str[i];
}
console.log(arr[arr.length-1],arr.length-1)

//第二种方法：利用Object中的key进行筛选（首选）

function func(str) {
    if(str.length === 1){
        return str;
    }
    let obj = {};
    for(let i = 0; i < str.length; i ++){//对字符串进行遍历
        if(!obj[str.charAt(i)]){//str.charAt(i):a b c
            obj[str.charAt(i)] = 1;//obj['a'] = 3;obj['b'] = 3;obj['c'] = 2
        }else{
            obj[str.charAt(i)] += 1;
        }
    }
    /*
    {
        a : 3,
        b : 3,
        c : 2
    }
    */
    let maxChar = "";
    let maxValue = 1;
    for(let key in obj){//对对象进行遍历
        if(obj[key] > maxValue){
            maxValue = obj[key];
            maxChar = key;
        }
    }
    console.log(maxChar + maxValue);
}
let str = "aabbbcac";
func(str);

Q:  找出一个字符串中的最后一个字符

var str = "123";
var res = str.substr(-1,1);
console.log(res);

Q: 求一个数组中最大的差值

function getMaxProfit(arr) {
    let min = arr[0];
    let maxProfit = 0;
    for (let i = 0; i < arr.length; i++) {
        let current = arr[i];
        min = Math.min(min, current);
        let profit = current - min;
        maxProfit = Math.max(maxProfit, profit);
    }
    return maxProfit;
}
console.log(Math.max(12,3,4));

Q: 随机生成指定长度的字符串

实现一个算法，随机生成指制定长度的字符串

比如给定 长度 8  输出 4ldkfg9j

function randomString(n) {
    let str = 'abcdefghijklmnopqrstuvwxyz9876543210';
    let tmp = '', len = str.length;
    for (let i = 0; i < n; i++) {
        tmp += str.charAt(Math.floor(Math.random() * len));
    }
    return tmp;
}
let n = 8;
console.log(randomString(n));

Q：字符串查找：判断字符a是否被包含在字符b中，并返回第一次出现的位置（找不到返回-1）

a = "34"; b = "1234567"; //返回2

a = "35"; b = "1234567";//返回-1

a = "355";b = "12354355";//返回5

function isContain(a,b){
    for(let index in b){
        if(a[0] === b[index]) {
            let temp = true;
            for (let i in a) {
                if (a[i] !== b[~~index + ~~i]) {
                    temp = false;
                }
            }
            if (temp) {
                return index;
            } else {
                return -1;
            }
        }
    }
}
let a = "34",b = "1234567"
console.log(isContain(a, b));

Q：给定一个字符串s，找出s中最长的回文子串，你可以假设s的最大长度为1000

例如：用例字符串是："gabcdcbaef"，那么最大回文子串是："abcdcba"

function lpds(str) {
    // 请输入代码
    let len = str.length;
    let drr = [];
    for(let i = 0; i < len; i ++){
        let arr =[];
        arr[i] = true;
        drr[i] = arr;
    }
    for(let i = 0; i < len;  i++){
        if(str[i] === str[i + 1])
            drr[i][i+1]  = true;
    }
    let maxLen = 1,resIndex = 0;
    for(let lenn = 3; lenn <= len; lenn ++){
        for(let i = 0;i < len - lenn + 1; i ++){
            if(str[i] === str[i + lenn - 1] && drr[i +1][i + lenn - 2]){
                drr[i][i+lenn - 1] = true;
                if(lenn > maxLen){
                    maxLen = lenn;
                    resIndex = i;
                }
            }
        }
    }
    return str.substr(resIndex,maxLen);

}
while(line=readline()){
    print(lpds(line));
}