Quickstart

  1. Upload a picture (or a batch of pictures as a .zip file);
  2. Click “Execute”;
  3. Wait for the script execution;
  4. Read & copy the line from the pseudo terminal.
upload a file

Advanced Settings

This section introduces the advanced settings that may be useful.

Optional OCR Modes

There are three OCR modes available: Full Scale (which is the default and scans the whole picture), Auto Cropping (which scans the bottom part of the picture where most hardsubs appear), and Custom Area (which allows you to scan a specific area). read more

中文说明

依赖于NLTK库,感谢前人的贡献。

本脚本可以识别出英语文本中的被动语态,包括主句和从句。

被动语态识别规则:

  • 若一个句子中没有被动分词,则该句不可能是被动句
  • 若一个句子中仅有一个被动分词且其为“been”,则该句不可能为被动句 eg: He has been a teacher since 2000.
  • 若一个句子中至少含有一个“been”之外的过去分词,且该过去分词到前方最近的人称代词或名词之间的所有动词均为be的某种形式,则该句中存在被动语态。
  • read more

    原题链接:http://www.lintcode.com/zh-cn/problem/strings-homomorphism/
    给定两个字符串 s 和 t ,确定它们是否是同构的。
    两个字符串是同构的如果 s 中的字符可以被替换得到 t。
    所有出现的字符必须用另一个字符代替,同时保留字符串的顺序。 没有两个字符可以映射到同一个字符,但一个字符可以映射到自己。

    样例
    给出 s = “egg”, t= “add”, 返回 true。
    给出 s = “foo”, t= “bar”, 返回 false。
    给出 s = “paper”, t= “title”, 返回 true。

    思路:由“映射”比较容易想到字典。可以由s到t逐位建立字符到字符之间的键值对,如果某个键第二次出现,则立刻去字典中检验此键对应的值是不是t中第二次出现的值。假如不是,则可以立刻返回False。在字典建立完毕后,再统计字典的值中有没有相同的元素,如果有,说明有一个值可以对应两个键,也不满足条件,直接return False。如果运行完毕没有问题,说明键值对存在一一对应的关系,return True即可。

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    
    class Solution:
        """
        @param: s: a string
        @param: t: a string
        @return: true if the characters in s can be replaced to get t or false
        """
        def isIsomorphic(self, s, t):
            if s == '' or t =='' or len(s)!=len(t):
                return False
            mapped = {}
            for i in range(len(s)):
                if s[i] not in mapped:
                    mapped[s[i]] = t[i]
                else:
                    if mapped[s[i]] != t[i]:
                        return False
            if len(mapped.values()) != len(set(mapped.values())):
                return False
            return True

    给出一个包含大小写字母的字符串。求出由这些字母构成的最长的回文串的长度是多少。

    数据是大小写敏感的,也就是说,”Aa” 并不会被认为是一个回文串。

    样例
    给出 s = “abccccdd” 返回 7

    一种可以构建出来的最长回文串方案是 “dccaccd”。

    思路:回文串的特性是对称性。若想构造回文串,只需将原字符串中数量为偶数个的元素放置在回文串两边,将某个数量为奇数个元素的元素放置在回文串正中间即可。题目的要求是构造最长回文串。那么我们可以对原字符串进行分解并统计其中每个元素出现的次数。若出现偶数次,则不用处理,直接放在新字符串两边即可;若出现奇数次,则可以减1放在新字符串两边;同时,原字符串内出现奇数次最多的元素可以放在新字符串正中间。同时满足这三个要求,即是最长回文串。

    解法一:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    
    class Solution:
        """
        @param: s: a string which consists of lowercase or uppercase letters
        @return: the length of the longest palindromes that can be built
        """
        def longestPalindrome(self, s):
            if s == '':
                return 0
            var = set(s)
            n = 0                                                 #n为新字符串中放置在两边的偶数元素
            m = 1                                                 #m为新字符串放置在正中间的奇数元素
            t = -1                                                #t为最多个奇数元素出现的次数(如aaabbbccc这种情况下,t=3)
            if len(var) == 1:
                return len(s)
            for i in var:
                if s.count(i) % 2 != 0 and s.count(i) > m:
                    m = s.count(i)
            for i in var:
                if s.count(i) % 2 == 0:
                    n += s.count(i)
                elif s.count(i) == m:
                    t += 1
                else:
                    n += s.count(i)-1
            return n+m+(m-1)*t

    解法二:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    
    class Solution:
        """
        @param: s: a string which consists of lowercase or uppercase letters
        @return: the length of the longest palindromes that can be built
        """
        def longestPalindrome(self, s):
            if s == '':
                return 0
            var = set(s)
            if len(var) == 1:
                return len(s)
            total = len(s)
            for i in var:
                if s.count(i) % 2 != 0:                            #简单优雅,遇到奇数直接减一
                    total -= 1
            return total+1

    首先看两段代码
    代码1

    1
    2
    3
    4
    5
    6
    7
    8
    
    def recursion_wrong(n):
        if n == 1:
            return n
        else:
            n -= 1
            recursion_wrong(n)
     
    print(recursion_wrong(10))

    结果为None

    代码2

    1
    2
    3
    4
    5
    6
    7
    8
    
    def recursion_correct(n):
        if n == 1:
            return n
        else:
            n -= 1
            return recursion_correct(n)
     
    print(recursion_correct(10))

    结果为1

    这是一个非常简单的递归程序,判断输入的n是否为1,如果不是,就继续判断n-1。直到n=1时,输出。

    乍一看,似乎第一段代码没有什么问题。然而实际运行时,发现不论输入的值是多少,一定会返回None。必须要在调用自己的部分,加上return,才能得到自己想要的结果。

    那么这是为什么呢?其实道理很简单。函数在执行时,递归到最内层的函数满足if条件,确实可以运算出结果,但此结果是最内层函数的结果而非最外层函数的结果。当这个运算结果一层一层返回到最外一层时,由于else语句中不包含return,此函数就会因执行完毕而返回None。因此递归函数的递归部分必须要加上return才可以。

    或者换一种思路考虑。仅看代码1,看一下代码实际走的流程。假如输入n=10。明显if条件不满足,继续执行else语句。可以看到,else语句块不包含return语句,也就是说不论else内部语句如何执行,函数最终也只能返回None。除非在else语句块中有全局变量,否则其中的任何运算结果都是无法返回到函数之外的。

    结论:递归函数的两个出口都需要有return才可以正常运行。

    =========================================================================================================================================
    2017.11.16更新
    之前的思路欠妥。若递归函数内部包含全局变量,可以记录每次递归所修改的内容,那么递归的部分不加return也是可以了。关键是要看递归函数的作用是修改某个变量(列表,字典….)还是要输出某个结果。若要输出,则必须确保每次递归的结果都能传递到上一层,且上一层可以记录下来并继续向上传递。

    基本需求:现有保存在本地的多个离线网页,其网页布局结构基本相似。需要将其中有意义的文字提取出来保存成单独的文件。

     

    思路分析:总体而言,而将此问题分成前后两个部分。第一部分是提取网页中的文字,可以使用BeautifulSoup库快速定位出需要保存的部分;第二部分是保存,使用Python自带的i/o功能即可。最后就是整体的运行逻辑,使用for循环遍历所有的网页文件,读取——提取——保存即可顺利完成。

     

    代码如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    
    import os
    import glob
    from bs4 import BeautifulSoup
     
    def filter(webpage):                               #抓取网页内容
        file = open(webpage,encoding='utf-8')
        page = BeautifulSoup(file,'html5lib')
        content = page.find_all(name='p')              #标签“p”可根据实际需要进行修改,
        for i in content[:]:                           #“p”适用率最高,但冗余信息也最多
            content.remove(i)
            content.append(i.get_text())               #将BeautifulSoup的标签转化成字符串
        return content                          
     
    def saver(filename,content):                       #保存文件部分             
        os.chdir('Info')                               #进入"Info"文件夹
        file = open(filename,'a+',encoding='UTF-8')
        for i in content:
            try:
                file.write(i + '\n')                   #每行加上一个换行符
            except TypeError:
                pass
        file.close()
        os.chdir('..')                                 #回到上层目录
     
    def main():                                        #主程序部分
        os.mkdir('Info')                               #新建“Info”文件夹
        files = glob.glob('*.htm*')                    #遍历获取本文件夹中所有的“htm”和“html”文件
        for file in files:
            filename = file.replace('.html','.txt')    #将html文件名转化成txt文件名
            filename = filename.replace('.htm','.txt')
            content = filter(file)                     #读取网页
            saver(filename,content)                    #保存网页
     
     
    if __name__ == '__main__':
        main()

    某页纸上有一个数列A。A包含了按照从小到大顺序排列的多个自然数,但是因为一些原因,其中有一些连续的位置(个数为M)看不清了。其中,左边最小的数是X,右边最大的数为Y。这些数符合累加在P和Q之间,大于等于P,小于等于Q,请写程序在输入M,X,Y,P,Q后自动给出所有可能的合法排列。 read more