LeetCode/字符串

把列表转为用 “,” 连接的新字符串

lists = ["ouyang1","ouyang2","ouyang3"]
sr = ",".join(lists)#join是把列表转为字符串，用逗号隔开
print("连接:",sr)#连接: ouyang1,ouyang2,ouyang3

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

输入: "III"
输出: 3

class Solution(object):
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        思路：
        1.创建hashMap字典表映射罗马数字和整数。
        2.如果当前字符代表的值不小于其右边，就加上该值；否则就减去该值。
        """
        dict_init = {'I':1,'V':5,'X':10,'L':50, 'C':100, 'D':500, 'M':1000}
        res = 0
        for i in range(0,len(s)):
            if i<len(s)-1 and dict_init[s[i]]<dict_init[s[i+1]]:
                res=res-dict_init[s[i]]
            else:
                res=res+dict_init[s[i]]
        return res

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        if len(s)=='' or len(s)%2==1:
            return False
        else:
            stack = []
            for i in s:
                if i=='[':
                    stack.append(']')
                elif i=='(':
                    stack.append(')')
                elif i=='{':
                    stack.append('}')
                elif not stack or i!= stack.pop():
                    return False
            if not stack:
                return True
            return False

编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”

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

class Solution(object):
    def longestCommonPrefix(self, strs):
		pre = ''
        zipped = zip(*strs)#zip()函数，将传入对象打包成元组，返回的列表长度与最短的对象相同，适合求最长公共前缀。
        #y= ["flower","flow","flight"] 打包后的结果：[('f', 'f', 'f'),('l', 'l', 'l'),('o', 'o', 'i')，('w', 'w', 'g')]
        for i in zipped:
            if len(set(i)) == 1:#set()函数，用来建立无序不重复的元素集，如果打包好的列表里的元组set后的长度为1，则是每个字符串中公有的字母
                pre = pre + i[0]
            else:
                return pre
        return pre 

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。
注意：
num1 和num2 的长度都小于 5100.
num1 和num2 都只包含数字 0-9.
num1 和num2 都不包含任何前导零。
你不能使用任何內建 BigInteger 库， 也不能直接将输入的字符串转换为整数形式。

class Solution(object):
    def addStrings(self, num1, num2):
        """
        :type num1: str
        :type num2: str
        :rtype: str
        """
        return (str(eval(num1 + '+' + num2)))

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

输入: "Let's take LeetCode contest"
输出: "s'teL ekat edoCteeL tsetnoc" 

class Solution(object):
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """
        #s.split(" ")#把输入字符串按照空格分隔；['Let's' 'take' 'LeetCode' 'contest']
        #s.split(" ")[::-1]#['contest' 'LeetCode' 'take' 'Let's']
        #" ".join(s.split(" ")[::-1])#将列表转换为字符串，以空格分隔"contest LeetCode take Let's"
        return " ".join(s.split(" ")[::-1])[::-1]#将字符串反转："s'teL ekat edoCteeL tsetnoc"

给定一个字符串 s 和一个整数 k，你需要对从字符串开头算起的每隔 2k 个字符的前 k 个字符进行反转。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

class Solution(object):
    def reverseStr(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: str
        """
        new = ''
        for i in range(0,len(s),2*k):

            new = new + "".join(s[i:i+k][::-1] + s[i+k:i+2*k])
        return new

在二维平面上，有一个机器人从原点 (0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在 (0, 0) 处结束。
移动顺序由字符串表示。字符 move[i] 表示其第 i 次移动。机器人的有效动作有 R（右），L（左），U（上）和 D（下）。如果机器人在完成所有动作后返回原点，则返回 true。否则，返回 false。
注意：机器人“面朝”的方向无关紧要。 “R” 将始终使机器人向右移动一次，“L” 将始终向左移动等。此外，假设每次移动机器人的移动幅度相同。

class Solution(object):
    def judgeCircle(self, moves):
        """
        :type moves: str
        :rtype: bool
        """
        r, l, u, d = 0,0,0,0#上下左右移动的次数
        for i in range(0,len(moves)):
            if moves[i] == 'R':
                r=r+1
            elif moves[i] == 'L':
                l=l+1
            elif moves[i] == 'U':
                u=u+1
            else:
                d=d+1
        if r==l and u==d:
            return True
        else:
            return False

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则按字典序打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba

import itertools
class Solution:
    def Permutation(self, ss):
        # write code here
        if not ss:
            return []
        res=list(set(map(''.join,itertools.permutations(ss))))
        res.sort()
        return res
		#法二：
		if not ss:
            return ss
        result=[]
        k=itertools.permutations(ss)
        #for data in k:
    		#print(data)#('a', 'b', 'c')('a', 'c', 'b')('b', 'a', 'c')('b', 'c', 'a'('c', 'a', 'b')('c', 'b', 'a')
        for i in k:
            result.append(''.join(i))#['abc', 'acb', 'bac', 'bca', 'cab', 'cba']
        result=list(set(result))
        result.sort()
        return result
        #Python中的itertools.permutations,返回可迭代对象的所有数学全排列方式。
        #join()方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
        #set()函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
        #sort()函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
        #list()方法用于将元组转换为列表

将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0
输入：
+2147483647
1a33
输出：
2147483647
0

# -*- coding:utf-8 -*-
class Solution:
    def StrToInt(self, s):
        # write code here
        if not s or len(s)<1:
            return 0
        numsdict={'0':0,'1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
        nums = []
        result = 0
        for char in s:
            if char =='+' or char =='-':
                continue
            elif char in numsdict:
                nums.append(numsdict[char])
            else:
                return 0
        for i in nums:
            result = result*10+i
        return -1*result if s[0]=='-' else result        

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。

class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if not numbers:
            return
        res = []#定义一个
        ma,mi = 0,14
        for num in numbers:
            if num==0:
                continue#调过大小王
            ma = max(ma,num)
            mi = min(mi,num)
            if num in res:
                return False#有重复提前返回false
            res.append(num)#添加牌
        if ma-mi<=4:
            return True
        else:
            return False

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

class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        #return s[n:]+s[:n]
        if not s:
            return ''
        if n<len(s):
            return s[n:]+s[:n] 
        if n>=len(s):
            n = n%len(s)
            return s[n:]+s[:n]

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.（从0开始计数）

class Solution:
    def FirstNotRepeatingChar(self, s):
        # write code here
        
        li = []
        n = len(s)
        if n==0:
            return -1
        for i in range(0,n):
            if s.count(s[i])==1:
                li.append(i)
                return li[0]
        return -1