js逻辑例题

1. 输入两个字符串，从第一个字符串中删除第二个字符串中的所有字符串（不可以使用replace）。例如：输入“This is an apple”和“sa” 则删除之后的第一个字符串变成 “Thi i n pple”

console.time()
var shanchu="sa";
var yuan="This is an apple";
var arr=yuan.split("");
for(var index in shanchu){
    var s=shanchu.charAt(index);
    for(var key in arr) {
        if (arr[key] === s) {
            arr.splice(key, 1);
        }
    }
}
console.log(arr.join(""));
console.timeEnd();

2. 给一个有序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，输出移除后数组的新长度。
   不要额外创建数组空间，你必须在原数组修改完成。

示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。

示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4], 函数应该返回新的长度 5, 并且原数组 nums
的前五个元素被修改为 0, 1, 2, 3, 4。 你不需要考虑数组中超出新长度后面的元素。

function removeRepeted(arr){
        if(arr == null && arr.length == 0){
            return 0;
        };
        /**size:用来统计数组中没有重复的元素个数*/
        var size = 0;
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] != arr[size]){
                /**修改数组中的值*/
                arr[++size] = arr[i];
				
            }
        };
        /**返回没有重复的个数*/
       return size+1;
};
removeRepeted([1,2,2,3])

3. 打印出 1 - 10000 之间的所有对称数 例如：121、1331 等

planA：

[...Array(10000).keys()].filter((x) => { 
  return x.toString().length > 1 && x === Number(x.toString().split('').reverse().join('')) 
})

plan B：

let result = [];
for (let i = 1; i <= 10000; i++) {
    let reverse = Number(i.toString().split('').reverse().join(''));
    if (i === reverse) {
        result.push(i);
    }
}

4.给定两个数组，写一个方法来计算它们的交集。
例如：给定 nums1 = [1, 2, 2, 1]，nums2 = [2, 2]，返回 [2, 2]。

function union (arr1, arr2) {
  return arr1.filter(item => {
  	return arr2.indexOf(item) > - 1;
  })
}
 const a = [1, 2, 2, 1];
 const b = [2, 3, 2];
 console.log(union(a, b)); // [2, 2]

5. 算法题「移动零」，给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
   示例:

输入: [0,1,0,3,12] 输出: [1,3,12,0,0]

说明:
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。

function zeroMove(array) {
        let len = array.length;
        let j = 0;
        for(let i=0;i<len-j;i++){
            if(array[i]===0){
                array.push(0);
                array.splice(i,1);
                i --;
                j ++;
            }
        }
        return array;
    }

6. 一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

Answer:
function jumpFloorII(number){
    if(number < 3){
        return number;
    }
    return 2 * jumpFloorII(number - 1);
}

7. 给定两个大小为 m 和 n 的有序数组 nums1 和 nums2, 请你找出这两个有序数组的中位数。你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

	nums1 = [1, 3]
	nums2 = [2]
	
	则中位数是 2.0

示例 2:

	nums1 = [1, 2]
	nums2 = [3, 4]
	
	则中位数是 (2 + 3)/2 = 2.5

var findMedianSortedArrays = function(nums1, nums2) {
    const arr = [...nums1, ...nums2].sort((a, b) => a - b);
    const { length } = arr;
    return length % 2 ? arr[Math.floor(length / 2)] : (arr[length / 2] + arr[length / 2 - 1]) / 2;
};

8. 给出一个32位的有符号整数，你需要将这个整数中每位上的数字进行反转。
   示例1：输入：123；输出：321
   示例2：输入：-123；输出：-321
   示例1：输入：120；输出：21
   注意：
   假设我们的环境只能存储得下32位的有符号整数，则其数值范围位[-2(↑31),2(↑31)-1]. 请根据这个假设，如果反转后整数溢出，那么就返回0.

var reverse = function(x) {
  let arrX = x.toString().split(''),pre='',temp,reverseX;
  if(arrX[0] === '-'){//负数处理
    pre = '-';
    arr.shift();
  };
  for(let i = 0, leng = arrX.length; i < leng/2; i++){
    temp = arrX[i];
    arrX[i] = arrX[leng - 1 - i];
    arrX[leng - 1 - i] = temp;
  }
  reverseX = parseInt(pre + arrX.join(''));
  if(reverseX > (Math.pow(2,31)-1) || reverseX < (Math.pow(-2,31)+1)){
    return 0
  }else{
    return reverseX
  }
};
reverse(89)

9.下面代码中 a 在什么情况下会打印 1？

//题目：
var a = ?;
if(a == 1 && a == 2 && a == 3){
 			conso.log(1);
}

//方案1：
var a = {
  i: 1,
  toString() {
    return a.i++;
  }
}

if( a == 1 && a == 2 && a == 3 ) {
  console.log(1);
}

//方法2
let a = [1,2,3];
a.toString = a.shift;
if( a == 1 && a == 2 && a == 3 ) {
console.log(1);
}

//方法3
var a = {num:0};
a.valueOf = function(){
  return ++a.num
}
if(a == 1 && a == 2 && a == 3){
  console.log(1);
}

//方法4：
var a = console.log(1);
if(a == 1 && a == 2 && a == 3){
 	console.log(1);
}