剑指offer在线编程（08-11）【7】

Date : 2019-08-11

1. 和为S的两个数字

题目描述

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

输出描述:

对应每个测试案例，输出两个数，小的先输出。

分析：刚开始直接想法就是：直接遍历数组取出满足条件（和）的所有数组对，然后基于这些数组对进行乘积最小的比较，即可得到最小乘积的数组对。

下面是想的代码，也通过！！！

# 备注：直接遍历选择相应的数组；注意几个条件的充分利用：
# 1：因为有序，所有先遍历到的A，一定比tsum-A的值小，所以在放置数组对时，直接放置
# 2：因为有多组满足之和相等，则直接选择数组对中最小的那一数组（两者之差越大，两者的乘积越小），所以有多组时，直接res[0] 
# -*- coding:utf-8 -*-
class Solution:
    def FindNumbersWithSum(self, array, tsum):
        # write code here
        if not array:
            return []
        res = []
        for i in range(len(array)):
            A = array[i]
            if tsum-A in array:
                res.append([A, tsum-A]) # 1
        if not res:
            return []
        else:
            return res[0]  # 2

但是看到别人share更好的方法，因为是有序的，所以利用双指针进行左右夹逼的方法：

0) array[low 和array[high]两者更接近时，其乘积更大，相差越大，他们的乘积越小！ 例如：【7，8】【1.14】明显后者的乘积更小。

1）若 array[low] +array[high] > tsum:右指针向前移动 high -= 1

2）若 array[low] +array[high] < tsum:左指针向后移动 small += 1

3）若 array[low] +array[high] = tsum:左右夹逼时，第一次遇到满足情况的，直接输出相应数组对。

# -*- coding:utf-8 -*-
class Solution:
    def FindNumbersWithSum(self, array, tsum):
        # write code here
        if not array:      # 如果数组为空数组，则直接返回空
            return [ ]
        low, high =0, len(array)-1
        while low < high:  # 循环的while条件： 左右夹逼法（双指针）
            if array[low]+array[high] > tsum:  # 如果两者之和大于tsum,右指针前移动
                high -= 1    
            elif array[low] + array[high] < tsum:  # 如果两指针之和小于tsum,左指针后移动
                low += 1
            else:
                return [array[low],array[high]]  # 当最先的一组满足之和等于tsum时，返回。且array已经有序
        return [ ]

2.    左旋转字符串   (考察知识点： 字符串)

题目描述

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

分析：（自己的思路）因为进行循环左移，实际上就是将前n位数字整体放到最后，然后将第n+1位数字及其以后的数字进行向前移动。s[n:] +s[:n]

# -*- coding:utf-8 -*-
class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        if not s or len(s)<n:
            return ''
        return s[n:] + s[:n]

但看别人的解析发现：这样回答面试官出的该题并非其本意，其应该是为了考察字符串的翻转，而由于python的特性，可以取巧。

翻转：BA = (A.reverse() B.reverse()).reverse(), 模拟这三个字符串翻转操作即可 （A=前面K个字符串，B=从第K+1位起的字符串）例如上例子中的 XYZdefabc = （(abc)^T(XYZdef)^T)^T = (cbafedZYX)^T   即：(BA) = (A^T*B^T)^T

class Solution:    # BA = (A.reverse() B.reverse()).reverse()
    def LeftRotateString(self, s, n):
        # write code here
        res, length = list(s), len(s)   # 将字符串转化为list的形式
        if n > length :
            return ""
        for i in range(int(n/2)):  # A.reverse()的实现
            res[i], res[n-1-i] = res[n-1-i], res[i]
        for i in range(n, int((n+length)/2)):  # B.reverse()的实现
            res[i], res[length-1-i+n] = res[length-1-i+n], res[i]
        for i in range(int(length/2)):  # 整体的reverse()的实现  
            res[i], res[length-1-i] = res[length-1-i], res[i]
            return "".join(res)

3.   翻转单词顺序列  （考察知识点：字符串）

题目描述

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

分析：这题和上一题一样都是陷阱题，如果直接利用python进行巧妙处理，并非本题的出题意愿；考察的同样是两次反转，先翻转所有字符，再逐个单词翻转。但这种翻转的pyhton实现不太好处理，遂下面只贴出了两种方法：巧妙地反序输出+利用栈的先进后出的思想：

# ver1: 反序输出
# -*- coding:utf-8 -*-
class Solution:
    def ReverseSentence(self, s):
        # write code here
        if not s:
            return ''
        return ' '.join(s.split(' ')[::-1])
# ver2: 利用栈的思想
# -*- coding:utf-8 -*-
class Solution:
    def ReverseSentence(self, s):
        alist = s.split(" ")
        stacklist = []
        for i in alist:
            stacklist.append(i)
        result = []
        while len(stacklist) > 0:
            result.append(stacklist.pop())
        return " ".join([x for x in result])

Problem:    
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。    
同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。
例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，
正确的句子应该是“I am a student.”。   
Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？
-----------------------------------------  
Think:    
1、直接法，直接分割字符串，然后反序拼接    
2、对所有的字符进行翻转，然后对整个字符串进行翻转。python不好实现。    
3、堆栈思想，反转字符串，先进后出，就是反转了     
-----------------------------------------    
Idea:    
1、直接分割字符串，然后反序拼接    
2、使用堆栈先进后出的规则，反转字符串     
-----------------------------------------    
Code[1]:    
def ReverseSentence(self, s):
        alist = s.split(" ")
        alist.reverse()
        return " ".join([x for x in alist])     
-----------------------    
运行时间：37ms    
占用内存：5752k    
量级:O（n）    
空间：n    
优点：很容易想到并实现    
缺点：需要多余的额外空间     
-----------------------------------------    
Code[2]:    
def ReverseSentence(self, s):        
    alist = s.split(" ")        
    stacklist = []        
    for i in alist:
       stacklist.append(i)    
       result = [] 
    while len(stacklist) > 0:
       result.append(stacklist.pop())
    return " ".join([x for x in result])
-----------------------    
运行时间：29ms    
占用内存：5612k    
量级:O（n）    
空间：2n    
优点：容易理解，而且比较巧妙    
缺点：需要多余的额外空间 

4.  扑克牌顺子  （考察知识点：字符串）

题目描述

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。

分析： 输入的是一个五元素的数组，然后期望输出是true或者false; 注意其中的0代表是大王或者小王。

思路是：因为可能会有0的涉及，所以取出numbers数组中的大于0的元素（假设某种情况中存在0，而且也构成顺子，最多排序后的某两个数字的差是2，后面<=4进行了刻画），并对其进行排序，初始累计差n=0，然后遍历计算相邻元素的差（在遍历过程中，要判断相邻两个元素的差是否大于零，大于零则累加；如果出现了相等的两个元素，此时差为0，则直接返回false,不能构成顺子），最终对循环得到的累计差n，进行判断：小于等于4则True,否则不能构成顺子。

# -*- coding:utf-8 -*-
class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if not numbers:
            return False
        lis1 = [i for i in numbers if i > 0]  # 取出numbers中的大于0的数字，并排序
        lis1.sort()
        n = 0  # 初始化累计差
        if len(new_list)==1:  # 这种情况的存在于：4个0，1个非0元素构成初始元组
            return True
        for i in range(len(lis1)-1):  # 遍历所有的相邻情况
            if lis1[i+1] - lis1[i] >0:  # 如果相邻差大于0，则对n进行累计差
                n += (lis1[i+1] - lis1[i])
            else:                       # 如果相邻差等于0，则会出现相同的两个元素，无法构成顺子
                return False 
        if n <= 4:                      # 如果累计差和n小于等于4，则可以构成顺子。
            return True
        else:                           # 否则大于4，不能构成顺子（如果含有0，且最大的相邻差为2）
            return False

5. 孩子们的游戏(圆圈中最后剩下的数)  （考察知识：链表+数学）  (难 难 难 多看)

题目描述

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

分析；这是一个约瑟环的问题，

首先想到的是利用一个循环链表来实现这个圆圈，每次向前走m-1步，然后删除当前结点；然后再继续走。未实现

但是还有一种思路就是从数学的角度去思考：我们首先走m步，然后删除当前节点，然后继续走，如果超过了当前剩下的i个人，则回到原地（理解上可以理解为继续往后走，然后除以i的余数，便是我们回到原点后的第几个元素），其实该种方法是一个找到规律然后递归的方法： 

方法2：找规律使用动态规划。我们注意到，输入的序列在删除一个元素后，序列的长度会改变，如果索引在被删除的元素位置开始计算，那么每删除一个元素，序列的长度减一而索引会完全改变。如果能找到改变前的索引和新索引的对应关系，那么该问题就容易解决了。我们定义一个函数f(n, m)，表示每次在n个数字0,1,2,3,…,n-1中每次删除第m个数字后剩下的数字。那么第一个被删除的数字的索引是(m-1)%n。删除该索引元素后，剩下的n-1个数字为0,1,2,…,m-1,m+1,…,n-1。下次删除数字是重m+1位置开始，于是可以把序列看作m+1,..,n-1,0,1,…,m-1。该序列最后剩下的序列也是f的函数。但该函数和第一个函数不同，存在映射关系，使用f'来表示，于是有：f(n, m)=f'(n-1, m)。接下来需要找到映射关系。
m+1 --> 0
m+2 --> 1
……
n-1 --> n-m-2
0   --> n-m-1 
1   --> n-m
……
m-1 --> n-2
所以可以得到：p(x) = (x-m-1)%n，而逆映射是p'(x) = (x+m+1)%n
即0~n-1序列中最后剩下的数字等于（0~n-2序列中最后剩下的数字+m）%n，
很明显当n=1时，只有一个数，那么剩下的数字就是0.
问题转化为动态规划问题，关系表示为：     f(n)=(f(n-1)+m)%n； 当n=1,f(1)=0;

class Solution:
    def LastRemaining_Solution(self, n, m):
        # write code here
          if n < 1 or m < 1:
            return -1
        last = 0
        for i in range(2, n+1):
            last = (last+m)%i
        return last

法1（调试，没过）：使用list模拟循环链表，用cur作为指向list的下标位置。
当cur移到list末尾直接指向list头部，当删除一个数后list的长度和cur的值相等则cur指向
0class Solution:
    def LastRemaining_Solution(self, n, m):
        # write code here
        if n < 1 or m < 1:
            return -1
        childNum = list(range(n))
        print(childNum)
        cur = 0  # 指向list的指针
        while len(childNum) > 1:
            for i in range(1,m):
                cur += 1             # 当指针移到list的末尾，则将指针移到list的头          
                if cur == len(childNum):
                    cur = 0
            # 删除一个数，此时由于删除之后list的下标随之变化
            # cur指向的便是原数组中的下一个数字，此时cur不需要移动
            childNum.remove(childNum[cur])
            if cur == len(childNum): # list的长度和cur的值相等则cur指向0
                  cur = 0
        return childNum

6.   求1+2+3+...+n   （考察知识点： 进制转换  ； 短路求值原理）

题目描述

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

分析：本题限制了不可以使用很多运算，那我们可以采用递归的思想，不断进累加 sum

解题思路：

1.需利用逻辑与的短路特性实现递归终止！

2.当n==0时，(n>0)and((sum+=Sum_Solution(n-1))>0)只执行前面的判断，为false,不再继续执行递归操作！子函数结束；

3.当n>0时，执行sum+=Sum_Solution(n-1)，实现递归计算Sum_Solution(n)！

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.sum = 0
    def Sum_Solution(self, n):
        # write code here
        def calsum(n):
            self.sum += n
            n -= 1
            return n >0 and self.Sum_Solution(n)
        calsum(n)
        return self.sum

在分析该题的代码时；在想几个问题：

1）为什么要写一个__init__（self）的初始函数，其中包含self.sum =0. 其实它相当于这个类下的一个数据成员的思想，有点类似在后面任何地方可以调用的全局变量。又因为是在类下，所以写成数据成员初始化的形式。

2）为什么在后面的函数中还要写一个子函数calsum，为何不直接在sum_solution下写递归的调用，因为最后是要在这个函数下面返回最重的结果 sum.如果调用和它在同一层，要如何计算？（因为调用的时候需要 一个return，返回最终的sum需要一个return）。因此写一个子函数cal_sum，在这个子函数中进行累加的运算以及递归调用的运算 ！然后在子函数的外层同级上进行一个子函数的调用，然后返回最终的结果！！！

还有一种更简单的利用短路原理进行计算的方法： 

# -*- coding:utf-8 -*-
class Solution:
    def Sum_Solution(self, n):
        # write code here
        sum1 = n
        tmp = n and self.Sum_Solution(n-1)
        sum1 += tmp
        return sum1

# 解释：在Python中， a and b:
#                     1) 如果a 为True,b为False, 返回a的值
#                     2) 如果a 为True,b为True, 返回b的值

7.  不用加减乘除做加法   （考察知识点： 进制转换）

题目描述

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

分析：

方法一：自加自减的思想

# 报错越界，难道是不能使用自加自减
# -*- coding:utf-8 -*-
class Solution:
    def Add(self, num1, num2):
        # write code here
        if num1 > 0:
            while num1-- != 0:
                num2++
        elif num1 < 0:
            while num1++ != 0:
                num2--
        return num2

  方法二：采用sum函数

# -*- coding:utf-8 -*- 通过
class Solution:
    def Add(self, num1, num2):
        # write code here
        return sum([num1, num2])

方法三：二进制转换的思想：不懂！！！

# -*- coding:utf-8 -*- 没懂这种利用异或操作进行计算的思路
class Solution:
    def Add(self, num1, num2):
        # write code here
        while num2!=0:
            carry=num1&num2
            num1=(num1^num2)%0x100000000
            num2=(carry<<1)%0x100000000
        return num1 if num1<=0x7FFFFFFF else num1 |(~0x100000000+1)

32位的int，正数的范围是(0,0x7FFFFFFF),负数(0x80000000,0xFFFFFFFF)

负数 = -(0x100000000 - (0x80000000,0xFFFFFFFF))
所以0x80000000实际代表的值是 -0x80000000（所以说既是源码也是补码）
   0xFFFFFFFF实际代表的值是 -1