def __init__(self, *dimensions): assert len(dimensions) > 1, 'The array must have 2 or more dimensions.' # The variable argument tuple contaims the dim sizes. self._dims = dimensions # Compute the total number of elements in the array. size = 1 for d in dimensions: assert d > 0, 'Demensions must be > 0.' size *= d # Create the 1-D array to store the elements. self._elements = Array(size) # Create a 1-D array to store the equation factors. self._factors = Array(len(dimensions)) self._computeFactors()
def radixSort(intList, numDigits): # Create an arrry of queues to represent the bins. binArray = Array(10) for k in range(10): binArray[k] = Queue() # The value of the current column. column = 1 # Iterate over the number of digits in the largest value. for d in range(numDigits): # Distribute the keys across the 10 bins. for key in intList: digit = (key // column) % 10 binArray[digit].enqueue(key) # Gather the keys from the bins and place them back in intList. i = 0 for bin in binArray: while not bin.isEmpty(): intList[i] = bin.dequeue() i += 1 # Advance to the next column value. column *= 10 return intList
def mergeSort(theSeq): n = len(theSeq) # Create a temporary array for use when merging subsequences. tmpArray = Array(n) # Call the private recursive merge sort function. recMergeSort(theSeq, 0, n - 1, tmpArray) return theSeq
def _rehash(self): # Create a new larger table. origTable = self._table newSize = len(self._table) * 2 + 1 self._table = Array(newSize) # Modify the size attributes. self._count = 0 self._maxCount = newSize - newSize // 3 # Add the keys from the original array to the new table. for entry in origTable: if entry is not self.UNUSED and entry is not self.EMPTY: slot = self._findSlot(entry.key, True) self._table[slot] = entry self._count += 1
class MultiArray(object): # Creates a multi-dimentional array. def __init__(self, *dimensions): assert len(dimensions) > 1, 'The array must have 2 or more dimensions.' # The variable argument tuple contaims the dim sizes. self._dims = dimensions # Compute the total number of elements in the array. size = 1 for d in dimensions: assert d > 0, 'Demensions must be > 0.' size *= d # Create the 1-D array to store the elements. self._elements = Array(size) # Create a 1-D array to store the equation factors. self._factors = Array(len(dimensions)) self._computeFactors() # Returns the number of dimensions in the array. def numDims(self): return len(self._dims) # Returns the length of the given dimention. def length(self, dim): assert dim >=1 and dim <= len(self._dims), \ 'Dimention component out of range.' return self._dims[dim - 1] # Clears the array by setting all elements to the given value. def clear(self, value): self._elements.clear(value) # Returns the contents of element(i_1, i_2, ..., i_n). def __getitem__(self, ndxTuple): assert len(ndxTuple) == self.numDims(), 'Invalid # of array subscripts.' index = self._computeIndex(ndxTuple) assert index is not None, 'Array subscript out of range.' return self._elements[index] # Sets the contents of element(i_1, i_2, ..., i_n). def __setitem__(self, ndxTuple, value): assert len(ndxTuple) == self.numDims(), 'Invalid # of array subscripts.' index = self._computeIndex(ndxTuple) assert index is not None, 'Array subscript out of range.' self._elements[index] = value # Computes the 1-D array offset for element (i_1, i_2, ..., i_n) # using the equation i_1 * f_1 + i_2 * f_2 + ... + i_n * f_n def _computeIndex(self, idx): offset = 0 for j in range(len(idx)): # Make sure the imdex components are within the legal range. if idx[j] < 0 or idx[j] >= self._dims[j]: return None else: # Sum the product of i_j * f_j. offset += idx[j] * self._factors[j] return offset # Computes the factor values used in the index equation. def _computeFactors(self): for j in range(len(self._factors)): self._factors[j] = 1 if j != len(self._factors) - 1: for i in range(j + 1, len(self._factors)): self._factors[j] *= self._dims[i]
class MultiArray(object): # Creates a multi-dimentional array. def __init__(self, *dimensions): assert len(dimensions) > 1, 'The array must have 2 or more dimensions.' # The variable argument tuple contaims the dim sizes. self._dims = dimensions # Compute the total number of elements in the array. size = 1 for d in dimensions: assert d > 0, 'Demensions must be > 0.' size *= d # Create the 1-D array to store the elements. self._elements = Array(size) # Create a 1-D array to store the equation factors. self._factors = Array(len(dimensions)) self._computeFactors() # Returns the number of dimensions in the array. def numDims(self): return len(self._dims) # Returns the length of the given dimention. def length(self, dim): assert dim >=1 and dim <= len(self._dims), \ 'Dimention component out of range.' return self._dims[dim - 1] # Clears the array by setting all elements to the given value. def clear(self, value): self._elements.clear(value) # Returns the contents of element(i_1, i_2, ..., i_n). def __getitem__(self, ndxTuple): assert len( ndxTuple) == self.numDims(), 'Invalid # of array subscripts.' index = self._computeIndex(ndxTuple) assert index is not None, 'Array subscript out of range.' return self._elements[index] # Sets the contents of element(i_1, i_2, ..., i_n). def __setitem__(self, ndxTuple, value): assert len( ndxTuple) == self.numDims(), 'Invalid # of array subscripts.' index = self._computeIndex(ndxTuple) assert index is not None, 'Array subscript out of range.' self._elements[index] = value # Computes the 1-D array offset for element (i_1, i_2, ..., i_n) # using the equation i_1 * f_1 + i_2 * f_2 + ... + i_n * f_n def _computeIndex(self, idx): offset = 0 for j in range(len(idx)): # Make sure the imdex components are within the legal range. if idx[j] < 0 or idx[j] >= self._dims[j]: return None else: # Sum the product of i_j * f_j. offset += idx[j] * self._factors[j] return offset # Computes the factor values used in the index equation. def _computeFactors(self): for j in range(len(self._factors)): self._factors[j] = 1 if j != len(self._factors) - 1: for i in range(j + 1, len(self._factors)): self._factors[j] *= self._dims[i]
def __init__(self, numLevels): self._qSize = 0 self._qLevels = Array(numLevels) for i in range(numLevels): self._qLevels[i] = Queue()
def __init__(self, maxSize): self._elements = Array(maxSize) self._count = 0
def __init__(self): self.UNUSED = None self.EMPTY = _MapEntry(None, None) self._table = Array(7) self._count = 0 self._maxCount = len(self._table) - len(self._table) // 3
def __init__(self, maxSize): self._count = 0 self._front = 0 self._back = maxSize - 1 self._qArray = Array(maxSize)
def __init__(self, numRows, numCols): self._numCols = numCols self._listOfRows = Array(numRows)
# Count the number of occurrences of each letter in a text file. from my_own_array import Array # Create an array for the counters and initialize each element to 0. theCounters = Array(127) theCounters.clear(0) # Open the text file for reading and extract each line from the file # and iterate over each character in the line. with open('atextfile.txt', 'r') as theFile: content = theFile.read() for letter in content: code = ord(letter) theCounters[code] += 1 # Print the result. The uppercase letters have ASCII values in the # range 65...90 and the lowercase letters are in the range 97...122. for i in range(26): print('%c - %4d %c - %4d' % \ (chr(65+i), theCounters[65+i], chr(97+i), theCounters[97+i]))