FreeCodeCamp高级算法Advance Algorithm Scripting

时间：2023-01-23 00:28:12

1.0 Validate US Telephone Numbers

/*
* 如果传入字符串是一个有效的美国电话号码，则返回 true.
正则表达式
^1?表示以1开头，1匹配0次或1次
\d{3}匹配一个0-9的数字三次
(\d{3})匹配（一个0-9的数字三次），比上面多一个括号，左右括号分别需要加上转义字符\
\s?表示空白字符匹配0次或1次
[ -]?表示空格或者连字符-匹配0次或1次
\d{4} 表示已4位数字结尾( )
* */

function telephoneCheck(str) {
    var re=/^1?\s?(\d{3}|\(\d{3}\))[ -]?\d{3}[ -]?\d{4}$/;
    return re.test(str);
}

2.0 Symmetric Difference

function sym(args) {
// 将参数转化为数组
    var arr = Array.prototype.slice.call(arguments);

// 过滤每个数组中重复的元素
arr.forEach(function(i){
    // 拿第一个元素和后面的元素比较，相同的就删除，以此类推
    for(var j = 0; j < i.length - 1; j++){
        for(var k = j+1; k<i.length; k++)
            if(i[j] == i[k]){
                i.splice(j,1);
                j--;               //重新定位J的位置
            }
    }
});

// 两个数组进行比较，得出不同的部分
arr.reduce(function(prev,cur,index,array){
    prev.forEach(function(m){
        if(cur.indexOf(m)==-1)
            cur.push(m);
        else cur.splice(cur.indexOf(m),1);
    });
    return cur;
});

return arr[arr.length-1];
}

3.0 Exact Change 不乘以100，算出来的结果有误差，应该是小数位的保留不正确，不想乘以100的话，注意保留两位小数

function checkCashRegister(price, cash, cid) {
cid  =  cid.map(function(val){
    return val.map(function(tar){
        if (!isNaN(tar)) {
            return tar * 100;
        }
        return tar;
    });

});
price = price * 100;
cash = cash * 100;

// 计算应找回的钱
var money = cash - price;
// 1分 5分 1角 0.25角 1元  5元 10元 20元 100元 零钱数组对应的二维数组级别
// var arr = [0.01, 0.05, 0.1, 0.25, 1, 5, 10, 20, 100];
var arr = [1, 5, 10, 25, 100, 500, 1000, 2000, 10000];
// 最大的面值
var level = 0;
arr.map(function (val, index, arr) {
    if (money >= val) {
        level = index;
    }
});
// 判断是否有足够的钱找回
var allMoney = 0;
for (var i = 0; i <= level; i++) {
    allMoney +=  cid[i][1];
}
// 钱不够找
if (allMoney < money) {
    return "Insufficient Funds";
}
// 钱刚好够
if (allMoney == money) {
    return "Closed";
}

// 应该返回的结果数组
var result = [];
// 从最大面值开始找钱，直到找完
for (var j = level; j >= 0; j--) {
    if(money === 0) break;
    // 是否刚好够整数
    var isCom = money % arr[j];
    // 刚好够找，不用继续往下
    if (isCom === 0 && money <= cid[j][1]) {
        var arr2 = [];
        arr2.push(cid[j][0]);
        arr2.push(money);
        result.push(arr2);
        // 除以100
        result  =  result.map(function(val1){
            return val1.map(function(tar1){
                if (!isNaN(tar1)) {
                    return tar1 / 100;
                }
                return tar1;
            });

        });

        return result;
    }

    // 最大面值张数
    var times = Math.floor(money / arr[j]);
    if (times === 0) {
        continue;
    }
    var money2 =  times * arr[j];
    // 超过最大面值的总金额
    if (money2 > cid[j][1]) {
        result.push(cid[j]);
        // 余额
        money = money - cid[j][1];

    } else {
        var arr3 = [];
        arr3.push(cid[j][0]);
        arr3.push(money2);
        result.push(arr3);
        // 余额
        money = money - money2;
    }

}
// 除以100
result  =  result.map(function(val1){
    return val1.map(function(tar1){
        if (!isNaN(tar1)) {
            return tar1 / 100;
        }
        return tar1;
    });

});

return result;
}

4. Inventory Update

function updateInventory(arr1, arr2) {
// 如果arr2为空，直接返回arr1
if (arr2.length <= 0) {
    arr1.sort(function (a, b) {
        return a[1] > b[1];

    });
    return arr1;
}

if (arr1.length <= 0) {
    arr2.sort(function (a, b) {
        return a[1] > b[1];

    });
    return arr2;
}

// 判断是否存在相同的
var arr = [];
arr2.map(function (val) {
    for (var i = 0; i < arr1.length; i++) {
        var isHave = arr1[i].indexOf(val[1]);
        if (isHave >= 0) {
            arr1[i][0] = arr1[i][0] + val[0];
            break;
        }

        if (i === arr1.length -1) {
            arr.push(val);
        }

    }
});

arr.map(function(val1){
    arr1.push(val1);
});



arr1.sort(function (a, b) {
    return a[1] > b[1];

});
return arr1;
}

5. No repeats please

function permAlone(str) {
var arr=str.split("");
var perarr=[];
var begin=0;
//创建正则，如果字符串全重复，则直接return 0
var reg = /(.)\1+/g;
if(str.match(reg)!==null&&str.match(reg)[0]===str){
    return 0;
}
//用于交换的函数
function swap(idx1,idx2){
    var temp=arr[idx1];
    arr[idx1]=arr[idx2];
    arr[idx2]=temp;
}
//如果begin到了最后一个字符，可以将这个字符串加入到全排列数组中了
function permall(arr,begin){
    if(begin==arr.length-1){
        perarr[perarr.length]=arr.join("");
        return;
    }
    for(var i=0;(i+begin)<arr.length;i++){
        swap(begin,begin+i);
        permall(arr,begin+1);
        swap(begin,begin+i);
    }
}
permall(arr,begin);
//返回相邻不重复的数量
return perarr.filter(function(val) {
    return !val.match(reg);
}).length;
}

6.0 Friendly Date Ranges , 这道题答案不正确 ，思路比较简单，就是根据不同的条件进行返回

function makeFriendlyDates(arr) {
var firstArr = arr[0].split('-');
var lastArr = arr[1].split('-');
// 不符合
if (firstArr[0] > lastArr[0]) {
    return undefined;
}
if (firstArr[1] > lastArr[1]) {
    return undefined;
}
if (firstArr[2] > lastArr[2]) {
    return undefined;
}
// 月份数组
var monthArr = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
// 日
var dayArr = ["st", "en", "rd"];

// 同年同月同日
if (firstArr[0] === lastArr[0] && firstArr[1] === lastArr[1] && firstArr[2] === lastArr[2]) {
    // 获取月份
    var monthStr = monthArr[parseInt(firstArr[1] - 1)];
    // 日期
    var dayF = parseInt(firstArr[2]);
    var dayFstr = dayString(dayF);
    return [monthStr + ' ' + dayFstr + ' ' + firstArr[0]];
}

// 同年同月
if (firstArr[0] === lastArr[0] && firstArr[1] === lastArr[1]) {
    // 获取月份
    var monthStr = monthArr[parseInt(firstArr[1] - 1)];
    // 日期
    var dayF = parseInt(firstArr[2]);
    var dayL = parseInt(lastArr[2]);
    var dayFstr = dayString(dayF);
    var dayLstr = dayString(dayL);
    return [monthStr + ' ' + dayFstr, dayLstr];
}

// 同年不同月
if (firstArr[0] === lastArr[0]) {
    // 获取月份
    var monthStrF = monthArr[parseInt(firstArr[1] - 1)];
    var monthStrL = monthArr[parseInt(lastArr[1] - 1)];
    // 日期
    var dayF = parseInt(firstArr[2]);
    var dayL = parseInt(lastArr[2]);
    var dayFstr = dayString(dayF);
    var dayLstr = dayString(dayL);
    return [monthStrF + ' ' + dayFstr, monthStrL + ' ' + dayLstr];
}

// 相差一年， 前一年的天 > 后一年的天 ，只有前面的有年份
if (lastArr[0] - firstArr[0] === 1 && firstArr[2] > lastArr[2]) {
    // 获取月份
    var monthStrF = monthArr[parseInt(firstArr[1] - 1)];
    var monthStrL = monthArr[parseInt(lastArr[1] - 1)];
    // 日期
    var dayF = parseInt(firstArr[2]);
    var dayL = parseInt(lastArr[2]);
    var dayFstr = dayString(dayF);
    var dayLstr = dayString(dayL);

    return [monthStrF + ' ' + dayFstr + "," + ' ' + firstArr[0], monthStrL + ' ' + dayLstr];
}

// 都不一样
// 获取月份
var monthStrF = monthArr[parseInt(firstArr[1] - 1)];
var monthStrL = monthArr[parseInt(lastArr[1] - 1)];
// 日期
var dayF = parseInt(firstArr[2]);
var dayL = parseInt(lastArr[2]);
var dayFstr = dayString(dayF);
var dayLstr = dayString(dayL);

return [monthStrF + ' ' + dayFstr + "," + ' ' + firstArr[0], monthStrL + ' ' + dayLstr + "," + ' ' + lastArr[0]];


function dayString(index) {
    if (index == 1) {
        return "1st";
    }
    if (index === 2) {
        return "2nd";
    }
    if (index === 3) {
        return "3rd";
    }

    if (index == 11) {
        return "11st";
    }
    if (index === 12) {
        return "12nd";
    }
    if (index === 13) {
        return "13rd";
    }

    if (index == 21) {
        return "21st";
    }
    if (index === 22) {
        return "22nd";
    }
    if (index === 23) {
        return "23rd";
    }

    if (index == 31) {
        return "31st";
    }
    return (index + "th");
    }
}

7. Make a Person

var Person = function(firstAndLast) {
var firstName, lastName;

this.getFirstName = function() {
    return firstName;
};

this.getLastName = function() {
    return lastName;
};

this.getFullName = function() {
    return firstName + ' ' + lastName;
};

this.setFirstName = function(first) {
    firstName = first;
};

this.setLastName = function(last) {
    lastName = last;
};

this.setFullName = function(firstAndLast) {
    firstAndLast = firstAndLast.split(' ');
    firstName = firstAndLast[0];
    lastName = firstAndLast[1];
};

// 调用
this.setFullName(firstAndLast);
};

8.0 Map the Debris 遍历数组，拿出对应的属性进行计算，返回数组即可，比较简单，知道计算公式就行

function orbitalPeriod(arr) {
var results = [];
var GM = 398600.4418,
    earthRadius = 6367.4447;

arr.forEach(function(element) {
    results.push({
        name: element.name,
        orbitalPeriod: getOrbitalPeriod(element.avgAlt, GM, earthRadius)
    });
});

return results;

function getOrbitalPeriod(avgAlt, GM, planetRadius) {
    return Math.round(2 * Math.PI * Math.sqrt(Math.pow(avgAlt + planetRadius, 3) / GM));
}
}

9.0 Pairwise 找到符合条件的两个元素，然后下标相加，返回相加后的结果，注意不能重复使用相同的元素

function pairwise(arr, arg) {
// 数组为空
if (arr.length <= 0) return 0;

// 依次拿数组中的元素遍历
var resultArr = [];
for (var i  = 0; i < arr.length; i++) {
    // 已经匹配过的，不再匹配
    var isHave = resultArr.indexOf(i);
    if (isHave > 0){
        continue;
    }
    // 计算得出另一个数的大小
    var tar = arg - arr[i];
    // 看数组中是否存在对应的数
    for (var j = i + 1; j < arr.length; j++) {
        // 如果已经匹配过了，就不在匹配
        var isHave2 = resultArr.indexOf(j);
        if (isHave2 > 0){
            continue;
        }
        if (arr[j] === tar) {
            resultArr.push(i);
            resultArr.push(j);
            break;
        }
    }
}

// 最后计算结果
if (resultArr.length <= 0) {
    return 0;
}
return resultArr.reduce(function (pre, cur) {
    return pre + cur;
});
}
标签：

相关文章