剑指offer（1/16）

和为S的两个数字

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

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

class Solution {
public:
    vector<int> FindNumbersWithSum(vector<int> array,int sum) {
    vector<int> result;
    int length = array.size();
    if (length <= 1)
        return result;
    int i = 0;
    int j = length - 1;
    int Sum;
    while (i < j)
    {
        Sum = array[i] + array[j];
        if (Sum > sum)
            j--;
        else if (Sum < sum)
            i++;
        else
        {
            result.push_back(array[i]);
            result.push_back(array[j]);
            break;
        }
    }
    return result;
    }
};
/*
不要被题目误导了！证明如下，清晰明了：
//输出两个数的乘积最小的。这句话的理解？
假设：若b>a,且存在，
a + b = s;
(a - m ) + (b + m) = s
则：(a - m )(b + m)=ab - (b-a)m - m*m < ab；说明外层的乘积更小
也就是说依然是左右夹逼法！！！只需要2个指针
1.left开头，right指向结尾
2.如果和小于sum，说明太小了，left右移寻找更大的数
3.如果和大于sum，说明太大了，right左移寻找更小的数
4.和相等，把left和right的数返回
*/

左旋转字符串

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

public class Solution {
    public String LeftRotateString(String str,int n) {
        if(n > str.length())
            return str;
        String s = str.substring(n,str.length()) + str.substring(0,n);
        return s;
    }
}

//按照剑指offer书上的方法，两次翻转字符串。
class Solution {
public:
    string LeftRotateString(string str, int n) {
        reverse(str.begin(), str.end());
        reverse(str.begin(), str.begin() + str.size() - n);
        reverse(str.begin() + str.size() - n, str.end());
        return str;
    }
};
/*
class Solution {
public:
    string LeftRotateString(string str, int n) {
        if(n<0) return NULL;
        if(n==0) return str;
        string strTemp="";
          
          strTemp=str.substr(0,n);
          str.erase(0,n);
         str+=strTemp;
        return str;
        
    }
};
*/

翻转单词顺序列

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

public class Solution {
    public String ReverseSentence(String str) {
        if(str == null || str.trim().length() == 0) return str;
        //trim()方法实际上的行为并不是”去掉两端的空白字符“，而是”截取中间的非空白字符“
        StringBuilder sb = new StringBuilder();
        String[] temp = str.split(" ");
        //将这个字符串按照指定的正则表达式分割
        int len = temp.length;
        for(int i = len-1;i >= 0; i--){
            if(i == 0){
                sb.append(temp[i]);
                break;
            }
            sb.append(temp[i]);
            sb.append(" ");
        }
        return sb.toString();
        //deleteCharAt（int  a）只有一个参数，使用时删除索引为a的字符；
    }
}

class Solution {
public:
    string ReverseSentence(string str) {
        int len = str.size();
     int start = 0;
     for(int i = 0; i < len; i ++)
     {
         if(str[i] == ' ')
         {
             reverse(str.begin()+start, str.begin()+i);
             start = i+1;
         }
         if(i == len-1)
         {
             reverse(str.begin()+start, str.end());
         }
     }
     reverse(str.begin(), str.end());
     return str;
    }
};

判断是不是顺子

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。

public class Solution {
    public boolean isContinuous(int [] numbers) {
        if(numbers.length == 0) return false;
        int[] arr = new int[14];
        int max = 0;
        int min = 14;
        for(int i = 0;i < numbers.length; i++){
            arr[numbers[i]]++;
            if(arr[numbers[i]]>=2 && numbers[i]!=0) return false;
            if(numbers[i] == 0) continue;
            if(numbers[i] > max) max = numbers[i];
            if(numbers[i] < min) min = numbers[i];
        }
        if(max - min <= 4)
            return true;
        else
            return false;
    }
}

class Solution {
public:
/*顺子满足的条件：max-min<5;
                除0外其他的数字都不能重复
                传入的数组放5个元素*/
    bool IsContinuous( vector<int> numbers ) {
        if(numbers.empty()) return 0;
        int count[14]={0};//记录每个元素出现的次数;以numbers中的元素作为下标(最大K,对应13)
        int len=numbers.size();
        int max=-1;
        int min=14;
        for(int i=0;i<len;++i)
            {
            count[numbers[i]]++;
            if(numbers[i]==0) 
                continue;
            if(count[numbers[i]]>1) 
                return 0;
            if(numbers[i]>max) 
                max=numbers[i];
            if(numbers[i]<min) 
                min=numbers[i];
        }//end for
        if(max-min<5) return 1;
        return 0;
    }//end IsContinuous()
};

圆圈中最后剩下的数

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

import java.util.*;
public class Solution {
    public int LastRemaining_Solution(int n, int m) {
        if(n<1 || m<1) return -1;
        LinkedList<Integer> list = new LinkedList<Integer>();
        for(int i = 0;i < n; i++){
            list.add(i);
        }
        int bt = 0;
        while(list.size() > 1){
            bt = (bt + m - 1) % list.size();
            list.remove(bt);
        }
        return list.size() == 1 ? list.get(0) : -1;
    }
}
// public class Solution {
// //思路2：用数学归纳法推导出递推公式，设有n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。令f[i]表示i个人时最后胜利者的编号，则有递推公式：
// f[1]=0;
// f[i]=(f[i-1]+m)%i; (i>1)
//     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;
//     }
// }

class Solution {
public:
    int LastRemaining_Solution(int n, int m)
{
        if(n<1||m<1) return -1;
        int i;
        queue<int> c;
        for(i=1;i<=n;i++)
        {
            c.push(i);
        }
        while(!c.empty())
        {
            for(i=1;i<m;i++)
            {
                c.push(c.front());
                c.pop();
            }
            if(c.size()==1)
                return c.front()-1;
            c.pop();
        }
        return -1;
    }
};