1、 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
var twoSum = function(nums, target) {
let number = [];
var set = new Set();
for(let j = 0; j < nums.length-1; j++){
for(let i = 1; i <= nums.length; i++){
if(nums[i] + nums[j] === target){
set.add(j);
set.add(i);
}
}
}
for(let x of set){
number.push(x)
}
return number
}
2、回文数字
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
var isPalindrome = function(x) {
if(x < 0){
return false;
}
let y = x;
let n = 0;
let m = 0;
while(y != 0){
n = y % 10;
m = m*10 + n;
y = Math.floor( y / 10);
}
return m == x;
};
3、 柠檬水找零
在柠檬水摊上，每一杯柠檬水的售价为 5 美元。
顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。
每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。
注意，一开始你手头没有任何零钱。
如果你能给每位顾客正确找零，返回 true ，否则返回 false 。
提示：
- 0 <= bills.length <= 10000
- bills[i] 不是 5 就是 10 或是 20
/**
* 已知题意：每杯柠檬水是 5 刀，且每人只能买一杯。
* @param {number[]} bills
* @return {boolean}
*/
var lemonadeChange = function (bills) {
let five = 0, ten = 0;
for(let i of bills){
if (i === 5) five++; //如果直接付款5，直接入账
else if (i === 10) {five--; ten++;}//付款10，入10，出5
else if (ten > 0 && five > 0) {ten--; five--;} // 如果有10和5，则出账
else five -= 3;
if (five < 0) return false;
}
return true;
}
4、整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。
请根据这个假设，如果反转后整数溢出那么就返回 0。
/*
* @param {number} x
* @return {number}
*/
var reverse = function (x) {
let str = '';
if (x < 0) {
str = '-'
x = -x;
}
let n = 0;
while (x != 0) {
n = n * 10 + x % 10;
x = Math.floor(x / 10);
}
n = str + n;
if (n >= (Math.pow(2, 31) - 1) || n <= -Math.pow(2, 31)) return 0;
return n;
};
5、 罗马数字转整数
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。
/*
* @param {string} s
* @return {number}
*/
var romanToInt = function (s) {
let romeLable = new Map([["I", 1],
["V", 5],
["X", 10],
["L", 50],
["C", 100],
["D", 500],
["M", 1000]]);
let number = 0;
let numbers = [];
for (let i = 0; i <= s.length-1; i++) {
if (romeLable.get(s[i]) >= romeLable.get(s[i + 1])) {
numbers.push(romeLable.get(s[i]))
}
if (romeLable.get(s[i]) < romeLable.get(s[i + 1])) {
numbers.push(-romeLable.get(s[i]))
}
}
numbers.push(romeLable.get(s[s.length-1]))
numbers.forEach(element => {
number += element;
})
return number;
};
6、最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。
示例 1:
输入: [“flower”,“flow”,“flight”]
输出: “fl”
示例 2:
输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。
说明:
所有输入只包含小写字母 a-z 。
/* 方法一
* @param {string[]} strs
* @return {string}
*/
var longestCommonPrefix = function (strs) {
let s = "";
let result = "";
let flag = false;
let j = 1;
for (let i = 0; i < strs[0].length; i++) {
s = strs[0].slice(0, j);
for (let n = 1; n < strs.length; n++) {
if (s === strs[n].slice(0, j)) {
if (n === strs.length - 1) {
result = strs[n].slice(0, j);
}
} else {
flag = true;
break;
}
}
if (flag) {
break;
}
j += 1;
}
return result;
};
/**
* 方法二
* @param {*} strs
*/
var longestCommonPrefix = function (strs) {
let arr = [];
let result = "";
for (let i = 0; i < strs.length; i++) {
arr.push(strs[i].length)
}
arr.sort((a, b) => a - b); // 进行排序从小到大-找出最小长度
for (let j = 0; j < arr[0]; j++) { //公共前缀小于等于最小长度
let s = strs[0][j]; // 取出第一个的每个字符
if (strs.every(val => val[j] === s)) { // 判断数组的每一项中的位置j的字符是否与取出进行比较的字符相等
result += s; //相等便记录下来
} else {
break; // 直到找到出现不同的地方
}
}
return result;
}
7、 有效括号
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’
的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
/*
* @param {string} s
* @return {boolean}
*/
var isValid = function (s) {
let valid = []
//前提是s 的长度为偶数 或 0
if (s.length % 2 === 0 || s.length === 0) {
let length = s.length;
for (let i = 0; i < length; i++) {
if (s[i] === '(') valid.push(')');
else if (s[i] === '[') valid.push(']');
else if (s[i] === '{') valid.push('}');
else {
if (s[i] === '' || s[i] !== valid.pop()) {
return false;
};
}
}
if (valid[0] !== undefined) return false;
return true;
} else {
return false;
}
};
8、移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
/**
* @param {number[]} nums
* @param {number} val
* @return {number}
*/
var removeElement = function (nums, val) {
let length = nums.length;
for (let i = 0; i < length; i++) {
if (nums.indexOf(val) !== -1) {
nums.splice(nums.indexOf(val), 1);
}
}
return nums.length;
};
9、外观数列
给定一个正整数 n ，输出外观数列的第 n 项。
「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。
你可以将其视作是由递归公式定义的数字字符串序列：
countAndSay(1) = “1”
countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。
前五项如下：
-
1 -
11 -
21 -
1211 -
111221
第一项是数字 1
描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 “11”
描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 “21”
描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 “1211”
描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 “111221”
要 描述 一个数字字符串，首先要将字符串分割为 最小 数量的组，每个组都由连续的最多 相同字符 组成。然后对于每个组，先描述字符的数量，然后描述字符，形成一个描述组。要将描述转换为数字字符串，先将每组中的字符数量用数字替换，再将所有描述组连接起来。
/*
* @param {number} n
* @return {string}
*/
var countAndSay = function (m) {
let s = '1';
for(let i = 0; i < m-1; i++){
s = say(s)
}
return s
};
var say = function(s) {
let str = s;
let ss = ''
let n = -1;
for (let i = 0; i < str.length; i++) {
let item = str[i];
let count = 0;
for (let j = n + 1; j < str.length; j++) {
if (str[j] === item) {
if (j === str.length - 1) {
n = str.length - 1
}
count += 1; // 获得个数
} else {
n = j - 1;
break;
}
}
j = n; // 获得停止处的位置
i = n;
ss += (count + item);
}
return ss;
}
10、 删除排序数组中的重复项
给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
/*
* @param {number[]} nums
* @return {number}
*/
var removeDuplicates = function (nums) {
let length = nums.length;
let s = new Set(nums) //去重
for(let j = 0; j<length; j++){ // 清空nums
nums.pop()
}
for (let i of s) { // 重新赋值
nums.push(i)
}
return s.size; //返回长度
};