1. 回文数
判断一个整数是否是回文数。回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。
java答案:
1. 首先先转成字符串,然后匹配后面的字符是否等于前面的字符,如果不等于,直接返回false
class Solution {
public boolean isPalindrome(int x) {
if(x==0){
return true;
}
String str = ""+x;
for(int i=0;i<=str.length()/2;i++){
if(str.charAt(i)!=str.charAt(str.length()-1-i)){
return false;
}
}
System.out.println(str);
return true;
}
}
2. 直接将x反转成字符串,判断两个字符串是否相等
class Solution {
public boolean isPalindrome(int x) {
String reversedStr = (new StringBuilder(x + "")).reverse().toString();
return (x + "").equals(reversedStr);
}
}
3. 先判断x是几位数,将x首尾一块往中间走,判断是否相等
class Solution {
public boolean isPalindrome(int x) {
//边界判断
if (x < 0) return false;
int div = 1;
// 先判断x是几位
while (x / div >= 10) div *= 10;
//将前面的数和后面的数进行比较
while (x > 0) {
int left = x / div;
int right = x % 10;
if (left != right) return false;
x = (x % div) / 10;
div /= 100;
}
return true;
}
}
4. 从后面走一半,根据奇偶性,然后和前面的数比较,
class Solution {
public boolean isPalindrome(int x) {
//是负数或10的倍数,返回fasle
if (x < 0 || (x % 10 == 0 && x != 0)) return false;
int revertedNumber = 0;
//当x<=revertedNumber,说明走完一半了
while (x > revertedNumber) {
revertedNumber = revertedNumber * 10 + x % 10;
x /= 10;
}
return x == revertedNumber || x == revertedNumber / 10;
}
}
JavaScript答案:
1. 使用字符串比较,数组反转,
/**
* @param {number} x
* @return {boolean}
*/
var isPalindrome = function(x) {
if(x<0){
return false;
}
var str = x+"";
var s = str.split("").reverse().join("");
return str==s;
};
2. 先计算x是几位数,然后根据收尾往中间走,判断
var isPalindrome = function(x) {
if(x<0){
return false;
}
let div=1;
while(x/div>=10){
div=div*10;
}
while(x>0){
var left = Math.floor(x/div);
var right=x%10;
if(left!=right){
return false;
}
x=Math.floor((x%div)/10);
Math.floor(div/=100);
}
return true;
};
3.
var isPalindrome = function(x) {
if(x<0 || x%10==0 && x!=0){
return false;
}
var num = 0;
while(x>num){
num = num*10+x%10;
x=Math.floor(x/10);
}
return x==num || x==Math.floor(num/10);
};
注意:
数组转换成字符串:arr.join("");
字符串转成数组:str.split("");
数组反转:arr.reverse();
字符串是否相等: str1==str2;
2. 反转字符串中的单词III
给定一个字符串,你需要反转字符串中每个单词的字符顺序,同时仍保留空格和单词的初始顺序。
示例 1:
输入: “Let’s take LeetCode contest”
输出: “s’teL ekat edoCteeL tsetnoc”
注意:在字符串中,每个单词由单个空格分隔,并且字符串中不会有任何额外的空格。
java答案:
1. 使用StringBuffer的反转方法,然后将字符串转成数组,反转数组。
class Solution {
public String reverseWords(String s) {
if(s.length()==0 || s.equals(" ")){
return s;
}
String str = new StringBuffer(s).reverse().toString();
String[] arr = str.split(" ");
//System.out.println(str);
StringBuffer sb = new StringBuffer();
for(int i=arr.length-1;i>=0;i--){
if(i==0){
sb.append(arr[i]);
}else
sb.append(arr[i]).append(" ");
}
return sb.toString();
}
}
2. 利用数组双指针思想:
class Solution{
public static String reverseWords(String s) {
if (s == null || s.length() < 2) {
return s;
}
// 将字符串转化为数组
char[] arr = s.toCharArray();
int l = 0;
int r = 0;
//
for (int i = 0; i < arr.length; i++) {
if (arr[i] == ' ') {
while (l < r) {
char t = arr[l];
arr[l] = arr[r];
arr[r] = t;
l++;
r--;
}
l = i + 1;
r = i + 1;
} else {
r = i;
}
}
while (l < r) {
char t = arr[l];
arr[l] = arr[r];
arr[r] = t;
l++;
r--;
}
return new String(arr);
}
}
JavaScript答案:
1. 使用字符串和数组的转换的方法
/**
* @param {string} s
* @return {string}
*/
var reverseWords = function(s) {
if(s.length==0 || s==null){
return s;
}
var arr = s.split(" ");
for(var i=0;i<arr.length;i++){
arr[i] = arr[i].split("").reverse().join("");
}
var str = arr.join(" ");
return str;
};
2. 使用双指针
var reverseWords = function(s) {
if(s.length==0 || s==null){
return s;
}
var arr = s.split("");
var l=0,r=0;
for(var i=0;i<arr.length;i++){
if(arr[i]==' '){
while(l<r){
var temp = arr[r];
arr[r] =arr[l];
arr[l] = temp;
l++;
r--;
}
l=i+1;
r=i+1;
}else{
r=i;
}
}
while(l<r){
var temp = arr[r];
arr[r] =arr[l];
arr[l] = temp;
l++;
r--;
}
return arr.join("");
};
3. 反转字符串
编写一个函数,其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间,你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
示例 1:
输入:[“h”,“e”,“l”,“l”,“o”]
输出:[“o”,“l”,“l”,“e”,“h”]
示例 2:
输入:[“H”,“a”,“n”,“n”,“a”,“h”]
输出:[“h”,“a”,“n”,“n”,“a”,“H”]
java答案:
1.使用双指针,前后转换
class Solution {
public void reverseString(char[] s) {
if(s==null || s.length<2)
return ;
for(int i=0,j=s.length-1;i<j;i++,j--){
char ch = s[j];
s[j] = s[i];
s[i] =ch;
}
}
}
2. 位运算,把两个值交换的,异或相同是0,不同是1
s[i] ^= s[end];
s[end] ^= s[i];
s[i] ^= s[end];
JavaScript答案:
/**
* @param {character[]} s
* @return {void} Do not return anything, modify s in-place instead.
*/
var reverseString = function(s) {
s.reverse();
};
4. 字符串相乘
给定两个以字符串形式表示的非负整数 num1 和 num2,返回 num1 和 num2 的乘积,它们的乘积也表示为字符串形式。
示例 1:
输入: num1 = “2”, num2 = “3”
输出: “6”
示例 2:
输入: num1 = “123”, num2 = “456”
输出: “56088”
说明:
num1 和 num2 的长度小于110。
num1 和 num2 只包含数字 0-9。
num1 和 num2 均不以零开头,除非是数字 0 本身。
不能使用任何标准库的大数类型(比如 BigInteger)或直接将输入转换为整数来处理。
java答案:
1. 不能直接转成整数处理,那就按位进行计算,使用数组保存
class Solution {
public String multiply(String num1, String num2) {
if(num1.length()==0 || num2.length()==0){
return "";
}
if(num1.equals("0") || num2.equals("0")){
return "0";
}
int[] arr = new int[num1.length()+num2.length()];
for(int i=num1.length()-1;i>=0;i--){
for(int j=num2.length()-1;j>=0;j--){
int result = ((num2.charAt(j)-'0')*(num1.charAt(i)-'0'))+arr[i+j+1];
arr[i+j+1] = result%10;
arr[i+j] += result/10;
}
}
StringBuffer sb = new StringBuffer();
int index=0;
while (index<arr.length&&arr[index]==0){
index++;
}
for (int i=index;i<arr.length;i++)
sb.append(arr[i]);
return sb.toString();
}
}
2.
class Solution {
public String multiply(String num1, String num2) {
if (num1.equals("0") || num2.equals("0")) {
return "0";
}
int length1 = num1.length();
int length2 = num2.length();
StringBuilder str = new StringBuilder();
int[] arrayInt = new int[length1 + length2];
for (int i = length1 - 1; i >= 0; i--) {
for (int z = length2 - 1; z >= 0; z--) {
int number1 = num1.charAt(i) - 48;
int number2 = num2.charAt(z) - 48;
arrayInt[i + z] += number1 * number2;
if (arrayInt[i + z] >= 10 && (i + z) != 0) {
arrayInt[i + z - 1] += arrayInt[i + z] / 10;
arrayInt[i + z] = arrayInt[i + z] % 10;
}
}
}
for (int i = 0; i <= length1 + length2 - 2; i++) {
str.append(arrayInt[i]);
}
return str.toString();
}
}
JavaScript答案:
/**
* @param {string} num1
* @param {string} num2
* @return {string}
*/
var multiply = function(num1, num2) {
if(num1.length==0 || num2.length==0){
return "";
}
if(num1=="0" || num2=="0"){
return "0";
}
var arr = new Array(num1.length+num2.length).fill(0);
for(var i=num1.length-1;i>=0;i--){
for(var j=num2.length-1;j>=0;j--){
var res = ((num1[i]*num2[j])+arr[i+j+1]);
arr[i+j+1] = res%10;
arr[i+j]+=Math.floor(res/10);
}
}
for(var i=0;i<arr.length;i++){
if(arr[i]==0){
arr.splice(i,1);
i--;
}else{
break;
}
}
var str = arr.join("");
console.log(str);
return str;
};
5. 字符串转换整数
请你来实现一个 atoi 函数,使其能将字符串转换成整数。
首先,该函数会根据需要丢弃无用的开头空格字符,直到寻找到第一个非空格的字符为止。
当我们寻找到的第一个非空字符为正或者负号时,则将该符号与之后面尽可能多的连续数字组合起来,作为该整数的正负号;假如第一个非空字符是数字,则直接将其与之后连续的数字字符组合起来,形成整数。
该字符串除了有效的整数部分之后也可能会存在多余的字符,这些字符可以被忽略,它们对于函数不应该造成影响。
注意:假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时,则你的函数不需要进行转换。
在任何情况下,若函数不能进行有效的转换时,请返回 0。
说明:
假设我们的环境只能存储 32 位大小的有符号整数,那么其数值范围为 [−231, 231 − 1]。如果数值超过这个范围,请返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。
示例 1:
输入: “42”
输出: 42
示例 2:
输入: " -42"
输出: -42
解释: 第一个非空白字符为 ‘-’, 它是一个负号。
我们尽可能将负号与后面所有连续出现的数字组合起来,最后得到 -42 。
示例 3:
输入: “4193 with words”
输出: 4193
解释: 转换截止于数字 ‘3’ ,因为它的下一个字符不为数字。
示例 4:
输入: “words and 987”
输出: 0
解释: 第一个非空字符是 ‘w’, 但它不是数字或正、负号。
因此无法执行有效的转换。
示例 5:
输入: “-91283472332”
输出: -2147483648
解释: 数字 “-91283472332” 超过 32 位有符号整数范围。
因此返回 INT_MIN (−231) 。
java答案:
1. 双指针,一个查第一个是否为正负号以及整数,第二个查整数的长度
class Solution {
public int myAtoi(String str) {
int i = 0, j = 0, len = str.length();
boolean negative = false;
//第一个for循环是判断第一个非空字符是数还是正负号,以及其他字符,
for (i = 0; i < len; i++) {
if ('0' <= str.charAt(i) && str.charAt(i) <= '9') {
System.out.println("str.charAt(i)"+str.charAt(i));
break;
} else if (str.charAt(i) == '-' || str.charAt(i) == '+') {
negative = str.charAt(i) == '-'; //判断是否为负号
i++;
break;
} else if (str.charAt(i) != ' ') {
return 0;
}
}
//第二个for循环是找出数的长度
for (j = i; j < len; j++) {
System.out.println("str.charAt(j)"+str.charAt(j));
if (str.charAt(j) < '0' || '9' < str.charAt(j)) {
break;
}
}
int ret = 0;
String num = str.substring(i, j); //截取整数,不加正负号的
System.out.println("num"+num);
for (int x = 0; x < num.length(); x++) { //判断是否溢出
int cur = num.charAt(x) - '0';
if (negative) {
//这里判断溢出的情况和第7题一样
if (ret < Integer.MIN_VALUE / 10|| ret == Integer.MIN_VALUE / 10 && cur > 8) {
return Integer.MIN_VALUE;
}
ret = ret * 10 - cur;
} else {
if (ret > Integer.MAX_VALUE / 10 || ret == Integer.MAX_VALUE / 10 && cur > 7) {
return Integer.MAX_VALUE;
}
ret = ret * 10 + cur;
}
}
return ret;
}
}
2. 正则表达式
// 整体思路
// trim()函数去除收尾空格,
// 使用Java正则表达式匹配到合适的字符串。
// 未匹配到则返回0,
// 匹配到字符串后判断是否只是一个+或-,这种情况同样返回0(例如只输入+或-)。
// 以上判断都通过使用Integer.parseInt()将字符串转成数字,并根据异常判定是否溢出
// 溢出的返回值可以由字符串第一个字符是否是-来判定。
// 存在的问题
// 对于正则匹配的结果处理显得冗余,还可以优化
// 异常判定的地方可能不够准确
import java.util.regex.Pattern;
import java.util.regex.Matcher;
class Solution {
public int myAtoi(String str) {
str=str.trim();
String pattern="^[\\+\\-\\d]\\d*";//正则表达式,表示以正号或负号或数字开头,且后面是0个或多个数字
Pattern p=Pattern.compile(pattern);
Matcher m=p.matcher(str);
String res="";
if(m.find()){//能匹配到
res=str.substring(m.start(),m.end());
}else{//不能匹配到
return 0;
}
//能匹配到但只有一个+-号,也返回0
if(res.length()==1&&(res.charAt(0)=='+'||res.charAt(0)=='-')){
return 0;
}
try{
int r=Integer.parseInt(res);
return r;
}catch(Exception e){
return res.charAt(0)=='-'?Integer.MIN_VALUE:Integer.MAX_VALUE;
}
}
}
3. 使用截取字符串的形式
// 假想使用插入合格元素的方式获取合格的字符串。
// 循环遍历整个字符串,将合格的元素放到新的字符串中,如果遇到一个不合格就立马停止循环,忽略剩余元素 时间复杂度为o(n) n为字符串的长度
class Solution {
public int myAtoi(String str) {
//去除掉前后的空格
String str1 = str.trim();
//存储最终过滤出来的字符串
String str2 = null;
//字符串不为空时并且字符串不全是空白字符串时才转换
if(str1 != null && str1.isEmpty() == false){
char f = str1.charAt(0);
//判断字符串中的第一个非空格字符是不是一个有效整数字符
if(f >= '0' && f <= '9' || f == '+'|| f == '-'){
str2 = str1.substring(0,1); // 把第一位放进去(只能是数字、正负号)
//这时候循环只要数字,因为正负号只能出现在第一位
for(int i = 1; i<str1.length();i++){
if(str1.charAt(i) >= '0' && str1.charAt(i) <= '9'){
str2 = str1.substring(0,i+1);
}
//这是遇到不符合要求的字符,直接忽略剩余元素
else{break;}
}
}
}
//判断最终字符串是否为空或则只有一个正负号
if(str2 == null || str2.equals("+") || str2.equals("-"))
//此时str2是String对象,如果使用==比较则比较的时内存地址
return 0;
//最终转换成的数字
int num = 0;
//使用异常机制打印结果
try{
num = Integer.parseInt(str2);
}catch (Exception e){
if(str2.charAt(0) == '-')
return Integer.MIN_VALUE;
return Integer.MAX_VALUE;
}
return num;
}
}
注意:
- 判断数字是否溢出的方法:一个是for循环比较:
if(是负数){
if (ret < Integer.MIN_VALUE / 10|| ret == Integer.MIN_VALUE / 10 && cur > 8) {
return Integer.MIN_VALUE;
}
ret = ret * 10 - cur;
} else {
if (ret > Integer.MAX_VALUE / 10 || ret == Integer.MAX_VALUE / 10 && cur > 7) {
return Integer.MAX_VALUE;
}
ret = ret * 10 + cur;
}
一个是异常处理
try{
int r=Integer.parseInt(res);
return r;
}catch(Exception e){
return res.charAt(0)==’-’?Integer.MIN_VALUE:Integer.MAX_VALUE;
} - str.trim(); //去电字符串前后的空格
str.isEmpty() //判断字符串是空字符串 - 正则表达式:
^ 定义了以什么开始
\d+ 匹配一个或多个数字
? 设置括号内的选项是可选的
. 匹配 “.”
String pattern="1\d*";//正则表达式,表示以正号或负号或数字开头,且后面是0个或多个数字
Pattern p=Pattern.compile(pattern); //创建Pattern对象
Matcher m=p.matcher(str);//创建matcher对象
while(m.find()) { //尝试查找与该模式匹配的输入序列的下一个子序列。
count++;
System.out.println("Match number "+count);
System.out.println("start(): "+m.start()); //返回以前匹配的初始索引。
System.out.println("end(): "+m.end());//返回最后匹配字符之后的偏移量。
}
JavaScript答案:
1.
/**
* @param {string} str
* @return {number}
*/
var myAtoi = function(str) {
var s= str.trim();
if(s==""){
return 0;
}
var i=0,j=0,len=s.length;
var flag = false;
for(i=0;i<len;i++){
if(s.charAt(i)>='0' && s.charAt(i)<='9'){
break;
}else if(s.charAt(i)=='-' || s.charAt(i)=='+'){
flag = s.charAt(i)=='-';
i++;
break;
}else if(s.charAt(i)!=' '){
return 0;
}
}
for(j=i;j<len;j++){
if(s.charAt(i)<'0' || s.charAt(i)>'9'){
break;
}
}
var string = s.substring(0,j);
if(string.length==1 && (s.charAt(0)=='-' || s.charAt(0)=='+')){
return 0;
}
if(flag==true && parseInt(string)< -Math.pow(2,31)){
return -Math.pow(2,31);
}else if(flag==false && parseInt(string)> Math.pow(2,31)-1){
return Math.pow(2,31)-1;
}else{
return parseInt(string);
}
};
2. 从第一个数开始找的
var myAtoi = function(str) {
var s= str.trim();
var str1 = null;
if(s.length!=0 && s!=""){
var zero = s.charAt(0);
if(zero>='0' && zero<='9' || zero=='-' || zero=='+'){
str1=s.substring(0,1);
for(var i=1;i<s.length;i++){
if(s.charAt(i)>='0' && s.charAt(i)<='9'){
str1 = s.substring(0,i+1);
}else{
break;
}
}
}
}
console.log(str1);
if(str1==null || str1=="-" || str1=="+"){
return 0;
}
if(str1.charAt(0)=='-' && parseInt(str1)< -Math.pow(2,31)){
return -Math.pow(2,31);
}else if(str1.charAt(0)!='-' && parseInt(str1)> Math.pow(2,31)-1){
return Math.pow(2,31)-1;
}else{
return parseInt(str1);
}
};
3. 使用parseInt方法,
var myAtoi = function(str) {
let m = parseInt(str);
if (m <= Math.pow(-2, 31)) {
return Math.pow(-2, 31)
}
if (m >= Math.pow(2, 31) - 1) {
return Math.pow(2, 31) - 1
}
return !parseInt(str) ? 0 : parseInt(str)
};
4. 使用Number.isNaN()方法
var myAtoi = function(str) {
// 替换掉e,防止parseFloat将 “12e16” 认成科学计数法
str = str.trim().replace(/e/g, 'a');
let num = parseFloat(str);
num = Number.isNaN(num) ? 0 : num;
const edge = Math.pow(2, 31);
return Math.max(-edge, Math.min(edge - 1, num));
};
注意:
- parseInt()和parseFloat ()方法传入的参数,如果字符串的第一个字符不能被转换为数字,那么 parseFloat() 和parseInt()会返回 NaN。
- NaN与任何的判断都是false.
- 可以通过调用 isNaN 函数来判断 parseFloat 的返回结果是否是 NaN。如果让 NaN 作为了任意数学运算的操作数,则运算结果必定也是 NaN。
isNaN() 函数可用于判断其参数是否是 NaN,该值表示一个非法的数字.
\+\-\d ↩︎