I don’t know if this supports all, but try lenntech, duckters, and I will add on later
Answer:
def feet_to_inches( feet ):
inches = feet * 12
print(inches, "inches")
feet_to_inches(10)
Explanation:
The code is written in python. The unit for conversion base on your question is that 1 ft = 12 inches. Therefore,
def feet_to_inches( feet ):
This code we define a function and pass the argument as feet which is the length in ft that is required when we call the function.
inches = feet * 12
Here the length in ft is been converted to inches by multiplying by 12.
print(inches, "inches")
Here we print the value in inches .
feet_to_inches(10)
Here we call the function and pass the argument in feet to be converted
Kinda of both. The processor, memory, hard drive and displays are all standard components and are provided by a variety computer competent manufacturers (except for the processors which are all supplied by Intel). Yet - while many components are standard - NO, the core, hardware components, like logic boards (motherboard), video cards, and other specialty components (some display connectors and displays, for example) are propriety Apple designs.
Answer:
Yes
Explanation:
Just like a human fingerprint, no 2 computers are the same.
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.
