StaticArray is a very simple class that simulates the behavior of a fixed-size array. It has only

Fantastic news! We've Found the answer you've been seeking!

Question:

Write a function that receives a StaticArray of integers and returns a new StaticArray object with the

StaticArray is a very simple class that simulates the behavior of a fixed-size array. It has only four methods, and contains code to support bracketed indexing ([]): 1) init() - Creates a new static array that will store a fixed number of elements. Once the StaticArray is created, its size cannot be changed. 2) set() - Changes the value of any element using its index. 3) get() - Reads the value of any element using its index. 4) length() - Queries the number of elements in the array.

Please review the code and comments in the StaticArray class to better understand the available methods, their use, and input/output parameters. Note that since StaticArray is intentionally a very simple class, it does not possess the many capabilities typically associated with Python solutions using only the available StaticArray functionality, as described above.

RESTRICTIONS: You are NOT allowed to use ANY built-in Python data structures and/or their methods in any of your solutions. This includes built-in Python lists, dictionaries, or anything else. Variables for holding a single value, or a tuple holding two/three values, are allowed. It is also OK to use built-in Python generator functions like range(). You are NOT allowed to directly access any variables of the StaticArray class (e.g. self._size or self._data). Access to StaticArray variables must be done by using the StaticArray class methods.

class StaticArrayException(Exception):
"""
Custom exception for Static Array class.
Any changes to this class are forbidden.
"""
  pass
class StaticArray:
"""
Implementation of Static Array Data Structure.
Implemented methods: get(), set(), length()
Any changes to this class are forbidden.
Even if you make changes to your StaticArray file and upload to Gradescope
along with your assignment, it will have no effect. Gradescope uses its
own StaticArray file (a replica of this one) and any extra submission of
a StaticArray file is ignored.
"""
  def __init__(self, size: int = 10) -> None:
"""
Create array of given size.
Initialize all elements with values of None.
If requested size is not a positive number,
raise StaticArray Exception.
"""
  if size raise StaticArrayException('Array size must be a positive integer')
# The underscore denotes this as a private variable and
# private variables should not be accessed directly.
# Use the length() method to get the size of a StaticArray.
self._size = size
# Remember, this is a built-in list and is used here
# because Python doesn't have a fixed-size array type.
# Don't initialize variables like this in your assignments!
self._data = [None] * size
def __iter__(self) -> None:
"""
Disable iterator capability for StaticArray class.
This means loops and aggregate functions like
those shown below won't work:
arr = StaticArray()
for value in arr: # will not work
min(arr) # will not work
max(arr) # will not work
sort(arr) # will not work
"""
  return None
def __str__(self) -> str:
"""Override string method to provide more readable output."""
  return f"STAT_ARR Size: {self._size} {self._data}"
def get(self, index: int):
"""
Return value from given index position.
Invalid index raises StaticArrayException.
"""
  if index = self.length():
raise StaticArrayException('Index out of bounds')
return self._data[index]
def set(self, index: int, value) -> None:
"""
Store value at given index in the array.
Invalid index raises StaticArrayException.
"""
  if index = self.length():
raise StaticArrayException('Index out of bounds')
self._data[index] = value
def __getitem__(self, index: int):
"""Enable bracketed indexing."""
  return self.get(index)
def __setitem__(self, index: int, value: object) -> None:
"""Enable bracketed indexing."""
  self.set(index, value)
def length(self) -> int:
"""Return length of the array (number of elements)."""
  return self._size
if __name__ == "__main__":
# Using the Static Array #
# Can use either the get/set methods or [] (bracketed indexing) #
# Both are public methods; using the [] calls the corresponding get/set #
arr = StaticArray()
# These two statements are equivalent
arr.set(0, 'hello')
arr[0] = 'hello'
# These two statements are equivalent
print(arr.get(0))
print(arr[0])
# Print the number of elements stored in the array
print(arr.length())
arr = StaticArray(5)
# Set the value of each element equal to its index multiplied by 10
for index in range(arr.length()):
arr[index] = index * 10
# Print the values of all elements in reverse order
for index in range(arr.length() - 1, -1, -1):
print(arr[index])
# Special consideration below #
# Don't do this! This creates a built-in Python list and if you use
# one you'll lose points.
forbidden_list = [None] * 10
print(type(arr))
print(type(forbidden_list))