剑指Offer/41-50

---

41. 和为S的连续正数序列

题目描述
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

解题思路：滑动窗口
1.什么是滑动窗口？
顾名思义，首先是一个窗口，既然是一个窗口，就需要用窗口的左边界i和右边界j来唯一表示一个窗口，其次，滑动代表，窗口始终从左往右移动，这也表明左边界i和右边界j始终会往后移动，而不会往左移动。
这里我用左闭右开区间来表示一个窗口。比如
2.滑动窗口的操作
  扩大窗口，j += 1
  缩小窗口，i += 1

算法步骤：
① 初始化，i=1,j=1, 表示窗口大小为0
② 如果窗口中值的和小于目标值sum， 表示需要扩大窗口，j += 1
③ 否则，如果狂口值和大于目标值sum，表示需要缩小窗口，i += 1
④ 否则，等于目标值，存结果，缩小窗口，继续进行步骤2,3,4

这里需要注意2个问题：
① 什么时候窗口终止呢，这里窗口左边界走到sum的一半即可终止，因为题目要求至少包含2个数
② 什么时候需要扩大窗口和缩小窗口？解释可看上述算法步骤。

public class Solution {
    public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        //窗口的两端，根据窗口内值的和来确定窗口的位置和大小
        int low = 1;
        int high = 2;
        while(low < high){
            int cur = (low + high) * (high - low + 1)/2;//求当前窗口内的和
            if(cur == sum){
                ArrayList<Integer> list = new ArrayList<>();
                for(int i = low; i<= high; i++){
                    list.add(i);
                }
                result.add(list);
                low++;
            }else if(cur < sum){
                high++;
            }else{
                low++;
            }
        }
        return result;
    }
}

42. 和为S的两个数字

题目描述
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

解题思路：双指针法
关键点：数组递增排序

public class Solution {
    public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
        ArrayList<Integer> result = new ArrayList<>();
        int low = 0;
        int high = array.length - 1;
        while(low < high){
            int temp = array[low] + array[high];
            if(temp < sum){
                low++;
            }else if(temp > sum){
                high--;
            }else{
                result.add(array[low]);
                result.add(array[high]);
                return result;
            }
        }
        return result;
    }
}

43. 左旋转字符串

题目描述
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

解题思路：利用辅助数组

public class Solution {
    public String LeftRotateString(String str,int n) {
        if(str == null || str.length() == 0 || n == str.length()){
            return str;
        } 
        int length = str.length();
        if(n > length){
            n %= length;
        }
        if(n == 0){
            return str;
        }
        char[] chars = str.toCharArray();
        char[] temp = new char[n];
        for(int i = 0; i < n; i++){
            temp[i] = chars[i];
        }
        for(int i = n; i < length; i++){
            chars[i-n] = chars[i];
        }
        for(int i = 0; i< n; i++){
            chars[length-n+i] = temp[i];
        }
        str = new String(chars);
        return str;
    }
}

44. 翻转单词顺序列

题目描述
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

解题思路：
利用字符串的 split 函数，切分出每个单词，以单词作为整体进行逆置。

public class Solution {
    public String ReverseSentence(String str) {
        //方法1：利用库函数split
        StringBuffer sb = new StringBuffer("");
        if(str.length() == 0 || str.trim().equals("")){
            return str;
        }
        String[] strSet = str.split(" ");
        int length = strSet.length;
        for(int i = length-1; i > 0; i--){
            sb.append(strSet[i]+" ");//从尾部添加
        }
        sb.append(strSet[0]);
        return sb.toString();

        //方法2：先翻转整个字符串，然后再翻转每个单词。具体来说，是先处理字符串前后的空格，然后把字符串转换成了字符数组，之后对字符数组进行翻转，再然后是根据空格出现的位置确定每个单词的位置，对每个单词再进行翻转。
//         if(str == null || str.length() == 0)
//             return str;
//         char[] arr = str.toCharArray();//转换成字符数组
//         reverse(arr, 0, arr.length-1);//先全部翻转一次
//         int start = 0;
//         int end = 0;
//         while(start < arr.length){
//             if(start == ' '){
//                 start++;
//                 end++;
//             }else if(end == arr.length || arr[end] == ' '){
//                 reverse(arr, start, end-1);
//                 end++;
//                 start = end;
//             }else{
//                 end++;
//             }
//         }
//         return String.valueOf(arr);
//     }
//     public void reverse(char[] arr, int begin, int end){
//         while(begin < end){
//             char temp = arr[begin];
//             arr[begin] = arr[end];
//             arr[end] = temp;
//             begin++;
//             end--;
//         }
    }
}

45. 扑克牌顺子

题目描述
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。

解题思路：排序+遍历
(1) 排序
(2) 计算0的个数
(3) 将除0之外剩余部分取出
(4) 如果存在相等元素，不是顺子
(5) 计算最大元素和最小元素(除0)的差，如果小于5则可视为顺子，否则不能被称为顺子

public class Solution {
    public boolean isContinuous(int [] numbers) {
        if(numbers == null || numbers.length == 0){
            return false;
        }
        Arrays.sort(numbers);
        int k = 0;
        for(int i = 0; i < numbers.length; i++){
            if(numbers[i] == 0){
                k++;//记录最小值的下标，同时也是0的个数
                continue;
            }
            //如果存在相同数字，返回false
            if(i+1 < numbers.length && numbers[i] == numbers[i+1]){
                return false;
            }
        }
        //最大和最小差值在5以内，并且没有重复数值。
        return numbers[numbers.length-1] - numbers[k] < numbers.length;
    }
}

46. 孩子们的游戏（圆圈中最后剩下的数）

题目描述
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)

如果没有小朋友，请返回-1

解题思路：
方法1：递归
假设f(n, m) 表示最终留下元素的序号。比如f(5,3) = 3
首先，长度为 n 的序列会先删除第 m % n 个元素，然后剩下一个长度为 n - 1 的序列。那么，我们可以递归地求解 f(n - 1, m)，就可以知道对于剩下的 n - 1 个元素，最终会留下第几个元素，我们设答案为 x = f(n - 1, m)。
由于我们删除了第 m % n 个元素，将序列的长度变为 n - 1。当我们知道了 f(n - 1, m) 对应的答案 x 之后，我们也就可以知道，长度为 n 的序列最后一个删除的元素，应当是从 m % n 开始数的第 x 个元素。因此有 f(n, m) = (m % n + x) % n = (m + x) % n。
当n等于1时，f(1,m) = 0

方法2：迭代
根据递归的过程可知
f[1] = 0
f[2] = (f{1] + m) % 2
f[3] = (f[2] + m) % 3
…
f[n] = (f[n-1] + m) % n

public class Solution {
//     int f(int n, int m){
//         if(n == 1){
//             return 0;
//         }
//         int x = f(n-1, m);
//         return (m+x) % n;
//     }
//     public int LastRemaining_Solution(int n, int m) {
//         if(n <= 0){
//             return -1;
//         }
//         return f(n, m);
//     }
    //迭代法
    public int LastRemaining_Solution(int n, int m) {
        if(n <= 0){
            return -1;
        }
        int index = 0;
        for(int i = 2; i<= n; i++){
            index = (index + m) % i;
        }
        return index;
    }
}

47. 求1+2+3+…+n

题目描述
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

解题思路：
方法1：递归
方法2：利用等差数列的求和公式进行求解

public class Solution {
    public int Sum_Solution(int n) {
        int sum = n;
        //方法1：递归,n为0的时候需要终止递归
        boolean stop = (n > 0)&&((sum += Sum_Solution(n-1))>0);
        return sum;
        
//         //方法2：非递归
//         //这是一个等差数列，sum=(a1+an)n/2=>(1+n)n/2=>(n+n^2)/2
//         int sum = (int)Math.pow(n,2) + n;
//         return sum>>1;
    }
}

48. 不用加减乘除做加法

题目描述
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

解题思路：
两个二进制的相加结果是用异或门实现；两个二进制的进位结果是用与或门实现。
在加法运算中，当进位值为0的时候，跳出循环

public class Solution {
    public int Add(int num1,int num2) {
        int result = 0;
        int carry = 0;
        do{
            result = num1 ^ num2;//不带进位的加法  异或运算
            carry = (num1 & num2) << 1;//进位
            num1 = carry;
            num2 = result;//
        }while(carry != 0);
        return result;
    }
}

49. 把字符串转换成整数

题目描述
将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0

解题思路：
主要从以下几个方面考虑问题：
字符串是否空
字符串是否“0”
首位是“+”or“-”
首位是否为“+”“-”“0-9”以外的字符
数值的上下溢出（Java中最大正整数是2147483647，最大负整数是-2147483648）

public class Solution {
    public int StrToInt(String str) {
        if(str.length() == 0 || str == null)
            return 0;
        //数字的正负，默认是正数
        int symbol = 1;
        char[] arr = str.toCharArray();
        int sum = 0;
        //如果第一位为'-'，说明结果应该是一个负数,
        //同时替换该位置上的字符为0，这样再下面的处理中可以认为是跳过该字符
        //因为0*10还是0
        if(arr[0] == '-'){
            symbol = -1;
            arr[0] = '0';
        }else if(arr[0] == '+'){
            arr[0] = '0';
        }
        for(int i=0; i<arr.length; i++){
            if(arr[i]<'0' || arr[i]>'9'){
                return 0;
            }
            sum = sum * 10 + arr[i] - '0';
        }
        return sum * symbol;
    }
}

50. 数组中重复的数字

题目描述
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中第一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
返回描述：
如果数组中有重复的数字，函数返回true，否则返回false。
如果数组中有重复的数字，把重复的数字放到参数duplication[0]中。（ps:duplication已经初始化，可以直接赋值使用。）

解题思路：
题目中已告知我们数据的范围是0-n-1。所以我们可以这么做：

(1) 设置一个指针i指向开头0，
(2) 对于arr[i]进行判断，如果arr[i] == i， 说明下标为i的数据正确的放在了该位置上，让i++
(3) 如果arr[i] != i, 说明没有正确放在位置上，那么我们就把arr[i]放在正确的位置上，也就是交换
arr[i] 和arr[arr[i]]。交换之后，如果arr[i] ！= i, 继续交换。
(4) 如果交换的过程中，arr[i] == arr[arr[i]]，说明遇到了重复值，返回即可。

public class Solution {
    // Parameters:
    //    numbers:     an array of integers
    //    length:      the length of array numbers
    //    duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;
    //                  Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++
    //    这里要特别注意~返回任意重复的一个，赋值duplication[0]
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    public boolean duplicate(int numbers[],int length,int [] duplication) {
        if(numbers == null || length == 0){
            return false;
        }
        for(int i=0;i<length;i++){
            if(numbers[i] != i){
                if(numbers[i] == numbers[numbers[i]]){
                    duplication[0] = numbers[i];
                    return true;
                }
                // swap
                int tmp = numbers[i];
                numbers[i] = numbers[tmp];
                numbers[tmp] = tmp;
            }
        }
        return false;
    }
}