力拓题目9-12-804,905,929,1021

﹏ヽ暗。殇╰゛Y 2021-12-22 02:43 402阅读 0赞

国际摩尔斯密码定义一种标准编码方式，将每个字母对应于一个由一系列点和短线组成的字符串， 比如: \`"a"\` 对应 \`".-"\`, \`"b"\` 对应 \`"-..."\`, \`"c"\` 对应 \`"-.-."\`, 等等。

为了方便，所有26个英文字母对应摩尔斯密码表如下：

\`\`\`  
\[".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."\]  
\`\`\`

给定一个单词列表，每个单词可以写成每个字母对应摩尔斯密码的组合。例如，"cab" 可以写成 "-.-..--..."，(即 "-.-." + "-..." + ".-"字符串的结合)。我们将这样一个连接过程称作单词翻译。

返回我们可以获得所有词不同单词翻译的数量。

\`\`\`  
例如:  
输入: words = \["gin", "zen", "gig", "msg"\]  
输出: 2  
解释:  
各单词翻译如下:  
"gin" -> "--...-."  
"zen" -> "--...-."  
"gig" -> "--...--."  
"msg" -> "--...--."

共有 2 种不同翻译, "--...-." 和 "--...--.".  
\`\`\`

注意:

\- 单词列表\`words\` 的长度不会超过 \`100\`。  
\- 每个单词 \`words\[i\]\`的长度范围为 \`\[1, 12\]\`。  
\- 每个单词 \`words\[i\]\`只包含小写字母。

\`\`\`python  
class Solution:  
def uniqueMorseRepresentations(self, words: List\[str\]) -> int:  
dic = \{'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': "--.."\}  
res = \[\]  
for i in range(len(words)):  
temp = words\[i\]  
s = ""  
for j in range(len(temp)):  
s = s + dic\[temp\[j\]\]  
if s not in res:  
res.append(s)  
return len(res)  
\`\`\`

思路： 暴力排序，最后排字典， 然后用索引来做

给定一个非负整数数组 \`A\`，返回一个数组，在该数组中， \`A\` 的所有偶数元素之后跟着所有奇数元素。

你可以返回满足此条件的任何数组作为答案。

示例：

\`\`\`  
输入：\[3,1,2,4\]  
输出：\[2,4,3,1\]  
输出 \[4,2,3,1\]，\[2,4,1,3\] 和 \[4,2,1,3\] 也会被接受。  
\`\`\`

提示：

1. \`1 <= A.length <= 5000\`  
2. \`0 <= A\[i\] <= 5000\`

\`\`\`python  
class Solution:  
def sortArrayByParity(self, A: List\[int\]) -> List\[int\]:  
i = 0  
for j in range(len(A)):  
if A\[j\] % 2== 0:  
A\[j\],A\[i\] = A\[i\],A\[j\]  
i += 1  
return A

\# lis = \[\]  
\# lis\_1 = \[\]  
\# for i in A:  
\# if i % 2 == 0:  
\# lis.append(i)  
\# else:  
\# lis\_1.append(i)  
\# return lis + lis\_1  
\`\`\`

思路 因为不对排序有要求，直接将偶数和从1开始的循序位置对换、

每封电子邮件都由一个本地名称和一个域名组成，以 @ 符号分隔。

例如，在 \`alice@leetcode.com\`中， \`alice\` 是本地名称，而 \`leetcode.com\` 是域名。

除了小写字母，这些电子邮件还可能包含 \`'.'\` 或 \`'+'\`。

如果在电子邮件地址的本地名称部分中的某些字符之间添加句点（\`'.'\`），则发往那里的邮件将会转发到本地名称中没有点的同一地址。例如，\`"alice.z@leetcode.com”\` 和 \`“alicez@leetcode.com”\` 会转发到同一电子邮件地址。 （请注意，此规则不适用于域名。）

如果在本地名称中添加加号（\`'+'\`），则会忽略第一个加号后面的所有内容。这允许过滤某些电子邮件，例如 \`m.y+name@email.com\` 将转发到 \`my@email.com\`。 （同样，此规则不适用于域名。）

可以同时使用这两个规则。

给定电子邮件列表 \`emails\`，我们会向列表中的每个地址发送一封电子邮件。实际收到邮件的不同地址有多少？

示例：

\`\`\`  
输入：\["test.email+alex@leetcode.com","test.e.mail+bob.cathy@leetcode.com","testemail+david@lee.tcode.com"\]  
输出：2  
解释：实际收到邮件的是 "testemail@leetcode.com" 和 "testemail@lee.tcode.com"。  
\`\`\`

提示：

\- \`1 <= emails\[i\].length <= 100\`  
\- \`1 <= emails.length <= 100\`  
\- 每封 \`emails\[i\]\` 都包含有且仅有一个 \`'@'\` 字符。

\`\`\`python  
class Solution:  
def numUniqueEmails(self, emails: List\[str\]) -> int:  
lis = \[\]  
for email in emails:  
A,B = email.split('@')  
A = A.split('+')\[0\]\# split分离之后就成列表\[0\]则取第一个  
A = A.replace('.','')  
email = A + '@' + B  
if email not in lis:  
lis.append(email)  
return len(lis)  
\`\`\`

思路：先以@ 进行分离，在以+ 为后面去除 分离成列表 在以\[0\]取列表第一个

有效括号字符串为空 \`("")\`、\`"(" + 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：

\`\`\`  
输入："(()())(())"  
输出："()()()"  
解释：  
输入字符串为 "(()())(())"，原语化分解得到 "(()())" + "(())"，  
删除每个部分中的最外层括号后得到 "()()" + "()" = "()()()"。  
\`\`\`

示例 2：

\`\`\`  
输入："(()())(())(()(()))"  
输出："()()()()(())"  
解释：  
输入字符串为 "(()())(())(()(()))"，原语化分解得到 "(()())" + "(())" + "(()(()))"，  
删除每隔部分中的最外层括号后得到 "()()" + "()" + "()(())" = "()()()()(())"。  
\`\`\`

示例 3：

\`\`\`  
输入："()()"  
输出：""  
解释：  
输入字符串为 "()()"，原语化分解得到 "()" + "()"，  
删除每个部分中的最外层括号后得到 "" + "" = ""。  
\`\`\`

提示：

1. \`S.length <= 10000\`  
2. \`S\[i\]\` 为 \`"("\` 或 \`")"\`  
3. \`S\` 是一个有效括号字符串

\`\`\`python  
class Solution:  
def removeOuterParentheses(self, S: str) -> str:  
a = 0  
b = 0  
s = ""  
for i in range(len(S)):  
if S\[i\] == '(':  
a += 1  
else:  
b += 1  
if a == b:  
s = s + S\[i-2\*(a-1):i\]\#切片顾头不顾尾  
a = 0  
b = 0  
return s  
\`\`\`

转载于:https://www.cnblogs.com/zrx19960128/p/10879402.html