zoukankan      html  css  js  c++  java
  • 力拓题目9-12-804,905,929,1021

    国际摩尔斯密码定义一种标准编码方式,将每个字母对应于一个由一系列点和短线组成的字符串, 比如: `"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
    ```

  • 相关阅读:
    SD卡测试
    测试人员可能会遇到的问题
    HDU 1024 Max Sum Plus Plus
    HDU 1176 免费馅饼
    HDU 1257 最少拦截系统
    HDU 1087 Super Jumping! Jumping! Jumping!
    poj 1328 Radar Installation
    poj 1753 Flip Game
    HDU 1003 Max Sum
    HDU 5592 ZYB's Premutation(BestCoder Round #65 C)
  • 原文地址:https://www.cnblogs.com/zrx19960128/p/10879402.html
Copyright © 2011-2022 走看看