1.弹出数组的最后一个元素
1）for (let i = 0; i <collection.length ; i++) {
return collection[collection.length-1];
}
2）return collection.pop();
//若是用这个，会返回数组的最后一个元素，但是同时会删除该元素，删除并返回数组的最后一个元素
2.弹出两个集合的交集
var collection_c=[];
1） // for (let i = 0; i <collection_b.length ; i++) {
// for (let j = 0; j <collection_a.length ; j++) {
// if(collection_b[i]==collection_a[j])
// {
// collection_c.push(collection_b[i]);
// }
// }
// }
// return collection_c;
2） for (let i = 0; i <collection_b.length ; i++) {
if(collection_a.indexOf(collection_b[i])!=-1)
//判断collection_b的元素在collection_a有没有出现，不等于-1出现，等与-1，没有出现。
{
collection_c.push(collection_b[i]);
}
}
return collection_c;
- 循环字母
var collection_a = ['t', 'u', 'v', 'w', 'x',
'y', 'z', 'aa', 'ab', 'ac', 'ad', 'ae', 'af', 'ag',
'ah', 'ai', 'aj', 'ak', 'al', 'am', 'an', 'ao', 'ap',
'aq', 'ar', 'as', 'at', 'au', 'av', 'aw', 'ax', 'ay',
'az', 'ba'
];
//'z'后依次是'aa', 'ab',用下面循环将之存入data数组中。
var str = '0abcdefghijklmnopqrstuvwxyz';
var data=[];
for (let i = 0; i < str.length; i++) {
data.push(str[i]);
}
for (let i = 1; i < str.length; i++) {
for (let j = 1; j <str.length ; j++) {
data.push(str[i]+str[j]);
}
}
4.求两个集合的并集
//将B集合中不存在a集合的元素放入 a集合中，最后反返回a集合。
1）//学会用标记值初始值=true，不满足的场景设为false,用来排除这种场景。
//break 语句可用于跳出循环。break 语句跳出循环后，会继续执行该循环之后的代码（如果有的话）。
//continue 语句中断循环中的迭代，如果出现了指定的条件，然后继续循环中的下一个迭代。
for (var i = 0; i < collection_b.length; i++){
var dup = true;
for (var j = 0; j < collection_a.length; j++){
if (collection_b[i] == collection_a[j]){
//若此处不用这种方式，写为不相等的情况下push,则会将b中每个元素push多次。所以有误。
dup = false;
break;
}
}
////dup=true的情况下push
if (dup){
collection_c.push(collection_b[i]);
}
}
return collection_c;
2） for (var i = 0; i < collection_b.length; i++){
if(collection_a.indexOf(collection_b[i])==-1)
//b中的元素不存在a集合中，则将该元素push到a集合中。
{
collection_a.push(collection_b[i]);
}
}
return collection_a;
5.从collection中选出不重复的数字
var collection_a=[];//一个新的临时数组
1）// //遍历当前数组
// for (let i = 0; i <collection.length ; i++) {
// //如果当前数组的第i已经保存进了临时数组，那么跳过，
// //否则把当前项push到临时数组里面
// if (collection_a.indexOf(collection[i]) == -1)
// {
// collection_a.push(collection[i]);
// }
// }
// return collection_a;
2）//element当前元素，index当前元素的索引
return collection.filter(function(element,index,collection_a){
return collection_a.indexOf(element) == index;
//indexOf只返回元素在数组中第一次出现的位置，如果与元素位置不一致，
说明该元素在前面已经出现过，是重复元素
});
6.从collection中计算出每个数的个数
var m={};
for (let i = 0; i <collection.length ; i++) {
if(collection[i] in m)
{
//把关键字为collection[i]的值赋值关键字为collection[i]的值+1.
m[collection[i]]=m[collection[i]]+1;
}
else
{
m[collection[i]]=1;//把关键字为collection[i]的值赋值为1.
}
}
return m;
7.选出A集合中与B集合中的不共有元素，即为并集减去交集
//splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。
//求差集
for (let i = 0; i <collection_c.length ; i++) {
// collection_a.splice(collection_a.indexOf(collection_c[i]),1);
for (let j = 0; j <collection_a.length ; j++) {
if(collection_c[i]==collection_a[j])
{
//删除collection_a集合中下标从j开始的第一个元素，即删除下标为j的元素。
collection_a.splice(j,1);
break;
}
}
}
return collection_a;
8.var collection = [1, [2], [3, 4]];将该数组转为一维数组。
var collection_a=[];
for (var i = 0; i < collection.length; i++) {
//instanceof则为判断一个对象是否为某一数据类型，或一个变量是否为一个对象的实例
if(collection[i] instanceof Array)
{
for (var j = 0; j < collection[i].length; j++) {
collection_a.push(collection[i][j]);
}
}
else
{
collection_a.push(collection[i]);
}
}
return collection_a;
9.把二维数组变成一维数组,消除重复,按照第一次出现的顺序排列最后的输出结果。
var collection_a=[];
var collection_b=[];
//在这里写入代码
//二维数组变成一维数组
for (var i = 0; i < collection.length; i++) {
for (var j = 0; j < collection[i].length; j++) {
collection_a.push(collection[i][j]);
}
}
//消除重复，按照第一次出现的顺序排列最后的输出结果
for (let i = 0; i < collection_a.length; i++) {
if(collection_b.indexOf(collection_a[i])==-1)//未出现
{
collection_b.push(collection_a[i]);
}
}
return collection_b;
- 从大到小排序
1）// for (let i = 0; i < collection.length; i++) {
// for (let j = i + 1; j < collection.length; j++) {
// if (collection[i] < collection[j]) {
// var temp;
// temp = collection[i];
// collection[i] = collection[j];
// collection[j] = temp;
// }
// }
// }
2）return collection.sort(function (a,b) {return -(a-b); });//从大到小排序
return collection.sort();//从小到大排序
11.判断两个集合是否相同
1）// if (collection_a.length == collection_b.length) {
// for (let i = 0; i < collection_a.length; i++) {
// if (collection_a[i] != collection_b[i]) {
// return false;
// }
// }
// }
// else {
// return false;
// }
// return true;
2） return collection_a.reduce(function (total, currentValue, currentIndex) {
return total && (currentValue == collection_b[currentIndex]);
}, true);
12.'1->4->6->2->3->10->9->8->11->20->19->30'的中位数。
//split()，根据特定的字符切割字符串并且返回生成的数组。
//splice()用法 ： splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。
//slice() 方法可从已有的数组中返回选定的元素。eg:arrayObject.slice(start,end)
//parseInt(a),字符串转整数
var a = collection.split("->").map(function (a) {
return parseInt(a);
});
a.sort(function (a, b) {
return a - b;
});
if(a.length%2==0)
{
return (a[a.length/2]+a[a.length/2-1])/2;
}
else {
return a[(a.length-1)/2];
}
- 找出某元素在给定集合中的第一个下标
return collection.reduce(function (init, value, index) {
if (value == element) {
if (init == -1) {
init=index;
}
}
return init;
}, -1);
14.找出某元素在给定集合中的最后一个下标
return collection.reduce(function (init,value,index) {
if(value==element)
{
init=index;
}
return init;
},-1);
15.根据给定数字无限分割至等于或者小于0
var collection=[number];
while (number>0){
number=Math.round((number-interval)*10)/10;//保留一位小数
collection.push(number);
}
return collection;
16.选出A集合中元素的key属性，跟B对象中value属性中的元素相同的元素
var collection_b=[];
for (let i = 0; i <collection_a.length ; i++) {
for (let k = 0; k <object_b.value.length ; k++) {
if(collection_a[i]['key'] == object_b.value[k])
{
collection_b.push(collection_a[i]['key']);
}
}
}
return collection_b;
17.把A集合中相同的元素统计出数量
var collection = [
"a", "a", "a",
"e", "e", "e", "e", "e", "e", "e",
"h", "h", "h", "h", "h", "h", "h", "h", "h", "h", "h",
"t", "t", "t", "t", "t", "t", "t", "t", "t", "t", "t", "t", "t",
"t", "t", "t", "t", "t", "t", "t",
"f", "f", "f", "f", "f", "f", "f", "f", "f",
"c", "c", "c", "c", "c", "c", "c", "c",
"g", "g", "g", "g", "g", "g", "g",
"b", "b", "b", "b", "b", "b",
"d", "d", "d", "d", "d"
];
var collection_a=[];
var m={};
for (let i = 0; i <collection.length ; i++) {
if (collection[i] in m) {
m[collection[i]]=m[collection[i]] + 1;
}
else {
m[collection[i]]=1;
}
}
for (var key in m) {
var temp={};
temp['key']=key;
temp['count']=m[key];
collection_a.push(temp);
}
return collection_a;
var collection = [
"a", "a", "a",
"e", "e", "e", "e", "e", "e", "e",
"h", "h", "h", "h", "h", "h", "h[3]", "h", "h",
"t", "t-2", "t", "t", "t", "t", "t", "t", "t[10]",
"f", "f", "f", "f", "f", "f", "f", "f", "f",
"c:8",
"g", "g", "g", "g", "g", "g", "g",
"b", "b", "b", "b", "b", "b",
"d-5"
];
var collection_a = [];
var m = {};
for (let i = 0; i < collection.length; i++) {
if (collection[i].length == 1) {
var k=collection[i];
var v=1;
if (k in m) {
m[k] = m[k] + v;
}
else {
m[k] = v;
}
}
else {
if(collection[i].length>3)
{
var k = collection[i][0];
var v = parseInt(collection[i].slice(2,collection[i].length-1));
if (k in m) {
m[k] = m[k] + v;
}
else {
m[k] = v;
}
}
else {
var k = collection[i][0];
var v = parseInt(collection[i].slice(2));
if (k in m) {
m[k] = m[k] + v;
}
else {
m[k] = v;
}
}
}
}
for (var key in m) {
var temp = {};
temp['name'] = key;
temp['summary'] = m[key];
collection_a.push(temp);
}
return collection_a;
17.统计出A集合中相同的元素的个数，有过有-就把-右边的数字也计算入个数，形成C集合，C集合中的元素要形如{key:"a", count: 3}，然后选出C集合中的元素的key属性跟B对象中value属性中的元素相同的元素,把他们的count，满3减1，输出减过之后的新C集合",
function() {
var collection_b = [];
var m = {};
for (let i = 0; i < collection_a.length; i++) {
if (collection_a[i].length == 1) {
var k=collection_a[i];
var v=1;
if (k in m) {
m[k] = m[k] + v;
}
else {
m[k] = v;
}
}
else {
var k = collection_a[i][0];
var v = parseInt(collection_a[i].slice(2));
if (k in m) {
m[k] = m[k] + v;
}
else {
m[k] = v;
}
}
}
for (var key in m) {
var temp = {};
temp.key = key;
temp.count = m[key];
collection_b.push(temp);
}
return collection_b.map((function (a) {
if (object_b.value.indexOf(a.key) != -1) {
a.count-=Math.floor(a.count/3);
}
return a;
}));
18.数组的每个偶数映射为字母
var str = '0abcdefghijklmnopqrstuvwxyz';
return collection.filter(function (a) {
return a % 2 == 0;
})
.map(function (a) {
return str[a];
});
19.(20,53)的中位数(如果是小数上取整)对应的字母
var str='0abcdefghijklmnopqrstuvwxyz';
var data=[];
for (let i = 0; i < str.length; i++) {
data.push(str[i]);
}
for (let i = 1; i <str.length ; i++) {
for (let j = 1; j < str.length; j++) {
data.push(str[i]+str[j]);
}
}
if(collection.length%2==1){
return data[collection[collection.length-1/2]];//长度为5，应该取下标为2的元素
}else {
return data[Math.ceil((collection[collection.length/2]+collection[(collection.length/2)-1])/2)];
}
20.计算第偶数个元素的平均数，即下标为偶数的元素的平均值
var calculate_average = function(collection){
var res=collection.filter(function (a,index) {
return index%2==1;//第偶数个元素即下标为奇数的元素
});
var sum=res.reduce(function (a,b) {
return a+b;
});
return sum/res.length;
21.集合中第偶数个元素的个数为奇数时，计算所有第偶数个元素的中位数
集合中第偶数个元素的个数为偶数时，计算所有第偶数个元素的中位数
//过滤所有第偶数个元素
var res=collection.filter(function (a,index) {
return index%2==1;//第偶数个元素即下标为奇数的元素
});
//判断第偶数个元素的个数为偶数或偶数
if(res.length%2 ==1)
{
return res[(res.length-1)/2];
}
else
{
return (res[res.length/2]+res[res.length/2-1])/2;
}
- it('首先选出所有第偶数个元素，然后选出其中的偶数，按几位数分组，并计算每组的平均数', function() {
var result = even_group_calculate_average(collection_a);
expect(result).toEqual([4, 56, 556]);
});
it('首先选出所有第偶数个元素，当不含有偶数时', function() {
var result = even_group_calculate_average(collection_b);
expect(result).toEqual([0]);
});
it('首先选出所有第偶数个元素，然后选出其中的偶数，按几位数分组，当不含有1位，2位的数字，但含有3位的情况时，计算这组的平均数', function() {
var result = even_group_calculate_average(collection_c);
expect(result).toEqual([218]);
});
//首先选出所有第偶数个元素，然后选出其中的偶数
var res = collection.filter(function (a, index) {
return index % 2 == 1 && a % 2 == 0;////第偶数个元素即下标为奇数的元素以及元素值为偶数
});
//首先选出所有第偶数个元素，然后选出其中的偶数，再判断其个数。
if (res.length == 0) {
return [0];
}
else {
var a1 = res.filter(function (a) {
return a / 10 < 1;
});
var a2 = res.filter(function (a) {
return a / 10 >= 1 && a / 100 < 1;
});
var a3 = res.filter(function (a) {
return a / 100 >= 1;
});
if(a1.length==0&& a2.length==0)
{
return [a3.reduce(function (a,b) {
return a+b;
})/a3.length];
}
else {
return [a1.reduce(function (a,b) {
return a+b;
})/a1.length,a2.reduce(function (a,b) {
return a+b;
})/a2.length,a3.reduce(function (a,b) {
return a+b;
})/a3.length];
}
}
- var collection_a = [1, 2, 3, 4, 5, 6];
it('下标为偶数的元素中，存在3', function() {
var result = is_exist_element(collection_a, 3);
expect(result).toEqual(true);
});
it('下标为偶数的元素中，不存在4', function() {
var result = is_exist_element(collection_a, 4);
expect(result).toEqual(false);
});
var res = collection.filter(function (value, index) {
return index % 2 == 0;//下标为偶数的元素
});
return res.indexOf(element) != -1;//不存在false,存在true.
网友评论