[2021 spring] CS61A Project 2: CATS (CS 61A Autocorrected Typing Software)
作者：互联网
项目说明： https://inst.eecs.berkeley.edu/~cs61a/sp21/proj/cats/#introduction
自动纠错打字软件
"""Typing test implementation"""
from utils import lower, split, remove_punctuation, lines_from_file
from ucb import main, interact, trace
from datetime import datetime
###########
# Phase 1 #
###########
def choose(paragraphs, select, k):
"""Return the Kth paragraph from PARAGRAPHS for which SELECT called on the
paragraph returns True. If there are fewer than K such paragraphs, return
the empty string.
Arguments:
paragraphs: a list of strings
select: a function that returns True for paragraphs that can be selected
k: an integer
>>> ps = ['hi', 'how are you', 'fine']
>>> s = lambda p: len(p) <= 4
>>> choose(ps, s, 0)
'hi'
>>> choose(ps, s, 1)
'fine'
>>> choose(ps, s, 2)
''
"""
# BEGIN PROBLEM 1
"*** YOUR CODE HERE ***"
selected = [paragraph for paragraph in paragraphs if select(paragraph)]
return selected[k] if k < len(selected) else ''
# END PROBLEM 1
def about(topic):
"""Return a select function that returns whether
a paragraph contains one of the words in TOPIC.
Arguments:
topic: a list of words related to a subject
>>> about_dogs = about(['dog', 'dogs', 'pup', 'puppy'])
>>> choose(['Cute Dog!', 'That is a cat.', 'Nice pup!'], about_dogs, 0)
'Cute Dog!'
>>> choose(['Cute Dog!', 'That is a cat.', 'Nice pup.'], about_dogs, 1)
'Nice pup.'
"""
assert all([lower(x) == x for x in topic]), 'topics should be lowercase.'
# BEGIN PROBLEM 2
"*** YOUR CODE HERE ***"
def abouts(paragraph):
for word in split(lower(remove_punctuation(paragraph))):
if word in topic:
return True
return False
return abouts
# END PROBLEM 2
def accuracy(typed, reference):
"""Return the accuracy (percentage of words typed correctly) of TYPED
when compared to the prefix of REFERENCE that was typed.
Arguments:
typed: a string that may contain typos
reference: a string without errors
>>> accuracy('Cute Dog!', 'Cute Dog.')
50.0
>>> accuracy('A Cute Dog!', 'Cute Dog.')
0.0
>>> accuracy('cute Dog.', 'Cute Dog.')
50.0
>>> accuracy('Cute Dog. I say!', 'Cute Dog.')
50.0
>>> accuracy('Cute', 'Cute Dog.')
100.0
>>> accuracy('', 'Cute Dog.')
0.0
>>> accuracy('', '')
100.0
"""
typed_words = split(typed)
reference_words = split(reference)
# BEGIN PROBLEM 3
"*** YOUR CODE HERE ***"
if len(typed_words) == len(reference_words) == 0:
return 100.0
elif len(typed_words) == 0:
return 0.0
correct = 0
for x, y in zip(typed_words, reference_words):
if x == y:
correct += 1
return correct / len(typed_words) * 100.0
# END PROBLEM 3
def wpm(typed, elapsed):
"""Return the words-per-minute (WPM) of the TYPED string.
Arguments:
typed: an entered string
elapsed: an amount of time in seconds
>>> wpm('hello friend hello buddy hello', 15)
24.0
>>> wpm('0123456789',60)
2.0
"""
assert elapsed > 0, 'Elapsed time must be positive'
# BEGIN PROBLEM 4
"*** YOUR CODE HERE ***"
return len(typed) / 5 * 60 / elapsed
# END PROBLEM 4
###########
# Phase 2 #
###########
def autocorrect(typed_word, valid_words, diff_function, limit):
"""Returns the element of VALID_WORDS that has the smallest difference
from TYPED_WORD. Instead returns TYPED_WORD if that difference is greater
than LIMIT.
Arguments:
typed_word: a string representing a word that may contain typos
valid_words: a list of strings representing valid words
diff_function: a function quantifying the difference between two words
limit: a number
>>> ten_diff = lambda w1, w2, limit: 10 # Always returns 10
>>> autocorrect("hwllo", ["butter", "hello", "potato"], ten_diff, 20)
'butter'
>>> first_diff = lambda w1, w2, limit: (1 if w1[0] != w2[0] else 0) # Checks for matching first char
>>> autocorrect("tosting", ["testing", "asking", "fasting"], first_diff, 10)
'testing'
"""
# BEGIN PROBLEM 5
"*** YOUR CODE HERE ***"
if typed_word in valid_words:
return typed_word
diff_list = [diff_function(typed_word, word, limit) for word in valid_words]
if min(diff_list) > limit:
return typed_word
else:
return valid_words[diff_list.index(min(diff_list))]
# END PROBLEM 5
def sphinx_switches(start, goal, limit):
"""A diff function for autocorrect that determines how many letters
in START need to be substituted to create GOAL, then adds the difference in
their lengths and returns the result.
Arguments:
start: a starting word
goal: a string representing a desired goal word
limit: a number representing an upper bound on the number of chars that must change
>>> big_limit = 10
>>> sphinx_switches("nice", "rice", big_limit) # Substitute: n -> r
1
>>> sphinx_switches("range", "rungs", big_limit) # Substitute: a -> u, e -> s
2
>>> sphinx_switches("pill", "pillage", big_limit) # Don't substitute anything, length difference of 3.
3
>>> sphinx_switches("roses", "arose", big_limit) # Substitute: r -> a, o -> r, s -> o, e -> s, s -> e
5
>>> sphinx_switches("rose", "hello", big_limit) # Substitute: r->h, o->e, s->l, e->l, length difference of 1.
5
"""
# BEGIN PROBLEM 6
# assert False, 'Remove this line'
def counts(cstart, cgoal, count):
if count > limit:
return limit + 1
if not cstart and not cgoal:
return count
elif not cstart or not cgoal:
return counts(cstart[1:], cgoal[1:], count + 1)
elif cstart[0] == cgoal[0]:
return counts(cstart[1:], cgoal[1:], count)
else:
return counts(cstart[1:], cgoal[1:], count + 1)
return counts(start, goal, 0)
# END PROBLEM 6
def pawssible_patches(start, goal, limit):
"""A diff function that computes the edit distance from START to GOAL.
This function takes in a string START, a string GOAL, and a number LIMIT.
Arguments:
start: a starting word
goal: a goal word
limit: a number representing an upper bound on the number of edits
>>> big_limit = 10
>>> pawssible_patches("cats", "scat", big_limit) # cats -> scats -> scat
2
>>> pawssible_patches("purng", "purring", big_limit) # purng -> purrng -> purring
2
>>> pawssible_patches("ckiteus", "kittens", big_limit) # ckiteus -> kiteus -> kitteus -> kittens
3
"""
# assert False, 'Remove this line'
if limit < 0: # Fill in the condition
# BEGIN
"*** YOUR CODE HERE ***"
return 0
# END
if not start and not goal:
return 0
elif not start or not goal:
return abs(len(start) - len(goal))
elif start[0] == goal[0]: # Feel free to remove or add additional cases
# BEGIN
"*** YOUR CODE HERE ***"
return pawssible_patches(start[1:], goal[1:], limit)
# END
else:
add = pawssible_patches(start, goal[1:], limit - 1) # Fill in these lines
remove = pawssible_patches(start[1:], goal, limit - 1)
substitute = pawssible_patches(start[1:], goal[1:], limit - 1)
# BEGIN
"*** YOUR CODE HERE ***"
return min(add, remove, substitute) + 1
# END
def final_diff(start, goal, limit):
"""A diff function that takes in a string START, a string GOAL, and a number LIMIT.
If you implement this function, it will be used."""
assert False, 'Remove this line to use your final_diff function.'
FINAL_DIFF_LIMIT = 6 # REPLACE THIS WITH YOUR LIMIT
标签：return,goal,spring,CS61A,limit,words,typed,diff,Autocorrected 来源： https://www.cnblogs.com/ikventure/p/14928958.html