算法题记录

1.给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

//法一  时间复杂度O(n^2) 空间复杂度O(n)
var twoSum = function(nums, target) {
    for(var i=0; i<nums.length; i++) {
       var need = target-nums[i];
       var needindex = nums.findIndex(function(value, index, arr) {
            return value === need && index!== i
        });
       if (needindex >-1) {
           return [i, needindex]
       }
    }
    throw new IllegalArgumentException("No two sum solution");
};
//法二 最简单直接的 两层for循环 时间复杂度O(n)，空间复杂度O(1)
var twoSum = function(nums, target) {
    for(var i=0; i<nums.length; i++) {
       for(var j=i+1; j<nums.length; j++) {
          if (nums[i] + nums[j] === target) {
            return [i, j]
          }
       }
    }
    throw new IllegalArgumentException("No two sum solution");
};

2. 找出一个字符串中最长的那个词的长度

//法一
function findLongestWords(str) {
  	let strArr = str.split(' ');
  	let maxLength = 0;
  	let maxWord = '';
  	for (let i=0; i<strArr.length; i++) {
  		if (strArr[i].length > maxLength) {
  			maxLength = strArr[i].length;
  			maxWord = strArr[i]
  		}
  	}
    return maxWord
  }
//法二
  function findLongestWords(str) {
     let strArr = str.split(' ');
     if (strArr.length === 1) return strArr[0]
     if (strArr[0].length >= strArr[1].length) {
     	strArr.splice(1, 1);
     	return findLongestWords(strArr.join(' '))
     } else {
     	return findLongestWords(strArr.slice(1).join(' '))
     }
  }
//法三 该方法只能返回最大长度 无法找出是哪个词
  function findLongestWords(str) {
	  return s.split(' ')
	    .reduce(function(x, y) {
	      return Math.max(x, y.length)
	    }, 0);
	}

3.判断一个字符串 是不是以另一个 字符串结尾

function confirmEnding(str, target) {
  return str.endsWith(target);
}
function confirmEnding(str, target) {
  return str.substring(str.length-target.length) === target;
}

4.一个函数接受至少2个数组参数，返回去重后的数组，并保留原来的顺序，数组可以是多维但只拉平一层。如：uniteUnique([1, 3, 2], [1, [5]], [2, [4]])返回[1, 3, 2, [5], [4]]

function uniteUnique(...args) {
  //法一
  let result = [];
  for (var i=0; i<args.length; i++) {
    for(var j=0; j<args[i].length; j++) {
      if (!result.includes(args[i][j])) {
        result.push(args[i][j])
      }
    }
  }
  //法二
  let result = args.reduce((arrA,arrB) => {
    return arrA.concat(arrB.filter(item => {
      return arrA.indexOf(item) === -1
    }))
  })
  //法三
  let flatArr = [].concat(...args);
  let result = [...new Set(flatArr)];
  
  return result;
}

5.把字符串中所有的 &, <, >, "(双引号), 和'(单引号) 转化成对应HTML实体，即 & =>  &​amp;   < => &​lt;  > => &​gt;  " => &​quot;  ' => &​apos; 

//法一
 function convertHTML(str) {
      var temp = str.split('');
      for (var i = 0; i < temp.length; i++) {
        switch (temp[i]) {
          case '<':
            temp[i] = '&lt;';
            break;
          case '&':
            temp[i] = '&amp;';
            break;
          case '>':
            temp[i] = '&gt;';
            break;
          case '"':
            temp[i] = '&quot;';
            break;
          case "'":
            temp[i] = "&apos;";
            break;
        }
      }
      temp = temp.join('');
      return temp;
    }
//法二
function convertHTML(str) {
    let reg = /&|<|>|"|'/g;
    let htmlEntities = {
      '&': '&amp;',
      '<': '&lt;',
      '>': '&gt;',
      '"': '&quot;',
      '\'': "&apos;"
    };
    let newStr = str.replace(reg, function (val) {
      return htmlEntities[val]
    })
}

//法三
function convertHTML(str) {
      htmlEntities={
        '&':'&amp;',
        '<':'&lt;',
        '>':'&gt;',
        '"':'&quot;',
        '\'':"&apos;"
      };
      return str.split('').map(entity => htmlEntities[entity] || entity).join('');
}

6.判断字符串是否是回文字符串（正方向和反方向值比较都是一样的），需要去除字符串中的非字母和数字字符并忽略大小写。

//法一 通过运用数组reverse方法
function palindrome(str) {
  let newStr = str.replace(/[\W_]/g, '').toLowerCase();
  return newStr === newStr.split('').reverse().join('');
}
//法二 通过两个index 一个自增 一个自减 比较字符串在两个index处是否相等 不想等返回false
function palindrome(str) {
  let newStr = str.replace(/_/g, '').replace(/\W/g, '').toLowerCase();
  let preIndex = 0;
  let backIndex = newStr.length-1;
  while (preIndex < backIndex) {
    if (newStr[preIndex] !== newStr[backIndex]) {
      return false
    } else {
      preIndex++;
      backIndex--;
    } 
  }
  return true
}
//法三  
 function palindrome(str) {
   str = str.toLowerCase().replace(/[\W_]/g, '');
   for(var i = 0, len = str.length - 1; i < len/2; i++) {
     if(str[i] !== str[len-i]) {
       return false;
     }
   }
   return true;
}

7.大数相加

function add(a ,b){
   //取两个数字的最大长度
   let maxLength = Math.max(a.length, b.length);
   //用0去补齐长度
   a = a.padStart(maxLength , 0);//"0009007199254740991"
   b = b.padStart(maxLength , 0);//"1234567899999999999"
   //定义加法过程中需要用到的变量
   let t = 0;
   let f = 0;   //"进位"
   let sum = "";
   for(let i=maxLength-1 ; i>=0 ; i--){
      t = parseInt(a[i]) + parseInt(b[i]) + f;
      f = Math.floor(t/10);
      sum = t%10 + sum;
   }
   if(f == 1){
      sum = "1" + sum;
   }
   return sum;
}