参考博客：葡萄美酒夜光杯

1、验证美国有效号码（Validate US Telephone Numbers）

如果传入字符串是一个有效的美国电话号码，则返回true.
用户可以在表单中填入一个任意有效美国电话号码. 下面是一些有效号码的例子(还有下面测试时用到的一些变体写法):
555-555-5555
(555)555-5555
(555) 555-5555
555 555 5555
5555555555
1 555 555 5555
在本节中你会看见如800-692-7753
or8oo-six427676;laskdjf
这样的字符串. 你的任务就是验证前面给出的字符串是否是有效的美国电话号码. 区号是必须有的. 如果字符串中给出了国家代码, 你必须验证其是1. 如果号码有效就返回true; 否则返回false.
对你有帮助的资源:
RegExp 正则表达式

//思路：基本上，就是九个规则并起来。
/* 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") */

function telephoneCheck(str) {
  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;
  }
}
telephoneCheck("555-555-5555");

2、对等差分(symmetric difference)

创建一个函数，接受两个或多个数组，返回所给数组的对等差分(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}).
些对你有帮助的资源:
Array.reduce()

function sym(args) {
   var arr=[].slice.call(arguments);//转化为单个数组；
  console.log(arr);
  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;
  });
  //之前只是比较数组彼此之间的重复，数组内部本身也可能存在重复
  //现在解决遗留下来的问题。
//自身查重只需要让它本身第一次出现在原数组的位置为索引值index，就可以保留且只保留一个。
}
sym([1, 2, 3], [5, 2, 1, 4]);

思考1：关于[].slice.call(arguments, 1) 的思考
思考2：关于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

3、零钱问题（Exact Change）

设计一个收银程序 checkCashRegister() ，其把购买价格(price)作为第一个参数 , 付款金额 (cash)作为第二个参数, 和收银机中零钱 (cid) 作为第三个参数.
cid 是一个二维数组，存着当前可用的找零.
当收银机中的钱不够找零时返回字符串 "Insufficient Funds". 如果正好则返回字符串 "Closed".
否则, 返回应找回的零钱列表,且由大到小存在二维数组中.

//可能还要翻译下。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;
}
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、库存更新(Inventory Update )

依照一个存着新进货物的二维数组，更新存着现有库存(在 arr1 中)的二维数组. 如果货物已存在则更新数量 . 如果没有对应货物则把其加入到数组中，更新最新的数量. 返回当前的库存数组，且按货物名称的字母顺序排列.

//思路：（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;
}

// 仓库库存示例
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);

5、没有重复字符串（No repeats please）

把一个字符串中的字符重新排列生成新的字符串，返回新生成的字符串里没有连续重复字符的字符串个数.连续重复只以单个字符为准
例如, 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、日期区间变得更友好（Friendly Date Ranges）

让日期区间更友好！
把常见的日期格式如：YYYY-MM-DD 转换成一种更易读的格式。
易读格式应该是用月份名称代替月份数字，用序数词代替数字来表示天 (1st 代替 1).
记住不要显示那些可以被推测出来的信息: 如果一个日期区间里结束日期与开始日期相差小于一年，则结束日期就不用写年份了；在这种情况下，如果月份开始和结束日期如果在同一个月，则结束日期月份也不用写了。
另外, 如果开始日期年份是当前年份，且结束日期与开始日期小于一年，则开始日期的年份也不用写。
例如:
包含当前年份和相同月份的时候，makeFriendlyDates(["2017-01-02", "2017-01-05"]) 应该返回 ["January 2nd","5th"]
不包含当前年份，makeFriendlyDates(["2003-08-15", "2009-09-21"]) 应该返回 ["August 15th, 2003", "September 21st, 2009"]。
请考虑清楚所有可能出现的情况，包括传入的日期区间是否合理。对于不合理的日期区间，直接返回 undefined 即可

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、构造一个对象（Make a Person）

用下面给定的方法构造一个对象.
方法有 getFirstName(), getLastName(), getFullName(), setFirstName(first), setLastName(last), and setFullName(firstAndLast).
所有有参数的方法只接受一个字符串参数.
所有的方法只与实体对象交互.
对你有帮助的资源:
Closures
Details of the Object Model

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;
    };

}
var bob = new Person('Bob Ross');
bob.getFullName();

8、地图的碎片（Map the Debris）

返回一个数组，其内容是把原数组中对应元素的平均海拔转换成其对应的轨道周期.
原数组中会包含格式化的对象内容，像这样{name: 'name', avgAlt: avgAlt}.
至于轨道周期怎么求，戳这里 on wikipedia(不想看英文的话可以自行搜索以轨道高度计算轨道周期的公式).
求得的值应该是一个与其最接近的整数，轨道是以地球为基准的.地球半径是 6367.4447 kilometers, 地球的GM值是 398600.4418, 圆周率为Math.PI
这是一些对你有帮助的资源:
Math.pow()

//地球半径是 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;
}
orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]);

9、找到你的另一半（Pairwise）

找到你的另一半
都说优秀的程序员擅长面向对象编程，但却经常找不到另一半，这是为什么呢？因为你总是把自己局限成为一个程序员，没有打开自己的思维。
这是一个社群的时代啊，在这里你应该找到与你有相同价值观但又互补的另一半。
譬如：你编程能力强，估值11分，如果以20分为最佳情侣来计算，你应该找一个设计能力强，估值为9分的女生。
那么当你遇到一个设计能力为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

//思路：原题意思是匹配了一次之后数组项就不能再用了。那就把它设为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;  
}

PS：暂时参照别人的博客整理运行了一下，还没有单个的做详细的研究，欢迎大家留言私信交流O(∩_∩)O