Leetcode 1、7、9：JavaScript版两数之和、反转整数、判断回文数

【简单】
1.两数之和

/**
 * 
 * @param {*} nums 数组
 * @param {*} target 目标值
 * @desc 给定一个整数数组和一个目标值，找出数组中和为目标值的 两个 数。
         你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
         示例:
            给定 nums = [2, 7, 11, 15], target = 9
            因为 nums[0] + nums[1] = 2 + 7 = 9
            所以返回 [0, 1]
 */

// 注意元素不能被重复利用：
 var twoSum = function(nums, target) {
  var a = []
  for (var i = 0, len = nums.length; i < len; i++) {
    var tmp = target - nums[i] 
    if (a[tmp] !== undefined) {
      return [a[tmp], i]
    }
    a[nums[i]] = i 
  }
}

console.log(twoSum([5, 7, 4, 6, 8, 6, 6, 6, 3, 9], 10))





//如果元素可以被重复利用
var twoSum = function(nums, target) {
  var firstNum
  for (var i = 0, len = nums.length; i < len; i++) {
    firstNum = target - nums[i]
    if (nums.indexOf(firstNum) > -1) {
      return [i, nums.indexOf(firstNum)]
    }
  }
}

let twoSum = (nums, target) => {
  let firstNum, index1
  for (let i = 0, len = nums.length; i < len; i++) {
    firstNum = target - nums[i]
    nums.filter((item, index) => {
      if (item === firstNum) {
        if (!index1) {
          index1 = index
        }
        return index
      }
    })
    return [i, index1]
  }
}

let twoSum = (nums, target) => {
  let firstNum, index1, index2

  nums.filter((item, index) => {
    firstNum = target - item

    if (nums.indexOf(firstNum) > -1) {
      index1 = index
      index2 = nums.indexOf(firstNum)
    }
  })
  return [index1, index2]
}

2.反转整数

/**
 * 
 *  @param {*} nums
 *  @desc  给定一个 32 位有符号整数，将整数中的数字进行反转。
            示例 1:
	            输入: 123
	            输出: 321
            示例 2:
	            输入: -123
	            输出: -321
            示例 3:
	            输入: 120
	            输出: 21
            注意:
            假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−2^31 ,  2^31 − 1]。
            根据这个假设，如果反转后的整数溢出，则返回 0。
 */
// 一 
var reverse = function(number) {
  var minn = -(1 << 30) * 2      //num <= Math.pow(-2,31) || num >= Math.pow(2,31) - 1
  var maxn = (1 << 30) * 2 - 1
  var le = String(number)
  var num = ''
  for (var i = le.length - 1; i >= 0; i--) {
    if (le[i] !== '-') {
      le[i] !== '0' ? (num += le[i]) : num
    } else {
      num = le[i] + num
    }
  }
  if (+num < minn || +num > maxn) {
    return 0
  } else {
    return num
  }
}
// 二
var reverse = function(x) {
  var minn = -(1 << 30) * 2
  var maxn = (1 << 30) * 2 - 1   //num <= Math.pow(-2,31) || num >= Math.pow(2,31) - 1
  var ans
  var arr = x.toString().split('')
  if (x < 0) {
    arr.shift() // remove '-'
    ans = Number(arr.reverse().join(''))
  }

  if (x < 0) {
    ans *= -1
  }
  console.log(minn, maxn)
  if (ans < minn || ans > maxn) {
    return 0
  } else return ans
}

3.判断回文数
可以用上面反转整数的方法先将数字反转再判断。

/**判断回文数:判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true

示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。 */
let num = 123454321;
 // 三
function isWen(num) {
  let Num = num
    .toString()
    .split("")
    .reverse()
    .join("");
  if (Num > 2 ** 31 - 1) return 0;
  return Number(Num) === num;
}
console.log(isWen(num));

// 
不将整数转为字符串 
function isPalindrome2(num) {
  if (num < 0) return false;
  if (num < 10) return true;
  if (num % 10 === 0) return false;
  if (num > Math.pow(2, 31) - 1) return 0;
  let rev = 0;
  while (num > rev) {
    rev = 10 * rev + (num % 10);
    num = Math.trunc(num / 10);
  }
  return rev === num || Math.trunc(rev / 10) === num;
}