第一次玩Leetcode，对代码提交格式不了解，提交了一上午，略尴尬

leetcode确实有很多有意思的地方，不像以前做各个高校ACM练习，leetcode会给出错误信息（哪个数据的错了），也会提供测试用例自定义窗口，你可以自己设置测试样例



对于输出结果会有个比较窗口，出现你的程序和源程序结果比对，帮你快速定位错误原因



此外，leetcode只需要你写核心代码部分，读取输入函数，函数调用都不需要自己做，在程序提交时，leetcode会自动补全，同时，也就要求我们写的核心代码部分必须按照leetcode规定的格式来写。

Python（像我这种习惯了C语言的人，刚开始就直接自己写了个函数就扔上面去，结果就是找不到Slution类）



C++



JAVA



C语言



主要是照着它的格式写，框框里就是leetcode提交需要的接口，你只需要实现这个接口就行了。

 

 

273. Integer to English Words

Convert a non-negative integer to its english words representation. Given input is guaranteed to be less than 231 - 1.

For example,

123 -> "One Hundred Twenty Three"
12345 -> "Twelve Thousand Three Hundred Forty Five"
1234567 -> "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"

Python实现：

class Solution(object):
    def __init__(self):
        self.units = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Eleven',
                      'Twelve', 'Thirteen', 'Fourteen', 'Fifteen', 'Sixteen', 'Seventeen', 'Eighteen', 'Nineteen', 'Twenty']
        self.tens = ['', 'Ten', 'Twenty', 'Thirty', 'Forty', 'Fifty', 'Sixty', 'Seventy', 'Eighty', 'Ninety']

    def numberToWords(self, num):
        if num > 999999999:
            if num % 1000000000 == 0:
                return self.numberToWords(num / 1000000000) + " Billion"
            else:
                return self.numberToWords(num / 1000000000) + " Billion " + self.numberToWords(num % 1000000000)
        elif num > 999999:
            if num % 1000000 == 0:
                return self.numberToWords(num / 1000000) + " Million"
            else:
                return self.numberToWords(num / 1000000) + " Million " + self.numberToWords(num % 1000000)
        elif num > 999:
            if num % 1000 == 0:
                return self.numberToWords(num / 1000) + " Thousand"
            else:
                return self.numberToWords(num / 1000) + " Thousand " + self.numberToWords(num % 1000)
        elif num > 99:
            if num % 100 == 0:
                return self.units[num / 100] + " Hundred"
            else:
                return self.units[num / 100] + " Hundred " + self.numberToWords(num % 100)
        elif num > 20:
            if num % 10 == 0:
                return self.tens[(num / 10)]
            else:
                return self.tens[(num / 10)] + " " + self.units[num % 10]
        else:
            return self.units[num]

 

博主的github链接，欢迎大家来访问~：https://github.com/Sh-Zh-7

和Luogu等其他OJ完全不一样，leetcode的代码不需要你printf，甚至不需要你有主函数。

它唯一有的就是一个叫做Solution的类，类中有一个函数，返回值和参数都给你写好了，算是一个提示吧。

在这种情况下我们提交代码就要注意以下几点：

完全不用担心头文件的问题，他都给你补全好了。
	
你不需要自己补全主函数，只要能够写出可以跑的目标函数即可。
	
如果你要引入其他函数，可以直接写在类里面。
关于leetcode还有其他几点要谈：

输入样例格式的问题：今天做到一题，对C++选手特别不友好，字符用双引号括起来，vector用Python中的list来表示。不过这个没什么影响，适应就行。
	
关于输入参数的问题：leetcode都把你的参数给封装好了。但是这个也有一点问题：那就是我们可能会缺少某些信息。比如他给你传一个vector，那其中就包含了vector的长度，你就应该自己去获取他，而不是以测试样例的长度作为一个常数来搞。
	
关于测试点数据的问题：leetcode的测试点数目很多，不单单是5个10个15个那么死板，有时候可能会有40多个；这么多测试点其中就包含了对你程序robust的考验——比如你要取绝对值，他就给你来个INT_MIN; 你不是要输入数据吗？我干脆给你一个空的。这些都很让人纠结，但是对你的代码能力也是很大的一个考验。
一些技巧：

如果你要使用类似全局变量的东西，可以在class内部声明。这样的效果就是所有的成员函数都可以使用，效果上等价于全局变量。
好了，先就讲这么多吧，以后碰到再提一下。

 

这篇有一些是在草稿箱里翻的，复制过来格式好像变了，间距变得很大
下篇开始用新的编辑器
另外发现了每次Leetcode提交答案时从detail里可以看自己的速度和别人的比较，但是好像速度和自己的机器有关？我的和第一的代码一样但就是排在了后面，这个功能相对能查看自己代码的好坏，也不用去discuss搜别人的代码了

643. Maximum Average Subarray I
给一个列表和一个数k，求这个列表里连续k个数的最大平均值
Example 1:
Input: [1,12,-5,-6,50,3], k = 4
Output: 12.75
Explanation: Maximum average is (12-5-6+50)/4 = 51/4 = 12.75
我的代码：
class Solution(object):  
    def findMaxAverage(self, nums, k):  
        """ 
        :type nums: List[int] 
        :type k: int 
        :rtype: float 
        """  
        ans = sum(nums[:k])  
        sum_ = ans  
        for i in range(len(nums)-k):  
            sum_ = sum_ - nums[i]+nums[k+i]  
            ans = max(ans,sum_)  
        return ans/float(k)
另一个思路：
def findMaxAverage(self, A, K):  
    P = [0]  
    for x in A:  
        P.append(P[-1] + x)  
  
    ma = max(P[i+K] - P[i]   
             for i in xrange(len(A) - K + 1))  
    return ma / float(K)  
大神的代码：
def findMaxAverage(self, nums, k):  
    sums = [0] + list(itertools.accumulate(nums))  
    return max(map(operator.sub, sums[k:], sums)) / k  #迭代器中两个参数列表会在达到最短列表长度就即刻停止  
#NumPy version (requires import numpy as np):  
def findMaxAverage(self, nums, k):  
    sums = np.cumsum([0] + nums)  
    return int(max(sums[k:] - sums[:-k])) / k  
20. Valid Parentheses
给出由‘()[]{}’组成的字符串，判断其中的符号是否使用正确
"()" and "()[]{}" are all valid but "(]" and "([)]" are not.
我的代码：很耗时的re
class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        last = ''
        new = s
        while last != new:
            last,new = new,re.sub('(\(\))|(\[\])|(\{\})','',new)
        return new == ''
            
大神的代码：思路很清晰：
class Solution:
    # @return a boolean
    def isValid(self, s):
        stack = []
        dict = {"]":"[", "}":"{", ")":"("}
        for char in s:
            if char in dict.values():
                stack.append(char)
            elif char in dict.keys():
                if stack == [] or dict[char] != stack.pop():
                    return False
            else:
                return False
        return stack == []
438. Find All Anagrams in a String
给出一个两个字符串s,p求s中子字符串由p打乱组成的索引
Example 1:
Input:
s: "cbaebabacd" p: "abc"

Output:
[0, 6]

Explanation:
The substring with start index = 0 is "cba", which is an anagram of "abc".
The substring with start index = 6 is "bac", which is an anagram of "abc".
Example 2:
Input:
s: "abab" p: "ab"

Output:
[0, 1, 2]

Explanation:
The substring with start index = 0 is "ab", which is an anagram of "ab".
The substring with start index = 1 is "ba", which is an anagram of "ab".
The substring with start index = 2 is "ab", which is an anagram of "ab".
我的代码：
class Solution(object):
    def findAnagrams(self, s, p):
        """
        :type s: str
        :type p: str
        :rtype: List[int]
        """
        
        pcount = dict.fromkeys('abcdefghijklmnopqrstuvwxyz',0)
        pcount.update(collections.Counter(p))
        scount = dict.fromkeys('abcdefghijklmnopqrstuvwxyz',0)
        l = len(p)
        for i in s[:l]:
            scount[i] += 1
        if scount == pcount:
            ans = [0]
        else:
            ans = []
        for j in range(len(s)-l):
            scount[s[j]] -= 1
            scount[s[l+j]] += 1
            if scount == pcount:
                ans.append(j+1)
        return ans
方法大同小异，有的用包含26个元素的list，或者ord对应的字典，我的代码中的字典本来只包含p中的元素，改为26个字母后减少了判断的次数，加快了算法
112. Path Sum
给出一个树和一个值，求是否有节点和为值的从根到叶的路径
For example:
Given the below binary tree and sum = 22,
              5
             / \
            4   8
           /   / \
          11  13  4
         /  \      \
        7    2      1
return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
我的代码：
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def hasPathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: bool
        """
        def dfs(node,sum_):
            if node:
                sum_ += node.val
                if not(node.left or node.right):
                    return sum_ == sum 
                return dfs(node.left,sum_) or dfs(node.right,sum_)
            else:
                return False
        return dfs(root,0)
大神的代码：思路都一样，几个版本供参考
# DFS Recursively 
def hasPathSum1(self, root, sum):
    res = []
    self.dfs(root, sum, res)
    return any(res)
    
def dfs(self, root, target, res):
    if root:
        if not root.left and not root.right:
            if root.val == target:
                res.append(True)
        if root.left:
            self.dfs(root.left, target-root.val, res)
        if root.right:
            self.dfs(root.right, target-root.val, res)

# DFS with stack
def hasPathSum2(self, root, sum):
    if not root:
        return False
    stack = [(root, root.val)]
    while stack:
        curr, val = stack.pop()
        if not curr.left and not curr.right:
            if val == sum:
                return True
        if curr.right:
            stack.append((curr.right, val+curr.right.val))
        if curr.left:
            stack.append((curr.left, val+curr.left.val))
    return False
    
# BFS with queue
def hasPathSum(self, root, sum):
    if not root:
        return False
    queue = [(root, sum-root.val)]
    while queue:
        curr, val = queue.pop(0)
        if not curr.left and not curr.right:
            if val == 0:
                return True
        if curr.left:
            queue.append((curr.left, val-curr.left.val))
        if curr.right:
            queue.append((curr.right, val-curr.right.val))
    return False
下面两个是没什么头绪或者看错了题做错了半天，看了discuss的，思路非常棒


205. Isomorphic Strings
给两个字符串，相同的字符可以换成一个另外的相同字符，是否能通过这样的变化让两个字符串一样
class Solution(object):
    def isIsomorphic(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        return len(set(zip(s,t))) == len(set(s)) == len(set(t))


141. Linked List Cycle
判断一个链表是否有循环
# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        slow = head
        fast = head
        try:
            while True:
                slow = slow.next
                fast = fast.next.next
                if slow == fast:
                    return True
        except:
            return False


        
        
        
        
        
        
        
        
        
        
        



                





205. Isomorphic Strings

重新格式化字符串 显示英文描述

通过的用户数3311

尝试过的用户数3450

用户总通过次数3455

用户总提交次数6732

题目难度Easy

给你一个混合了数字和字母的字符串 s，其中的字母均为小写英文字母。

请你将该字符串重新格式化，使得任意两个相邻字符的类型都不同。也就是说，字母后面应该跟着数字，而数字后面应该跟着字母。

请你返回 重新格式化后 的字符串；如果无法按要求重新格式化，则返回一个 空字符串 。

示例 1：

输入：s = “a0b1c2”

输出：“0a1b2c”

解释：“0a1b2c” 中任意两个相邻字符的类型都不同。 “a0b1c2”, “0a1b2c”, “0c2a1b” 也是满足题目要求的答案。

示例 2：

输入：s = “leetcode”

输出：""

解释：“leetcode” 中只有字母，所以无法满足重新格式化的条件。

示例 3：

输入：s = “1229857369”

输出：""

解释：“1229857369” 中只有数字，所以无法满足重新格式化的条件。

示例 4：

输入：s = “covid2019”

输出：“c2o0v1i9d”

示例 5：

输入：s = “ab123”

输出：“1a2b3”

提示：

1 <= s.length <= 500

s 仅由小写英文字母和/或数字组成。

这里面有几个需要考虑的，在提交的时候才发现的：

1.如果只有1个数字或者字符，应当返回本身

2.数字和字符哪个多哪个先开头
我自己写得比较复杂
class Solution:
    def reformat(self, s: str) -> str:
        m=[]
        n=[]
        result=''
        if len(s)==1:
            result=s
        else:
            for i in s:
                if i in '0123456789':

                    m.append(i)
                else:
                    n.append(i)
            
            if (len(m)==len(s))|(len(n)==len(s)):
                result=''
            else:
                if len(m)>len(n):
                    for i in range(len(m)+len(n)):
                        if i%2==0:
                            result+=m[int(i/2)]
                        else:
                            result+=n[int((i+1)/2-1)]
                else:
                    for i in range(len(m)+len(n)):
                        if i%2==0:
                            result+=n[int(i/2)]
                        else:
                            result+=m[int((i+1)/2-1)]
        return result

最快完成的里面 用C++和JAVA的比较多

找了一个PYTHON的
class Solution:
    def reformat(self, s: str) -> str:
        cc = []
        nn = []
        for c in s:
            if c.isdigit():
                nn.append(c)
            else:
                cc.append(c)
        if abs(len(cc) - len(nn)) > 1:
            return ''
        if len(cc) < len(nn):
            cc, nn = nn, cc
        res = []
        for i in range(len(cc)):
            res.append(cc[i])
            if i < len(nn):
                res.append(nn[i])
        return ''.join(res)