This program will calculate the rise in ocean levels over 5, 10, and 50 years, Part of the program has been written for you. The
part that has been written will read in a rise in ocean levels (per year) in millimeters. This value is read into a variable of type double named risingLevel. You will be completing the program as follows Output the value in risingLevel. This should be the first line of output. The output should be as follows (assume risingLevel has a value of 2.1) Level: 2.1 The number of millimeters higher than the current level that the ocean's level will be in 5 years (assuming the ocean is rising at the rate of risingLevel per year). This is your second line of output. The output will be as follows Years: 5, Rise: 10.5 The number of millimeters higher than the current level that the ocean's level will be in 10 years (assuming the ocean is rising at the rate of risingLevel per year). This is your third line of output. The output will be as follows (for a risingLevel" of 2.1 Years: 10, Rise: 21 The number of millimeters higher than the current level that the ocean's level will be in 50 years (assuming the ocean is rising at the rate of risingLevel per year). This is your final line of output.The output will be as follows (for a risingLevel" of 2.1) Years: 50, Rise: 105 For each of the above you need to output the number of years and the total rise in ocean levels for those years. This is all based on the value in risingLevel For example: ArisingLevel of 2.1 for 5 years would have the following output: Level: 2.1 Years: 5, Rise: 10.5 Years: Years: 50, Rise: 105 10, Rise: 21 Your output must have the same syntax and spacing as above
1 answer:
Answer:
Here is the C++ program:
#include <iostream> //to use input output functions
using namespace std; //to identify objects cin cout
int main(){ //start of main method
double risingLevel; //declares a double type variable to hold rising level
cin>>risingLevel; //reads the value of risingLevel from user
cout<<"Level: "<<risingLevel<<endl; //displays the rising level
cout << "Years: 5, Rise: " << risingLevel * 5<<endl; //displays the rise in ocean level over 5 years
cout << "Years: 10, Rise: " << risingLevel * 10<<endl; //displays the rise in ocean level over 10 years
cout << "Years: 50, Rise: " << risingLevel * 50<<endl; //displays the rise in ocean level over 50 years
}
Explanation:
The program works as follows:
Lets say the user enters rising level 2.1 then,
risingLevel = 2.1
Now the first print (cout) statement :
cout<<"Level: "<<risingLevel<<endl; prints the value of risingLevel on output screen. So this statement displays:
Level: 2.1
Next, the program control moves to the statement:
cout << "Years: 5, Rise: " << risingLevel * 5<<endl;
which computes the rise in ocean levels over 5 years by formula:
risingLevel * 5 = 2.1 * 5 = 10.5
It then displays the computed value on output screen. So this statement displays:
Years: 5, Rise: 10.5 Next, the program control moves to the statement:
cout << "Years: 10, Rise: " << risingLevel * 10<<endl;
which computes the rise in ocean levels over 10 years by formula:
risingLevel * 10 = 2.1 * 10 = 21
It then displays the computed value on output screen. So this statement displays:
Years: 10, Rise: 21
Next, the program control moves to the statement:
cout << "Years: 50, Rise: " << risingLevel * 50<<endl;
which computes the rise in ocean levels over 50 years by formula:
risingLevel * 50 = 2.1 * 50 = 105
It then displays the computed value on output screen. So this statement displays:
Years: 50, Rise: 105 Hence the output of the entire program is:
Level: 2.1 Years: 5, Rise: 10.5 Years: 10, Rise: 21 Years: 50, Rise: 105
The screenshot of the program and its output is attached.
You might be interested in
Answer:
Here is the python method:
def is_power(n1, n2): # function that takes two positive integers n1 and n2 as arguments
if(not n1>0 and not n2>0): #if n1 and n2 are not positive integers
print("The number is not a positive integer so:") # print this message if n1 and n2 are negative
return None # returns none when value of n1 and n2 is negative.
elif n1 == n2: #first base case: if both the numbers are equal
return True #returns True if n1=n2
elif n2==1: #second base case: if the value of n2 is equal to 1
return False #returns False if n2==1
else: #recursive step
return is_divisible(n1, n2) and is_power(n1/n2, n2) #call divisible method and is_power method recursively to determine if the number is the power of another
Explanation:
Here is the complete program.
def is_divisible(a, b):
if a % b == 0:
return True
else:
return False
def is_power(n1, n2):
if(not n1>0 and not n2>0):
print("The number is not a positive integer so:")
return None
elif n1 == n2:
return True
elif n2==1:
return False
else:
return is_divisible(n1, n2) and is_power(n1/n2, n2)
print("is_power(10, 2) returns: ", is_power(10, 2))
print("is_power(27, 3) returns: ", is_power(27, 3))
print("is_power(1, 1) returns: ", is_power(1, 1))
print("is_power(10, 1) returns: ", is_power(10, 1))
print("is_power(3, 3) returns: ", is_power(3, 3))
print("is_power(-10, -1) returns: ", is_power(-10, -1))
The first method is is_divisible method that takes two numbers a and b as arguments. It checks whether a number a is completely divisible by number b. The % modulo operator is used to find the remainder of the division. If the remainder of the division is 0 it means that the number a is completely divisible by b otherwise it is not completely divisible. The method returns True if the result of a%b is 0 otherwise returns False.
The second method is is_power() that takes two numbers n1 and n2 as arguments. The if(not n1>0 and not n2>0) if statement checks if these numbers i.e. n1 and n2 are positive or not. If these numbers are not positive then the program prints the message: The number is not a positive integer so. After displaying this message the program returns None instead of True of False because of negative values of n1 and n2.
If the values of n1 and n2 are positive integers then the program checks its first base case: n1 == n2. Suppose the value of n1 = 1 and n2 =1 Then n1 is a power of n2 if both of them are equal. So this returns True if both n1 and n2 are equal.
Now the program checks its second base case n2 == 1. Lets say n1 is 10 and n2 is 1 Then the function returns False because there is no positive integer that is the power of 1 except 1 itself.
Now the recursive case return is_divisible(n1, n2) and is_power(n1/n2, n2) calls is_divisible() method and is_power method is called recursively in this statement. For example if n1 is 27 and n2 is 3 then this statement:
is_divisible(n1, n2) returns True because 27 is completely divisible by 3 i.e. 27 % 3 = 0
is_power(n1/n2,n2) is called. This method will be called recursively until the base condition is reached. You can see it has two arguments n1/n2 and n2. n1/n2 = 27/3 = 9 So this becomes is_power(9,3)
The base cases are checked. Now this else statement is again executed return is_divisible(n1, n2) and is_power(n1/n2, n2) as none of the above base cases is evaluated to true. when is_divisible() returns True as 9 is completely divisible by 3 i.e. 9%3 =0 and is_power returns (9/3,3) which is (3,3). So this becomes is_power(3,3)
Now as value of n1 becomes 3 and value of n2 becomes 3. So the first base case elif n1 == n2: condition now evaluates to true as 3=3. So it returns True. Hence the result of this statement print("is_power(10, 2) returns: ", is_power(10, 2)) is:
is_power(27, 3) returns: True
