数据结构与算法之字符串

基于字符计数的问题

 一、偶数字串的数量**********************

Given a string of digits 0 – 9. The task is to count number of substrings which when convert into integer form an even number.

Input : str = "1234".

Output : 6

"2", "4", "12", "34", "234", "1234" are 6 substring which are even.

Input : str = "154".

Output : 3

Input : str = "15".

Output : 0

def evenNum(s):
    count = res = 0    
    for i in s:
        if i == 0:
            count += 1
        if i % 2 == 0:
            res += i + 1 - count
    return res    

二、学生出勤记录

给一个代表学生出勤记录的字符串，该记录只包含以下三个字符：

A：缺席  L：迟到  P：出席

如果学生的出勤记录不包含多于一个A或超过两个连续的L，则可以获得奖励。

def isprise(s):
    count1 = count2 = 0 
    for i in range(len(s)):
        if s[i] == 'A':
            count1 += 1
            if count1 == 2:
                return False
        if s[i] == 'L':
            if s[i-1] != 'L':
                count2 = 0
            count2 += 1
            if count2 > 2:
                return False
    return True

#Python  s.count('A')-->O(n)
def checkRecord(s):
    return not (s.count('A') > 1 or 'LLL' in s)

三、对具有相同首尾字符的连续子字符串进行计数

给出一个字符串S，找到所有连续的子字符串，其开始和结束的字符都相同

We are given a string S, we need to find count of all contiguous substrings starting and ending with same character.

Input : S = "abcab"

Output : 7

There are 15 substrings of "abcab"

Out of the above substrings, there are 7 substrings : a, abca, b, bcab, c, a and b.

from collections import Counter
def countSub(s):
    counter = Counter(s)
    res = 0
    for x in counter:
        res += counter[x] * (counter[x]+1)//2
    return res

四、字符串中最大连续重复字符

给定一个字符串，在字符串中查找最大连续重复字符

Given a string, the task is to find maximum consecutive repeating character in string.

def maxRepeating(s):
    count = 0
    n = len(s)
    res = s[0]
    local = 1
    for i in range(n):
        if i < n-1 and s[i] == s[i+1]:
            local += 1
        else:
            if local > count:
                count = local    
                res = s[i]
            local = 1
    return res

五、在排序数组中删除重复

双指针

def removeDuplicates(A):
    if not A:
        return 0 
    newTail = 0
    for i in range(1, len(A)):
        if A[i] != A[newTail]:
            newTail += 1
            A[newTail] = A[i]
    for j in range(newTail+1, len(A)):
        A[j] = 'X'
    return newTail + 1

同字母异序：排序、字典/Counter、双指针

一、Anagrams

Write a function to check whether two given strings are anagram of each other or not. An anagram of a string is another string that contains same characters, only the order of characters can be different. For example, “abcd” and “dabc” are anagram of each other.

def areAnagram(s1, s2):
    if len(s1) != len(s2):
        return False
    return sorted(s1) == sorted(s2)

from collections import Counter
def areAnagram(s1, s2):
    return Counter(s1) == Counter(s2)

二、Find All Anagrams in a String 

Given a string s and a non-empty string p, find all the start indices of p's anagrams in s.

Strings consists of lowercase English letters only and the length of both strings s and p will not be larger than 20,100.

The order of output does not matter.

Input:

s: "cbaebabacd" p: "abc"

Output:

[0, 6]

Explanation:

The substring with start index = 0 is "cba", which is an anagram of "abc".

The substring with start index = 6 is "bac", which is an anagram of "abc".

from collections import Counter
def findAnagrams(s, p):
    res = []
    pCounter = Counter(p)
    sCounter = Counter(s[len(p)-1])
    for i in range(len(p)-1, len(s)):
        sCounter[s[i]] += 1
        if sCounter == pCounter:
            res.append(i - len(p) + 1)
        sCounter[s[i-len(p)+1]] -= 1
        if sCounter[s[i-len(p)+1]] == 0:
            del sCounter[s[i-len(p)+1]]
    return res

三、Find Anagram Mappings

Given two lists Aand B, and B is an anagram of A. B is an anagram of A means B is made by randomizing the order of the elements in A.

We want to find an index mapping P, from A to B. A mapping P[i] = j means the ith element in A appears in B at index j.

These lists A and B may contain duplicates. If there are multiple answers, output any of them.

For example, given

A = [12, 28, 46, 32, 50]

B = [50, 12, 32, 46, 28]

We should return

[1, 4, 3, 2, 0]

as P[0] = 1 because the 0th element of A appears at B1, and P1 = 4 because the 1st element of A appears at B[4], and so on. 

def anagramMappings(A, B):
    dic = {}
    for ind, val in enumerate(B):
        dic[val] = i
    return [dic[a] for a in A]

回文：rotation、counter

一、移位

给定两个字符串s1和s2，判断s2是否是s1的移位 

def areRotations(s1, s2):
    size1 = len(s1)
    size2 = len(s2)
    if size1 != size2:
        return 0
    temp = s1 + s1
    return temp.count(s2) > 0

二、移位Ⅱ

将大小为n的数组移动d个单位

# 三段反转  左移
def reverse(arr, start, end):
    while start < end:
        arr[start], arr[end] = arr[end], arr[start]
        start += 1
        end -= 1
def rotate(arr, d):
    n = len(arr)
    reverse(arr, 0, d-1)
    reverse(arr, d, n-1)
    reverse(arr, 0, n-1)

# 右移
def reverse(arr, start, end):
    while start < end:
        arr[start], arr[end] = arr[end], arr[start]
        start += 1
        end -= 1
def rotation(arr, d):
    n = len(arr)
    reverse(arr, 0, n-d-1)
    reverse(arr, n-d-1, n-1)
    reverse(arr, 0, n-1)

三、回文

判断一个字符串是否是回文

def reverse(s):
    return s[::-1]
def isPalindrome(s):
    rev = reverse(s)
    if s== rev:
        return True
    return False

四、数字回文

判断一个整数是否是回文数

def intPalindrome(n):
    return str(n) == str(n)[::-1]

def isPalindrome(x):
    if x < 0:
        return False
    ranger = 1
    while x // ranger >= 10:
        ranger *= 10
    while x:
        left = x // ranger
        right = x % 10
        if left != right:
            return False
        x = (x % ranger) // 10
        ranger //=100
    return True

五、移位回文

判断给定的字符串是否是一个回文的移位

def isRotationOfPalindrome(s):
    n = len(s)
    s = s + s
    for i in range(n):
        if isPalindrome(s[i:i+n]):
            return True
    return False

六、重排回文

给定一个字符串，检查字符串中的各字符是否可以构成一个回文字符串

from collections import Counter
def canRearrange(s):
    odd = 0
    counter = Counter(s)
    for key in counter.keys():
        if counter[key] % 2 == 1:
            odd += 1
        if odd > 1:
            return False
    return True

七、最长回文

给定一个由大小写字母组成的字符串，找到可由这些字符构成的最长的回文字符串

from collections import Counter
def longestPalindrome(s):
    ans = 0
    counter = Counter(s)
    for key in counter.keys():
        v = counter[key]
        ans += v // 2 * 2
        if ans % 2 == 0 and v % 2 == 1:
            ans += 1
    return ans

八、最长子回文串（LeetCode 5）

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

找长度为1的-->找长度为2的-->找长度为3以上的

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if not s or len(s) == 0:
            return s
        dp = [[False for _ in range(len(s))] for _ in range(len(s))]
        start = 0
        max_len = 1
        for i in range(len(s)):
            dp[i][i] = True
            if i + 1 < len(s) and s[i] == s[i+1]:
                dp[i][i+1] = True
                start = i
                max_len = 2
        for l in range(3, len(s)+1):
            for i in range(len(s) - l + 1):
                r = i + l - 1
                if s[i] == s[r] and dp[i+1][r-1]:
                    dp[i][r] = True
                    start = i
                    max_len = l
        return s[start:start+max_len]

九、回文流

 heap-->数据流取中位数，minHeap+maxHeap

 

 

二进制字符串

子序列

一、最长子序列

给定一个字符串s和一个整数k，找到其他字符串t，使得t是给定字符串s的最大子序列，同时t的每个字符在字符串s中必须至少出现k次

from collections import Counter
def longestSub(s, k):
    res = list()
    c = Counter(s)
    for i in s:
        if c[i] >= k:
            res.append(i)
    return "".join(res)

二、检查子序列

给定两个字符串s1和s2，确定s1是否是s2的子序列。子序列是可以通过删除一些元素而不改变其余元素的顺序从另一个序列派生的序列。

#递归
def isSubSequence(s1, s2, m, n):
    if m == 0:
        return True
    if n == 0:
        return False
    if s1[m-1] == s2[n-1]:
        return isSubSequence(s1, s2, m-1, n-1)
    return isSubSequence(s1, s2, m, n-1)

# 双指针
def isSubSequence(s1, s2):
    m = len(s1)
    n = len(s2)
    j = 0
    i = 0
    while j < m and i < n:
        if s1[j] == s2[i]:
            j += 1
        i += 1
    return j == m

三、通过删除给定字符串的字符得到字典中最长的单词

给一个字典和一个字符串，找到字典中最长的字符串，它可以通过删除给定的字符串中的一些字符来形成

def findLongestString(words, s):
    res = ""
    length = 0
    for w in words:
        if length < len(w) and isSubSequence(w, s):
            res = w
            length = len(w)
    return res

四、找出所有子序列元素之和的和

subset-->2**n   每一个数字出现的次数是2**（n-1）

def sumSub(arr):
    ans = sum(arr)
    return ans * pow(2, len(arr)-1)

五、模式搜索

strStr 字符串匹配算法

python-->find  index

def find(text, pattern): #O(n**2)
    for i in range(len(text)-len(pattern)+1):
        if text[i:i+len(pattern)] == pattern:
            return i
    return -1

def strStr(text, pattern):
    n, m = len(text), len(pattern)
    for i in range(n - m + 1):
        start = i
        for j in range(len(pattern)):
            if text[i] != pattern[j]:
                break
            i += 1
        else:
            return start
    return -1

#Rolling Hash  -->Hash+Sliding Window
#Horner's Rule -->abc:(axp+b)xp+c   a+bp+cp**2  O(n)
def strStr(text, pattern):
    base = 29
    patternHash = 0
    tempBase = 1
    hayHash = 0
    for i in range(len(pattern)-1, -1, -1):
        patternHash += ord(pattern[i]) * tempBase
        tempBase *= base
    
    tempBase = 1
    for i in range(len(pattern)-1, -1, -1):
        hayHash += ord(text[i]) * tempBase
        tempBase *= base
    
    if patternHash == hayHash and text[0:len(pattern)] == pattern:
         return 0
    
    tempBase /= base
    for i in range(len(pattern), len(text)):
        hayHash = (hayHash - ord(text[i-len(pattern)]) * tempBase])) * base + ord(text[i])
        if hayHash == patternHash and text[i-len(pattern)+1:i+1] == pattern:
        　　return i - len(pattern) + 1
    return -1

六、敏感词

字典+split

For the given sentence as input， censor a specific word with asterisks ‘*’

def censor(text, word):
    word_list = text.split()
    result = ' '
    stars = '*' * len(word)
    count = 0
    index = 0
    for i in word_list:
        if i == word:
            word_list[index] = stars
        index += 1
    result = ' '.join(word_list)
    return result

七、用C替换所有出现的字符串AB

def translate(st):
    l = len(st)
    if l < 2:
        return
    i = 0
    j = 0
    while j < i - 1:
        if st[j] == 'A' and st[j+1] == 'B':
            j += 2
            st[i] = 'C'
            i += 1
            continue
        st[i] = st[j]
        i += 1
        j += 1
    if j == l-1:
        st[i] = st[j]
        i += 1
    return i

八、Count of Occurrences of “1(0+)1” Pattern

Given an alphanumeric string, find the number of times a pattern 1(0+)1 occurs in the given string. Here, (0+) signifies the presence of non empty sequence of consecutive 0’s.

def patternCount(s):
    last = s[0]
    i = 1
    counter = 0
    while i < len(s):
        if s[i] =='0' and last == '1':
            while i < len(s) and s[i] == '0':
                i += 1
                if i == len(s):
                    return counter
            if s[i] == '1':
                counter += 1
        last = s[i]
        i += 1
    return counter

九、与通配符匹配的字符串

*  0个或者多个

？1个

Given two strings where first string may contain wild card characters and second string is a normal string. Write a function that returns true if the two strings match. The following are allowed wild card characters in first string.

* --> Matches with 0 or more instances of any character or set of characters.

? --> Matches with any one character.

 

T(i,j)  string里面的前i个字符和pattern里面的前j个字符是否是match

T(i, j) = False if s[i] != p[j]

T(i, j) = T(i-1, j-1)  if s[i] == p[j]

T(i, j) = T(i-1, j-1)  if p[j] = ?

T(i, j) = T(i, j-1) or T(i-1, j) if p[j] = *