核心提示：本部分一個9道題，給定時間50小時。屬於fcc前端學習的“高級編程腳本”題，對於初學者來說，確實算是“高級”了。如果只想著閉門造車，50小時確實也不過分。就題目設的坑和古怪規則來說，估計趕得上實際的情形。有些題目，可能要有一點數理基礎才行。 1.如果傳入字元串是一個有效的美國電話號碼，則返 ...
核心提示：本部分一個9道題，給定時間50小時。屬於fcc前端學習的“高級編程腳本”題，對於初學者來說，確實算是“高級”了。如果只想著閉門造車，50小時確實也不過分。就題目設的坑和古怪規則來說，估計趕得上實際的情形。有些題目，可能要有一點數理基礎才行。
1.如果傳入字元串是一個有效的美國電話號碼，則返回 true.
用戶可以在表單中填入一個任意有效美國電話號碼. 下麵是一些有效號碼的例子(還有下麵測試時用到的一些變體寫法):
555-555-5555
(555)555-5555
(555) 555-5555
555 555 5555
5555555555
1 555 555 5555
在本節中你會看見如 800-692-7753 or 8oo-six427676;laskdjf這樣的字元串. 你的任務就是驗證前面給出的字元串是否是有效的美國電話號碼. 區號是必須有的. 如果字元串中給出了國家代碼, 你必須驗證其是 1. 如果號碼有效就返回 true ; 否則返回 false.
思路：基本上，就是九個規則並起來。
function telephoneCheck(str) {
// Good luck!
/*
var re1=/^[1-9]\d{9}$/g;
var re2=/^[1-9]\d{2}-[0-9]\d{2}-[0-9]\d{3}$/g;
var re3=/^\([1-9]\d{2}\)[0-9]\d{2}-[0-9]\d{3}$/g;
var re4=/^\([1-9]\d{2}\)\s[0-9]\d{2}-[0-9]\d{3}$/g;
var re5=/^[1-9]\d{2}\s[0-9]\d{2}\s[0-9]\d{3}$/g;
var re6=/^[1]\s[0-9]\d{2}\s[0-9]\d{2}\s[0-9]\d{3}$/g;
var re7=/^[1]\s[0-9]\d{2}-[0-9]\d{2}-[0-9]\d{3}$/;
var re8=/^[1]\s\([0-9]\d{2}\)\s[0-9]\d{2}-[0-9]\d{3}$/;
var re9=/^[1]\([0-9]\d{2}\)[0-9]\d{2}-[0-9]\d{3}$/;
//telephoneCheck("5554555555");
//telephoneCheck("555-555-5555");
//telephoneCheck("(555)555-5555");
//telephoneCheck("(555) 555-5555")
//telephoneCheck("555 555 5555")
//telephoneCheck("1 555 555 5555")
//telephoneCheck("1 555-555-5555")
//telephoneCheck("1 (555) 555-5555")
//telephoneCheck("1(555)555-5555")
*///9個規則
var re=/^[1-9]\d{9}$|^[1-9]\d{2}-[0-9]\d{2}-[0-9]\d{3}$|^\([1-9]\d{2}\)[0-9]\d{2}-[0-9]\d{3}$|^\([1-9]\d{2}\)\s[0-9]\d{2}-[0-9]\d{3}$|^[1-9]\d{2}\s[0-9]\d{2}\s[0-9]\d{3}$|^[1]\s[0-9]\d{2}\s[0-9]\d{2}\s[0-9]\d{3}$|^[1]\s[0-9]\d{2}-[0-9]\d{2}-[0-9]\d{3}$|^[1]\s\([0-9]\d{2}\)\s[0-9]\d{2}-[0-9]\d{3}$|^[1]\([0-9]\d{2}\)[0-9]\d{2}-[0-9]\d{3}$/g;
console.log(str.match(re));
if(str.match(re)){
console.log('true')
return true;
}else{
console.log('false')
return false;
}
}2.創建一個函數，接受兩個或多個數組，返回所給數組的 對等差分(symmetric difference) (△ or ⊕)數組.
給出兩個集合 (如集合 A = {1, 2, 3} 和集合 B = {2, 3, 4}), 而數學術語 "對等差分" 的集合就是指由所有隻在兩個集合其中之一的元素組成的集合(A △ B = C = {1, 4}). 對於傳入的額外集合 (如 D = {2, 3}), 你應該安裝前面原則求前兩個集合的結果與新集合的對等差分集合 (C △ D = {1, 4} △ {2, 3} = {1, 2, 3, 4}).
補白：題目提示用的是reduce方法：
reduce 為數組中的每一個元素依次執行回調函數，不包括數組中被刪除或從未被賦值的元素，接受四個參數：初始值（或者上一次回調函數的返回值），當前元素值，當前索引，調用 reduce 的數組。
回調函數第一次執行時，previousValue 和 currentValue 的取值有兩種情況，如果 initialValue 在調用 reduce 時被提供，那麼第一個 previousValue 等於 initialValue ，並且currentValue 等於數組中的第一個值；如果initialValue 未被提供，那麼previousValue 等於數組中的第一個值，currentValue等於數組中的第二個值。
如果數組為空並且沒有提供initialValue， 會拋出TypeError 。如果數組僅有一個元素（無論位置如何）並且沒有提供initialValue， 或者有提供initialValue但是數組為空，那麼此唯一值將被返回並且callback不會被執行。
例子：數組求和——
var total = [0, 1, 2, 3].reduce(function(a, b) {
return a + b;
});
// total == 6現在來寫這個函數。非常感謝此博客提供的思路。
function sym(args) {
var arr=[].slice.call(arguments);//轉化為數組；
var temp=arr.reduce(function(prev,cur,index,array){
var a=prev.filter(function(item){
return cur.indexOf(item)==-1;
});//返回前一個結果中，沒有出現在下個結果中的部分（數組）
var b=cur.filter(function(item){
return prev.indexOf(item) < 0;
});//返回下個參數中，未有出現在上個結果中的部分（數組）
return a.concat(b);//通通連起來。輸出為下個結果
});
console.log(temp);
return temp.filter(function(item,index,array){
return array.indexOf(item) == index;
});
//之前只是比較數組彼此之間的重覆，數組內部本身也可能存在重覆
//現在解決遺留下來的問題。
return temp.filter(function(item,index,array){
return array.indexOf(item) == index;
});//自身查重只需要讓它本身第一次出現在原數組的位置為索引值index，就可以保留且只保留一個。
}筆者在使用reduce方法用兩個for迴圈進行逐個排查，方法看上去沒有錯，但會發生記憶體溢出。在此需要強調下。
3.設計一個收銀程式 checkCashRegister() ，其把購買價格(price)作為第一個參數 , 付款金額 (cash)作為第二個參數, 和收銀機中零錢 (cid) 作為第三個參數.
cid 是一個二維數組，存著當前可用的找零.
當收銀機中的錢不夠找零時返回字元串 "Insufficient Funds". 如果正好則返回字元串 "Closed".
否則, 返回應找回的零錢列表,且由大到小存在二維數組中.
function checkCashRegister(price, cash, cid) {
var change;
// Here is your change, ma'am.
return change;
}
// Example cash-in-drawer array:
// [["PENNY", 1.01],
// ["NICKEL", 2.05],
// ["DIME", 3.10],
// ["QUARTER", 4.25],
// ["ONE", 90.00],
// ["FIVE", 55.00],
// ["TEN", 20.00],
// ["TWENTY", 60.00],
// ["ONE HUNDRED", 100.00]]
checkCashRegister(19.50, 20.00, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.10], ["QUARTER", 4.25], ["ONE", 90.00], ["FIVE", 55.00], ["TEN", 20.00], ["TWENTY", 60.00], ["ONE HUNDRED", 100.00]]);可能還要翻譯下。panny——1美分，nickel——5美分，dime——1角，quarter，25美分，one：1美元，...5美元，10美元，20美元，100美元。
找錢系統在行業中，為了避免浮點數的不精確，通通採用整數計算。
function checkCashRegister (price, cash, cid) {
// 剛剛好
if(price==cash){
return "No Need Back";
}
// 付款不足
if (price > cash){
return "Need More Money";
}
var base=100;//金額基數
var change=(cash-price)*base; //找零
//定義一個函數，用來求零錢和。
var getTotalMoney=function(arr){
var totalMoney=0;
arr.reduce(function (preV, currV, currIndex, array){
totalMoney+=base*(preV[1]+currV[1]);
return currV;
});//疊代演算法：求零錢之和。
return totalMoney;
}
//餘額不足，沒法找了
var remain = getTotalMoney(cid);
if (remain==change){//如果零錢數等於應找數額，返回closed
return "Closed";
}else if(remain < change){//沒錢找了
return "Insufficient Funds";
};
// 對應：1角-5角-1元-5元-10元-20元-50元-100元(以元為單位的基礎上乘以面值基數：base這裡為100)
var dollar= [1, 5, 10, 25, 100, 500, 1000, 2000, 10000]; // TODO
var pay={};//保存的key：dollar中面值索引，value：要找的此面值的個數
var currLast=0;// 當前面值所剩餘額
var currMoney=0;//當前金錢面額(dollar中對應的值)
for (var i=dollar.length-1;i>=0;i--){//由大到小迴圈
//當前面值剩餘金額
currLast=cid[i][1]*base;
if (currLast<=0) {
continue;//當前面值的金額剩餘0，跳過
}
//當前金額面值
currMoney=dollar[i];
// 在當前面值下取錢必須同時滿足兩個條件：
// 1. 找零必須大於當前面值，比如找零51元，才可以從50裡面取錢。
// 2. 剩餘的當前面值的總額足夠，比如找4元，但我只有3張1元，就不符合取錢條件
if(change>currMoney){//如果當前金額面值小於應找錢數
if(change<currLast){
// 找零小於當前面值剩餘金額：比如找錢51元，當前50面值總額餘額還有150元。
pay[i]=Math.floor(change/currMoney);//取最大張數
change-=currMoney*pay[i];//取完之後從應找餘額中減去（張數x面值）
}else{
// 找零大於當前面值剩餘金額，比如找零51元，我50元面額總值只有50元
// 則將所有剩餘金額找出
pay[i]=Math.floor(currLast/currMoney);
change-=currLast;//就直接減去當前面值剩餘所有金額
}
}
}//迴圈結束之後得到一個pay對象，裡面包括了面值和對應應找的錢。
console.log(pay)
var res=[];
// 組織最後需要找零的錢，作為最終返回的數組。
var keys=Object.keys(pay);//找到pay對象
var idx=0;
var total=0;//應找零錢（pay）的總額
for (var j=0; j<keys.length; j++) {
// 需要找零的面值索引：比如100，50，20,10...等等
idx=parseInt([keys[j]]);
//計算該面值最後找出的零錢(公式：面值x需要找出數量 / 金錢面值基數)
cid[idx][1]=dollar[idx]*pay[keys[j]]/base;
res.unshift(cid[idx]);//把結果添加到數組的開頭。符合由面值大到小的規律。
total += dollar[idx]*pay[keys[j]];
// 順便計算下這裡計算的結果應該和最開始需要找零的金額一致：
// 面值x需要找出數量——返回到total結果中
}
// 找到最後，所有能找的面值加起來還不夠
// 這裡與最開始不同，這裡是過濾掉了所有找不開的面值
// 比如：要找0.05元，但是目前剩餘一張0.01和1元的面值，依舊判定為找不開
// 而最開始的是所有餘額加起來都不夠找
if (total<change) {
return "Insufficient Funds";
}
console.log(res)
return res;
}
// Example cash-in-drawer array:
// [["PENNY", 1.01],
// ["NICKEL", 2.05],
// ["DIME", 3.10],
// ["QUARTER", 4.25],
// ["ONE", 90.00],
// ["FIVE", 55.00],
// ["TEN", 20.00],
// ["TWENTY", 60.00],
// ["ONE HUNDRED", 100.00]]
checkCashRegister(19.50, 20.00, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.10], ["QUARTER", 4.25], ["ONE", 90.00], ["FIVE", 55.00], ["TEN", 20.00], ["TWENTY", 60.00], ["ONE HUNDRED", 100.00]]);4.依照一個存著新進貨物的二維數組，更新存著現有庫存(在 arr1 中)的二維數組. 如果貨物已存在則更新數量 . 如果沒有對應貨物則把其加入到數組中，更新最新的數量. 返回當前的庫存數組，且按貨物名稱的字母順序排列.
unction updateInventory(arr1, arr2) {
// All inventory must be accounted for or you're fired!
return arr1;
}
// Example inventory lists
var curInv = [
[21, "Bowling Ball"],
[2, "Dirty Sock"],
[1, "Hair Pin"],
[5, "Microphone"]
];
var newInv = [
[2, "Hair Pin"],
[3, "Half-Eaten Apple"],
[67, "Bowling Ball"],
[7, "Toothpaste"]
];
updateInventory(curInv, newInv);思路好像不複雜，
（1）對兩個數組構建對象。然後用hasOwnProperty判斷有，則累加，沒有則定義這個屬性並給他賦值。
（2）獲取對象的屬性名併排序：Object.keys(obj).sort(),返回的是一個數組。再重新定義這個數組並輸出。
function updateInventory(arr1, arr2) {
var oCur={};
var oNew={};
function arrToObj(arr,obj){
for(var i=0;i<arr.length;i++){
obj[arr[i][1]]=arr[i][0];
}
}//構造庫存對象。
arrToObj(arr1,oCur);
arrToObj(arr2,oNew);
//添加貨物及屬性
for(i in oNew){
console.log(oCur.hasOwnProperty(i))
if(oCur.hasOwnProperty(i)){
oCur[i]+=oNew[i];
}else{
oCur[i]=oNew[i];
}
}
//屬性名排序
function objKeySort(obj) {//排序的函數
var newkey = Object.keys(obj).sort();
//newkey是一個排序後的屬性名數組
var newObj = {};
for (var i = 0; i < newkey.length; i++) {
newObj[newkey[i]] = obj[newkey[i]];
}
return newObj;//返回排好序的新對象
}
oCur=objKeySort(oCur);
//反向編譯這個對象，然後返回成最初的數組。
var newArr=[]
for(i in oCur){
newArr.push([oCur[i],i])
}
console.log(newArr);
return newArr;
}5. 把一個字元串中的字元重新排列生成新的字元串，返回新生成的字元串里沒有連續重覆字元的字元串個數.連續重覆只以單個字元為準
例如, aab 應該返回 2 因為它總共有6中排列 (aab, aab, aba, aba, baa, baa), 但是只有兩個 (aba and aba)沒有連續重覆的字元 (在本例中是 a).
嘗試過兩個排列組合的演算法，但是只有這個能驗證通過。
function permAlone(str) {
//創建正則
var regex = /(.)\1+/g;
// 轉化數組
var arr = str.split('');
var permutations = [];
var tmp;
//全部相等時返回0，否則再判斷沒意義。
if (str.match(regex) !== null && str.match(regex)[0] === str) return 0;
// 創建一個swap函數來交換變數的內容。
function swap(index1, index2) {
tmp = arr[index1];
arr[index1]=arr[index2];
arr[index2]=tmp;
}//簡單地說是：ab，ba
//使用該函數演算法生成數組排列。
function generate(int) {
if(int === 1){//如果數組內只有一個數據，換言之只有單個字母，直接返回原數組。
//確保加入我們創建的字元排列是個數組
permutations.push(arr.join(''));
}else{
for (var i=0; i<int;i++){
generate(int-1);//自身調用，簡而言之就是把後邊自身的全排列好。
swap(int % 2? 0 : i, int - 1);//偶數取0，否則取i
}
}
}
generate(arr.length);
//過濾重覆排列的數組。
var filtered = permutations.filter(function(string) {
return !string.match(regex);
});
//統計變數
return filtered.length;
}
permAlone('abfdefa');6.讓日期區間更友好！
把常見的日期格式如：YYYY-MM-DD 轉換成一種更易讀的格式。
易讀格式應該是用月份名稱代替月份數字，用序數詞代替數字來表示天 (1st 代替 1).
記住不要顯示那些可以被推測出來的信息: 如果一個日期區間里結束日期與開始日期相差小於一年，則結束日期就不用寫年份了。月份開始和結束日期如果在同一個月，則結束日期月份就不用寫了。
另外, 如果開始日期年份是當前年份，且結束日期與開始日期小於一年，則開始日期的年份也不用寫。
只能說它這個規則設置是非常非常坑爹的。
makeFriendlyDates(["2016-07-01", "2016-07-04"]) should return ["July 1st","4th"].
makeFriendlyDates(["2016-12-01", "2017-02-03"]) should return ["December 1st","February 3rd"].
makeFriendlyDates(["2016-12-01", "2018-02-03"]) should return ["December 1st, 2016","February 3rd, 2018"].
makeFriendlyDates(["2017-03-01", "2017-05-05"]) should return ["March 1st, 2017","May 5th"]
makeFriendlyDates(["2018-01-13", "2018-01-13"]) should return ["January 13th, 2018"].
makeFriendlyDates(["2022-09-05", "2023-09-04"]) should return ["September 5th, 2022","September 4th"].
makeFriendlyDates(["2022-09-05", "2023-09-05"]) should return ["September 5th, 2022","September 5th, 2023"].
function makeFriendlyDates(arr) {
//定義兩個對象，一個存放參數1，一個存放參數2
var oDate1={},oDate2={};
var reArr=[];
for(var i=0;i<arr.length;i++){
reArr[i]=arr[i].split('-');
if(i==0){
oDate1["year"]=reArr[i][0];
oDate1["month"]=reArr[i][1];
oDate1["day"]=reArr[i][2];
}else{
oDate2["year"]=reArr[i][0];
oDate2["month"]=reArr[i][1];
oDate2["day"]=reArr[i][2];
}
}//通過這段程式把兩個日期參數轉化為兩個json對象。格式為{"year":xxxx,"month:xx","day":xxx}（xxx全為數字）
//因為上面的json還不足以滿足格式，所以還得寫個json，再寫個函數轉化這兩個json。
var oMonth={
"01":"January",
"02":"February",
"03":"March",
"04":"April",
"05":"May",
"06":"June",
"07":"July",
"08":"August",
"09":"September",
"10":"October",
"11":"November",
"12":"December"
};//定義月份對象
function getFunDay(obj){
//判斷日期:
switch(obj["day"]){
case "01":
obj["day"]="1st";
break;
case "02":
obj["day"]="2nd";
break;
case "03":
obj["day"]="3rd";
break;
case "04":
case "05":
case "06":
case "07":
case "08":
case "09":
obj["day"]=obj["day"][1]+"th";
break;
case "21":
obj["day"]+='st';
break;
case "22":
obj["day"]+='nd';
break;
case "23":
obj["day"]+='rd';
break;
default:
obj["day"]+='th';
}
//判斷月份
for(i in oMonth){
if(obj["month"]==i){
obj["month"]=oMonth[i];
}
}
}
getFunDay(oDate1);
getFunDay(oDate2);
//console.log(oDate1);
//轉化之後這兩個對象的格式就正確了。
//接下來是一段非常繁瑣的判斷流程，如果是新手，建議畫出流程圖來做
if(oDate1["year"]==oDate2["year"]){//是否同年
if(oDate1["month"]==oDate2["month"]){//是否同年同月
if(oDate1["day"]==oDate2["day"]){//是否同年同月同日
console.log([[oDate1["month"],oDate1["day"]+",",oDate1["year"]].join(' ')])//註意，同年同月同日的話，這裡有個全直接輸出口。
return [[oDate1["month"],oDate1["day"]+",",oDate1["year"]].join(' ')];
}else{//同年同月不同日
delete oDate1["year"];
delete oDate2["year"];
delete oDate2["month"];
}
}else{ //同年不同月
delete oDate2["year"];
}
}else if((Math.abs(oDate1["year"]-oDate2["year"])==1)){//不同年，年份但只差一年
if(oDate1["month"]<oDate2["month"]){//如果在一年以內
delete oDate1["year"];
delete oDate2["year"];
}else if(oDate1["month"]==oDate2["month"]){//差一年同月
if(oDate1["day"]>oDate2["day"]){ //小於一年
delete oDate2["year"];
}
}
}
//以下定義輸出函數。把json數據轉化為一個字元串。
//預設的輸出格式里，日期是帶逗號的，但經過上面一輪判斷，日期可能變成字元串的最後一個。在帶逗號就不對了。所以需要判斷字元串
function retArr(obj1,obj2){
var returnArr=[];
//先按輸出規則構造一個數組
//這些規則可能調用了已被刪除的屬性。對應為undefined。所以過濾掉。
var objstr1=[obj1["month"],obj1["day"]+",",obj1["year"]].filter(function(a){return a!=undefined}).join(' ');
var objstr2=[obj2["month"],obj2["day"]+",",obj2["year"]].filter(function(a){return a!=undefined}).join(' ');
//
if(objstr1.substring(objstr1.length-1)==','){
objstr1=objstr1.replace(objstr1.substring(objstr1.length-1),'')
}
if(objstr2.substring(objstr2.length-1)==','){
console.log(objstr1.substring(objstr1.length-1))
objstr2=objstr2.replace(objstr2.substring(objstr2.length-1),'')
}
returnArr=[objstr1,objstr2];
return returnArr;
}
console.log(retArr(oDate1,oDate2));
return retArr(oDate1,oDate2);
}
makeFriendlyDates(["2016-07-01", "2016-07-04"]);
//makeFriendlyDates(["2016-12-01", "2017-02-03"]);
//makeFriendlyDates(["2016-12-01", "2018-02-03"]);
//makeFriendlyDates(["2017-03-01", "2017-05-05"]);
//makeFriendlyDates(["2018-01-13", "2018-01-13"]);
//makeFriendlyDates(["2022-09-05", "2023-09-04"]);
//makeFriendlyDates(["2022-09-05", "2023-09-05"])7.用下麵給定的方法構造一個對象.
方法有 getFirstName(), getLastName(), getFullName(), setFirstName(first), setLastName(last), and setFullName(firstAndLast).
所有有參數的方法只接受一個字元串參數.
所有的方法只與實體對象交互.
思路，好像沒什麼思路。
function Person(fullName){
this.getFirstName=function(){
return fullName.split(' ')[0];
};
this.getLastName=function(){
return fullName.split(' ')[1];
};
this.getFullName=function(){
return fullName;
};
this.setFirstName=function(firstName){
var arr=fullName.split(' ');
arr.splice(0,1,firstName)
fullName=arr.join(' ');
};
this.setLastName=function(lastName){
var arr=fullName.split(' ');
arr.splice(1,1,lastName);
fullName=arr.join(' ');
};
this.setFullName=function(name){
fullName=name;
};
}註意set首名和尾名不能採用鏈式寫法。
8.返回一個數組，其內容是把原數組中對應元素的平均海拔轉換成其對應的軌道周期.
原數組中會包含格式化的對象內容，像這樣 {name: 'name', avgAlt: avgAlt}.
至於軌道周期怎麼求，戳這裡 on wikipedia (不想看英文的話可以自行搜索以軌道高度計算軌道周期的公式).
求得的值應該是一個與其最接近的整數，軌道是以地球為基準的.
地球半徑是 6367.4447 kilometers, 地球的GM值是 398600.4418, 圓周率為Math.PI
orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]) 應該返回 [{name: "sputnik", orbitalPeriod: 86400}].
orbitalPeriod([{name: "iss", avgAlt: 413.6}, {name: "hubble", avgAlt: 556.7}, {name: "moon", avgAlt: 378632.553}]) 應該返回 [{name : "iss", orbitalPeriod: 5557}, {name: "hubble", orbitalPeriod: 5734}, {name: "moon", orbitalPeriod: 2377399}].
function orbitalPeriod(arr) {
var GM = 398600.4418;
var earthRadius = 6367.4447;
return arr;
}
orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]);在此需要補下高一物理的課。以萬有引力做向心力，則GMm/R^2=mrω^2 ω=2π/T，R=r+h，所以T=2π(r+h)·sqr((r+h)/GM)。
function orbitalPeriod(arr) {
var GM = 398600.4418;
var earthRadius = 6367.4447;
for(var i=0;i<arr.length;i++){
var R=(arr[i].avgAlt+6367.4447);
var T=R*2*Math.PI*Math.sqrt((R/GM));
delete arr[i].avgAlt;
arr[i].orbitalPeriod=Math.round(T);
}
console.log(arr)
return arr;
}好像也沒什麼思路可說的。
9.找到你的另一半
舉個例子：有一個能力數組[7,9,11,13,15]，按照最佳組合值為20來計算，只有7+13和9+11兩種組合。而7在數組的索引為0，13在數組的索引為3，9在數組的索引為1，11在數組的索引為2。
所以我們說函數：pairwise([7,9,11,13,15],20) 的返回值應該是0+3+1+2的和，即6。
我們可以通過表格來更直觀地查看數組中索引和值的關係：
| Index | 0 | 1 | 2 | 3 | 4 |
| Value | 7 | 9 | 11 | 13 | 15 |
任務：幫右邊的pairwise函數實現上面的功能。
思路，原題意思是匹配了一次之後數組項就不能再用了。那就把它設為false吧。
function pairwise(arr, arg) {
var arr2=arr;
var count=0;
for(var j=0;j<arr.length;j++){
for(var i=j+1;i<arr2.length;i++){
if(arr[j]+arr2[i]==arg){
count+=i+j;
arr[i]="false";
arr[j]="false"
}
}
}
console.log(count)
return count;
}題目來源：
FCC中文網：https://www.freecodecamp.cn/
參考資料：
[1]《javascript高級程設計》第3，5，6，7章。 （就做題查閱學習而言，這本書確實無愧於“紅寶書”）
[2] MOZILLA開發者社區：
