力扣练习1（十题）
Posted 冷血～多好
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了力扣练习1（十题）相关的知识，希望对你有一定的参考价值。
1.给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：输入：nums = [3,3], target = 6
输出：[0,1]
class Solution
public int[] twoSum(int[] nums, int target)
int [] result=new int[2];
for(int i=0;i<=nums.length;i++)
for(int j=i+1;j<=nums.length-1;j++)
int sum=nums[j]+nums[i];
if(sum==target)
result[0]=i;
result[1]=j;
return result;
2.给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。
示例 1：
输入：x = 123
输出：321
示例 2：输入：x = -123
输出：-321
示例 3：输入：x = 120
输出：21
示例 4：输入：x = 0
输出：0
提示：
-231 <= x <= 231 - 1
public static int reverse(int x)
try
boolean b = true;
if (x < 0)
x = x * (-1);
b = false;
String num = String.valueOf(x);
String num2 = "";
for (int i = num.length() - 1; i >= 0; i--)
if (num.charAt(i) != 'a')
num2 += num.charAt(i);
if (b)
return Integer.parseInt(num2);
else
return -Integer.parseInt(num2);
catch (Exception e)
return 0;
3.你和你的朋友，两个人一起玩 Nim 游戏：
桌子上有一堆石头。
你们轮流进行自己的回合，你作为先手。
每一回合，轮到的人拿掉 1 - 3 块石头。
拿掉最后一块石头的人就是获胜者。
假设你们每一步都是最优解。请编写一个函数，来判断你是否可以在给定石头数量为 n 的情况下赢得游戏。如果可以赢，返回 true；否则，返回 false 。
示例 1：
输入：n = 4
输出：false
解释：如果堆中有 4 块石头，那么你永远不会赢得比赛；
因为无论你拿走 1 块、2 块 还是 3 块石头，最后一块石头总是会被你的朋友拿走。
示例 2：输入：n = 1
输出：true
示例 3：输入：n = 2
输出：true
提示：
1 <= n <= 231 - 1
public boolean canWinNim(int n)
try
if(1<=n&&n<=3)
return true;
else
if(n%4==0)
return false;
return true;
catch (Exception e)
return false;
4.回文数
给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。
示例 1：
输入：x = 121
输出：true
示例 2：输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3：输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。
示例 4：输入：x = -101
输出：false提示：
-231 <= x <= 231 - 1
class Solution
public boolean isPalindrome(int x)
try
if (x < 0)
return false;
else
String num = String.valueOf(x);
String num2 = "";
for (int i = num.length() - 1; i >= 0; i--)
if (num.charAt(i) != 'a')
num2 += num.charAt(i);
if (Integer.parseInt(num2) == x)
return true;
return false;
catch (Exception e)
return false;
5.两数相加
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
提示：
每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零
/**
* Definition for singly-linked list.
* public class ListNode
* int val;
* ListNode next;
* ListNode()
* ListNode(int val) this.val = val;
* ListNode(int val, ListNode next) this.val = val; this.next = next;
*
*/
class Solution
public ListNode addTwoNumbers(ListNode l1, ListNode l2)
List<Integer> listNodes1=new ArrayList<>();
while (true)
listNodes1.add(l1.val);
if (l1.next==null)
break;
l1=l1.next;
List<Integer> listNodes2=new ArrayList<>();
while (true)
listNodes2.add(l2.val);
if (l2.next==null)
break;
l2=l2.next;
String num1="";
String num2="";
int num=0;
int redis=0;
int redis2=0;
SingleLinkedList singleLinkedList=new SingleLinkedList();
ListNode listNode=null;
ListNode listNode2=null;
List<Integer> maxList=new ArrayList<>();
int max=0;
int min=0;
// System.out.println("listNodes1.size()="+listNodes1.size());
//System.out.println("listNodes2.size()="+listNodes2.size());
if(listNodes1.size()>listNodes2.size())
max=listNodes1.size();
min=listNodes2.size();
maxList= listNodes1;
else
max=listNodes2.size();
min=listNodes1.size();
maxList= listNodes2;
System.out.println("max="+max);
System.out.println("min="+min);
for (int i=0;i<max;i++)
if(i<min)
num=listNodes2.get(i)+listNodes1.get(i)+redis2;
if (num>10)
redis=num%10;
redis2=1;
listNode2=new ListNode(redis);
else if (num==10)
redis=0;
redis2=1;
listNode2=new ListNode(redis);
else
listNode2=new ListNode(num);
redis2=0;
listNode=singleLinkedList.add(listNode2);
if(i>=min)
num=maxList.get(i)+redis2;
if (num>10)
redis=num%10;
redis2=1;
listNode2=new ListNode(redis);
else if (num==10)
redis=0;
redis2=1;
// System.out.println("000");
listNode2=new ListNode(redis);
else
listNode2=new ListNode(num);
redis2=0;
listNode=singleLinkedList.add(listNode2);
if(redis2>0)
listNode2=new ListNode(redis2);
listNode=singleLinkedList.add(listNode2);
return listNode;
class SingleLinkedList
//先初始化一个头节点，头节点不用动
ListNode head = new ListNode(0);
public ListNode add(ListNode listNode)
ListNode temp=head;
//遍历链表，找到最后
while (true)
//找到链表最后
if(temp.next==null)
break;
//如果没有找到最后，将temp后移
temp=temp.next;
//当退出while循环时，temp就指向了链表的最后
//将最后节点的next，指向新的节点
temp.next=listNode;
return head.next;
6. 罗马数字转整数
罗马数字包含以下七种字符: 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 的范围内
示例 1:
输入: "III"
输出: 3
示例 2:输入: "IV"
输出: 4
示例 3:输入: "IX"
输出: 9
示例 4:输入: "LVIII"
输出: 58
解释: L = 50, V= 5, III = 3.
示例 5:输入: "MCMXCIV"
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.提示：
1 <= s.length <= 15
s 仅含字符 ('I', 'V', 'X', 'L', 'C', 'D', 'M')
题目数据保证 s 是一个有效的罗马数字，且表示整数在范围 [1, 3999] 内
题目所给测试用例皆符合罗马数字书写规则，不会出现跨位等情况。
IL 和 IM 这样的例子并不符合题目要求，49 应该写作 XLIX，999 应该写作 CMXCIX 。
关于罗马数字的详尽书写规则，可以参考 罗马数字 - Mathematics 。
通过次数463,234提交次数732,562
class Solution
public int romanToInt(String s)
int values[] =1,4,5,9,10,40,50,90,100,400,500,900,1000;
String roman[]="I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M";
int Roman=0;
for(int i=0;i<s.length();i++)
for(int j=12;j>=0;j--)
if (i + 1 < s.length() && (String.valueOf(s.charAt(i)) + String.valueOf(s.charAt(i+1))).equals(roman[j]))
Roman+=values[j];
i++;
break;
else
if (String.valueOf(s.charAt(i)).equals(roman[j]))
Roman += values[j];
return Roman;
7. 整数转罗马数字
罗马数字包含以下七种字符： 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:
输入: num = 3
输出: "III"
示例 2:输入: num = 4
输出: "IV"
示例 3:输入: num = 9
输出: "IX"
示例 4:输入: num = 58
输出: "LVIII"
解释: L = 50, V = 5, III = 3.
示例 5:输入: num = 1994
输出: "MCMXCIV"
解释: M = 1000, CM = 900, XC = 90, IV = 4.
提示：
1 <= num <= 3999
class Solution
public String intToRoman(int num)
int values[] =1,4,5,9,10,40,50,90,100,400,500,900,1000;
String roman[]="I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M";
int i=12;
String Roman="";
while (num>0)
if(num>=values[i])
num=num-values[i];
Roman+=roman[i];
else
i--;
return Roman;
8. 有效的括号
给定一个只包括 '('，')'，''，''，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
示例 1：
输入：s = "()"
输出：true
示例 2：输入：s = "()[]"
输出：true
示例 3：输入：s = "(]"
输出：false
示例 4：输入：s = "([)]"
输出：false
示例 5：输入：s = "[]"
输出：true
提示：
1 <= s.length <= 104
s 仅由括号 '()[]' 组成
class Solution
public boolean isValid(String s)
int length = s.length() / 2;
for (int i = 0; i < length; i++)
s = s.replace("()", "").replace("", "").replace("[]", "");
System.out.println(s);
return s.length() == 0;
9. 最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
示例 1：
输入：strs = ["flower","flow","flight"]
输出："fl"
示例 2：输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。
提示：
1 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] 仅由小写英文字母组成
class Solution
public String longestCommonPrefix(String[] strs)
String s="";
String s2="";
int num[]=new int[strs.length];
for(int i=0;i<strs.length;i++)
num[i]=strs[i].length();
for (int gap = num.length / 2; gap > 0; gap /= 2)
// 从第gap个元素，逐个对其所在的组进行直接插入排序
for (int i = gap; i < num.length ; i++)
int j = i;
int temp = num[j];
if (num[j] < num[j - gap])
while (j - gap >= 0 && temp < num[j - gap])
//移动
num[j] = num[j-gap];
j -= gap;
//当退出while后，就给temp找到插入的位置
num[j] = temp;
boolean b=false;
int sum=0;
String snum="";
if(strs.length>1)
for (int k = 0; k < num[0]; k++)
for (int p = 1; p < strs.length; p++)
if (String.valueOf(strs[0].charAt(k)).equals(String.valueOf(strs[p].charAt(k))))
b = true;
sum++;
else
b = false;
sum--;
break;
if (k == 0)
if (!b)
return "";
if(k>0)
if (!b)
break;
if (b)
snum += String.valueOf(strs[0].charAt(k));
else
snum=strs[0];
return snum;
10. 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 2：
输入：l1 = [], l2 = []
输出：[]
示例 3：输入：l1 = [], l2 = [0]
输出：[0]
提示：
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列
/**
* Definition for singly-linked list.
* public class ListNode
* int val;
* ListNode next;
* ListNode()
* ListNode(int val) this.val = val;
* ListNode(int val, ListNode next) this.val = val; this.next = next;
*
*/
class Solution
public ListNode mergeTwoLists(ListNode l1, ListNode l2)
if(l1!=null||l2!=null)
List<Integer> list = new ArrayList<>();
while (true)
if (l1 != null)
list.add(l1.val);
if (l1.next == null)
break;
l1 = l1.next;
else
break;
while (true)
if (l2 != null)
list.add(l2.val);
if (l2.next == null)
break;
l2 = l2.next;
else
break;
int temp = 0;
for (int i = 0; i < list.size() - 1; i++)
for (int j = 0; j < list.size() - 1 - i; j++)
// 如果前面的数比后面的数大，则交换
if (list.get(j) < list.get(j + 1))
temp = list.get(j);
list.set(j, list.get(j + 1));
list.set(j + 1, temp);
// list.forEach(System.out::println);
ListNode listNode[] = new ListNode[list.size()];
if (list != null)
for (int i = 0; i < list.size(); i++)
if (i == 0)
listNode[i] = new ListNode(list.get(i));
else
listNode[i] = new ListNode(list.get(i), listNode[i - 1]);
return listNode[list.size() - 1];
else
return null;
以上是关于力扣练习1（十题）的主要内容，如果未能解决你的问题，请参考以下文章