nltk 3.2__zip → 3.3__zip

{nltk-3.2 → nltk-3.3}/nltk/misc/sort.py

@@ -1,157 +1,157 @@
-# Natural Language Toolkit: List Sorting
-#
-# Copyright (C) 2001-2015 NLTK Project
-# Author: Steven Bird <stevenbird1@gmail.com>
-# URL: <http://nltk.org/>
-# For license information, see LICENSE.TXT
-
-"""
-This module provides a variety of list sorting algorithms, to
-illustrate the many different algorithms (recipes) for solving a
-problem, and how to analyze algorithms experimentally.
-"""
-from __future__ import print_function, division
-
-# These algorithms are taken from:
-# Levitin (2004) The Design and Analysis of Algorithms
-
-##################################################################
-# Selection Sort
-##################################################################
-
-def selection(a):
-    """
-    Selection Sort: scan the list to find its smallest element, then
-    swap it with the first element.  The remainder of the list is one
-    element smaller; apply the same method to this list, and so on.
-    """
-    count = 0
-
-    for i in range(len(a) - 1):
-        min = i
-
-        for j in range(i+1, len(a)):
-            if a[j] < a[min]:
-                min = j
-
-            count += 1
-
-        a[min],a[i] = a[i],a[min]
-
-    return count
-
-##################################################################
-# Bubble Sort
-##################################################################
-
-def bubble(a):
-    """
-    Bubble Sort: compare adjacent elements of the list left-to-right,
-    and swap them if they are out of order.  After one pass through
-    the list swapping adjacent items, the largest item will be in
-    the rightmost position.  The remainder is one element smaller;
-    apply the same method to this list, and so on.
-    """
-    count = 0
-    for i in range(len(a)-1):
-        for j in range(len(a)-i-1):
-            if a[j+1] < a[j]:
-                a[j],a[j+1] = a[j+1],a[j]
-                count += 1
-    return count
-
-
-##################################################################
-# Merge Sort
-##################################################################
-
-def _merge_lists(b, c):
-    count = 0
-    i = j = 0
-    a = []
-    while (i < len(b) and j < len(c)):
-        count += 1
-        if b[i] <= c[j]:
-            a.append(b[i])
-            i += 1
-        else:
-            a.append(c[j])
-            j += 1
-    if i == len(b):
-        a += c[j:]
-    else:
-        a += b[i:]
-    return a, count
-
-def merge(a):
-    """
-    Merge Sort: split the list in half, and sort each half, then
-    combine the sorted halves.
-    """
-    count = 0
-    if len(a) > 1:
-        midpoint = len(a) // 2
-        b = a[:midpoint]
-        c = a[midpoint:]
-        count_b = merge(b)
-        count_c = merge(c)
-        result, count_a = _merge_lists(b, c)
-        a[:] = result # copy the result back into a.
-        count = count_a + count_b + count_c
-    return count
-
-##################################################################
-# Quick Sort
-##################################################################
-
-def _partition(a, l, r):
-    p = a[l]; i = l; j = r+1
-    count = 0
-    while True:
-        while i < r:
-            i += 1
-            if a[i] >= p: break
-        while j > l:
-            j -= 1
-            if j < l or a[j] <= p: break
-        a[i],a[j] = a[j],a[i]               # swap
-        count += 1
-        if i >= j: break
-    a[i],a[j] = a[j],a[i]                   # undo last swap
-    a[l],a[j] = a[j],a[l]
-    return j, count
-
-def _quick(a, l, r):
-    count = 0
-    if l<r:
-        s, count = _partition(a, l, r)
-        count += _quick(a, l, s-1)
-        count += _quick(a, s+1, r)
-    return count
-
-def quick(a):
-    return _quick(a, 0, len(a)-1)
-
-##################################################################
-# Demonstration
-##################################################################
-
-def demo():
-    from random import shuffle
-
-    for size in (10, 20, 50, 100, 200, 500, 1000):
-        a = list(range(size))
-
-        # various sort methods
-        shuffle(a); count_selection = selection(a)
-        shuffle(a); count_bubble    = bubble(a)
-        shuffle(a); count_merge     = merge(a)
-        shuffle(a); count_quick     = quick(a)
-
-        print((("size=%5d:  selection=%8d,  bubble=%8d,  "
-                "merge=%6d,  quick=%6d") %
-               (size, count_selection, count_bubble,
-                count_merge, count_quick)))
-
-if __name__ == '__main__':
-    demo()
+# Natural Language Toolkit: List Sorting
+#
+# Copyright (C) 2001-2018 NLTK Project
+# Author: Steven Bird <stevenbird1@gmail.com>
+# URL: <http://nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+This module provides a variety of list sorting algorithms, to
+illustrate the many different algorithms (recipes) for solving a
+problem, and how to analyze algorithms experimentally.
+"""
+from __future__ import print_function, division
+
+# These algorithms are taken from:
+# Levitin (2004) The Design and Analysis of Algorithms
+
+##################################################################
+# Selection Sort
+##################################################################
+
+def selection(a):
+    """
+    Selection Sort: scan the list to find its smallest element, then
+    swap it with the first element.  The remainder of the list is one
+    element smaller; apply the same method to this list, and so on.
+    """
+    count = 0
+
+    for i in range(len(a) - 1):
+        min = i
+
+        for j in range(i+1, len(a)):
+            if a[j] < a[min]:
+                min = j
+
+            count += 1
+
+        a[min],a[i] = a[i],a[min]
+
+    return count
+
+##################################################################
+# Bubble Sort
+##################################################################
+
+def bubble(a):
+    """
+    Bubble Sort: compare adjacent elements of the list left-to-right,
+    and swap them if they are out of order.  After one pass through
+    the list swapping adjacent items, the largest item will be in
+    the rightmost position.  The remainder is one element smaller;
+    apply the same method to this list, and so on.
+    """
+    count = 0
+    for i in range(len(a)-1):
+        for j in range(len(a)-i-1):
+            if a[j+1] < a[j]:
+                a[j],a[j+1] = a[j+1],a[j]
+                count += 1
+    return count
+
+
+##################################################################
+# Merge Sort
+##################################################################
+
+def _merge_lists(b, c):
+    count = 0
+    i = j = 0
+    a = []
+    while (i < len(b) and j < len(c)):
+        count += 1
+        if b[i] <= c[j]:
+            a.append(b[i])
+            i += 1
+        else:
+            a.append(c[j])
+            j += 1
+    if i == len(b):
+        a += c[j:]
+    else:
+        a += b[i:]
+    return a, count
+
+def merge(a):
+    """
+    Merge Sort: split the list in half, and sort each half, then
+    combine the sorted halves.
+    """
+    count = 0
+    if len(a) > 1:
+        midpoint = len(a) // 2
+        b = a[:midpoint]
+        c = a[midpoint:]
+        count_b = merge(b)
+        count_c = merge(c)
+        result, count_a = _merge_lists(b, c)
+        a[:] = result # copy the result back into a.
+        count = count_a + count_b + count_c
+    return count
+
+##################################################################
+# Quick Sort
+##################################################################
+
+def _partition(a, l, r):
+    p = a[l]; i = l; j = r+1
+    count = 0
+    while True:
+        while i < r:
+            i += 1
+            if a[i] >= p: break
+        while j > l:
+            j -= 1
+            if j < l or a[j] <= p: break
+        a[i],a[j] = a[j],a[i]               # swap
+        count += 1
+        if i >= j: break
+    a[i],a[j] = a[j],a[i]                   # undo last swap
+    a[l],a[j] = a[j],a[l]
+    return j, count
+
+def _quick(a, l, r):
+    count = 0
+    if l<r:
+        s, count = _partition(a, l, r)
+        count += _quick(a, l, s-1)
+        count += _quick(a, s+1, r)
+    return count
+
+def quick(a):
+    return _quick(a, 0, len(a)-1)
+
+##################################################################
+# Demonstration
+##################################################################
+
+def demo():
+    from random import shuffle
+
+    for size in (10, 20, 50, 100, 200, 500, 1000):
+        a = list(range(size))
+
+        # various sort methods
+        shuffle(a); count_selection = selection(a)
+        shuffle(a); count_bubble    = bubble(a)
+        shuffle(a); count_merge     = merge(a)
+        shuffle(a); count_quick     = quick(a)
+
+        print((("size=%5d:  selection=%8d,  bubble=%8d,  "
+                "merge=%6d,  quick=%6d") %
+               (size, count_selection, count_bubble,
+                count_merge, count_quick)))
+
+if __name__ == '__main__':
+    demo()

{nltk-3.2 → nltk-3.3}/nltk/misc/wordfinder.py

@@ -1,129 +1,129 @@
-# Natural Language Toolkit: Word Finder
-#
-# Copyright (C) 2001-2015 NLTK Project
-# Author: Steven Bird <stevenbird1@gmail.com>
-# URL: <http://nltk.org/>
-# For license information, see LICENSE.TXT
-
-# Simplified from PHP version by Robert Klein <brathna@gmail.com>
-# http://fswordfinder.sourceforge.net/
-from __future__ import print_function
-
-import random
-
-
-# reverse a word with probability 0.5
-def revword(word):
-    if random.randint(1,2) == 1:
-        return word[::-1]
-    return word
-
-# try to insert word at position x,y; direction encoded in xf,yf
-def step(word, x, xf, y, yf, grid):
-    for i in range(len(word)):
-        if grid[xf(i)][yf(i)] != "" and grid[xf(i)][yf(i)] != word[i]:
-            return False
-    for i in range(len(word)):
-        grid[xf(i)][yf(i)] = word[i]
-    return True
-
-# try to insert word at position x,y, in direction dir
-def check(word, dir, x, y, grid, rows, cols):
-    if dir==1:
-        if x-len(word)<0 or y-len(word)<0:
-            return False
-        return step(word, x, lambda i:x-i, y, lambda i:y-i, grid)
-    elif dir==2:
-        if x-len(word)<0:
-            return False
-        return step(word, x, lambda i:x-i, y, lambda i:y, grid)
-    elif dir==3:
-        if x-len(word)<0 or y+(len(word)-1)>=cols:
-            return False
-        return step(word, x, lambda i:x-i, y, lambda i:y+i, grid)
-    elif dir==4:
-        if y-len(word)<0:
-            return False
-        return step(word, x, lambda i:x, y, lambda i:y-i, grid)
-
-def wordfinder(words, rows=20, cols=20, attempts=50,
-               alph='ABCDEFGHIJKLMNOPQRSTUVWXYZ'):
-    """
-    Attempt to arrange words into a letter-grid with the specified
-    number of rows and columns.  Try each word in several positions
-    and directions, until it can be fitted into the grid, or the
-    maximum number of allowable attempts is exceeded.  Returns a tuple
-    consisting of the grid and the words that were successfully
-    placed.
-
-    :param words: the list of words to be put into the grid
-    :type words: list
-    :param rows: the number of rows in the grid
-    :type rows: int
-    :param cols: the number of columns in the grid
-    :type cols: int
-    :param attempts: the number of times to attempt placing a word
-    :type attempts: int
-    :param alph: the alphabet, to be used for filling blank cells
-    :type alph: list
-    :rtype: tuple
-    """
-
-    # place longer words first
-    words = sorted(words, key=len, reverse=True)
-
-    grid = []  # the letter grid
-    used = []  # the words we used
-
-    # initialize the grid
-    for i in range(rows):
-        grid.append([""] * cols)
-
-    # try to place each word
-    for word in words:
-        word = word.strip().upper()  # normalize
-        save = word                  # keep a record of the word
-        word = revword(word)
-        for attempt in range(attempts):
-            r = random.randint(0, len(word))
-            dir = random.choice([1,2,3,4])
-            x = random.randint(0,rows)
-            y = random.randint(0,cols)
-            if   dir==1: x+=r; y+=r
-            elif dir==2: x+=r
-            elif dir==3: x+=r; y-=r
-            elif dir==4: y+=r
-            if 0<=x<rows and 0<=y<cols:
-                if check(word, dir, x, y, grid, rows, cols):
-#                   used.append((save, dir, x, y, word))
-                    used.append(save)
-                    break
-
-    # Fill up the remaining spaces
-    for i in range(rows):
-        for j in range(cols):
-            if grid[i][j] == '':
-                grid[i][j] = random.choice(alph)
-
-    return grid, used
-
-def word_finder():
-    from nltk.corpus import words
-    wordlist = words.words()
-    random.shuffle(wordlist)
-    wordlist = wordlist[:200]
-    wordlist = [w for w in wordlist if 3 <= len(w) <= 12]
-    grid, used = wordfinder(wordlist)
-
-    print("Word Finder\n")
-    for i in range(len(grid)):
-        for j in range(len(grid[i])):
-            print(grid[i][j], end=' ')
-        print()
-    print()
-
-    for i in range(len(used)):
-        print("%d:" % (i+1), used[i])
-
-if __name__ == '__main__':
-    word_finder()
+# Natural Language Toolkit: Word Finder
+#
+# Copyright (C) 2001-2018 NLTK Project
+# Author: Steven Bird <stevenbird1@gmail.com>
+# URL: <http://nltk.org/>
+# For license information, see LICENSE.TXT
+
+# Simplified from PHP version by Robert Klein <brathna@gmail.com>
+# http://fswordfinder.sourceforge.net/
+from __future__ import print_function
+
+import random
+
+
+# reverse a word with probability 0.5
+def revword(word):
+    if random.randint(1,2) == 1:
+        return word[::-1]
+    return word
+
+# try to insert word at position x,y; direction encoded in xf,yf
+def step(word, x, xf, y, yf, grid):
+    for i in range(len(word)):
+        if grid[xf(i)][yf(i)] != "" and grid[xf(i)][yf(i)] != word[i]:
+            return False
+    for i in range(len(word)):
+        grid[xf(i)][yf(i)] = word[i]
+    return True
+
+# try to insert word at position x,y, in direction dir
+def check(word, dir, x, y, grid, rows, cols):
+    if dir==1:
+        if x-len(word)<0 or y-len(word)<0:
+            return False
+        return step(word, x, lambda i:x-i, y, lambda i:y-i, grid)
+    elif dir==2:
+        if x-len(word)<0:
+            return False
+        return step(word, x, lambda i:x-i, y, lambda i:y, grid)
+    elif dir==3:
+        if x-len(word)<0 or y+(len(word)-1)>=cols:
+            return False
+        return step(word, x, lambda i:x-i, y, lambda i:y+i, grid)
+    elif dir==4:
+        if y-len(word)<0:
+            return False
+        return step(word, x, lambda i:x, y, lambda i:y-i, grid)
+
+def wordfinder(words, rows=20, cols=20, attempts=50,
+               alph='ABCDEFGHIJKLMNOPQRSTUVWXYZ'):
+    """
+    Attempt to arrange words into a letter-grid with the specified
+    number of rows and columns.  Try each word in several positions
+    and directions, until it can be fitted into the grid, or the
+    maximum number of allowable attempts is exceeded.  Returns a tuple
+    consisting of the grid and the words that were successfully
+    placed.
+
+    :param words: the list of words to be put into the grid
+    :type words: list
+    :param rows: the number of rows in the grid
+    :type rows: int
+    :param cols: the number of columns in the grid
+    :type cols: int
+    :param attempts: the number of times to attempt placing a word
+    :type attempts: int
+    :param alph: the alphabet, to be used for filling blank cells
+    :type alph: list
+    :rtype: tuple
+    """
+
+    # place longer words first
+    words = sorted(words, key=len, reverse=True)
+
+    grid = []  # the letter grid
+    used = []  # the words we used
+
+    # initialize the grid
+    for i in range(rows):
+        grid.append([""] * cols)
+
+    # try to place each word
+    for word in words:
+        word = word.strip().upper()  # normalize
+        save = word                  # keep a record of the word
+        word = revword(word)
+        for attempt in range(attempts):
+            r = random.randint(0, len(word))
+            dir = random.choice([1,2,3,4])
+            x = random.randint(0,rows)
+            y = random.randint(0,cols)
+            if   dir==1: x+=r; y+=r
+            elif dir==2: x+=r
+            elif dir==3: x+=r; y-=r
+            elif dir==4: y+=r
+            if 0<=x<rows and 0<=y<cols:
+                if check(word, dir, x, y, grid, rows, cols):
+#                   used.append((save, dir, x, y, word))
+                    used.append(save)
+                    break
+
+    # Fill up the remaining spaces
+    for i in range(rows):
+        for j in range(cols):
+            if grid[i][j] == '':
+                grid[i][j] = random.choice(alph)
+
+    return grid, used
+
+def word_finder():
+    from nltk.corpus import words
+    wordlist = words.words()
+    random.shuffle(wordlist)
+    wordlist = wordlist[:200]
+    wordlist = [w for w in wordlist if 3 <= len(w) <= 12]
+    grid, used = wordfinder(wordlist)
+
+    print("Word Finder\n")
+    for i in range(len(grid)):
+        for j in range(len(grid[i])):
+            print(grid[i][j], end=' ')
+        print()
+    print()
+
+    for i in range(len(used)):
+        print("%d:" % (i+1), used[i])
+
+if __name__ == '__main__':
+    word_finder()