力扣练习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;
         }
    }
}