Answer:
# create the file
filename = "Testfile.txt"
# for writing, we create the output file:
outPutfile = open(filename, "w")
# Writing numbers from 1-100
for item in range(1,101):
outPutfile.write((str)(item))
outPutfile.close()
# printing the contents to verify it worked correctly
infile = open(filename, "r") #note the "r" indicates the mode
fileContents = infile.read()
infile.close()
print(fileContents)
Explanation:
- Define the working file fileName = TestFile
- Create the output file for writting outPutfile = open(filename, "w")
- Use a for loop to write numbers from 1-100 to the file outPutfile.write((str)(item))
- Close the file outPutfile.close()
- You may open the file read its content and print the contents to verify it worked correctly
Answer:
1. Standard User
2. Company Admin
3. Reports only
4. Time tracking only
5. Accountant
Explanation:
There are different types of user permissions one can set up when adding a new team member in QuickBooks Online Accountant. This includes the following:
1. Standard User: this can be utilized to specialize user's access right
2. Company Admin: this gives such users additional or access rights in the firm.
3. Reports only: this gives users the rights to reports only.
4. Time tracking only: this only gives users the ability to see the version that has timesheets and time reports
5. Accountant: this is designed for the firm's accountant.
Big-O notation is a way to describe a function that represents the n amount of times a program/function needs to be executed.
(I'm assuming that := is a typo and you mean just =, by the way)
In your case, you have two loops, nested within each other, and both loop to n (inclusive, meaning, that you loop for when i or j is equal to n), and both loops iterate by 1 each loop.
This means that both loops will therefore execute an n amount of times. Now, if the loops were NOT nested, our big-O would be O(2n), because 2 loops would run an n amount of times.
HOWEVER, since the j-loop is nested within i-loop, the j-loop executes every time the i-loop <span>ITERATES.
</span>
As previously mentioned, for every i-loop, there would be an n amount of executions. So if the i-loop is called an n amount of times by the j loop (which executes n times), the big-O notation would be O(n*n), or O(n^2).
(tl;dr) In basic, it is O(n^2) because the loops are nested, meaning that the i-loop would be called n times, and for each iteration, it would call the j-loop n times, resulting in n*n runs.
A way to verify this is to write and test program the above. I sometimes find it easier to wrap my head around concepts after testing them myself.