Here is a somewhat cryptic solution that works:
#include <algorithm>
#include <cstdlib>
using namespace std;
void q(char c, int count)
{
for (int i = 0; i < count; i++) {
putchar(c);
}
}
void p(int b1, int plusses)
{
q(' ', b1);
q('+', plusses);
}
int main()
{
for (int i = -3; i <= 3; i++)
{
int pl = min(6, (3 - abs(i)) * 2 + 1);
p(6-pl, pl);
i == 0 ? p(0, 6) : p(6, 0);
p(0, pl);
putchar('\n');
}
getchar();
}
Specifications are the technical details about each hardware component
Answer:
file_name = 'orders.txt'
file_obj = open( file_name, 'r' )
lines = file_obj.read()
print(lines.upper(), end = '')
Explanation:
- Define the name of the file
.
- Use the built-in open function to open the file in read mode
.
- Use the built-in read function to read the file and assign this to lines variable.
- Finally display the lines by converting them to capital alphabets by using the built-in upper() function.
Answer:
Greg can see previews of his ad in the Preview tab of his Google My Business account.
Google My Business is a free tool for businesses to manage their online existence across Google including Search and Maps. It also provides them to edit their business information which helps customers to find their business. They can also find how many customers searched for their business.
So once Greg's ad has been officially accepted, he can enter the specific keywords he’s targeting to have a generic view of the ad in the browser. Google gives examples of desktop ads using the keywords selected in the campaign to make a general preview. As Greg types his URL, headline, and description, a generic preview of mobile and desktop versions of his ad will show up.
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.
