Javascript算法练习（四）

Javascript算法练习（四）

将数组分割成等长数组，然后组合成一个二维数组返回

循环 + slice + push

• 函数名：function chunkArrayInGroups(arr, size)；
• arr: 需要被分割的数组，size：指定等分数组的长；
• 情况分析：这个方法的实现主要考虑两个方面
  
  1. 数组长被size整除，即刚好能分成n个等分数组；
  2. 不能整除，即最后一个数组的长度是数组长与size取余数的结果。

function chunkArrayInGroups(arr, size) {

    if ( !arr || size <= 0 ) return "Invalid Arguments !";

    var iLen    = arr.length,
        iDiv    = 0,
        iMod    = 0,
        aTmp    = [],
        oLst    = null;

    // 在数组长小于传入的size时，直接返回原数组就行
    if ( iLen <= size ) return arr;

    iDiv = Math.floor(iLen / size); // 取出相除后的结果向下取整

    // 取余数，用于判断是否存在需要单独处理的最后一个不够size长的数组
    iMod = iLen % size;                 

    // 不能被size整除，表示最后一个数组里包含< size个元素，需要单独处理
    if ( iMod !== 0 ) {
        oLst = arr.slice( (-1) * iMod);
    }

    for (var i = 0; i < iDiv; i++) {
        aTmp.push( arr.slice( i * size, i * size + size  ) );
    }

    if ( oLst ) aTmp.push(oLst);

    return aTmp;
}

var f = chunkArrayInGroups;

console.log( f([1, 2, 3, 4], 2) );    // [[1,2], [3, 4]]
console.log( f([1, 2, 3, 4, 5], 3) ); // [[1, 2], [3, 4], [5]] 
console.log( f([1, 2, 3, 4, 5], 6) ); // [1, 2, 3, 4, 5]
console.log( f([1, 2, 3, 4, 5], -1) ); // Invalid Arguments ! 

两个字符串中的字符是否包含（即：str1中的所有字符是否都能在str2中找到，忽略顺序和大小写）

• 简单的实现了下功能

// 判断数组中的两个元素是否相互包含
// 即：将元素字符串格式化之后，忽略大小写和顺序
// 判断一个字符串中的所有字符是否都在另一个字符串中能找到；
// 如：“acdb” 中所有字符都能在 "abcdefg" 中找到；
// 只有全部找到的情况下才会返回：true;
function mutation ( arr ) {
    if ( !arr || arr.length < 2 ) return "Invalid argument !";

    // 还可以通过arguments来判断参数的个数
    // 如果是两个参数，视为传入的是两个字符串
    // 如果只有一个参数，则当为数组来处理
    var iArgLen = arguments.length,
        eFirst      = arr[0].toString().toLowerCase(),
        eSec        = arr[1].toString().toLowerCase(),
        sTmp        = "";

    // 保持被比较的第一个元素总比第二个元素长，避免在查找时才去考虑长度问题
    // 只是引用的改变（类似指针），实质不会改变数组内容
    if ( eFirst.length < eSec.length ) {
        sTmp    = eFirst;
        eFirst  = eSec;
        eSec    = sTmp;
    }

    for ( var i = 0; i < eSec.length; i++ ) {
        // 此处尚欠缺重复字符串的判断 
        // one char not found, return false.
        if ( eFirst.indexOf(eSec[i]) < 0 ) return false;
    }

    return true;
}

console.log( mutation(["hello", "HLOOOOEO"]) ); // true
console.log( mutation(["hello", "HLElO"]) );    // true
console.log( mutation(["hello", "HLE"]) );      // false

// 还可以用递归来进行扩展，判断数组中最小的那个元素是不是在数组中其他元素中都能找到

从数组中过滤掉指定的元素

• 原型：function filterEleFromArray(arr[, item1[, item2[, … itemn]]];

// 过滤掉满足回调函数内条件的元素
// 然后返回剩下不符合条件的元素组成的数组
function filterEleFromArray(arr) {
    var args = arguments,
        aTmp = [];

    // arguments并非是数组对象，所以需要将第二个开始的参数保存到数组里
    for (var i = 1; i < args.length; i++ ) {
        aTmp.push(args[i]);
    }
    return arr.filter(function(value){
        return aTmp.indexOf(value) < 0;
    });
}

console.log(filterEleFromArray([1, 2, 3, 5, 1, 2, 3], 2, 3));
console.log(filterEleFromArray([1, 2, 3, 1, 2, 3], 2, 3));
console.log(filterEleFromArray([3, 5, 1, 2, 2], 2, 3, 5));
console.log(filterEleFromArray([2, 3, 2, 3], 2, 3));
console.log(filterEleFromArray(["aaa", "bbb", 3, "ddddd"], "aaa", 3));

// 执行结果：
algorithm-04.htm:26 [1, 5, 1]
algorithm-04.htm:27 [1, 1]
algorithm-04.htm:28 [1]
algorithm-04.htm:29 []
algorithm-04.htm:30 ["bbb", "ddddd"]

字符串加密处理

• 这里使用的是最简单的方式，对每个字符串进行转码之后加上或减掉固定的数值，然后再转回字符组成字符串
• 主要学习：
  
  • str.charCodeAt(index); 返回字符串中指定索引index的字符的10进制编码
  • String.fromCharCode(a1, a2, …); 将整数参数(可多个参数，非整数会被当做0处理)逐个转成字符之后再组合成字符串返回，此方法为String的静态方法，所以只能用String去调用。

// 加密字符串
function stringEncoding( __str ) {

    if ( !__str ) return;

    return __str.toUpperCase().split("").map(function( elem, index ) {

        // get elem's Unicode
        var code = elem.toString().charCodeAt(0);

        // only deal with "A" - "Z"
        if ( code >= 65 && code <= 90 ) {
            // 根据Unicode编码，按照一定规律处理之后，返回
            // 这里是做了 + 13处理，当结果 > “Z” 之后重新从 “A” 开始计算
            // return String.fromCharCode( code + 13 > 90 ? code + 13 - 90 + 65 : code + 13);

            // var iStep = 10;                  // [1]
            // 还可以将索引利用起来
            var iStep = index % 2 ? 10 : 13;    // [2]
            return String.fromCharCode( code + iStep > 90 ? code + iStep - 90 + 65 : code + iStep);
        } else { // 除字母以外的所有字符原样返回
            return elem;
        }
    }).join(""); // 处理之后重新组合成字符串返回
}

console.log("result = " + stringEncoding("Hello!!!!")); // URYYC!!!!    [1]
console.log("result = " + stringEncoding("Hello!!!!")); // UOYVC!!!!    [2]