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