JavaScript （练习题）

• 1.题目要求

  
  图片.png
  

  答案

function get_letter_interval_2(number_a, number_b) {
  var r = [];
  var letter = ["", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
  if (number_a < number_b) {
    for (var i = number_a; i <= number_b; i++) {
      if (i % 26 === 0) {
        r.push(letter[Math.floor(i / 26) - 1].concat(letter[26]));
      }
      else {
        r.push(letter[Math.floor(i / 26)].concat(letter[i % 26]));
      }
    }
    return r;
  }
  if (number_a > number_b) {
    for (var j = number_a; j >= number_b; j--) {
      if (j % 26 === 0) {
        r.push(letter[Math.floor(j / 26) - 1].concat(letter[26]));
      }
      else {
        r.push(letter[Math.floor(j / 26)].concat(letter[j % 26]));
      }
    }
    return r;
 if (number_a = number_b) {
        r.push(letter[Math.floor( number_a/ 26)].concat(letter[number_a % 26]));
      }
     return r;
}

• 2.从数组中选出不重复的数字

var collection = [1, 1, 1, 2, 2, 3, 4];

function choose_no_repeat_number(collection) {

  var result = [];

  result = collection.filter(function (value,index,array){   // filter（）方法：检测数值元素，并返回符合条件所有元素的数组。

  return index == array.indexOf(value); //indexof（）方法：搜索数组中的元素，并返回它所在的位置。看这个位置是否等于元素第一次出现的位置
  })
  return result;
}

• 3.找出一个数组中元素出现频率最高的元素

 var arr = [1, -1, 2, 4, 5, 5, 6, 7, 5, 8, 6];

        var m = {};
        var mnum = 0;
        var mmb;
        for (var i = 0; i < arr.length; i++) {
            var a = arr[i];
            m[a] === undefined ? m[a] = 1 : (m[a]++);
            if (m[a] > mnum) {
                mmb = a;
                mnum = m[a];
            }
        }
        document.write("出现频率最高的元素为：" + mmb);  //出现频率最高的元素为：5 

• 4.从数组中计算出每个数的个数

var collection = [1,1,1,1,2,3,1,3,4,2,3,1,3,4,2];
function grouping_count(collection) {
  var h = {};
  var num = 0;
  for (var i = 0; i < collection.length; i++) {
    var a = collection[i];
    h[a] === undefined ? h[a] = 1 : (h[a]++);
  }

  return h;
}                        //{'1':6, '2':3, '3':4, '4':2}

• 5.将二维数组变为一维数组

var collection = [1, [2], [3, 4]];
function double_to_one(collection) {
  var arr1 = (collection + '').split(',');            //将数组转字符串后再以逗号分隔转为数组
  var arr2 = arr1.map(function (value, index, arr)  { //map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
    return Number(value);
  });
  return arr2;
}

• 6.将数字变为字符串
  图片.png
  答案：

var number_map_to_word_over_26 = function(collection){
  var c=[]
  var r=collection.map(function(value,index,collection){
     if(value<=26) {
     c= String.fromCharCode(value+96);
     }
     else{
      c=String.fromCharCode(97).concat(String.fromCharCode(value%26+96));
     }
     return c;
 })
 return r;
};

• 7.将数组的数字进行排序操作

   //按照数值的大小对数字进行排序，必须使用一个排序函数：a代表数组的前一位，b代表数组的后一位。
var arr = [1,2,3,5,2,5,3,6,2,6,2,6,2,5,9,6,8,54,3,6,8];
arr.sort(function(a,b){return a-b});  //这样是升序排列。
                                      //如果希望降序排列，就写成return b-a；

• 8.求数组的中位数
  图片.png
  答案

function compute_chain_median(collection) {
  //在这里写入代码
  var ary = collection.split('->').sort(function (a, b) {   //split（）将chain以指定的"->”为分界，分割成一个数组，结果是一个数组
    return a - b;                                          //sort() 将数组进行升序操作
  });

  var lowMiddle = Math.floor((ary.length - 1) / 2);   // Math.floor（）向下取整
  var highMiddle = Math.ceil((ary.length - 1) / 2);   //Math.ceil  ()  向上取整
  return (Number(ary[lowMiddle]) + Number(ary[highMiddle])) / 2;
}

• 9.编写一个函数，实现以下功能：计算出一个字符串共有多少个单词组成。

    <script type="text/javascript">
        var r = 0;
        var n;
        function countWords(message) {
            n = message.split(" ")   //split() 方法用于把一个字符串分割成字符串数组。
            r = n.length;            //n=Good,morning,,I,love,JavaScript
            return r;
        }
        countWords('Good morning, I love JavaScript.');
        document.write(r);
    </script>         //5

• 10 .题目

  
  图片.png
  

  答案

var r = [];
  for (var i = 0; i < collection.length;) {
    let count = 0;
    for (var j = 0; j < collection.length; j++) {
      if (collection[i] === collection[j]) {
        count++;
      }
    }
    r.push({
      key: collection[i],
      count: count
    })
    i += count;
  }
  return r;
}

• 11.题目要求（如何遍历对象，如何使用正则表达式）

  
  图片.png

 let result = [];
  let H = {};
  for (let item of collection) {
    if (item.length === 1) {
      H[item] === undefined ? H[item] = 1 : H[item] += 1;
    } else {
      let grexNum = /\d{1,2}/;  //正则表达式  ：获取两位数以内的数字
      let grexWord = /^\w/;    //正则表达式：   获取首位字母的字母
      let num = item.match(grexNum)   //match() 方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配               
      let word = item.match(grexWord)
      H[word[0]] === undefined ? H[word[0]] = Number(num[0]) : H[word[0]] += Number(num[0]);
    }
  }
  let r = [];
  for (let i in H) {    //遍历对象H 赋值给数组r
    r.push({
      name: i,
      summary: H[i]
    })
  }
  return r;
}

• 11.遍历对象数组

  var collection_a = [
    {key: "a", count: 3},
    {key: "e", count: 7},
    {key: "h", count: 11},
    {key: "t", count: 20},
    {key: "f", count: 9},
    {key: "c", count: 8},
    {key: "g", count: 7},
    {key: "b", count: 6},
    {key: "d", count: 5}
  ];
//选出A集合中元素的key属性跟B对象中value属性中的元素相同的元素,把他们的count，满3减1，输出减过之后的新A集
 for (var i = 0; i < collection_a.length; i++) {
    for (var j = 0; j < object_b.value.length; j++) {
      if (collection_a[i].key === object_b.value[j]) {
        collection_a[i].count = collection_a[i].count - Math.floor(collection_a[i].count / 3);
      }
    }

  }
  return collection_a;

• 12.for in 和 for of 遍历的区别

et iterable = [3, 5, 7];

for (let i in iterable) {
  console.log(i); //  0, 1, 2  //for in 是获得索引值

for (let i of iterable) {
  console.log(i); // 3, 5, 7   //for of 是获得元素值