阿里前端实习一面

阿里菜鸟网络前端实习一面

判断回文序列

字符串的转换

• 简单点，使用高阶函数来完成

思路： 先将数字转成字符串A，再经过变成数组，数组反转，数组变成字符串B三步操作之后，比较字符串A和B，得出结论

/**
* @param {number} x
* @return {boolean}
*/
var isPalindrome = function(x) {
  if ( x < 0 ) return false
  let str = '' + x
  return Array.from(str).reverse().join('') === str
};

• 从后往前循环字符串数组

思路：将数字转换成字符串A，从后往前循环字符串A，将循环出来的字符拼接成新的字符串B，比较字符串A和B，得出结论。

/**
* @param {number} x
* @return {boolean}
*/
var isPalindrome = function(x) {
  let str = x + ''
  let newStr = ''
  for(let len = str.length, i = len - 1; i >= 0 ; i--) {
    newStr += str[i]
  }}
  return newStr === str
};

• 以中间数为节点，判断左右两边首尾是否相等

/**
* 以中间数为节点，判断左右两边首尾是否相等
* @param {number} x
* @return {boolean}
*/
var isPalindrome = function(x) {
  if ( x < 0 || (x !== 0 && x % 10 === 0)) {
    return false
  } else if ( 0 <= x && x < 10) {
    return true
  }
  x = '' + x
  for(let i = 0 ; i < x.length/2; i++) {
    if (x[i] !== x[x.length - i - 1]) {
      return false
    }
  }
  return true
};

数字转换

• 求模得尾数，除10得整数

思路： 先判断一些特殊情况【小于0的、尾数为0的、小于10的正整数】。之后，将整数反转，反转前后两个整数是否相等来判断是否为回文整数。
这里的反转：将整数求模得到尾数，之后每求一次模，都再原数上添加一位(通过*10来得到），这样就能得到一个反转的数。

/**
* 求模得尾数，除10得整数
* @param {number} x
* @return {boolean}
*/
var isPalindrome = function(x) {
  if ( x < 0 || (x !== 0 && x % 10 === 0)) {
    return false
  } else if ( 0 <= x && x < 10) {
    return true
  }
  let y = x
  let num = 0
  while(x !== 0) {
    num = x % 10 + num * 10
    x = Math.floor(x / 10)
  }
  return y === num
};

数组相邻k个元素最大子序列求和

• 冒泡排序

/**
* @param {number[]} nums
* @param {number} k
* @return {number}
*/
// k = 1 key = 3
var findKthLargest = function (nums, k) {
  let start = 0, end = nums.length - 1;
  // 排好序后，数组中第key个元素就是第K大的元素
  let key = nums.length - k;
  while (true) {
      let i = partition(nums, start, end);
      if (i === key) {
          return nums[key];
      } else if (i < key) {
          // 说明要找的值比nums[i]要大，所以要在[i+1, end]中继续切分
          start = i + 1;
      } else {
          // 说明要找的值比nums[i]要小，所以要从[0, i-1]中继续切分
          end = i - 1;
      }
  }
};
function partition(arr, start, end) {
  // 找出中间值与起始值交换位置，再用起始值做pivot值，防止顺序数组与倒序数组。
  if (end > start) {
      swap(arr, start, start + Math.floor((end - start) / 2));
  }
  // j 记录pivot值最终在数组中的索引（也表示比pivot小的元素的个数）
  let pivot = arr[start], j = start;
  
  // 从start+1开始到end结束
  for (let i = start + 1; i <= end; i++) {
      // 将比pivot小的都放到pivot前面去
      if (arr[i] < pivot) {
          // 当有一个比pivot小的值就将pivot值最终索引j + 1
          if(++j === i) continue // 如果j+1 后与i相等，则直接跳过，索引相同不需要交换
          swap(arr, i, j);
      }
  }
  // 循环完了之后，索引j和j之前的元素都是比pivot小的，j就是pivot所在数组中最终的索引
  // 循环完成后交换pivot和arr[j]的位置
  swap(arr, start, j);
  return j;
}
function swap(ary, i, j) {
  let temp = ary[i];
  ary[i] = ary[j];
  ary[j] = temp;
}

mi-su-3

完成一个函数，从淘宝网获取所有图片信息返回所有url序列，之后从中截取每张图片的名称，并根据每张图片的大小排序返回并下载

青蛙跳台

function jumpFloor2(n) {
      var target = 0, number1 = 1, number2 = 2;

      if(n<=0)return 0;
      if(n == 1) return 1;
      if(n==2) return 2;
      for(var i=3;i<=n;++i) {
          target = number1 + number2;
          number1 = number2;
          number2 = target;
      }
      return target;
  }

  console.log(jumpFloor2(100)) // 输出 573147844013817200000
  console.log(jumpFloor2(1000)) // 输出 7.0330367711422765e+208
  console.log(jumpFloor2(10000)) // 输出 Infinity

JavaScript实现青蛙跳台阶问题（斐波那契数列）