力扣练习4（十题）

1.（412） Fizz Buzz

给你一个整数 n ，找出从 1 到 n 各个整数的 Fizz Buzz 表示，并用字符串数组 answer（下标从 1 开始）返回结果，其中：

answer[i] == "FizzBuzz" 如果 i 同时是 3 和 5 的倍数。
answer[i] == "Fizz" 如果 i 是 3 的倍数。
answer[i] == "Buzz" 如果 i 是 5 的倍数。
answer[i] == i 如果上述条件全不满足。

例 1：

输入：n = 3
输出：["1","2","Fizz"]
示例 2：

输入：n = 5
输出：["1","2","Fizz","4","Buzz"]
示例 3：

输入：n = 15
输出：["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]
 

提示：

1 <= n <= 104

class Solution {
    public List<String> fizzBuzz(int n) {


   List<String> list=new ArrayList<>();
        for(int i=1;i<=n;i++){
            if(i%3==0&&i%5==0){
                list.add("FizzBuzz");
            }
            else if(i%3==0){
                list.add("Fizz");
            }
            else if(i%5==0){
                list.add("Buzz");
            }
            else {
             list.add(String.valueOf(i));
            }
        }


        return list;

    }
}

2. 剑指 Offer II 069. 山峰数组的顶部

符合下列属性的数组 arr 称为 山峰数组（山脉数组） ：

arr.length >= 3
存在 i（0 < i < arr.length - 1）使得：
arr[0] < arr[1] < ... arr[i-1] < arr[i]
arr[i] > arr[i+1] > ... > arr[arr.length - 1]
给定由整数组成的山峰数组 arr ，返回任何满足 arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1] 的下标 i ，即山峰顶部。

示例 1：

输入：arr = [0,1,0]
输出：1
示例 2：

输入：arr = [1,3,5,4,2]
输出：2
示例 3：

输入：arr = [0,10,5,2]
输出：1
示例 4：

输入：arr = [3,4,5,1]
输出：2
示例 5：

输入：arr = [24,69,100,99,79,78,67,36,26,19]
输出：2
 

提示：

3 <= arr.length <= 104
0 <= arr[i] <= 106
题目数据保证 arr 是一个山脉数组

class Solution {
    public int peakIndexInMountainArray(int[] arr) {
        int n=0;
     int n2=0;
        for(int i=1;i<arr.length;i++){
            if(n<=arr[i]){
                n2=i;   
                n=arr[i];                      
                 }
                 else{
                     break;
                 }
        }
        return n2;

    }
}

3.（17） 电话号码的字母组合

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
示例 2：

输入：digits = ""
输出：[]
示例 3：

输入：digits = "2"
输出：["a","b","c"]
 

提示：

0 <= digits.length <= 4
digits[i] 是范围 ['2', '9'] 的一个数字。

class Solution {

    public List<String> letterCombinations(String digits) {


            List<List<String>> lists=new ArrayList<>();
            List<String> list=new ArrayList<>();
            list.add("a");list.add("b");list.add("c");lists.add(list);list= new ArrayList<>();
            list.add("a");list.add("b");list.add("c");lists.add(list);list= new ArrayList<>();
            list.add("a");list.add("b");list.add("c");lists.add(list);list= new ArrayList<>();
            list.add("d");list.add("e");list.add("f");lists.add(list);list= new ArrayList<>();
            list.add("g");list.add("h");list.add("i");lists.add(list);list= new ArrayList<>();
            list.add("j");list.add("k");list.add("l");lists.add(list);list= new ArrayList<>();
            list.add("m");list.add("n");list.add("o");lists.add(list);list= new ArrayList<>();
            list.add("p");list.add("q");list.add("r");list.add("s");lists.add(list);list= new ArrayList<>();
            list.add("t");list.add("u");list.add("v");lists.add(list);list= new ArrayList<>();
            list.add("w");list.add("x");list.add("y");list.add("z");lists.add(list);
//        for(int i=0;i<lists.size();i++){
//            list= lists.get(i);
//            for(int j=0;j<list.size();j++){
//                System.out.println(list.get(j));
//            }
//        }
        List<String> list0=new ArrayList<>();

      if(digits.length()>0&&digits.length()<=1){

          list=lists.get(Integer.parseInt(String.valueOf(digits.charAt(0))));
          for(int i=0;i<list.size();i++){
              list0.add(list.get(i));
          }


      }
      else if(digits.length()>1&&digits.length()<=2){
         
          list=lists.get(Integer.parseInt(String.valueOf(digits.charAt(0))));
          for(int i=0;i<list.size();i++){
          String  s=list.get(i);
            List<String>  list2=lists.get(Integer.parseInt(String.valueOf(digits.charAt(1))));
            for(int j=0;j<list2.size();j++){
               list0.add(s+list2.get(j));
//["ad","ae","af","bd","be","bf","cd","ce","cf"]
            }
          
          }


      }
      else if(digits.length()>2&&digits.length()<=3){

          list=lists.get(Integer.parseInt(String.valueOf(digits.charAt(0))));
          for(int i=0;i<list.size();i++){
              String  s=list.get(i);
              List<String>  list2=lists.get(Integer.parseInt(String.valueOf(digits.charAt(1))));
              for(int j=0;j<list2.size();j++){
                 String s2=list2.get(j);
                  List<String>  list3=lists.get(Integer.parseInt(String.valueOf(digits.charAt(2))));
                  for(int k=0;k<list3.size();k++){
                      list0.add(s+s2+list3.get(k));
                  }
              }
          }


      }
      else if(digits.length()>3&&digits.length()<=4){

          list=lists.get(Integer.parseInt(String.valueOf(digits.charAt(0))));
          for(int i=0;i<list.size();i++){
              String  s=list.get(i);
              List<String>  list2=lists.get(Integer.parseInt(String.valueOf(digits.charAt(1))));
              for(int j=0;j<list2.size();j++){
                  String s2=list2.get(j);
                  List<String>  list3=lists.get(Integer.parseInt(String.valueOf(digits.charAt(2))));
                  for(int k=0;k<list3.size();k++){
                      String s3=list3.get(k);
                      List<String>  list4=lists.get(Integer.parseInt(String.valueOf(digits.charAt(3))));
                      for(int p=0;p<list4.size();p++){
                          list0.add(s+s2+s3+list4.get(p));
                      }
                  }
              }
          }

      }

        return list0;


    }
}

4.（24） 两两交换链表中的节点

/**
 * 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 swapPairs(ListNode head) {

   
   if(head==null||head.next==null){

            return head;
        }

        ListNode list1=new ListNode();
        ListNode list2=new ListNode();
        ListNode list3=new ListNode();
        ListNode list4=new ListNode();
        ListNode head2=list4;
        while(true){

            if(head==null||head.next==null){
                break;
            }
            list1=head;
            list2=list1.next;
            list3=list2.next;

            list4.next=list2;
            list2.next=list1;
            list1.next=list3;

            head=list3;
            list4=list4.next.next;
         //   System.out.println(list4.val);

        }
        return head2.next;
    }
}

5.（29） 两数相除

给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。

返回被除数 dividend 除以除数 divisor 得到的商。

整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2

示例 1:

输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = truncate(3.33333..) = truncate(3) = 3
示例 2:

输入: dividend = 7, divisor = -3
输出: -2
解释: 7/-3 = truncate(-2.33333..) = -2
 

提示：

被除数和除数均为 32 位有符号整数。
除数不为 0。
假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231,  231 − 1]。本题中，如果除法结果溢出，则返回 231 − 1。

class Solution {
    int num=0;
  public  int divide(int dividend, int divisor) {
        // 考虑被除数为最小值的情况
        if (dividend == Integer.MIN_VALUE) {
            if (divisor == 1) {
                return Integer.MIN_VALUE;
            }
            if (divisor == -1) {
                return Integer.MAX_VALUE;
            }
        }
        // 考虑除数为最小值的情况
        if (divisor == Integer.MIN_VALUE) {
            return dividend == Integer.MIN_VALUE ? 1 : 0;
        }
        // 考虑被除数为 0 的情况
        if (dividend == 0) {
            return 0;
        }
        boolean b=false;
        boolean b2=false;
        boolean b3=false;
        if(dividend>0){
            dividend=-dividend;
            b=true;
        }
        if(divisor>0){
            divisor=-divisor;
            b2=true;
        }
          if(dividend>divisor){
            return 0;
        }
        if(dividend==Integer.MIN_VALUE){
            dividend=dividend+1;
            b3=true;
        }
        int m=add(dividend,divisor,0);

         if(b3){
            if((num-1)==divisor) {
                m = m + 1;
            }
        }
      if(b&&b2){
       return m;
     }
      else if(b==false&&b2==false){
          return m;
      }


        return -m;
    }

    public  int add(int dividend, int divisor,int n){
    
        int i=0;
        int  divisor2=0;
        while (true){
         divisor2=divisor<<i;

         if(divisor2<dividend||divisor2>0){
             divisor2=divisor<<(i-1);
             while (divisor2>0){
                 i--;
                 divisor2=divisor<<(i-1);
             }

             break;
         }
         i++;
        }


        dividend=dividend-divisor2;
        if(dividend>divisor){
            num=dividend;
            return (1<<i-1)+n;
        }


        return     add(dividend,divisor,(1<<i-1))+n;



    }
}

6.(34) 在排序数组中查找元素的第一个和最后一个位置

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

进阶：

你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]
示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]
示例 3：

输入：nums = [], target = 0
输出：[-1,-1]
 

提示：

0 <= nums.length <= 105
-109 <= nums[i] <= 109
nums 是一个非递减数组
-109 <= target <= 109。

class Solution {
    public int[] searchRange(int[] nums, int target) {

boolean b1=false;
boolean b2=false;
      int n[]=new int[2];
      for(int i=0;i<nums.length;i++){
          if(nums[i]==target){
              n[0]=i;
              b1=true;
              break;
          }
      }

      for(int i=nums.length-1;i>=0;i--){
          if(nums[i]==target){
              n[1]=i;
              b2=true;
              break;
          }
      }
      if(b1&&b2){
           return n;
      }
   n[0]=-1;
   n[1]=-1;
      return n;
    }
}

7.(38) 外观数列

给定一个正整数 n ，输出外观数列的第 n 项。

「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。

你可以将其视作是由递归公式定义的数字字符串序列：

countAndSay(1) = "1"
countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。
前五项如下：

1.     1
2.     11
3.     21
4.     1211
5.     111221
第一项是数字 1 
描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 "11"
描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 "21"
描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 "1211"
描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 "111221"
要 描述 一个数字字符串，首先要将字符串分割为 最小 数量的组，每个组都由连续的最多 相同字符 组成。然后对于每个组，先描述字符的数量，然后描述字符，形成一个描述组。要将描述转换为数字字符串，先将每组中的字符数量用数字替换，再将所有描述组连接起来。

例如，数字字符串 "3322251" 的描述如下图：

class Solution {
   static String num[]=new String[30];
    static int sum2=1;
     static {
          num[0]="1";
        sum("1");
    }
    public String countAndSay(int n) {

     
      return num[n-1];
    }

      public static  void sum(String s){
        
            char s1 = 0;
           StringBuilder stringBuilder=new StringBuilder();
        int k=0;
        for(int i=0;i<s.length();i++){

            if(i==0){
                s1=s.charAt(i);
                if(s.length()==1){
                    stringBuilder.append(String.valueOf(i+1)+s1);
                }
            }
            else {
                if(s1!=s.charAt(i)){
                   // s3=String.valueOf(i+1-k)+s1;
                    stringBuilder.append(String.valueOf(i-k)+s1);
                    s1=s.charAt(i);
                    k=i;
                }
                 if(i==s.length()-1&&s1==s.charAt(i)){
                    stringBuilder.append(String.valueOf(i+1-k)+s1);
                }
                else if(i==s.length()-1&&s1!=s.charAt(i)){
                    stringBuilder.append(String.valueOf(i-k)+s.charAt(i));
                }
            }

        }
            num[sum2]=String.valueOf(stringBuilder);
           if(sum2==29){
              return;
          }
           sum2++;
                sum( num[sum2-1]);

    }
}

8.(211) 添加与搜索单词 - 数据结构设计

请你设计一个数据结构，支持 添加新单词 和 查找字符串是否与任何先前添加的字符串匹配 。

实现词典类 WordDictionary ：

WordDictionary() 初始化词典对象
void addWord(word) 将 word 添加到数据结构中，之后可以对它进行匹配
bool search(word) 如果数据结构中存在字符串与 word 匹配，则返回 true ；否则，返回  false 。word 中可能包含一些 '.' ，每个 . 都可以表示任何一个字母。

示例：

输入：
["WordDictionary","addWord","addWord","addWord","search","search","search","search"]
[[],["bad"],["dad"],["mad"],["pad"],["bad"],[".ad"],["b.."]]
输出：
[null,null,null,null,false,true,true,true]

解释：
WordDictionary wordDictionary = new WordDictionary();
wordDictionary.addWord("bad");
wordDictionary.addWord("dad");
wordDictionary.addWord("mad");
wordDictionary.search("pad"); // return False
wordDictionary.search("bad"); // return True
wordDictionary.search(".ad"); // return True
wordDictionary.search("b.."); // return True
 

提示：

1 <= word.length <= 500
addWord 中的 word 由小写英文字母组成
search 中的 word 由 '.' 或小写英文字母组成
最多调用 50000 次 addWord 和 search

class WordDictionary {
 HashMap<Integer, Set<String>> map;
     public WordDictionary() {
            map = new HashMap<>();
        }

        public void addWord(String word) {
           int n=word.length();
           if(map.get(n)!=null){
             map.get(n).add(word);
           }
           else {
               Set<String> s=new HashSet<>();
               s.add(word);
               map.put(n,s);
           }

        }

    public boolean search(String word) {


            int k=0;
        Set<String> s=map.get(word.length());
         if(s== null){
            return false;
        }
        for(String s2:s){

            for(int j=0;j<word.length();j++){

                if(word.charAt(j)!='.'&&s2.charAt(j)!=word.charAt(j)){
                    k++;
                    break;
                }
            }
            if(k==0){
                return true;
            }
            k=0;
        }



        return false;

    }

}

/**
 * Your WordDictionary object will be instantiated and called as such:
 * WordDictionary obj = new WordDictionary();
 * obj.addWord(word);
 * boolean param_2 = obj.search(word);
 */

9.( 71) 简化路径

给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 '/' 开头），请你将其转化为更加简洁的规范路径。

在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （..） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠（即，'//'）都被视为单个斜杠 '/' 。 对于此问题，任何其他格式的点（例如，'...'）均被视为文件/目录名称。

请注意，返回的 规范路径 必须遵循下述格式：

始终以斜杠 '/' 开头。
两个目录名之间必须只有一个斜杠 '/' 。
最后一个目录名（如果存在）不能 以 '/' 结尾。
此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含 '.' 或 '..'）。
返回简化后得到的 规范路径

例 1：

输入：path = "/home/"
输出："/home"
解释：注意，最后一个目录名后面没有斜杠。 
示例 2：

输入：path = "/../"
输出："/"
解释：从根目录向上一级是不可行的，因为根目录是你可以到达的最高级。
示例 3：

输入：path = "/home//foo/"
输出："/home/foo"
解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。
示例 4：

输入：path = "/a/./b/../../c/"
输出："/c"
 

提示：

1 <= path.length <= 3000
path 由英文字母，数字，'.'，'/' 或 '_' 组成。
path 是一个有效的 Unix 风格绝对路径。

class Solution {
    public String simplifyPath(String path) {

  String s[]=path.split("/");
        Stack<String> stack=new Stack<>();
        for(String str:s){
            if(str.equals("")||str.equals(".")){
                continue;
            }
            if(str.equals("..")){
                if(!stack.empty())
                stack.pop();
            }else {
                stack.push(str);
            }
        }
      

   return "/"+String.join("/",stack);
        

    }
}

 10.(217) 存在重复元素

给定一个整数数组，判断是否存在重复元素。

如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

示例 1:

输入: [1,2,3,1]
输出: true
示例 2:

输入: [1,2,3,4]
输出: false
示例 3:

输入: [1,1,1,3,3,4,3,2,4,2]
输出: true

class Solution {
    public boolean containsDuplicate(int[] nums) {
       Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){

        if((i+1<nums.length)&&nums[i]==nums[i+1]){
        return true;
        }

        }
        return false;

    }


}

。