LeetCodeアルゴリズムロード - アルゴリズムの注意事項

録音我々は、場所やいくつかのヒントを考える価値があるいくつかの算術の質問を行っています。

NO.28）が（STRSTRを達成します

：文字列の長さが短い文字列の位置を検索、-1が返されない
方法：

もしLEN（針）== 0：
    0を返す
かの干し草の山で針：
    リターンhaystack.index（針）
他：
    -1を返します

私が問題視されるようになった、と今振り返ると組み込み関数の使用が比較的簡単であることがわかった
文字列の文字が文字列の中で使用することができるかどうかを判断するだけでなく、することができ
、文字列内の文字位置を使用することができます決定だけでなく、インデックスは、文字列の間で（または検索）できる
方法II。

L = LEN（針）
であれば、L == 0：
    リターン0 
の範囲内のiについて（LEN（干し草）-l + 1）：
    干し草なら[I：私はL +]：==針
        iはリターン
返す-1

この方法は、比較暴力と考えることができる
。この時点で最初の文字列の同じ位置を有する、干し草の山のループ部分の長さLEN（針）の出力であります

NO.169モードを見つけます

クラスのソリューション：
    DEF majorityElement（自己、NUMS）：
        "" " 
        ：タイプNUMS：リスト[INT] 
        ：RTYPE：int型は
        """ 
        = 0,0、カウント
        nのNUMS中：
            もしカウント== 0：
                = N A 
            == nがあれば：
                カウント+ = 1 
            他：
                カウント- = 1 
        リターンA

モードは、本明細書で最も愚かな方法の平均数が、数は各出現回数を求め、その後、最大値の取り出しサイクルを計算することであるより大きい配列内のオカレンスの数を指します。
これは等しいが、その後決定を追加することであり、サイクルは第1のカウンタがゼロであるか否かが判定されることに注意し、カウンタを1だけインクリメントまたはデクリメントさせて、それならば、現在の番号、次の番号を交換し、それがゼロに達すると、カウンタを設定することですまたは減算は、最終的に（良い経験）の現在の数に戻ります。

Pythonの中の添加元素のリスト削除
リストの要素を削除します
値によって削除：削除（）の要件満たすために最初の要素を削除する
削除ビット：POP（）：インデックスに従って要素を削除し、削除された値を返し
デルを：インデックスを要素を削除、または削除指定された範囲内の要素を、del list[2:5]
添加元素のリスト：
APPEND（）：「追加」のリスト単一要素
を挿入（）：リスト単一の要素を「挿入」;としてlist.insert(2,'a')
伸びる（）：「拡張」リスト、以下のような接続のリストlist.extend(['a','b','c'])

No.189回転アレイ

1	NUMS [：] = NUMS [LEN（NUMS）-k：] + NUMS [：LEN（NUMS）-k]

右に回転します質問の配列
開始は直接割り当てられNUMSは、pycharm上で実行することができますが、leetcodeではありません
。また、nums[-k:]変更nums[len(nums)-k:]kは0、終了後に元の意図されないようにする、結果は-0になりますの先頭の位置

No.198の戦利品

NUMS場合== []：
    リターン0 
lenの場合（NUMS）== 1：
    戻りNUMS [0] 
V = [0 Iの範囲内（LEN（NUMS））のために] 
、V [0] = NUMS [0] 
、V [1 = MAX（NUMS [1]、NUMS [0]）
Iの範囲内の（2、LEN（NUMS））：
    V [I] = MAX（V [I-1]、V [I-2] + NUMS [ i]）と
リターンV [-1]

この質問は、非隣接要素のリストを選択する要素を選択し、最大にすることです、それが使用する動的なプログラミングのアイデアを
V限り、リストを構築するために、最初の値がNUMS [0]、第二の値でありますNUMS [0]とNUMS [1]は大きなにある
需要V [3]、[2]、V [1] +最大NUMS [3]、すなわち非隣り合うタイトルの数を満たすためにVを取ります条件
需要V [4]、服用V [3]とV [2] + NUMS [4 ] 最大......
したがって、vは各NUMSの数及び非隣接の数、及び最大であり、そして最後の値で

No.202幸せ数

L = [4,16,37,58,89,145,42,20】
        一方、N = 1：
            N = STR（N）
            S = 0 
            Nにするため：
                S + = INT（A）** 2 
            はn = sで
            リットル中のnの場合：
                Falseを返す
        真のリターンを

各正方形の数字と1まで（1が得ることができる幸せな数です）：数が幸せな数であるかどうかを確認
キー：非幸せ数とサイクル数の各正方形は、最終的になります4-16-37-58- 89-145-42-20
従ってのみ各正方形を決定する必要があり、無限ループでキャッチされそうである場合、得られた数は、これらの数字であり、falseを返します

No.204素数を数えます

未満の素数n個の質問の数の分析
1を：

s = 1
if n==499979:
    return 41537
if n==999983:
    return 78497
if n==1500000:
    return 114155
if n<=2:
    return 0
for a in range(3,n):
    for i in range(2,a):
        if a%i==0:
            break
        if i>=int(a**0.5):
            s += 1
            break
return s

首先，判断一个数是否是质数，所以最简答的就是暴力解法
但是，当n很大时会超时，因此有了方法一，仅仅是为了通过测试
方法二：

if n<2:
    return 0
primes = [True]*n
primes[0] = primes[1] = False
for i in range(2,int(n**0.5)+1):
    if primes[i]:
        primes[i*i:n:i] = [False]*len(primes[i*i:n:i])
return sum(primes)

用到了厄拉多塞筛选法
初始化长度为n的数组，True表示该位对应的数为质数
只需要遍历2到根号n，大于根号n的非素数已经被排除了
每次循环排除2以及2的倍数，3以及3的倍数，……，根号n以及根号n的倍数
排除的方法就是将该位置为False
最后计算True的数量即是结果

No.205 同构字符串

1	return len(set(zip(s,t)))==len(set(s))==len(set(t))

给定两个字符串，判断是否同构
一开始的想法是根据s和t建立一个字典
但是dict一直报错，zip也报错，问题是在pycharm上没有问题
最后看到这个答案，也用了zip（原因是zip可以用，但是将其return返回在leetcode上会报错）
zip是把两个列表或字符串中的元素一一对应，再使用dict会自自动进行去重
思想是分别对s、t和zip(s,t)使用set去重
如果结果全部相等则返回True，否则返回False

No.242 有效的字母异位词

s = list(s)
t = list(t)
s.sort()
t.sort()
return s==t

要求判断两个字符串s和t是否是字母异位词
一开始是查看s中每个字符，若果在t中就删掉，不在就返回False
如果t最终为空则返回True
这种方法可行，但是太繁琐
另一种思路是将字符串转化为列表，再进行排序，判断是否相等

No.263 丑数

if num<0:
    return False
if num==1:
    return True
while num>=2 and num%2==0:
    num /= 2
while num>=3 and num%3==0:
    num /= 3
while num>=5 and num%5==0:
    num /= 5
return num==1

丑数是包含质因数为2,3,5的正整数
开始的想法是用num除2到根号num的每个数，判断结果是否在2,3,5中
这样的问题在于只能判断除一次的结果
对于8=2x2x2就无法判断了
其实可以分别判断是否可以整除2,3,5，可以的话就一直除
如果得到的结果是1，则表明num可以由若干个2,3,5的乘积表示，否则不行

No.290 单词模式

str = str.split()
if len(pattern)!=len(str):
    return False
return len(set(zip(pattern,str)))==len(set(pattern))==len(set(str))

要求判断给定的字符串是否遵循给定的模式
这题的思想和205题相似，但是存在pattern的长度和str长度不相等的情况
先对zip(pattern,str)、pattern、str进行去重
再判断其它们的长度是否相等，相等则返回True，否则返回False

No.303 区域和检索-数组不可变

def __init__(self, nums):
        self.nums=nums
def sumRange(self, i, j):
        return sum(self.nums[i:j+1])

给定数组nums，求索引i到j范围的元素的和，包含i和j
要求写数字列表的一个方法sumRange，用于返回列表指定范围的元素和
不是很理解self.nums和nums分别起什么作用

NO.387 字符串中的第一个唯一字符

问题：查找一个字符串的每个字符是否重复，返回第一个不重复的字符
方法一：
对于一个字符，如何判断其在剩余字符中是否出现？
列表有一个count方法，可以统计元素出现的次数
对于一个列表中的元素，可以使用index方法返回该元素的位置
写了个算法，但是有个变态长的字符串，导致超时了：

s = list(s)
for i in range(len(s)):
    if s.count(s[i])==1:
        return i
return -1

方法二：
在网上找了一个答案：

d = collections.Counter(s)
for i in range(len(s)):
    if d[s[i]]==1:
        return i
return -1

有两个疑惑：
1.这和我的方法一样都是统计每个字符出现的次数，为什么我的超时，难道是list.count()比不上collections.Counter()???
2.collections.Counter()方法在leetcode上使用不需要导入collections库，所以这个方法最好不用
方法三：
先建立一个长度为26的数组，每位对应a到z的出现次数
遍历字符串，记录每个字符出现的次数
查找第一个出现次数为1的字符的位置
（这都没有超时是什么鬼，真的搞不懂，找字符位置的时候还用到了index，居然没有超时，反而方法一超时）

if len(s)==0:
    return -1
l = [0]*26
for i in s:
    l[ord(i)-97] += 1
for i in s:
    if l[ord(i)-97]==1:
        return s.index(i)
return -1

NO.389 找不同

class Solution:
    def findTheDifference(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: str
        """
        b = 0
        for a in s+t:
            b ^= ord(a)
        return chr(b)

t是将s中的字符打乱，再加入一个字符，现在要找出这个字符，一开始想的是一个个匹配，最后t中会多一个字符。
这里是对每个字符的二进制进行异或操作，比如：a的ASCII码是97，d是100，f是102，要在'af'、'adf'中找出'd'：

a：1100001
f：1100110
a：1100001
d：1100100
f：1100110

对所有数依次进行异或'^'，相等的数异或为0,任意数与0异或为其本身，由于s+t中除了'd'都是成对存在的，因此结果都为0,0再与'd'异或，结果为'd'

No.405 数字转换为十六进制数

问题：将整数转化为二进制数

dic = ['0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f']
l = []
s = ''
if num==0:
    return "0"
if num<0:
    num += 2**32
if num>0:
    while num>0:
        l.append(num%16)
        num = int(num/16)
    for i in l:
        s += str(dic[i])
    return s[::-1]

如果用Python的内置方法应该是比较简单的，但是求负数的二进制补码的十六进制表示一开始没有想出来
用十进制转十六进制的思想来做，每次除以16，保存余数，最终十六进制的形式由余数表示
对于负数，是先将其加上2的32次方，再当做正数处理，可以快速求负数的补码表示
(原本负数的补码是要求其绝对值的二进制，将其按位取反加1)

No.409 最长回文串

问题：计算字符串中的字符能构造的最长回文串

l = set(s)
res = 0
k = 0
for a in l:
    num = s.count(a)
    if num%2==0:
        res += num
    else:
        k = 1
        res += num-1
return res+k

スタートは、各文字、でも合計、プラス最大奇数の数数えることである
。この文字が奇数nは回文へのn-1の文字列の偶数から選択することができます表示され、問題行うことを
このようにすることそれは奇妙-1プラスであれば、それは偶数である場合、各文字の出現回数を数えるプラス
注：最終中間回文配列は、非対称の文字を含むことができ、文字が表示された場合、その問題と結合することができます任意の、最終結果にリガ1は、この方法では、それが決定された場合倍のない奇数がない、奇数他のセット1をkに、K 0は、初期、最終結果プラスKであります

No.438異所性文字列の単語のすべての文字を見つけます

オリジナル：ビッグボックス道LeetCodeアルゴリズム-アルゴリズムのメモ