编程能力提升_1

目录

1.给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

2.给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

3.判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

4，罗马数字转数字；数字转罗马

5.编写一个函数来查找字符串数组中的最长公共前缀。

---

1.给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

class Solution(object):
    def twoSum(self, nums, target):
        for i in range(len(nums)):
            nums_copy=nums[:]
            diff=target-nums_copy[i]
            nums_copy.pop(i)
            if diff in nums_copy:
                returnList=[i,nums_copy.index(diff)+1]
                return returnList

class Solution(object):
    def twoSum(self, numbers, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
        dic={}
        for i in range(len(numbers)):
            if target-numbers[i] in dic:
                #下标从1开始
                return [dic[target-numbers[i]]+1,i+1]
            else:
                dic[numbers[i]]=i

 

2.给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321

 示例 2:

输入: -123
输出: -321

方法一：

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """

        strNew=''
        strx=str(x)
        if strx[0].isdigit()==False:
                strNew+=strx[0]
                strNew+=strx[len(strx)-1:0:-1]
                      
        else:
            strNew=strx[::-1]
        retr=int(strNew)
        if retr> 2**31-1 or retr<-2**31:
            retr=0
        return(retr)

方法二：

class Solution:
    def reverse(self, x: int) -> int:
        xcopy=x
        if xcopy<0:
            x=-x
        rev=0
        while(x!=0):
            rev=10*rev+x%10
            x=int(x/10)
        if xcopy<0:
            rev=-1*rev
        if rev> 2**31-1 or rev<-2**31:
            rev=0
        return(rev)
            

3.判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121
输出: true

示例 2:

输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

方法一：

class Solution:
    def isPalindrome(self, x: int) -> bool:
        if x<0:
            return False
        newStr=str(x)[::-1]
        if int(newStr)==x:
            return True
        return False

方法二：

class Solution(object):
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        if x<0:
            return False
        copy_x=x
        rev=0
        while(x!=0):
            rev=10*rev+x%10
            x=int(x/10)
        return True if rev==copy_x else False

4，罗马数字转数字；数字转罗马

 罗马数字 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 的范围内。

class Solution(object):
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """
        a = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}        
        ans=0        
        for i in range(len(s)):
            #只要左侧数字小于右侧数字，则减去该数字，其他数字都加和
            if i<len(s)-1 and a[s[i]]<a[s[i+1]]:                
                ans-=a[s[i]]
            else:
                ans+=a[s[i]]
        return ans

给定一个数字，将其转换成罗马数字。输入确保在 1 到 3999 的范围内

def solution(n):
    roman_numerals = {1000:'M',
                      900: 'CM',
                      500: 'D',
                      400: 'CD',
                      100: 'C',
                      90: 'XC',
                      50: 'L',
                      40: 'XL',
                      10: 'X',
                      9: 'IX',
                      5: 'V',
                      4: 'IV',
                      1: 'I'
    }
    roman_string = ''
    for key in sorted(roman_numerals.keys(),reverse=True):
        while n >= key:
            roman_string += roman_numerals[key]
            n -= key
    return roman_string

5.编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1:

输入: ["flower","flow","flight"]
输出: "fl"

示例 2:

输入: ["dog","racecar","car"]
输出: ""
解释: 输入不存在公共前缀。

方法一：

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if strs==[]:
            return ''
        #假设strs[0]为共有字符串，转换为列表是为了方便删除末位元素
        comls=list(strs[0])
        #遍历每一个字符串
        for i in range(1,len(strs)):
            copy_ls=list(strs[i])
            #死循环，如果字符串删改后不等于共有字符串且共有串不为空
            while(copy_ls!=comls and comls):
                if len(copy_ls)>len(comls):
                    #选择删除较长字符串的末位元素
                    copy_ls.pop()
                elif len(copy_ls)<len(comls):
                    comls.pop()
                else:
                    #如果等长则一起删除
                    comls.pop()
                    copy_ls.pop()
                    
            if not comls:
                return ""
        return ''.join(comls)#将列表等转换为字符串用‘-’中的元素来连接
                

方法二：

class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        res = ''
        size = len(strs)
        if size == 0:
            return res
        #共同长度一定小于最小字符串的长度
        min_size = min([len(s) for s in strs])
        #只对比各个字符串前min_size位是否共有
        for i in range(min_size):
            #从第0位开始，各个字符串中的第i位元素是否唯一
            if len(set([s[i] for s in strs])) == 1:
                #如果唯一，则第i位元素共有
                res += strs[0][i]
            else:
                break
        return res