Jed Rembold
November 22, 2024
The two classes to the right mimic a bit of what might occur in the
course of the Adventure Project. What python data type is
ANS?
class AdvObject:
def __init__(self, name, loc):
self.name = name
self.loc = loc
def get_loc(self):
return self.loc
class AdvLocation:
def __init__(self, name):
self.name = name
self.stuff = []
def store(self, item):
self.stuff.append(item)
def retrieve_top(self):
return self.stuff.pop()
A = AdvObject("Hammer", "RA")
B = AdvObject("Torch", "RA")
RA = AdvLocation("Room A")
RA.store(A)
RA.store(B)
ANS = RA.retrieve_top().get_loc()|||scanner|||.set_input(|||str|||)
|||scanner|||.next_token()
"" at the end|||scanner|||.has_more_tokens()
True if more tokens exist,
False otherwise|||scanner|||.ignore_whitespace()
# File: tokenscanner.py
"""
This file implements a simple version of a token scanner class.
"""
# A token scanner is an abstract data type that divides a string into
# individual tokens, which are strings of consecutive characters that
# form logical units. This simplified version recognizes two token types:
#
# 1. A string of consecutive letters and digits
# 2. A single character string
#
# To use this class, you must first create a TokenScanner instance by
# calling its constructor:
#
# scanner = TokenScanner()
#
# The next step is to call the set_input method to specify the string
# from which tokens are read, as follows:
#
# scanner.set_input(s)
#
# Once you have initialized the scanner, you can retrieve the next token
# by calling
#
# token = scanner.next_token()
#
# To determine whether any tokens remain to be read, you can either
# call the predicate method scanner.has_more_tokens() or check to see
# whether next_token returns the empty string.
#
# The following code fragment serves as a pattern for processing each
# token in the string stored in the variable source:
#
# scanner = TokenScanner(source)
# while scanner.has_more_tokens():
# token = scanner.next_token()
# . . . code to process the token . . .
#
# By default, the TokenScanner class treats whitespace characters
# as operators and returns them as single-character tokens. You
# can set the token scanner to ignore whitespace characters by
# making the following call:
#
# scanner.ignore_whitespace()
class TokenScanner:
"""This class implements a simple token scanner."""
# Constructor
def __init__(self, source=""):
"""
Creates a new TokenScanner object that scans the specified string.
"""
self.set_input(source)
self._ignore_whitespace_flag = False
# Public methods
def set_input(self, source):
"""
Resets the input so that it comes from source.
"""
self._source = source
self._nch = len(source)
self._cp = 0
def next_token(self):
"""
Returns the next token from this scanner. If called when no
tokens are available, next_token returns the empty string.
"""
if self._ignore_whitespace_flag:
self._skip_whitespace()
if self._cp == self._nch:
return ""
token = self._source[self._cp]
self._cp += 1
if token.isalnum():
while self._cp < (
self._nch and self._source[self._cp].isalnum()):
token += self._source[self._cp]
self._cp += 1
return token
def has_more_tokens(self):
"""
Returns True if there are more tokens for this scanner to read.
"""
if self._ignore_whitespace_flag:
self._skip_whitespace()
return self._cp < self._nch
def ignore_whitespace(self):
"""
Tells the scanner to ignore whitespace characters.
"""
self._ignore_whitespace_flag = True
# Private methods
def _skip_whitespace(self):
"""
Skips over any whitespace characters before the next token.
"""
while self._cp < self._nch and self._source[self._cp].isspace():
self._cp += 1TokenScannerTokenScanner in
PigLatinfrom tokenscanner import TokenScanner
def to_pig_latin(text):
translation = ""
scanner = TokenScanner()
scanner.set_input(text)
while scanner.has_more_tokens():
token = scanner.next_token()
if token.isalpha():
token = word_to_pig_latin(token)
translation += token
return translationSuppose you needed to determine if a particular element was in a list, and didn’t have any of the built-in methods available to you
The easiest method (which many of you have indeed used!) is to just search through the list element by element and check it to see if it is the one you desire
Easy to understand and implement:
def linear_search(target, array):
for i in range(len(array)):
if array[i] == target:
return i
return -1def binary_search(target, array):
lh = 0
rh = len(array) - 1
while lh <= rh:
middle = (lh + rh) // 2
if array[middle] == target:
return middle
elif array[middle] < target:
lh = middle + 1
else:
rh = middle - 1
return -1| Problem Size | Linear (\(N\)) | Binary (\(log_2 N\)) |
|---|---|---|
| 10 | 10 | 3 |
| 100 | 100 | 7 |
| 1,000 | 1,000 | 10 |
| 1,000,000 | 1,000,000 | 20 |
| 1,000,000,000 | 1,000,000,000 | 30 |