1.思路：暴力法，两个列表元素一一对比
#小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？
#输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。
#示例 1：
#输入：guess = [1,2,3], answer = [1,2,3]
#输出：3
#解释：小A 每次都猜对了。
#me
class Solution0(object):
def game(self, guess, answer):
sum = 0
for i in range(len(guess)):
if guess[i]==answer[i]:
sum += 1
return sum
#other
class Solution1(object):
def game(self, guess, answer):
return sum(guess[i] == answer[i] for i in range(len(guess)))
2.思路：暴力法，两个列表元素一一对比
#给你一个字符串 S，请你删去其中的所有元音字母（ 'a'，'e'，'i'，'o'，'u'），并返回这个新字符串。
#示例 1：
#输入："leetcodeisacommunityforcoders"
#输出："ltcdscmmntyfrcdrs"
#me
class Solution0(object):
def removeVowels(self, S):
yuanYin = ['a', 'e', 'i', 'o', 'u']
Slast = ''
for s in S:
if s not in yuanYin:
Slast += s
return Slast
#other
class Solution1(object):
def removeVowels(self, S):
return ''.join(filter(lambda c: c not in 'aeiou', S))
3.思路：暴力法，计算第i+1个元素与第i个元素的距离
#我们定制了一款特殊的力扣键盘，所有的键都排列在一行上。
#我们可以按从左到右的顺序，用一个长度为 26 的字符串 keyboard （索引从 0 开始，到 25 结束）来表示该键盘的键位布局。
#现在需要测试这个键盘是否能够有效工作，那么我们就需要个机械手来测试这个键盘。
#最初的时候，机械手位于左边起第一个键（也就是索引为 0 的键）的上方。当机械手移动到某一字符所在的键位时，就会在终端上输出该字符。
#机械手从索引 i 移动到索引 j 所需要的时间是 |i - j|。
#当前测试需要你使用机械手输出指定的单词 word，请你编写一个函数来计算机械手输出该单词所需的时间。
#示例 1：
#输入：keyboard = "abcdefghijklmnopqrstuvwxyz", word = "cba"
#输出：4
#解释：
#机械手从 0 号键移动到 2 号键来输出 'c'，又移动到 1 号键来输出 'b'，接着移动到 0 号键来输出 'a'。
#总用时 = 2 + 1 + 1 = 4.
#me
class Solution0(object):
def calculateTime(self, keyboard, word):
sum=0
for i in range(len(word)):
if i==0:
cha = abs(keyboard.index(word[i])-0)
else:
cha = abs(keyboard.index(word[i]) - keyboard.index(word[i - 1]))
sum += cha
return sum
#other
class Solution1(object):
def calculateTime(self, keyboard, word):
index = 0
count = 0
for i in word:
count += abs(index - keyboard.index(i))
index = keyboard.index(i)
return count
4.思路：暴力法，两个列表元素一一对比
#给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
#J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。
#示例 1:
#输入: J = "aA", S = "aAAbbbb"
#输出: 3
#me
class Solution(object):
def numJewelsInStones(self, J, S):
sumnum = 0
for j in J:
sumnum += S.count(j)
return sumnum
#other
class Solution1(object):
def numJewelsInStones(self, J, S):
return sum(S.count(i) for i in J)
5.思路：Str.replace
#给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。
#所谓无效化 IP 地址，其实就是用 "[.]" 代替了每个 "."。
#示例 1：
#输入：address = "1.1.1.1"
#输出："1[.]1[.]1[.]1"
#me
class Solution(object):
def defangIPaddr(self, address):
return address.replace('.', '[.]')
6.思路：暴力法，两个列表元素一一对比
#给定两个列表 Aand B，并且 B 是 A 的变位（即 B 是由 A 中的元素随机排列后组成的新列表）。
#我们希望找出一个从 A 到 B 的索引映射 P 。一个映射 P[i] = j 指的是列表 A 中的第 i 个元素出现于列表 B 中的第 j 个元素上。
#列表 A 和 B 可能出现重复元素。如果有多于一种答案，输出任意一种。
#例如，给定
#A = [12, 28, 46, 32, 50]
#B = [50, 12, 32, 46, 28]
#需要返回
#[1, 4, 3, 2, 0]
#P[0] = 1 ，因为 A 中的第 0 个元素出现于 B[1]，而且 P[1] = 4 因为 A 中第 1 个元素出现于 B[4]，以此类推。
#me
class Solution(object):
def anagramMappings(self, A, B):
return [B.index(i) for i in A]
7.思路：1.暴力法，依次取字符子串进行判断，2.判断前n个元素组成的字符串'L'和'R'的个数是否相等
#在一个「平衡字符串」中，'L' 和 'R' 字符的数量是相同的。
#给出一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。
#返回可以通过分割得到的平衡字符串的最大数量。
#示例 1：
#输入：s = "RLRRLLRLRL"
#输出：4
#解释：s 可以分割为 "RL", "RRLL", "RL", "RL", 每个子字符串中都包含相同数量的 'L' 和 'R'。
#me
class Solution0(object):
def balancedStringSplit(self, s):
allnum = 0
start = 0
for i in range(len(s)):
ss = s[start:i+1]
if ss.count('R') == ss.count('L'):
allnum += 1
start = i+1
return allnum
#other
class Solution1(object):
def balancedStringSplit(self, s):
count = 0
count_L = 0
count_R = 0
for s_ in s:
if s_ == 'L':
count_L += 1
else:
count_R += 1
if count_L == count_R:
count += 1
return count
8.思路：暴力法，取字符子串进行判断
#有效括号字符串为空 ("")、"(" + A + ")" 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。例如，""，"()"，"(())()" 和 "(()(()))" 都是有效的括号字符串。
#如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。
#给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + ... + P_k，其中 P_i 是有效括号字符串原语。
#对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。
#示例 1：
#输入："(()())(())"
#输出："()()()"
#解释：
#输入字符串为 "(()())(())"，原语化分解得到 "(()())" + "(())"，
#删除每个部分中的最外层括号后得到 "()()" + "()" = "()()()"。
#me
class Solution0(object):
def removeOuterParentheses(self, S):
allss = ''
start = 0
for i in range(len(S)+1):
ss = S[start:i+1]
if ss.count('(') == ss.count(')'):
allss=allss+ss[1:-1]
start = i+1
return allss
#other
class Solution1(object):
def removeOuterParentheses(self, S) :
mark = 0
stack = []
for s in S:
if s == '(':
if mark != 0:
stack.append(s)
mark += 1
if s == ')':
mark -= 1
if mark != 0:
stack.append(s)
return ''.join(stack)
9.思路：Str.lower()
#实现函数 ToLowerCase()，该函数接收一个字符串参数 str，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串。
#示例 1：
#输入: "Hello"
#输出: "hello"
#me
class Solution(object):
def toLowerCase(self, str):
return str.lower()
10.思路：暴力法，enumerate
#给定已经按升序排列、由不同整数组成的数组 A，返回满足 A[i] == i 的最小索引 i。如果不存在这样的 i，返回 -1。
#示例 1：
#输入：[-10,-5,0,3,7]
#输出：3
#解释：
#对于给定的数组，A[0] = -10，A[1] = -5，A[2] = 0，A[3] = 3，因此输出为 3 。
#me
class Solution(object):
def fixedPoint(self, A):
for i,j in enumerate(A):
if i==j:
return j
return -1
11.思路：暴力法，写出公式进行判断
#假设存在一个 k 位数 N，其每一位上的数字的 k 次幂的总和也是 N，那么这个数是阿姆斯特朗数。
#给你一个正整数 N，让你来判定他是否是阿姆斯特朗数，是则返回 true，不是则返回 false。
#示例 1：
#输入：153
#输出：true
#示例：
#153 是一个 3 位数，且 153 = 1^3 + 5^3 + 3^3。
#me
class Solution0(object):
def isArmstrong(self, N):
A = sum([int(i)**len(str(N)) for i in str(N)])
print A
if A == N:
return True
else:
return False
class Solution1(object):
def isArmstrong(self, N):
A = sum(map(lambda x:x**3, [int(i) for i in str(N)]))
if A == N:
return True
else:
return False
12.思路：暴力法，求并集元素，set()
#给出三个均为 严格递增排列 的整数数组 arr1，arr2 和 arr3。
#返回一个由 仅 在这三个数组中 同时出现 的整数所构成的有序数组。
#示例：
#输入: arr1 = [1,2,3,4,5], arr2 = [1,2,5,7,9], arr3 = [1,3,4,5,8]
#输出: [1,5]
#解释: 只有 1 和 5 同时在这三个数组中出现.
#me
class Solution0(object):
def arraysIntersection(self, arr1, arr2, arr3):
outlist = []
for i in arr1:
if i in arr2 and i in arr3:
outlist.append(i)
return outlist
#other
class Solution1(object):
def arraysIntersection(self, arr1, arr2, arr3):
return sorted(list(set(arr1)&set(arr2)&set(arr3)))
13.思路：异或运算
#两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。
#给出两个整数 x 和 y，计算它们之间的汉明距离。
#注意：
#0 ≤ x, y < 231.
#示例:
#输入: x = 1, y = 4
#输出: 2
#解释:
#1 (0 0 0 1)
#4 (0 1 0 0)
# ↑ ↑
#other
class Solution(object):
def hammingDistance(self, x, y):
return bin(x^y).count('1')
14.思路：暴力法，字典元素匹配，dict
#国际摩尔斯密码定义一种标准编码方式，将每个字母对应于一个由一系列点和短线组成的字符串， 比如: "a" 对应 ".-", "b" 对应 "-...", "c" 对应 "-.-.", 等等。
#为了方便，所有26个英文字母对应摩尔斯密码表如下：
#[".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
#给定一个单词列表，每个单词可以写成每个字母对应摩尔斯密码的组合。例如，"cab" 可以写成 "-.-..--..."，(即 "-.-." + "-..." + ".-"字符串的结合)。我们将这样一个连接过程称作单词翻译。
#返回我们可以获得所有词不同单词翻译的数量。
#例如:
#输入: words = ["gin", "zen", "gig", "msg"]
#输出: 2
#解释:
#各单词翻译如下:
#"gin" -> "--...-."
#"zen" -> "--...-."
#"gig" -> "--...--."
#"msg" -> "--...--."
#共有 2 种不同翻译, "--...-." 和 "--...--.".
#me
class Solution1(object):
def uniqueMorseRepresentations(self, words):
dict={'a':".-",'b':"-...",'c':"-.-.",'d':"-..",'e':".",'f':"..-.",'g':"--.",'h':"....",'i':"..",'j':".---",'k':"-.-",'l':".-..",'m':"--",'n':"-.",'o':"---",'p':".--.",'q':"--.-",'r':".-.",'s':"...",'t':"-",'u':"..-",'v':"...-",'w':".--",'x':"-..-",'y':"-.--",'z':"--.."}
allword = []
for word in words:
sigword = ''
for i in word:
signal = dict[i]
sigword += signal
allword.append(sigword)
return len(set(allword))
class Solution2(object):
def uniqueMorseRepresentations(self, words):
dict={'a':".-",'b':"-...",'c':"-.-.",'d':"-..",'e':".",'f':"..-.",'g':"--.",'h':"....",'i':"..",'j':".---",'k':"-.-",'l':".-..",'m':"--",'n':"-.",'o':"---",'p':".--.",'q':"--.-",'r':".-.",'s':"...",'t':"-",'u':"..-",'v':"...-",'w':".--",'x':"-..-",'y':"-.--",'z':"--.."}
allword = []
for word in words:
sigword = ''.join([dict[i] for i in word])
allword.append(sigword)
return len(set(allword))
15.思路：List.reverse()、[::-1]倒序
#给定一个二进制矩阵 A，我们想先水平翻转图像，然后反转图像并返回结果。
#水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。
#反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如，反转 [0, 1, 1] 的结果是 [1, 0, 0]。
#示例 1:
#输入: [[1,1,0],[1,0,1],[0,0,0]]
#输出: [[1,0,0],[0,1,0],[1,1,1]]
#解释: 首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]]；
# 然后反转图片: [[1,0,0],[0,1,0],[1,1,1]]
#me
class Solution(object):
def flipAndInvertImage(self, A):
allNewList = []
for i in A:
newList = i[::-1]
newList = [1-i for i in newList]
allNewList.append(newList)
return allNewList
#other
class Solution1(object):
def flipAndInvertImage(self, A):
for l in A:
l.reverse()
for l in A:
for i in range(len(l)):
l[i] = l[i] ^ 1
return A
16.思路：暴力法
#给你一个正整数的数组 A。
#然后计算 S，使其等于数组 A 当中最小的那个元素各个数位上数字之和。
#最后，假如 S 所得计算结果是 奇数 的请你返回 0，否则请返回 1。
#示例 1:
#输入：[34,23,1,24,75,33,54,8]
#输出：0
#解释：
#最小元素为 1，该元素各个数位上的数字之和 S = 1，是奇数所以答案为 0。
#来源：力扣（LeetCode）
#me
class Solution(object):
def sumOfDigits(self, A):
minNum = min(A)
lastNum = sum([int(i) for i in str(minNum)])
if lastNum%2 == 0:
return 1
else:
return 0
#other
class Solution1(object):
def sumOfDigits(self, A):
return 1 if sum(map(int,list(str(min(A))))) % 2 == 0 else 0
17.思路：计算'U'、'D'、'L'和'R'的次数，Str.count()
#在二维平面上，有一个机器人从原点 (0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在 (0, 0) 处结束。
#移动顺序由字符串表示。字符 move[i] 表示其第 i 次移动。机器人的有效动作有 R（右），L（左），U（上）和 D（下）。如果机器人在完成所有动作后返回原点，则返回 true。否则，返回 false。
#注意：机器人“面朝”的方向无关紧要。 “R” 将始终使机器人向右移动一次，“L” 将始终向左移动等。此外，假设每次移动机器人的移动幅度相同。
#示例 1:
#输入: "UD"
#输出: true
#解释：机器人向上移动一次，然后向下移动一次。所有动作都具有相同的幅度，因此它最终回到它开始的原点。因此，我们返回 true。
#me
class Solution(object):
def judgeCircle(self, moves):
return 1 if moves.count('U') == moves.count('D') and moves.count('L') == moves.count('R') else 0
18.思路：暴力法，依次判断
#学校在拍年度纪念照时，一般要求学生按照 非递减 的高度顺序排列。
#请你返回至少有多少个学生没有站在正确位置数量。该人数指的是：能让所有学生以 非递减 高度排列的必要移动人数。
#示例：
#输入：[1,1,4,2,1,3]
#输出：3
#解释：
#高度为 4、3 和最后一个 1 的学生，没有站在正确的位置。
#me
class Solution0(object):
def heightChecker(self, heights):
return sum([heights[i] != sorted(heights)[i] for i in range(len(heights))])
#other
class Solution1(object):
def heightChecker(self, heights):
res = sorted(heights)
count = 0
for i in range(len(heights)):
if res[i] != heights[i]:
count += 1
return count
19.思路：公式计算
#给你一个字符串 S，返回只含 单一字母 的子串个数。
#示例 1：
#输入： "aaaba"
#输出： 8
#解释：
#只含单一字母的子串分别是 "aaa"， "aa"， "a"， "b"。
# "aaa" 出现 1 次。
# "aa" 出现 2 次。
# "a" 出现 4 次。
# "b" 出现 1 次。
# 所以答案是 1 + 2 + 4 + 1 = 8。
#other
class Solution:
def countLetters(self, S):
cnt=1
s=0
for i in range(1,len(S)):
#print(i)
if(S[i]==S[i-1]):
cnt+=1
else:
s+=cnt*(cnt+1)/2
#print(s)
cnt=1
return int(s+cnt*(cnt+1)/2)
20：思路：暴力法，写出公式进行判断
#自除数 是指可以被它包含的每一位数除尽的数。
#例如，128 是一个自除数，因为 128 % 1 == 0，128 % 2 == 0，128 % 8 == 0。
#还有，自除数不允许包含 0 。
#给定上边界和下边界数字，输出一个列表，列表的元素是边界（含边界）内所有的自除数。
#示例 1：
#输入：
#上边界left = 1, 下边界right = 22
#输出： [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]
#me
class Solution(object):
def selfDividingNumbers(self, left, right):
allDividingNumbers = []
for num in range(left,right+1):
sigNumList = [int(i) for i in str(num)]
print(sigNumList)
flag = 0
for sigNum in sigNumList:
if sigNum != 0:
if num % sigNum != 0:
flag += 1
if flag == 0 and 0 not in sigNumList:
allDividingNumbers.append(num)
return allDividingNumbers
浙公网安备 33010602011771号