C++ Assignment. Read all instructions carefully please!
Add to the program below by adding two additional elements to the program:
1. A way of saving the order data to a file (write to a file)
2. Allowing the food truck employee to put in a 10% discount on the order total.
Use standard C++ code and the entire code must be in one file with at most three or four functions. You can use items from the STL library.
Make sure to make good clean code with the same program parameters as before. Also make sure to write in the comments about your two additional elements that you added to the program. Be sure the program runs without error!
The code to work with is provided below.
#include
using namespace std;
int main()
{
string menuItems[7] = { "Hamburger Buns", "Hamburger Patties", "Hot Dog Buns", "Hot Dogs", "Chilli", "Fry Baskets", "Soda Pop" };
static int stockQuantity[7] = { 200, 75, 200, 75, 500, 75, 200 };
// price
int price[7] = { 5, 5, 5, 5, 4, 7, 2 };
// twenty percent of each item stock level
int twentyPercentStock[7] = { 40, 15, 40, 15, 100, 15, 40 };
int i, customerChoice, orderTotal = 0, n;
double tax = 0;
string promptUser;
while (1)
{
// display menu items
for (i = 0; i < 7; i++)
{ // if item quantity is at 0 then exclude from menu
if (stockQuantity[i] != 0)
{
if (menuItems[i].length() >= 12)
cout << endl
<< i + 1 << ". " << menuItems[i] << " \t " << stockQuantity[i] << " \t $" << price[i];
else
cout << endl
<< i + 1 << ". " << menuItems[i] << " \t\t " << stockQuantity[i] << " \t $" << price[i];
}
}
// promt for customers choice
cout << endl
<< "Enter your order: ";
cin >> customerChoice;
// details for chilli
if (customerChoice == 5)
{
// ask for details of chilli
cout << endl
<< "Do you want chilli with fries?(y / n, 9999): ";
cin >> promptUser;
if (promptUser == "y")
{
top1:
// ask for the quantity of chilli
cout << endl
<< "Enter the quantity of " << menuItems[customerChoice - 1] << ": ";
cin >> n;
// calculate total
orderTotal = orderTotal + 2 * (n / 4);
// calculate tax
tax = tax + (double)(0.05) * (2 * n);
// update the quantity
stockQuantity[customerChoice - 1] = stockQuantity[customerChoice - 1] - n;
}
else
{
top:
// ask for quantity
cout << endl
<< "Enter the quantity of " << menuItems[customerChoice - 1] << ": ";
cin >> n;
tax = tax + (double)(0.05) * (price[customerChoice - 1] * n);
orderTotal = orderTotal + price[customerChoice - 1] * n + tax;
stockQuantity[customerChoice - 1] = stockQuantity[customerChoice - 1] - n;
}
}
else
{
// get quantity
cout << endl
<< "Enter the quantity of " << menuItems[customerChoice - 1] << ": ";
cin >> n;
// calculate tax amount
tax = tax + (double)(0.05) * (price[customerChoice - 1] * n);
orderTotal = orderTotal + price[customerChoice - 1] * n + tax;
// update quantity
stockQuantity[customerChoice - 1] = stockQuantity[customerChoice - 1] - n;
}
for (i = 0; i < 7; i++)
{
if (stockQuantity[i] < twentyPercentStock[i])
cout << endl
<< menuItems[i] << " becomes below 20% full";
}
// ask user to continue or not
cout << endl
<< "Would you like to continue to add more items?(Enter y / n, or 9999): ";
cin >> promptUser;
if (promptUser == "n" || promptUser == "9999")
break;
}
cout << endl
<< "Total Tax to pay : $" << tax;
// displaying the total
cout << endl
<< "Total Amount to pay : $" << orderTotal;
}

Arrow networks are also known as Directed Acyclic Graphs (DAGs) due to their structure.

Arrow networks, commonly referred to as Directed Acyclic Graphs (DAGs), are a type of data structure used in computer science and mathematics. The name "Directed Acyclic Graphs" provides a concise description of the key characteristics of these networks.

Firstly, the term "Directed" indicates that the connections between nodes in the network have a specific direction. In other words, the relationship between the nodes is one-way, where each node can have multiple outgoing connections, but no incoming connections. This directed nature of the connections allows for the representation of cause-and-effect relationships or dependencies between different nodes in the network.

Secondly, the term "Acyclic" signifies that the network does not contain any cycles or loops. In other words, it is impossible to start at any node in the network and traverse the connections in a way that eventually brings you back to the starting node. This acyclic property is essential in various applications, such as task scheduling or dependency management, where cycles can lead to infinite loops or undefined behaviors.

The name "Directed Acyclic Graphs" accurately captures the fundamental characteristics of these networks and provides a clear understanding of their structure and behavior. By using this name, researchers, programmers, and mathematicians can easily communicate and refer to these specific types of networks in their respective fields.

Learn more about Directed Acyclic Graphs

brainly.com/question/33345154

#SPJ11

Below is the program code for the Sailboat Race Ranking challenge in ASP.NET. The program code is written in C# and is based on the .NET Framework version 4.5. The program is implemented using ASP.NET Web Forms. The program allows the user to enter the race results for three boats in four races

. The program calculates the total score for each boat and ranks the boats based on their total score. The program also checks the user input for errors and displays an appropriate message if an error is found. The program uses nested IF statements to check all possible combinations of the three rankings for each race. The program is well-documented and includes comments explaining the purpose of each section of the code. The program also includes error handling code to prevent the program from crashing in case of errors.

Program Code:Below is the program code for the Sailboat Race Ranking challenge in ASP.NET. The program code is written in C# and is based on the .NET Framework version 4.5. The program is implemented using ASP.NET Web Forms. The program allows the user to enter the race results for three boats in four races. The program calculates the total score for each boat and ranks the boats based on their total score. The program also checks the user input for errors and displays an appropriate message if an error is found. The program uses nested IF statements to check all possible combinations of the three rankings for each race. The program is well-documented and includes comments explaining the purpose of each section of the code. T

To know more about race visit:

https://brainly.com/question/23303650

#SPJ11

Analyzing the application's architecture, identifying significant requirements, addressing quality attributes, identifying architectural patterns used, and suggesting improvements for failure scenarios or overall enhancement.

Application: E-commerce Website

1. Architecture Diagram:

2. Architecturally Significant Requirements:

3. Addressing Quality Attributes:

4. Architectural Patterns:

5. Failure Scenarios and Improvements:

    Improvement: Implementing database replication or a distributed database solution to ensure data availability and fault tolerance.

    Improvement: Introducing a content delivery network (CDN) to cache static assets and reduce dependency on a single network infrastructure.

    Improvement: Implementing a robust authentication and authorization mechanism, performing regular security audits, and staying up-to-date with security patches and protocols.

The above example is generalized, and the actual architecture, requirements, and improvements will vary depending on the specific application being analyzed.

For your own application, you will need to study and understand its architecture, document the architecture diagram, identify architecturally significant requirements, discuss how the architecture addresses quality attributes, identify architectural patterns, and analyze failure scenarios to suggest improvements.

Learn more about the application's architecture and architectural patterns: https://brainly.com/question/31061973

#SPJ11

The modified program for the given requirements is as follows:#includeusing namespace std;int main() {    float average;    cout << "Input your average: ";    cin >> average;    if (average < 0 || average > 100) {        cout << "Invalid Data" << endl;    }    else if (average >= 90) {        cout << "You got an A" << endl;    }    else if (average >= 80) {        cout << "You got a B" << endl;    }    else if (average >= 70) {        cout << "You got a C" << endl;    }    else {        cout << "You Fail" << endl;    }    return 0;
}

The program asks the user to enter the average grade of a student and based on the value, the program outputs the grade category or Invalid Data if the entered grade is not in the range [0, 100].Explanation:First, the program takes input from the user of the average grade in the form of a float variable named average.

The if-else-if conditions follow after the input statement to categorize the average grade of the student. Here, average < 0 || average > 100 condition checks whether the entered average is in the range [0, 100] or not.If the entered average is outside of this range, the program outputs Invalid Data.

If the average lies within the range, it checks for the average in different grade categories by using else-if statements:else if (average >= 90) { cout << "You got an A" << endl; }else if (average >= 80) { cout << "You got a B" << endl; }else if (average >= 70) { cout << "You got a C" << endl; }else { cout << "You Fail" << endl; }.

The first else-if condition checks whether the entered average is greater than or equal to 90. If the condition is true, the program outputs "You got an A."If the condition is false, the next else-if condition is checked. It checks whether the average is greater than or equal to 80.

If the condition is true, the program outputs "You got a B."This process continues with the else-if conditions until the last else condition. If none of the above conditions are true, the else part of the last else-if condition executes. The program outputs "You Fail" in this case.

For more such questions program,Click on

https://brainly.com/question/23275071

#SPJ8

The  predicted number ofpertussis cases in the U.S. in 2023 is 24,195.

1) This is based on the empirical probability   of 0.0071,which is the number of cases per 1 million people in 2022. The U.S. population in   2023 is estimatedto be 339,665,000 people, so the predicted number of cases is 24,195.

2) The data was sourced from Centers for Disease Control and Prevention (CDC) and
World Health Organization (WHO).

3) The table   shows that the number of pertussis cases in the U.S. hasbeen declining in recent years.

However, the predicted number of cases in 2023 is still relatively high,so it is important for health care providers to be   prepared.

Learn more about relative frequency at:

https://brainly.com/question/3857836

#SPJ1

Following is the procedure to modify the program

1. The readData method needs to be updated to accept an additional parameter of type int[] (array of integers). This parameter will be used to store all the valid values read from user input. The method will iterate through the input values, discard invalid entries (such as 0 or out-of-range values), and store the valid ones in the provided array.

2. The print array method should be created with the signature void printarray(int[] a, int n). This method will take an array and the number of elements to be printed. It will format the output by printing the first n elements of the array, separated by commas, without any trailing comma. The output should match the desired format specified in the question.

3. The average method should be implemented with the signature double average(int[] a, int n). This method will calculate the average of the first n values in the array. To ensure accuracy, the sum of the values will be divided by n as a double, producing a precise decimal average.

In the main method, an array capable of holding up to 100 int values should be created. The readData method will be used to populate this array with valid input values. Then, the printArray method will be called to print the elements from the array, and the average method will calculate and display the average.

By following these steps, the program will be modified to store valid values in an array, print the desired output format, and calculate an accurate average.

Learn more about Program

brainly.com/question/30613605

#SPJ11

The information security gap analysis conducted for EZTechMovie aims to identify and mitigate security gaps. Compliance with the ISO/IEC 27001 framework ensures protection of sensitive data and adherence to legal requirements.

The information security gap analysis conducted for EZTechMovie aims to identify and mitigate any security gaps within the organization. By applying the ISO/IEC 27001 framework, EZTechMovie can establish and maintain an effective information security management system.

The existing information security policy aligns with the framework, indicating a strong foundation for protecting sensitive data. Compliance with the ISO/IEC 27001 framework is crucial for EZTechMovie due to its handling of sensitive information and the need to meet legal and regulatory requirements.

Although implementing and maintaining the framework may be time-consuming, it provides a systematic and risk-based approach to ensure the confidentiality, integrity, and availability of information.

Learn more about gap analysis: brainly.com/question/28444684

#SPJ11

Below is a C function called outputvals() that takes two integer parameters and outputs the   integers in reverseorder.

#include <stdio.h>

void outputvals(int start, int end) {

   int i;

   for (i = end; i >= start; i--) {

         printf("%d\n", i);

   }

}

int main() {

     int first = 3;

   int last =7;

   outputvals(first, last);

  return0;

}

Whenyou run this program, it will output the integers from end to start in reverse order, each followed by a newline. In   this example, the output will be  -

7

6

5

4

3

You can   modify the values of first and last in the main() function to specify differentstarting and ending parameters for the outputvals() function.

Learn more about C function at:

https://brainly.com/question/14001167

#SPJ4

(a) Algorithm to check if a string contains properly nested and balanced parentheses or not:

Step 1: Define a stack to store opening brackets

.Step 2: Scan each character of the string from left to right.

Step 3: If a left bracket ( (, [, or { ) is encountered, push it onto the stack.

Step 4: If a right bracket ( ), ], or } ) is encountered, pop the top element from the stack. If the stack is empty, the string contains an excess right bracket and is not properly nested and balanced. If the popped bracket doesn't match with the current bracket, the string contains mismatched brackets and is not properly nested and balanced.

Step 5: If the stack is empty at the end of the string, the string contains properly nested and balanced parentheses; otherwise, it contains excess left brackets and is not properly nested and balanced.

(b) Algorithm to find the position of the first offending parenthesis if the string is not properly nested and balanced:Step 1: Define a stack to store opening brackets and their positions.

Step 2: Scan each character of the string from left to right.

Step 3: If a left bracket ( (, [, or { ) is encountered, push its position onto the stack.

Step 4: If a right bracket ( ), ], or } ) is encountered, pop the top element from the stack. If the stack is empty, return the position of the excess right bracket. If the popped bracket doesn't match with the current bracket, return the position of the mismatched bracket. Repeat this step until the stack is empty.

Step 5: If the stack is empty at the end of the string, return -1 (the string contains properly nested and balanced parentheses); otherwise, return the position of the first excess left bracket.

For further information on String   visit :

https://brainly.com/question/33546918

#SPJ11

To write code that spawns 30 parallel threads that each thread executes the print function illustrated in the lab activities, and then end the main program when all threads spawned are finished, there are two source files needed. The first source file is for when a lock guard is used to protect each iteration of the for loop in print. The second source file is for when no mutex or lock guard is used

.The first step to solve this is to define the `print()` function that each thread will execute. The print function illustrated in the lab activities is:```void print(int num) {for (int i = 0; i < 10; ++i) {cout << "Thread: " << num << " prints " << i << endl;}}} ```For this question, the print() function is adapted to accept a pointer to a mutex as an argument.```void print(int num, std::mutex *mu) {for (int i = 0; i < 10; ++i) {std::lock_guard guard(*mu);cout << "Thread: " << num << " prints " << i << endl;}}} ```In this new version of the print() function, a lock_guard object is created with the mutex object passed as an argument, and the cout statement is enclosed in the lock_guard object.

This ensures that only one thread at a time can execute the cout statement.``void print(int num) {for (int i = 0; i < 10; ++i) {cout << "Thread: " << num << " prints " << i << endl;}}} int main() {std::thread threads[30];for (int i = 0; i < 30; ++i) {threads[i] = std::thread(print, i);}for (int i = 0; i < 30; ++i) {threads[i].join();}}```This program is similar to the previous one, but it does not include the mutex object or the lock_guard in the print() function. This means that each thread can execute the cout statement without waiting for any other thread to release the mutex. The output of this program may appear scrambled, as different threads will execute the cout statement at different times.Here are the screenshots of the output of the two programs:Output of the program that uses a mutex and lock_guard to protect the cout statement:Output of the program that does not use a mutex or lock_guard to protect the cout statement:

To know more about parallel visit:

brainly.com/question/32888312

#SPJ11

The output of the first program with the lock guard is synchronized and each thread's output is displayed sequentially, while the second program without any synchronization may produce jumbled output due to concurrent execution of the print function by multiple threads.

Here are two source files, one using a lock guard to protect each iteration of the print function, and another where no mutex or lock guard is used.

Source File 1: Using Lock Guard

#include <iostream>

#include <thread>

#include <mutex>

std::mutex mtx; // Mutex to protect the print function

void print(int thread_id)

{

   std::lock_guard<std::mutex> lock(mtx); // Lock guard for thread-safe printing

   std::cout << "Thread ID: " << thread_id << std::endl;

}

int main()

{

   const int num_threads = 30;

   std::thread threads[num_threads];

   for (int i = 0; i < num_threads; ++i)

   {

       threads[i] = std::thread(print, i);

   }

   // Join all the threads

   for (int i = 0; i < num_threads; ++i)

   {

       threads[i].join();

   }

   return 0;

}

Source File 2: No Mutex or Lock Guard

#include <iostream>

#include <thread>

void print(int thread_id)

{

   std::cout << "Thread ID: " << thread_id << std::endl;

}

int main()

{

   const int num_threads = 30;

   std::thread threads[num_threads];

   for (int i = 0; i < num_threads; ++i)

   {

       threads[i] = std::thread(print, i);

   }

   // Join all the threads

   for (int i = 0; i < num_threads; ++i)

   {

       threads[i].join();

   }

   return 0;

}

To compile and run these programs, you can use a C++ compiler such as g++:

g++ -std=c++11 -pthread -o program1 program1.cpp

g++ -std=c++11 -pthread -o program2 program2.cpp

Please note that the -pthread flag is necessary to link the pthread library for thread support.

After compiling, you can run the programs:

./program1

./program2

Learn more about mutex and lock guard click;

https://brainly.com/question/32493037

#SPJ4

The corresponding MIPS assembly code for the given C statement f = g + (h - 5) is addi f, g, 0x1f4; addi f, f, -0x5, where f, g, and h are 32-bit integers. The MIPS assembly code can be achieved by breaking the C statement into its corresponding parts.

The (h + 5) part can be represented by adding -5 to the register containing h and then adding g to that result. Then, the value in the register can be stored in the register that contains f. Explanation:Given C statement, f = g + (h - 5)In MIPS assembly code, the corresponding statement for it can be given as follows: addi f, g, 0x1f4; addi f, f, -0x5Where f, g, h, and i are given as 32-bit integers as declared in a C program. The 0x1f4 and -0x5 in MIPS code correspond to the numerical values of decimal 500 and -5, respectively.

The MIPS code can be generated as:

Step 1: Subtract 5 from register h and save the result to register f.addi f, h, -5

Step 2: Add the value in register g to the value in register f and store the result in register f.add f, g, and f. By combining these two MIPS code statements, we can get:addi f, g, 0x1f4; addi f, f, -0x5Therefore, the corresponding MIPS assembly code for the given C statement f = g + (h - 5) is addi f, g, 0x1f4; addi f, f, -0x5.

To know more about MIPS assembly code, visit:

https://brainly.com/question/31428060

#SPJ11

The flag required to link the math library in C is "-1 m". The srand function is used to seed the random number generator. The value stored in the variable "result" is 20.

The statement "A local variable (automatic variable) exists for the life of the program and can be accessed anywhere in the program file" is false. Local variables have a limited scope and exist only within the block of code where they are declared.

When using the C math library, the flag "-lm" is required to link the math library functions. This flag instructs the compiler to include the math library during the linking process, enabling the use of mathematical functions in the program.

A break statement can be used to exit a while loop. When encountered, the break statement immediately terminates the loop and control is transferred to the next statement outside the loop.

The srand() function is used to seed the random number generator. It initializes the random number generator with a seed value, allowing for the generation of different sequences of random numbers. The srand() function is typically used with the time() function to seed the generator based on the current time.

In the given declaration and initialization, double result = 104/5, the division operation is performed using integer operands. Since both operands are integers, the division results in the quotient of 20. Therefore, the value stored in the variable result is 20.

Learn more about srand

brainly.com/question/31141817

#SPJ11

To convert a positive integer to reverse binary, write a program that uses the given algorithm: output the remainder (0 or 1) of the integer modulo 2 while it is greater than 0, and then divide the integer by 2. The resulting string will represent the integer in reverse binary.

To convert a positive integer to reverse binary, we can use the following algorithm:

1. Take the positive integer as input.

2. While the integer is greater than 0, perform the following steps:

  a. Output the remainder (0 or 1) of the integer modulo 2.

  b. Divide the integer by 2 and assign the quotient back to the integer.

3. The above steps will output the bits in reverse order, representing the integer in reverse binary.

For example, if the input is 6, the algorithm will output "011." In binary, 6 is represented as 110, but the algorithm outputs the bits in reverse.

Learn more about  positive integer

brainly.com/question/18380011

#SPJ11

There can be several reasons why it might be useful to keep old routers:
1. Backup or Redundancy:
2. Experimental or Learning Purposes:

Keeping old routers can serve as a backup or redundancy option. In case your current router malfunctions or stops working, having an old router can be a lifesaver. You can quickly switch to the old router and continue using the internet until you can replace or repair the new one. This ensures uninterrupted connectivity and avoids any inconvenience caused by a sudden internet outage. Additionally, if you have a large house or office space, using old routers as Wi-Fi extenders can help improve the Wi-Fi coverage in areas where the main router's signal is weak.

Another reason to keep old routers is for experimental or learning purposes. If you are interested in networking or want to gain hands-on experience with routers, having access to old routers can be beneficial. You can experiment with different settings, configurations, and firmware updates without risking the functionality of your primary router.  In summary, keeping old routers can be useful for backup or redundancy purposes, providing uninterrupted internet connectivity in case of router failure. Additionally, it can serve as a valuable tool for experimentation and learning about networking concepts.

Learn more about old routers: https://brainly.com/question/28180161

#SPJ11

a FLOWGORITHM program that calculates a mobile phone bill based on customer plan and data used. The program performs the following steps:Prompt for input of customer name.Prompt for input of customer’s mobile plan.Prompt for input of number of gigabytes of data used.

If the plan choice is invalid or gigabytes used is less than zero (0), display a message and terminate program.Calculate the monthly bill based on plan & data usage.Display customer name, plan, and monthly mobile charges.Mobile data plans are:Plan A 19.99/month, w/6 gigs of data, additional data $8.50/gig.Plan B 29.99/month, w/10 gigs of data, additional data $3.50/gig.Plan C 39.99/month, unlimited data.

Declare necessary variables and constants.Initialize the constants.Use a comment box for your name, date, and purpose of the program.Use other comments where appropriate.DO NOT "hard code numbers" in calculations, use constants.

To know more about FLOWGORITHM visit:

https://brainly.com/question/32060515

#SPJ11

The statements that are true about the DOM (Document Object Model) are:Interaction with DOM elements is through event handlers, The DOM represents a document as a tree-like structure.

The Document Object Model (DOM) is a programming interface for web documents that represents the page so that programs can change the document structure, style, and content. The DOM represents the document as nodes and objects. That way, programming languages can interact with the page. Here, statements A and C are incorrect as the DOM can be manipulated using other languages and not only using JavaScript.

Also, the DOM represents a document as a tree-like structure and not as a sequential structure. Therefore, options B and D are correct. Hence, the main answer is option B, C. Option A and C are incorrect.

Therefore, the conclusion is that the interaction with DOM elements is through event handlers, and the DOM represents a document as a tree-like structure.

To know more about DOM (Document Object Model) visit:

brainly.com/question/32015402

#SPJ11

Here is the Python code implementation of the CheckBST function and MaxHeap class: Function to Check if a Binary Tree is a Binary Search Tree

def CheckBST(btree):
   def CheckBSTHelper(node, min_val, max_val):
       if node is None:
           return True
       if node.key < min_val or node.key > max_val:
           return False
       return (CheckBSTHelper(node.left, min_val, node.key - 1) and
               CheckBSTHelper(node.right, node.key + 1, max_val))

   return CheckBSTHelper(btree.root, float("-inf"), float("inf"))```
Class for MaxHeap```python
class MaxHeap:
   def __init__(self):
       self.heap_list = [0]
       self.size = 0

   def percolate_up(self, i):
       while i // 2 > 0:
           if self.heap_list[i] > self.heap_list[i // 2]:
               self.heap_list[i], self.heap_list[i // 2] = \
                   self.heap_list[i // 2], self.heap_list[i]
           i //= 2

   def insert(self, k):
       self.heap_list.append(k)
       self.size += 1
       self.percolate_up(self.size)

   def percolate_down(self, i):
       while (i * 2) <= self.size:
           mc = self.max_child(i)
           if self.heap_list[i] < self.heap_list[mc]:
               self.heap_list[i], self.heap_list[mc] = \
                   self.heap_list[mc], self.heap_list[i]
           i = mc

   def max_child(self, i):
       if (i * 2) + 1 > self.size:
           return i * 2
       else:
           if self.heap_list[i * 2] > self.heap_list[(i * 2) + 1]:
               return i * 2
           else:
               return (i * 2) + 1

   def find_max(self):
       if self.size > 0:
           return self.heap_list[1]
       else:
           return None

   def del_max(self):
       if self.size == 0:
           return None
       max_val = self.heap_list[1]
       self.heap_list[1] = self.heap_list[self.size]
       self.size -= 1
       self.heap_list.pop()
       self.percolate_down(1)
       return max_val

A binary tree can be checked if it is a binary search tree or not by traversing through all the nodes of the tree and checking whether it satisfies the properties of binary search tree or not.

Binary Heap can be implemented as MaxHeap and the methods that it can include are insert(k), find_max(), and del_max() which add new item to heap, return the maximum key value item and delete the maximum item respectively.

To know more about Python, visit:

brainly.com/question/32166954

#SPJ11

The RISC-V assembly code for the provided C-code is as follows:

``` .text
   .align 2
   .globl main
main:
   addi    sp,sp,-16
   sw  ra,12(sp)
   sw  s0,8(sp)
   addi    s0,sp,16

   li  a0,10
   jal foo

   lw  ra,12(sp)
   lw  s0,8(sp)
   addi    sp,sp,16
   jr  ra

   .align 2
   .globl foo
foo:
   addi    sp,sp,-16
   sw  ra,12(sp)
   sw  s0,8(sp)
   addi    s0,sp,16

   li  t0,0
   mv  t1,a0

loop:
   beq t0,t1,exit
   jal bar
   addi    t0,t0,1
   j   loop

exit:
   lw  ra,12(sp)
   lw  s0,8(sp)
   addi    sp,sp,16
   jr  ra

   .align 2
   .globl bar
bar:
   addi    sp,sp,-16
   sw  ra,12(sp)
   sw  s0,8(sp)
   addi    s0,sp,16

   sw  a1,0(a0)    # Stores the value of 'y' in the D[x] array
   lw  ra,12(sp)
   lw  s0,8(sp)
   addi    sp,sp,16
   jr  ra

```

Comments next to instructions are as follows:-

First, it declares the memory for D.```int D[100];```

- It starts the main function.```int main(int argc, char *argv[])```

- The function 'foo' is called with argument 10.```return foo(10);```

- The 'foo' function starts here.```int foo(int a)```

- Initializes register t0 to 0 and moves the value of register a0 to t1.```li  t0,0
   mv  t1,a0```

- Loops through values of i using register t0 and t1.

If the value of t0 is equal to t1, the loop ends.```loop:
   beq t0,t1,exit
   jal bar
   addi    t0,t0,1
   j   loop
exit:```

- The 'bar' function starts here.```void bar(int x, int y)```- The value of register a1 is stored in the array D[x].```sw  a1,0(a0)```

Learn more about RISC-V from the given link:

https://brainly.com/question/29817518

#SPJ11

Retrieving specific data from a particular disk is not a "random" act.

When retrieving specific data from a particular disk, the process involves accessing the disk's file system and locating the desired information using specific file paths or indexing methods. This retrieval is not random because it follows a predetermined structure and organization within the disk's file system. The data is stored in a logical and hierarchical manner, allowing for efficient retrieval based on the file's location and metadata.

The user or the software accessing the disk knows where the data is expected to be located and uses this knowledge to navigate the file system and retrieve the desired information accurately. Therefore, the act of retrieving specific data from a particular disk is a deliberate and targeted process rather than a random one.

Learn more about disk

brainly.com/question/32110688

#SPJ11

An assembly program for a phone book that can create a new contact info, delete a contact info, edit a contact info, and output the result of each action above can be written, compiled, and run using the 8086 Emulator only.

Here's the solution to your query:Writing an assembly program for a phone book requires the following steps:Step 1: Open an editor and type the assembly program's code. The code will be saved as a text file with an extension.asm.Step 2: Assemble the code using an assembler. The assembler reads the code in assembly language and generates object code as output. A .obj file is created, which contains the object code.Step 3: Compile the code using a linker. The linker generates an executable program file from the object file by combining it with system libraries and relocating it. The .exe file is created, which is ready to be run.Step 4: Run the program. The executable file is run using the 8086 emulator or a simulator.

The pointer to the address field call get input mov ah, 0 mov al, 0 mov bl, 0 add si, 10 ;move the pointer to the phone number field call get_input mov ah, 0 mov al, 0 mov bl, 0 ;increment the index by 32 add dx, 32 ;check if the last contact has been reached cmp dx, 320 ;10 contacts, each 32 bytes je output_results ;jump if the last contact has been created jmp create_new_contactdelete_contact: ;code to delete a contact from the array ;code to edit a contact in the arrayoutput_results: ;code to output the results of each action above;exit the program mov ah, 4ch mov al, 00 int 21h.endThe above code is a basic code to create a phone book program using 8086 Emulator only.

To know more about program visit:

https://brainly.com/question/30613605

#SPJ11

00000110b in ASCII stands for End of Transmission.The correct option is True.

In ASCII, 00000110b represents the End of Transmission (EOT) character. This character is used to indicate the end of a transmission or message and is commonly used in telecommunications and computer networking.ASCII is a character encoding scheme that represents text in computers and other devices. It assigns unique binary codes to each character in the standard ASCII character set, which includes letters, numbers, and symbols.ASCII codes are widely used in computing, telecommunications, and other fields where data needs to be transmitted and processed electronically.

Therefore, the given statement is true.

Learn more about ASCII at https://brainly.com/question/30399752

#SPJ11

In a data transfer instruction the effective address will be given by the sum of the base register and the immediate field. The effective address is defined as the address produced by adding a register's content or an immediate value to a memory address during the execution of an instruction.

The addressing modes used by MIPS are:

Register Mode, Base or displacement addressing, Immediate addressing, PC-relative addressing, and Pseudodirect addressing.

Explanation:

In computer programming, the addressing mode specifies how the effective address of an operand is calculated from its logical address. The effective address is defined as the address produced by adding a register's content or an immediate value to a memory address during the execution of an instruction.There are four main types of addressing modes that are used by a processor.

These include:

Immediate addressing mode: In this mode, the operand is specified within the instruction, rather than being loaded from memory. This is also called a constant mode because it is used to provide constant data to the program.

Register addressing mode: In this mode, the operand is specified in a register. It is usually faster than other addressing modes, as it avoids accessing memory.

Base or displacement addressing mode: In this mode, the effective address is calculated by adding a constant value (called the displacement) to the value in a register. It is also called an offset mode because it is used to access data that is located at a specific offset from a base address.

PC-relative addressing mode: In this mode, the effective address is calculated by adding a constant value to the program counter. This mode is useful for accessing data that is located close to the current instruction.

Pseudodirect addressing mode: This mode is a variation of the base or displacement mode, where the offset is stored in a register.

#SPJ11

Learn more about  MIPS:

https://brainly.com/question/15396687

The five testing tools that provide the least decision code coverage are: JUnit, Selenium WebDriver, Mockito, Cucumber, and Postman.

JUnit is a popular unit testing framework for Java applications. While it is effective for testing individual units of code, such as methods or classes, it does not provide extensive coverage of decision-based code paths. It focuses more on verifying the correctness of individual units rather than exploring different decision outcomes.

Selenium WebDriver is a widely used tool for automating web browsers. It is primarily used for functional testing of web applications by interacting with elements on web pages. However, its purpose is not to specifically target decision-based code coverage. Instead, it focuses on simulating user interactions and validating expected behaviors.

Mockito is a mocking framework for Java that allows developers to create test doubles of dependencies. It is commonly used in unit testing to isolate and test individual components. While Mockito helps in isolating dependencies, it does not explicitly address decision coverage. Its main goal is to facilitate unit testing by providing a means to stub or mock dependencies.

Cucumber is a behavior-driven development (BDD) tool that enables collaboration between developers, testers, and business stakeholders. It uses plain-text specifications written in a language called Gherkin to define test scenarios. Although Cucumber encourages specifying scenarios with different inputs and expected outcomes, it does not inherently focus on decision-based code coverage.

Postman is an API testing tool that allows developers to send HTTP requests and analyze responses. It is primarily used for functional testing and integration testing of APIs. While it helps in verifying the correctness of API endpoints, it does not specifically target decision coverage within the codebase.

In summary, while these testing tools are valuable in their respective areas, they do not provide extensive support for achieving high decision code coverage. It's important to use additional testing techniques and tools to ensure comprehensive coverage of decision paths in software applications.

Learn more about code coverage

brainly.com/question/28231949

#SPJ11

Asymmetric key encryption and Symmetric key encryption are two different encryption techniques used to secure data and protect it from any unauthorized access.

In asymmetric encryption, two keys are used to encrypt and decrypt the data whereas in symmetric encryption, only one key is used.

Below are the functions and Python code that can be used to encrypt user input and encrypt the data of the file provided in the problem statement using these two encryption techniques:

Asymmetric Key EncryptionIn asymmetric key encryption, two keys are used, i.e., Public Key and Private Key. The data is encrypted with the Public key and can only be decrypted with the Private key.

The following is the Python code to encrypt data using Asymmetric Key encryption using the RSA algorithm:

import rsa
import osdef fun_asymm(text):
   # Generate a key pair
   (public_key, private_key) = rsa.newkeys(512)
   
   # Encrypt the text using the Public Key
   encrypted_text = rsa.encrypt(text.encode(), public_key)

   # Write the Private and Public keys to files
   with open("private_key.txt", mode='wb') as privatefile:
       privatefile.write(private_key.save_pkcs1(format='PEM'))

   with open("public_key.txt", mode='wb') as publicfile:
       publicfile.write(public_key.save_pkcs1(format='PEM'))

   # Return the Encrypted text
   return encrypted_text

Symmetric Key Encryption

In symmetric key encryption, the same key is used to encrypt and decrypt the data.

The following Python code can be used to encrypt data using symmetric key encryption using the Fernet module.

from cryptography.fernet import Fernetdef fun_symm(text):

   # Generate a Key
   key = Fernet.generate_key()

   # Create the Fernet Object
   f = Fernet(key)

   # Encrypt the Text
   encrypted_text = f.encrypt(text.encode())

   # Write the Key to a file
   with open("symmetric_key.txt", mode='wb') as keyfile:
       keyfile.write(key)

   # Return the Encrypted text
   return encrypted_text

Reading the File and Encrypting it

The following Python code reads the content of the file "plain_text.txt" and encrypts it using asymmetric key encryption. The encrypted data is stored in the "encryption.txt" file.

with open("plain_text.txt", mode='r') as file:
   data = file.read()

encrypted_data = fun_asymm(data)

with open("encryption.txt", mode='wb') as file:
   file.write(encrypted_data)

Thus, the above code demonstrates how to encrypt data using asymmetric and symmetric key encryption. Also, it includes the reading of the file, encrypting the file data, and storing the encrypted data in another file.

To know more about Python, visit:

brainly.com/question/32166954

#SPJ11

The two terms that are often synonymous with or made possible with CIDR include: Classless and VLSM. CIDR (Classless Inter-Domain Routing) is an IP addressing scheme that modifies the traditional IP address structure.

The notation used in CIDR is a suffix attached to the IP address that indicates the number of bits in the address that can be used to identify hosts. It uses Variable Length Subnet Masks (VLSM) that allow for efficient allocation of IP addresses and routing. CIDR replaced the Classful network addressing scheme.

NAT (Network Address Translation) is a technique used in IP addressing that translates IP addresses from one network to another. OSPF (Open Shortest Path First) is a routing protocol that is used for dynamic routing in IP networks. It helps routers to calculate the shortest path to a destination network. Classful is an outdated IP addressing scheme that was used in the early stages of the internet.

To know more about synonymous visit:

brainly.com/question/30080861

#SPJ11

The if/else statement executes one block of statements if a test condition is true, and another block if the condition is false.

This statement is used to create conditional programming, meaning a program that can act differently based on the input or other factors.To put it simply, if/else is used when we want to execute a statement or a block of statements when a certain condition is true, and another statement/block when that condition is false.An if/else statement is an important construct in programming languages, as it allows the program to make choices based on certain conditions. Using conditional statements such as if/else helps create code that is more flexible, interactive, and easier to read and understand.

:Thus, the if/else statement is used to execute a block of statements if a test condition is true, and another block if the condition is false.

To know more about if/else statement visit:

brainly.com/question/13382093

#SPJ11

Gezbackay ARO offers higher efficiency and selective repeat ARQ, while Stop-and-Wait has limitations in efficiency and error handling.

Improved Efficiency: The Stop-and-Wait protocol is a simple and reliable method for error detection and correction. However, it suffers from low efficiency as it requires the sender to wait for an acknowledgment before sending the next data frame.

This leads to significant delays in the transmission process. The Gezbackay ARO protocol, on the other hand, employs an Automatic Repeat Request (ARQ) mechanism that allows for continuous data transmission without waiting for acknowledgments. This results in higher throughput and improved efficiency.

Error Handling: Stop-and-Wait ARQ protocol handles errors by retransmitting the entire frame when an error is detected. This approach is inefficient for large frames and high-error rate channels.

The Gezbackay ARO protocol utilizes selective repeat ARQ, where only the damaged or lost frames are retransmitted, reducing the overhead and improving the overall error handling capability.

Data Link Control (DLC): Data Link Control refers to the protocols and mechanisms used to control the flow of data between two network nodes connected by a physical link.

It ensures reliable and error-free transmission of data over the link, taking care of issues such as framing, error detection and correction, flow control, and access control.

Framing: Framing is the process of dividing a stream of data bits into manageable units called frames. Frames consist of a header, data payload, and sometimes a trailer.

The header contains control information, such as source and destination addresses, sequence numbers, and error detection codes. Framing is necessary to delineate the boundaries of each frame so that the receiver can correctly interpret the data.

Controlled Access Protocols: Controlled Access Protocols are used in computer networks to manage and regulate access to a shared communication medium. These protocols ensure fair and efficient sharing of the medium among multiple network nodes.

They can be categorized into two types: contention-based protocols (e.g., CSMA/CD) and reservation-based protocols (e.g., token passing). Controlled access protocols help avoid data collisions and optimize the utilization of the communication channel.

The usefulness of piggybacking can be understood in the context of acknowledgement messages in a network.

Instead of sending a separate acknowledgment frame for each received data frame, the receiver can piggyback the acknowledgment onto the next outgoing data frame. This approach reduces the overhead of transmission and improves efficiency by utilizing the available bandwidth more effectively.

Piggybacking is particularly beneficial in scenarios where network resources are limited or when the transmission medium has constraints on the number of messages that can be sent.

By combining data and acknowledgments in a single frame, piggybacking optimizes the utilization of the network and reduces the overall latency in the communication process.

Learn more about Efficiency upgrade

brainly.com/question/32373047

#SPJ11

The main method of the driver will think the given command passes 4 arguments.

In the command "hadoop MyProgram foo bar -D zipcode=90210", the main method of the driver will receive four arguments. Let's break down the command to understand the number of arguments:

1. "hadoop" - This is the name of the program or command being executed. It is not considered an argument for the driver's main method.

2. "MyProgram" - This is an argument passed to the driver's main method.

3. "foo" - This is another argument passed to the driver's main method.

4. "bar" - This is a third argument passed to the driver's main method.

5. "-D zipcode=90210" - This is a fourth argument passed to the driver's main method. It is a command-line option or flag that is often used to specify properties or configurations for the program.

Therefore, the main method of the driver will receive a total of four arguments.

Learn more about Command

brainly.com/question/31910745

#SPJ11

The program has 1010 bytes and will be loaded into page frames of 256 bytes each. The instruction to be used is at Byte 577. Find the page number and the exact displacement for the byte addresses where the data is stored.

Given that the page frames are 256 bytes, it is necessary to calculate the number of page frames that are needed to store the program. This can be computed using the following formula:Number of Page Frames = Size of Program / Size of Page Frame= 1010/256= 3.945 ≈ 4 page framesFor the instruction that will be used, the byte address is 577.

Therefore, the page number is given by the formula:Page Number = Byte Address / Size of Page Frame= 577/256 = 2.253 ≈ 2 page framesTo determine the exact displacement, the byte address must be taken modulo the size of the page frame as follows: Displacement = Byte Address modulo Size of Page Frame= 577 modulo 256= 65Therefore, the data is stored in Page 2, and the exact displacement is 65. Hence,Page number is 2, and the exact displacement is 65.

To know more about program visit:

https://brainly.com/question/18763374

#SPJ11

The program will prompt the user to enter the principal, interest rate, and length of the loan. It will then convert the interest rate to a monthly rate and the length of the loan to months.

Finally, it will calculate the monthly payment using the formula provided and output the result with 2 decimals and a dollar sign before the payment amount. The program will then prompt the user to go again or exit and output the total number of loans processed.```# Program to calculate monthly payment for a loanimport math# Initialize loop variablekeep_going = True# Initialize loan countloan_count = 0# Loop until user wants to exitwhile keep_going:# Get user input for principal, interest rate, and length of loanprincipal = float(input("Enter the principal amount: "))interest_rate = float(input("Enter the annual interest rate: "))loan_length = int(input("Enter the length of the loan in years: "))# Convert annual interest rate to monthly rate and loan length to monthsmonthly_rate = interest_rate / 1200months = loan_length * 12#

Calculate monthly payment payment = (principal * (monthly_rate * ((1 + monthly_rate) ** months))) / (((1 + monthly_rate) ** months) - 1)# Output monthly paymentprint("Monthly payment: ${:.2f}".format(payment))# Increment loan countloan_count += 1# Prompt user to go again or exitresponse = input("Do you want to go again? (Y/N): ")if response.upper() != "Y":keep_going = False# Output total number of loans processed print("Total number of loans processed:", loan_count)```

To know more about program visit:-

https://brainly.com/question/30613605

#SPJ11