文章目录
- 计算字符串最后一个单词的长度
- 计算某字符出现次数
- 明明的随机数
- 回文字符串
- 回文数字
- 无重复字符的最大子串长度
- 有效的括号
- 罗马数字转整数
- 字符串通配符
- 杨辉三角
- 查找两个字符串a,b中的最长公共子串 **
- 找出字符串中第一个只出现一次的字符
计算字符串最后一个单词的长度
pending
计算某字符出现次数
写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出字符串中该字符的出现次数。（不区分大小写字母）
输入描述：
第一行输入一个由字母、数字和空格组成的字符串，
第二行输入一个字符（非空格）
输出描述：
输出字符串中含有该字符的个数。（不区分大小写字母）
示例1
输入：
ABCabc
A
输出：
2
python实现：
def statistic_char_num():
s1 = input()
s2 = input().strip().lower()
num = 0
for i in s1.lower():
if i == s2:
num += 1
print(num)
statistic_char_num()
明明的随机数
生成N个 1到500之间 的随机整数。
删去其中重复的数字，即相同的数字只保留一个，然后把这些数从小到大排序，按照排好的顺序输出。
1≤N≤1000
1≤val≤500
输入描述：
第一行先输入随机整数的个数 N ；接下来的 N 行每行输入一个整数；
代表明明生成的随机数。
输出描述：
输出多行，表示处理后的结果
示例1
输入：
3
2
2
1
输出：
1
2
说明：
输入解释：
第一个数字是3，也即这个小样例的N=3，说明用计算机生成了3个1到500之间的随机整数，接下来每行一个随机数字，共3行，也即这3个随机数字为：
2
2
1
所以样例的输出为：
1
2
pending…
回文字符串
- 判断一个字符串是否为回文字符串。
- 找出一个字符串中的最大回文子串。
最大回文子串
回文数字
给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
例如，121 是回文，而 123 不是。
示例 1：
输入：x = 121
输出：true
示例 2：
输入：x = -121
输出：false
示例 3：
输入：x = 10
输出：false
进阶：你能不将整数转为字符串来解决这个问题吗？
python实现：
思路：将整数反转过来，与原值比较，相等则为True，否则False
class Solution:
def isPalindrome(self, x: int) -> bool:
# 负数不是
if x < 0:
return False
# 单个数字 是回文
elif x <= 9:
return True
else: # >= 10 O(n)
origin = x
reverse = 0
base = 10
while x // base:
base *= 10
base /= 10
while x:
reverse += x % 10 * base
x //= 10
base /= 10
return reverse == origin
无重复字符的最大子串长度
pending
有效的括号
给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
- 左括号必须用相同类型的右括号闭合。
- 左括号必须以正确的顺序闭合。
- 每个右括号都有一个对应的相同类型的左括号。
示例 1：
输入：s = “()”
输出：true
示例 2：
输入：s = “()[]{}”
输出：true
示例 3：
输入：s = “(]”
输出：false
提示：
1 <= s.length <= 104
s 仅由括号 ‘()[]{}’ 组成
python 实现:
hash + 栈空间
# hash存储对应关系
# 遍历字符串，左括号入栈
# 右括号出栈，并对比
class Solution:
def isValid(self, s: str) -> bool:
n = len(s)
if n % 2 != 0: # 有效则必然成对出现
return False
dict_ = { # 存储对应关系
"(": ")",
"[": "]",
"{": "}",
"0": "0"
}
stack = ["0"] # 防止第一个就是右括号，出栈报错
for c in s:
if c in dict_: # 左括号入栈
stack.append(c)
elif dict_[stack.pop()] != c: # 右括号出栈
return False
return len(stack) == 1
罗马数字转整数
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，12 写做 XII ，27 写做 XXVII 。
罗马数字中小的数字在大的数字的右边。但也存在特例，例如 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:
输入: s = “III”
输出: 3
示例 2:
输入: s = “IV”
输出: 4
示例 3:
输入: s = “IX”
输出: 9
示例 4:
输入: s = “LVIII”
输出: 58
解释: L = 50, V= 5, III = 3.
示例 5:
输入: s = “MCMXCIV”
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.
python实现：
- 当前符号大于等于右边的符号，则表示为正；
- 当前符号小于右边的符号，则表示为负。
class Solution:
def romanToInt(self, s: str) -> int:
dict_ = {
"I": 1,
"V": 5,
"X": 10,
"L": 50,
"C": 100,
"D": 500,
"M": 1000
}
result = 0
n = len(s)
for i in range(n-1):
c = s[i]
if dict_.get(c) >= dict_.get(s[i+1]):
# positive
result += dict_.get(c)
else:
# negative
result -= dict_.get(c)
result += dict_.get(s[-1])
return result
字符串通配符
通配符是一种特殊语法，广泛应用于文件搜索、数据库、正则表达式等领域。
实现如下2个通配符：
*：匹配0个或以上的字符（注：能被 *和 ?匹配的字符仅由字母和数字0到9组成）
？：匹配1个字符
注意：匹配时不区分大小写。
输入：
- 通配符表达式；
- 一组字符串。
输出：
- 匹配成功输出true
- 匹配失败输出false
进阶：时间复杂度： O ( n 2 ) {O(n^2)} O(n2)，空间复杂度： O ( n ) {O(n)} O(n)
示例1
输入：
- 第一行 te?t*.*
- 第二行 txt12.xls
输出：
- false
示例2
输入：
- 第一行 z
- 第二行 zz
输出：
- false
示例3
输入：
- pq
- pppq
输出：
- false
示例4
输入：
- **z
- 0QZz
输出：
- true
示例5
输入：
- ?*Bc*?
- abcd
输出：
- true
示例6
输入：
- h*?*a
- h#a
输出：
- false
示例7
输入：
- p*p*qp**pq*p**p***ppq
- pppppppqppqqppqppppqqqppqppqpqqqppqpqpppqpppqpqqqpqqp
输出：
- false
python实现：
- s1, s2均为空；
- s1, s2有一个空；
- s1, s2均非空；从最后一个元素，递归解决。
- s1最后一位是字母、数字时；
- s1最后一位是？时；
- s1最后一位是*时；
# 匹配函数
def fun(s1, s2):
if s1 == "" and s2 == "":
return True
elif s1 == "" and s2 != "":
return False
elif s1 != "" and s2 == "":
if s1.replace("*", "") == "":
return True
else:
return False
else:
m, n = len(s1), len(s2)
if s1[m - 1] == s2[n - 1] or (s1[m - 1] == "?" and s2.isalnum()):
return fun(s1[: m - 1], s2[: n - 1])
elif s1[m - 1] == "*":
return fun(s1[: m - 1], s2) or fun(s1, s2[: n - 1])
else:
return False
s1, s2 = input().lower(), input().lower()
if fun(s1, s2):
print("true")
else:
print("false")
有点问题。
杨辉三角
第一行只有一个数1，以下每行的每个数，是恰好是它上面的数、左上角数和右上角的数，3个数之和（如果不存在某个数，认为该数就是0）。
求第n行第一个偶数出现的位置。如果没有偶数，则输出-1
输入第n行，
输出第n行第一个偶数的位置。
示例1
输入：
4
输出：
3 即第四行的6
python代码
import sys
alt=[2,3,2,4] # 发现规律，从第三行开始偶数位置为2324循环
for line in sys.stdin:
n=int(line.strip())
if n<3:
print(-1)
if n>=3:
print(alt[(n-3)%4]) #所以对4求余，映射到上面alt列表中
查找两个字符串a,b中的最长公共子串 **
进阶：时间复杂度：
O
(
n
3
)
{O(n^3)}
O(n3)
空间复杂度：
O
(
n
)
{O(n)}
O(n)
输入：
输入两个字符串
输出：
返回重复出现的字符
示例1
输入：
abcdefghijklmnop
abcsafjklmnopqrstuvw
输出：
jklmnop
python实现
遍历短的子串，判断是否in长的字符串中。
def max_common_substring(a, b):
if not a or not b:
print("")
return ""
if len(a) > len(b):
a, b = b, a
res = ''
# 遍历短的字符串
for i in range(0, len(a)):
for j in range(i, len(a)):
if a[i:j + 1] in b:
if j + 1 - i > len(res):
res = a[i:j + 1]
print(a[i:j + 1], "在")
else:
print(a[i:j + 1], "不在")
break
print(res)
找出字符串中第一个只出现一次的字符
找出字符串中第一个只出现一次的字符
输入描述：
输入一个非空字符串
输出描述：
输出第一个只出现一次的字符，如果不存在输出-1
示例1
输入：
asdfasdfo
输出：
o
python实现:
- hash统计出现次数；
- 列表记录出现一次的字符
def count_char(s):
dict_ = {}
temp = []
for c in s:
if c in dict_:
if c in temp:
temp.remove(c)
else:
dict_[c] = 1
temp.append(c)
if temp:
print(temp[0])
return temp[0]
print(-1)
return -1
s = input()
count_char(s)
