Question

This programming task will be a bit different. It will be more like what you would receive if you were a maintenance engineer working in a corporate information systems or technology department. In other words, you will have some prebuilt source code provided for you that you must alter so it will meet the given programming specification..

• Build a program from what you have been given as a starting-point.
• Rename the “starter code”.
• Do not add any modules; just, use the ones provides and add the necessary code in each one.
• In the production of your final work-product do not modify the module names or any code in a module which has the following comment block at the beginning, “Finished - Do not alter!” You can re-work any other module so you generate a validate program which meets this specification.
• Add the appropriate code when finishing the modules that start with a comment block which says “Finish adding Code.”
• The array has 10,000 elements, its base type is integer, and it is filled with random numbers automatically when one calls the FillTheArray() module.
• The numbers that will fill the array is are in the range, [ 0 .. 2200 ].
• The array is unsorted and any particular random number, such as 1320, may appear more than once.
• Build a pair of linear searches modules.
• The search key, which your modules will find and count, is 1320, and it is an arbitrary value selected from the range [ 0 .. 2200 ] by the problem designer.
• The output for the program will be simple, stating only if 1320 is present in the array of 10000 random values and how many times if it is found.
• Finish filling out the explanation in the Main() labeled “Array as an argument comment:”, explaining how the array is passed an argument, modified in the module, and the modified array is available for the main program without having it explicitly returned by FillTheArray().
• Modules:
  • FillTheArray()
    • Parameters: Integer Array iTempArray, Integer SIZE
    • Return: Nothing
  • LinearSearchOne() – This linear search will check for the existence of the number 1320
    • Parameters: Integer Array iTempArray, Integer SIZE, Integer ENTRY
    • Return: Boolean bTempDoesItExist
  • LinearSearchTwo() – This linear search will see how many of the number 1320 actually exists in the array
    • Parameters: Integer Array iTempArray, Integer SIZE, Integer ENTRY
    • Return: Integer iHowManyExist
  • ProgramHeader() - ProgramHeader(5), where 5 is the assignment number, can also be a variable holding the “5”
    • Output: Assignment 5 programmed by Hugh Schuett, where “Hugh Schuett” will be replaced by your name
    • Called at the beginning of the main()
  • ProgramOutput()
    • Parameters: Boolean bTempDoesItExist, Integer iHowManyExist
    • Return: Nothing

Note: Because the function Random() is used when filling the array, the number of times that 1320 occurs in the array of 10000 values will be different each time. Also, desk-checking an array of 10,000 numbers is an impractical way of validating the correctness of your program. As a result, you might consider adjusting the SIZE of the array and the RANGE of values randomly generated when testing. This is so one might use the "Watch Variables" feature and validate the programs output. A SIZE of 25 and a RANGE of 5 should work reasonably well. The values for the SIZE and RANGE should be reset before the program is turnt in.

Answer 1

import random
import array

def programHeader(number):
    print ('Assignment {0} programmed by xyz.'.format(number))

def fillTheArray(itemp, size):
    for i in range(size):
        arr.append(random.randint(0, itemp))

def linearSearchOne(val):
    if val in arr:
        return True

def linearSearchTwo(val):
    counter = 0
    if val in arr:
        counter = +1
        return counter

def programOutput(boolval, iHowManyTimes):
    print(boolval,iHowManyTimes)

if __name__ == '__main__':
    arr = array.array('i',)
    programHeader(1)
    fillTheArray(10000, 2200)
    a = linearSearchOne(1320)
    b = linearSearchTwo(1320)
    programOutput(a,b)