I have attached two documents.One is “Chapter 3” which includes all the text from

I have attached two documents.One is “Chapter 3” which includes all the text from the e-textbook in the course. This is the reading that serves the basis for the assignment. The second document includes some context for the discussion assignment. The questions for the assignment that need answering are at the bottom of this document – highlighted and bolded so you cant miss them! This assignment requires at least 3 citations, APA format.
[supanova_question]

Complete the following in your own words

Resources:
Baltzan, P. (2016). Business driven information systems. New York, NY: McGraw Hill Education (On the internet)
It is recommended students search the Internet for a Data Collection Plan template.
Scenario: You are an entrepreneur in the process of researching a business development idea. As you create a high-level Information Technology (IT) strategy for your new enterprise, it is important to consider how digital data will be collected, stored, analyzed, and used. A Project Data Collection Plan will guide the process of identifying enterprise digital data needs, maintenance, and use in the context of your goal to incorporate business driven IT. The Data Collection Plan is intended to describe a high-level process for collecting and maintaining digital data. The Data Collection Plan is a working document, which is expected to change over time as new project details emerge.
Create a high-level Project Data Collection Plan for your project in a minimum of 700 words which includes the following information:
A description of the digital data needs of the enterprise organized by department
A summary of the type data to be collected and who will use it
A description of how the data management system will contribute to organizational collaboration
An innovative plan for collecting, storing, analyzing and distributing data that employs emerging technologies such as cloud computing, virtualization, and big data

done
Seen
few seconds ago[supanova_question]

What’s wrong with my codes? It doesn’t display any clock timer???

Programming Assignment Help out.print(“0”);
System.out.print(hr “:”);
if (min < 10)
System.out.print(“0”);
System.out.print(min “:”);
if (min < 10)
System.out.print(“0”);
System.out.print(sec);
}
public void incrementHours()
{
hr ;
if (hr > 23)
hr = 0;
}
public void incrementMinutes()
{
min ;
if (min > 59)
{
min = 0;
incrementHours();
}
}
public void incrementSeconds()
{
sec ;
if (sec > 59)
{
sec = 0;
incrementMinutes();
}
}

}

done
Seen
7 years ago[supanova_question]

Answer the following IN YOUR OWN WORDS. Respond to each of the following in a minimum of 400 words each.

Answer the following IN YOUR OWN WORDS. Respond to each of the following in a minimum of 400 words each, supported with a minimum of two references each. It will be run thru a checker, thanks.
Q1) Explain the risks to enterprise security.
Q2) Determine appropriate risk management practices.
** Minimum400 of two references each**

done
Seen
few seconds ago[supanova_question]

respond to the following IN YOUR OWN WORDS. 400 each

respond to the following two posts IN YOUR OWN WORDS with a minimum of 400 words each, supported with a minimum of two references. It will be run thru a checker, thanks.
1.There are several management information systems available for business and organizations. Which one to use can be decided according to the type of industry as well as the type of information that should be captured. The various systems can be very effective in the areas of design. According to Baltzan (2016), management information systems is a business function, like accounting and human resources, which moves information about people, products, and processes across the company to facilitate decision making and problem solving. MIS can also be an important enabler of business success and innovation. (2016)
The roles for MIS may vary. For instance, the accounting systems might include maintaining the fiscal operations of the business while the human resources systems is held accountable for identifying qualified candidates to join the team as well as developing and enforcing policies and procedures to ensure equality and consistency is achieved. According to Zeng, (2021), good management of human resource can enable businesses to operate effectively but most enterprises still use traditional methods of allocating human resources, which is difficult to meet the development needs of enterprises. The decision making system is also vital to the success as well as the reputation of the business. These systems must be implemented in a consistent and orderly fashion. Capturing true data and maintaining accurate records can benefit the assessment and evaluation processes. This can also support the need for change and or adjustments. My organization is very strategic when conducting assessments to determine the direction of the organization. In some cases, change might be justified but in other cases change might just be a matter of opinion.
2.According to “Types Of Collaboration Technology”(2019), Collaborative technology refers to tools and systems designed to better facilitate group work, both in office and remote. Also known as groupware, these pieces of technology trim the costs and time associated with facilitating group work, from designating roles and responsibilities to routing documents to checking and approving project parts. They allow for more intuitive and coordinated group problem solving across an entire team’s workflows. Depending on the individual team or department, the technicality of the project and the overall goal of the work, you’re bound to find group work methodologies prevail like permissiveness(“Types Of Collaboration Technology”, 2019).
Telecommunications allows groups to collaborate even when not in close physical proximity via voice, video and data-based technology like the internet. This means coordination and activity at times and in locations that otherwise would be difficult, if not impossible. Travel expenditures are reduced and the pool of subject-matter experts widens, strengthening overall work. Premise-based collaborative software is bought and installed onto individual desktops on a company’s network. These tools expand the shared project management functions and capacities of teams, allowing members to track and organize project tasks as well as locate important network files, make informational updates and message anyone with access to the on-site software. Communication technology suggests that communication software tools allow for messages, chat groups and conversations to be conducted between individuals and parties via the Internet, whether those parties are in different parts of the office or different parts of the world. Communication tools also tend to be unstructured(“Types Of Collaboration Technology”, 2019).
They do not require prior scheduling or calendar sharing to be effective, they’re not intended to be formally preemptive at all. Coordination technology rounds out the three main types of collaborative software. Arguably the most holistic of collaborative tools, coordination software is designed to integrate both teamwork and taskwork functions. In other words, they allow individuals and groups to connect interpersonally as well as coordinate work tasks and activities (“Types Of Collaboration Technology”, 2019).

done
Seen
few seconds ago[supanova_question]

This project uses an Enigma® machine simulator. It functions like the Enigma machines used during

This project uses an Enigma® machine simulator. It functions like the Enigma machines used during WWII. This example has been included to help you better understand how encryption worked in the early days. It is a great learning tool for when you first start exploring the subject of cryptography. Enigma machines provided good encryption strength for their day. Modern cryptographic systems are much more secure than Enigma machines.
Pay attention to the “red ball” path as the simulator encrypts text. The red ball goes through the three rotors, bounces off the reflector, and then goes back through the three rotors. In the physical machine, the rotors would move with each keystroke. If it completes one full cycle, it will advance the middle rotor and, subsequently, the left rotor as well.
Directions:
Open a web browser and go to Observable Enigma Machine (Links to an external site.).
Type your first name and last name without a space into the “Input” field.
Wait until the complete encryption is completed. Note: The text in the Input text box is what you typed. The text in the Output text box is what you would send.
Take a screenshot.
Now Open a web browser and go to Crypii (Links to an external site.). (This is a visually simpler but faster Enigma simulation.)
Click in the “Plaintext” text box and type in again your name without spaces. (The three rotors or “rings” should be set to their AAA position.) Click on “ENCODE”.
The encoded text appears instantly in the “Ciphertext” textbox.
Now click on the “DECODE” button and the encoded text is decoded.
Take a screenshot.
Submit your screenshots and answer the following questions:
Why did Enigma machines use multiple rotors?
How did WWII cryptographers know which rotor settings to use?
Your well-written paper should meet the following requirements:
Be 3–4 pages in length.
Contain an illustrative table or a diagram created from properly cited external references.
Include two credible external references in addition to the textbook.

done
Seen
few seconds ago[supanova_question]

Need help with spark programming assignment. need someone who can write the code in google

Programming Assignment Help Need help with spark programming assignment. need someone who can write the code in google Collab and share the File as well as need a document that has the code and output screenshots with an explanation. Please refer to the assignment document for more understanding.
[supanova_question]

A.  Input Requirements
1.  Include a prompt that allows the user to enter a

A.  Input Requirements
1.  Include a prompt that allows the user to enter a command from the following four options, repeating the process of displaying the menu screen until the user has selected “quit.”
•  add a business contact
•  add a personal contact
•  display contacts
•  quit
2.  Include a prompt that allows the user to enter the following identifiable information when the “add a business contact” command is selected:
•  first name
•  last name
•  address
•  phone number
•  e-mail address
•  job title
•  organization
Note: You are not required to store the contact information as persistent data in a database.
3.  Include a prompt that allows the user to enter the following identifiable information when the “add a personal contact” command is selected:
•  first name
•  last name
•  address
•  phone number
•  e-mail address
•  date of birth
B.  Output Requirements
1.  Display the results to the user on screen in a readable and descriptive format (e.g., System.out) by doing the following:
a.  Display all contacts’ first and last names when the “display contacts” command is selected.
b.  Include a numeric key for each contact that will be used to invoke the method that displays the contact details.
2.  Include a prompt that allows the user to enter the numeric key to display all details of the contact in a readable and descriptive format (e.g., System.out, output to a text file using FileWriter).
a.  Identify contacts by type when displaying the details of a contact: business or personal.
C.  Design Requirements
1.  Demonstrate use of collections (e.g., TreeSets, ArrayList).
2.  Demonstrate use of encapsulation.
3.  Demonstrate use of inheritance by doing the following:
a.  Create one abstract class.
b.  Create two subclasses.
4.  Demonstrate use of polymorphism by overriding a method of the abstract class in both subclasses (i.e., method that displays contact details).

done
Seen
7 years ago[supanova_question]

need to hold RStudio ONLY do 1236 the Q1 need use 3 data files Q2 need to use date

need to hold RStudio
ONLY do 1236
the Q1 need use 3 data files
Q2 need to use date file is Handwriting.zip
Fifa analysis is in the extra data
there r 3 data zips,
Final exam include questions
extra data and Handwriting are the extra data needed[supanova_question]

a network TCP stream socket and random numbers generating

Create a program to generate pseudorandom
random numbers, which will then be transmitted from clients to a server using TCP
stream sockets.
The exact instructions are in the attached file.. The code is almost done .. just a matter of assembling things. use the given code in the solution.
Document the code you add and explain what it does
Hint: Your output should resemble:
Server PID 123 received value 987654 from Client PID 456.
[supanova_question]

Business computer languages-manal

Programming Assignment Help You must submit two separate copies (one Word file and one PDF file) using the Assignment Template on Blackboard via the allocated folder. These files must not be in compressed format.
Zero mark will be given if you try to bypass the SafeAssign (e.g. misspell words, remove spaces between words, hide characters, use different character sets, convert text into image or languages other than English or any kind of manipulation).
You are advised to make your work clear and well-presented. This includes filling your information on the cover page.
You must use this template, failing which will result in zero mark.
You MUST show all your work, and text must not be converted into an image, unless specified otherwise by the question.
The work should be your own, copying from students or other resources will result in ZERO mark.
Use Times New Roman font for all your answers
[supanova_question]

Matlab: highpass laplacian filter, FFT2, IFFT2, lowpass Gaussian filter

Write a Matlab code to apply highpass laplacian filter on Lab8_1.jpg image.
Write a Matlab code to apply ideal highpass filter on Lab8_1.jpg image for D0=100
Apply FFT2, IFFT2, lowpass Gaussian filter, and highpass laplacian filter onLab8_3.jpg image.
Please see the attahced document for more details

[supanova_question]

Business computer languages-manal

All answered must be typed using Times New Roman (size 12, double-spaced) font. No pictures containing text will be accepted and will be considered plagiarism). The Assignment must be submitted in (WORD format only). Use 2 to 4 References and write it in the last page by APA style. I want new words, No plagiarism “Please make it 0% percentage (we want put it the solution with the Cove page🙏)
[supanova_question]

it 401- manal

All answered must be typed using Times New Roman (size 12, double-spaced) font. No pictures containing text will be accepted and will be considered plagiarism). The Assignment must be submitted in (WORD format only). Use 2 to 4 References and write it in the last page by APA style. I want new words, No plagiarism “Please make it 0% percentage (we want put it the solution with the Cove page?)
[supanova_question]

it 401- manal

Programming Assignment Help All answered must be typed using Times New Roman (size 12, double-spaced) font. No pictures containing text will be accepted and will be considered plagiarism). The Assignment must be submitted in (WORD format only). Use 2 to 4 References and write it in the last page by APA style. I want new words, No plagiarism “Please make it 0% percentage (we want put it the solution with the Cove page?)
[supanova_question]

Need help with MATLAB project

Hello,
I need help with my with project. All the problems have to be solved using ONLY MATLAB.
The project is attached.
When you are done with it send it to me as a zip file.
********** I’ll send you all the data you need to work on the project **********
[supanova_question]

Programming Question

Exam 3 TopicsDictionaries, Chapter 11: pages 328-331, 334-335Classes, chapter 14. Pages 374-382, 388, , 392, 394, 396. Ignore UML diagrams. Ignore “properties” as per page 398.Class definition, private attributes, methods. Object instantiation, explicit constructor (__init__ method): study program Bank2 (canvas files folder nov16-18-OOP). Use of decorator (Program Bank1)Composition of classes: study program Bank4Concepts of information hiding, data encapsulation, interface, implementation , pages 392, 394, 396Subclasses and inheritance, chapter 15: pages 414, 416, 418, 420Study program Bank5 (in canvas files folder nov23-OOP): definition of subclass, superclass, constructor of a subclass, method overriding, inheritance, polymorphism, isinstanceGraphical User Interface, Chapter 18.Understand the Python features involved in GUI programmingRoot (ignore root.mainloop), page 513Study Frame, Button, p.515Ignore padding argument: frame = ttk.Frame(root, padding=”10 10 10 10″)Ignore: frame.pack(fill = tk.BOTH, expand =True)Study Page 517: callback functions, event handlingStudy Page 523: subclass Investment of class Frame: its constructor, callback functionIgnore the method ”grid”, the “for child” loop
[supanova_question]

Solving 2 questions by using python

Hi there, I have 2 questions that should be answered by using PYTHON. I will add the questions sheet, including the guidance in the file section. you have to include the picture of the code so I can rewrite it and make sure that it worked. also include the file.
[supanova_question]

Programming Question

Programming Assignment Help Explain in your own words, the four steps you should take to ensure that a gpu Kernel (as shown below) is properly invoked to take as input an array called, inArray, and produce as output another array called, outArray.NOTE: Both inArray and outArray are one dimensional arrays of 4096 interger values.__global__ void kernelgpu( int* d_input, int* d_output){int idx = threadIdx.x blockIdx.x*blockDim.x;d_output[idx] = 3.1415* d_input[idx];}

done
Seen
3 hours ago[supanova_question]

CMSC 430 Project 4

CMSC 430 Project 4
The fourth project involves modifying the semantic analyzer for the attached compiler by adding
checks for semantic errors. The static semantic rules of this language are the following:
Variables and parameter names have local scope. The scope rules require that all names be
declared and prohibit duplicate names within the same scope. The type correspondence rules are
as follows:

? Boolean expressions cannot be used with arithmetic or relational operators.

? Arithmetic expressions cannot be used with logical operators.

? Reductions can only contain numeric types.

? Only integer operands can be used with the remainder operator.
? The two statements in an if statement must match in type. No coercion is performed.
? All the statements in a case statement must match in type. No coercion is performed
.
? The type of the if expression must be Boolean.

? The type of the case expression must be Integer

? A narrowing variable initialization or function return occurs when a real value is being
forced into integer. Widening is permitted.

? Boolean types cannot be mixed with numeric types in variable initializations or function
returns.
Type coercion from an integer to a real type is performed within arithmetic expressions.
You must make the following semantic checks. Those highlighted in yellow are already
performed by the code that you have been provided, although you are must make minor
modifications to account for the addition of real types and the need to perform type coercion and
to handle the additional arithmetic and logical operators.
? Using Boolean Expressions with Arithmetic Operator
? Using Boolean Expressions with Relational Operator
? Using Arithmetic Expressions with Logical Operator
? Reductions containing nonnumeric types

? Remainder Operator Requires Integer Operands

? If-Then Type Mismatch

? Case Types Mismatch

? If Condition Not Boolean

? Case Expression Not Integer
? Narrowing Variable Initialization

? Variable Initialization Mismatch

? Undeclared Variable
? Duplicate Variable

? Narrowing Function Return
This project requires modification to the bison input file, so that it defines the additional
semantic checks necessary to produce these errors and addition of functions to the library of type
checking functions already provided in types.cc. You must also make some modifications to
the functions provided. You need to add a check to the checkAssignment function for
mismatched types in the case that Boolean and numeric types are mixed. You need to also add
code to the checkArithmetic function to coerce integers to reals when the types are mixed and
the error message must be modified to indicate that numeric rather than only integer types are
permitted.
The provided code includes a template class Symbols that defines the symbol table. It already
includes a check for undeclared identifiers. You need to add a check for duplicate identifiers.
Like the lexical and syntax errors, the compiler should display the semantic errors in the
compilation listing, after the line in which they occur.
An example of compilation listing output
containing semantic errors is shown below:

done
Seen
2 mins ago[supanova_question]

Programming Question

For this assignment, you are required conduct research and provide a recent example for any three of the following mobile device vulnerabilities and exploits
Location snooping
Extortion via ransomware
Participating in distributed denial of service (DDoS) attacks as part of a botnet
Posting to social media sites
SMS redirection

done
Seen
14 mins ago[supanova_question]

matlab: Computer Vision and Image Processing lab “Image enhancement “

Lab tasks:
Enhance your image jpg( black and white image) using the three intensity transformations described above. Let c =1 always. Use different values of ? (0.3, 0.4, 0.6, 1.0, 3.0, and 5.0) for each image.
Comment on the results you have got.
Redo excursive 6 using salt and paper noise.
Redo excursive 3 and 4 using your image
I will provide you with images
_________________________________
EXERCISE1: IMAGE NEGATIVES2: CHANGE THE VALUES OF C AND GAMMA (AT LEAST 3 VALUES EACH), AND COMMENT ON YOUR RESULTS.EXERCISE3: IMAGE HISTOGRAM
EXERCISE4: HISTOGRAM EQUALIZATION
EXERCISE5: IMAGE ENHANCEMENT USING SUBTRACTION
EXERCISE6: IMAGE ENHANCEMENT USING AVERAGING
PLEASE SEE THE ATTACHED FILE FOR DETAILS
[supanova_question]

matlab: Computer Vision and Image Processing lab “Image enhancement “

Programming Assignment Help Lab tasks:
Enhance your image jpg( black and white image) using the three intensity transformations described above. Let c =1 always. Use different values of ? (0.3, 0.4, 0.6, 1.0, 3.0, and 5.0) for each image.
Comment on the results you have got.
Redo excursive 6 using salt and paper noise.
Redo excursive 3 and 4 using your image
I will provide you with images
_________________________________
EXERCISE1: IMAGE NEGATIVES2: CHANGE THE VALUES OF C AND GAMMA (AT LEAST 3 VALUES EACH), AND COMMENT ON YOUR RESULTS.EXERCISE3: IMAGE HISTOGRAM
EXERCISE4: HISTOGRAM EQUALIZATION
EXERCISE5: IMAGE ENHANCEMENT USING SUBTRACTION
EXERCISE6: IMAGE ENHANCEMENT USING AVERAGING
PLEASE SEE THE ATTACHED FILE FOR DETAILS
[supanova_question]

Electrical

Lab tasks:
Enhance your image jpg( black and white image) using the three intensity transformations described above. Let c =1 always. Use different values of ? (0.3, 0.4, 0.6, 1.0, 3.0, and 5.0) for each image.
Comment on the results you have got.
Redo excursive 6 using salt and paper noise.
Redo excursive 3 and 4 using your image
I will provide you with images
_________________________________
EXERCISE1: IMAGE NEGATIVES2: CHANGE THE VALUES OF C AND GAMMA (AT LEAST 3 VALUES EACH), AND COMMENT ON YOUR RESULTS.EXERCISE3: IMAGE HISTOGRAM
EXERCISE4: HISTOGRAM EQUALIZATION
EXERCISE5: IMAGE ENHANCEMENT USING SUBTRACTION
EXERCISE6: IMAGE ENHANCEMENT USING AVERAGING
PLEASE SEE THE ATTACHED FILE FOR DETAILS
[supanova_question]

Credit Card Fraud Detection

As discussed in Lesson 27, can use a supervised or unsupervised algorithm to detect credit card fraud. This assignment is for you to try it yourself if you are interested. Also, It can replace your lowest quiz score if the % score of this assignment is higher than that.
Step 0: Clean Data
Obtain data from Kaggle (Links to an external site.). Remove all duplicates. For the attribute “class”, change 0 to -1 so that -1 represents normal and 1 represents fraud. After this, the resulting dataset should contain 473 fraud and 283253 normal transactions.
Step 1: Scale Time [supanova_question]

HMM

As discussed in Lesson 26, HMM can be used to break a simple substitution cipher. This assignment is for you to try it yourself if you are interested. Also, It can replace your lowest quiz score if the % score of this assignment is higher than that.
Step 0: Encryption
Obtain an English plaintext message of 50,000 plaintext characters, where the characters consist only of lowercase a through z (i.e., remove all punctuation, special characters, and spaces, and convert all upper case to lower case). Set a key yourself and encrypt this plaintext using a simple substitution cipher.
Step 1: Generate a digraph frequency matrix A for English text
Use an English text with 1,000,000 characters (only 26 letters in lowercases) to compute a digraph frequency matrix A, where aij is the count of the number of times that letter i is followed by letter j. Here, we assume that a is letter 0, b is letter 1, c is letter 2, and so on. Next, add five to each element in your 26×26 matrix A. Finally, normalize your matrix A by dividing each element by its row sum. The resulting matrix A will be row stochastic, and it will not contain any 0 probabilities.
Step 2: Train an HMM with M = N = 26
Using the first 1000 characters of ciphertext you generated in step 0 as O to train an HMM, where the A matrix is initialized with your A matrix from step 1. That is, in your HMM, do not re-estimate A. For B [supanova_question]

BUS 120G prgramming

Programming Assignment Help This notebook includes the narrative for 2 programs.
KDP Printing costs
Kindle Vella Royalties
Your narrative
Each narrative must provide two solutions: solution 1 for a known number of items (for loop); solution 2 for an unknown number of items.
1. KDP printing costs
Create a program that calculates the cost of printing books in Amazon.com (only Amazon.com marketplace)
https://kdp.amazon.com/en_US/help/topic/G201834340
2. Kindle Vella Royalties
Calculate the royalties paid for multiple episodes.
https://kdp.amazon.com/en_US/help/topic/G5TFR9WSHB46ZKFN
3. Add your own narrative
Requirements for the narrative:
Must solve a real business problem
Must include if-the-else (at least two) and loops (at least one)
It can be simplified
Must include link

done
Seen
5 mins ago[supanova_question]

Keyword: Traffic Generator, Packet Sender/Receiver, Network Throughput Measure Tool

CS 578 Wireless Networks
Programming Assignment – Get Your Bonus Points
Keyword: Traffic Generator, Packet Sender/Receiver, Network Throughput Measure Tool
Responding to students’ requests, the total bonus is increased from 3 points to 5 points. To be fair, the TCP feature in Step 9 is required (it was optional).
There are many, many software programs available online (some are free) to test the throughput of your wireless network. For this assignment you are to implement you own version of wireless network throughput testing software. After your implementation, you should:
Have two programs – both a packet sender and a packet receiver piece of software.
Mandatory feature to support UDP packet transmission, due to its simplicity.
The sender program can specify the packet size, destination IP address and port, and continuously send packets to the receiver.
The receiver program should be able to pick up all the packets arriving at the said port.
The receiver program should display the current throughput (bps, kbps, Mbps, etc.) and keep logging the relevant data in a file or certain storage places for future analysis.
Use your software to test your WiFi network throughput at different locations/distances. Try to disable/minimize other traffic of your own WiFi network in order to have accurate testing results. Test both downlink and uplink throughputs. Draw a diagram of throughput-distance curve (x- distance; y-throughput).
Change to several different packet sizes, and repeat 6 to generate new throughput-distance curves. Put all these curves in a single figure for comparison and analysis. Discuss the results you collected.
Write a report to supersize your software implementation, and analyze your wireless network testing results.
[New: required] Add a new feature to support TCP, test the throughput of TCP traffic over WiFi for downlink and uplink. Discuss results and draw figures of TPC throughput-distance curves.
This programming assignment is designed to get you exposed to low level packet network operations and the convenient usage of socket provided by most of the mainstream operating systems. However, you may use any high-level language that provides built in networking support.
Please feel free to choose any programming language, on any operating system. Due to the diversity of operating systems and software run-time library dependency, a live demo is not required. In lieu of a live demo, please include your software screen shot in the report, as evidence of your working software measuring the throughput.
Partially finished programs are acceptable and grading will be prorated. Clearly state what features you have implemented and what features/tests are missing. Attach your essential source code upon submission for code review.
[Deliverable] Submit a short report in PDF, and essential source code in a ZIP file. There is no specific format of the report. Typically, the PDF report should summarize your software implementation and analysis of your wireless network testing results.

done
Seen
5 mins ago[supanova_question]

Traffic lights

Learning Goal: I’m working on a computer science multi-part question and need an explanation and answer to help me learn.
Learning Goal: I’m working on a computer science multi-part question and need an explanation and answer to help me learn.
a) A working product. Your system must work. Show the functionality of your system.
b) Presentation. You must present your work in the best possible way in fifteen minutes. Make
sure to rehearse your presentation many times with your teammate and be sure to define the
role of each member.
c) A formal, technical report, which must be in journal or conference format. You can choose
IEEE format. The length of the report must be a minimum of five and a maximum of 10 pages
(double space with 12 pt. font.)
Your report must contain the following sections:
1) Cover page
2) Abstract or objective (Section I)
3) Introduction and historical facts (Section II)
4) Methodology. Show your techniques, design, etc. (Section III)
5) Software Code (Sect. IV)
6) Discussions of your product achievements and the results. This is the most important
part of your report (Sect. V)
7) Future work (Sect. VI)
8) Conclusions (Sect. VII)
9) References. You must show all references in your paper to validate your work.
TRAFFIC LIGHT:
Simulate the operation of a traffic light in an intersection, as shown below
PLEASE LOOK AT THE ATTACHED FILE OF THE OPERATION OF A TRAFFIC LIGHT IN AN INTERSECTION
Cars arrive at random intervals and wait at the light until it’s green. The simulation should keep
track of the state of the intersection with a resolution of 1 second. Two variable parameters will
drive the simulation:
1. The number of seconds between the light changing (assume that it
says red and green in each direction for the same amount of time.)
2. The probability that at any given second, a new car arrives at
intersection
Assume that it takes exactly 3 seconds for each car to clear at intersection once the light turns
green. The simulation should keep track of the number of cars that pass through the intersection
and the average time that cars wait. Graph these two variables across a range of timing
variables.
Keep a queue for each direction for entering the intersection and add a car to the appropriate
queue when it reaches the intersection.
Note: The way the simulation is set up you do not really need to keep a queue , just a count.
Modify the problem as follow:
1) Create three types of vehicles, say, cars, buses, and trucks. The relative probabilities and
time taken to pass through the intersection should be different for each vehicle type.
2) Allow some percentage of the vehicles to turn left-turning vehicles block the line until the
light changes, if there’s traffic in the opposite direction .
[supanova_question]

assembly language

explain the code in details what does the code do how does it work how does it calculate the points
#################################################################
# Display Configuration#
#—————————————————————#
# Unit Width in pixels: 8#
# Unit Height in Pixels: 8#
# Display Width in Pixels: 512#
# Display Height in Piexels: 256#
#—————————————————————#
# Total units: (512/8) * (256/8) = 64 x 32 = 2048 pixels #
# Arena units: (256/8) * (216/8) = 32 x 27 = 864 pixels#
#################################################################
#########################################################################################
# Here we use the first byte of the color word to store other informations#
# 00 – moving Right | 01 – moving Down | 02 – moving Left | 03 moving Up#
# these flags are useful to erase the tail#
.data#————————
# Colors # FLAG | R | G | B #
scoreColor: .word 0x00FFFF00 # 00 | FF | FF | 00#
arenaBG: .word 0xBBBBFFFF # BB | B2 | 22 | 22 —-BACKGROUND COLOR #
appleColor: .word 0xFFFF0000 # FF (DM) | FF | 00 | 00#
snakeRight: .word 0x0000FF00 # 00 | 00 | FF | 00 –|#
snakeDown: .word 0x0100FF00 # 01 | 00 | FF | 00 |- MOVEMENT#
snakeLeft: .word 0x0200FF00 # 02 | 00 | FF | 00 |#
snakeUp: .word 0x0300FF00 # 03 | 00 | FF | 00 –|#
#————————##
#* DM = Dont matter#
# Addresses ————————————————————————
screenStart: .word 0x10010500
add_end_flag: .word 0x1fffff0f
# # # Numbers
dozen_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x10011394, 0x10011398, 0x1001139C,
0x10011494, 0x10011498, 0x1001149C,
0x10011594, 0x10011598, 0x1001159C,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen0_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x10011394, 0x1001139C,
0x10011494, 0x1001149C,
0x10011594, 0x1001159C,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen1_start: .word 0x1001129C,
0x1001139C,
0x1001149C,
0x1001159C,
0x1001169C, 0x1fffff0f
dozen2_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x1001139C,
0x10011494, 0x10011498, 0x1001149C,
0x10011594,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen3_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x1001139C,
0x10011494, 0x10011498, 0x1001149C,
0x1001159C,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen4_start: .word 0x10011294, 0x1001129C,
0x10011394, 0x1001139C,
0x10011494, 0x10011498, 0x1001149C,
0x1001159C,
0x1001169C, 0x1fffff0f
dozen5_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x10011394,
0x10011494, 0x10011498, 0x1001149C,
0x1001159C,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen6_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x10011394,
0x10011494, 0x10011498, 0x1001149C,
0x10011594, 0x1001159C,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen7_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x1001139C,
0x1001149C,
0x1001159C,
0x1001169C, 0x1fffff0f
dozen8_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x10011394, 0x1001139C,
0x10011494, 0x10011498, 0x1001149C,
0x10011594, 0x1001159C,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen9_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x10011394, 0x1001139C,
0x10011494, 0x10011498, 0x1001149C,
0x1001159C,
0x1001169C, 0x1fffff0f
#################################################################################################
#################################################################################################
# Macros:
# _____
.macro Pause
li $a0, 100 #
li $v0, 32 # Pause for 80 milisec
syscall#
.end_macro
.macro MegaPause
li $a0, 500 #
li $v0, 32 # Pause for 500 milisec
syscall#
.end_macro
#———————————————————————————————–#
# __________
.macro PaintArena
li $t0, 128 #starting line index [halved line size]
li $t1, 0 #starting pixel index
lw $t3, screenStart # load starting address on t3
lw $t2, arenaBG #load bg color on t2
drawline:
sw $t2, ($t3)# paint pixel_address
addi $t3, $t3, 4 # pixel_adress
addi $t1, $t1, 4 # pixel_i
blt $t1, $t0, drawline # if pixel_index < (line_size/2), keep painting line
addi $t3, $t3, 128 # else, jump pixel_adress to next beginning line.
addi $t1, $t1, 128 # jump pixel_i to next beginning line.
addi $t0, $t0, 256 # line_i .
ble $t0, 6784, drawline# if not finished painting line, do it again
# (27*line_size) (line_size/2)=6784
.end_macro
#———————————————————————————————–#
# _________
.macro ScorePlusPlus
addi $s0, $s0, 1
.end_macro
# _________
.macro SaveDispVal
move $s1, $t4 # save current unit value
move $s2, $t5 # save current dozen value
move $s3, $t6 # save current unit value
.end_macro
#################################################################################################
#################################################################################################
.text
PaintArena#Paint the arena
# Loading starting values…
li $s0, 3# load initial score (size of the initial snake)
li $s4, 3# Head x_pos
li $s5, 2# Head y_pos
li $s6, 0x10010704 # Tracking the tail to erase
lw $s7, snakeRight # Current movement
# for init
li $t0, 0x10010704 # Snake begin
li $t1, 0x10010710 # Snake end — total size: (end – begin)/4
li $t4, 0xFFFF0000 # Apple color
initialSnake:
sw $s7, ($t0) #
addi $t0, $t0, 4 # while SB < SE, fill the display with the snake body (size: 6/4??)
blt $t0, $t1, initialSnake # initial size will be 2.
jal generateApple
addi $ra, $ra, 20 # jumps to the line after addi to avoid verification
# of self collision (the instruction: beq $t0, 0x0000FF00, quit)
jr $ra
moveRight:
lw $s7, snakeRight
jal drawHead
addi $s4, $s4, 1
#init line 89 will jump here
Pause
lw $t7, 0xFFFF0004# Verifying which key is pressed
# OBS: This value stays on the register until another key is pressed
beq $t7, 0x00000077, moveUp # w key is pressed
beq $t7, 0x00000073, moveDown # s key is pressed
beq $t7, 0x00000071, quit # q key is pressed
j moveRight
moveDown:
lw $s7, snakeDown
jal drawHead
addi $s5, $s5, 1
Pause
lw $t7, 0xFFFF0004# Verifying which key is pressed
# OBS: This value stays on the register until another key is pressed
beq $t7, 0x00000061, moveLeft # a key is pressed
beq $t7, 0x00000064, moveRight # d key is pressed
beq $t7, 0x00000071, quit # q key is pressed
j moveDown
moveLeft:
lw $s7, snakeLeft
jal drawHead
subi $s4, $s4, 1
Pause
lw $t7, 0xFFFF0004# Verifying which key is pressed
# OBS: This value stays on the register until another key is pressed
beq $t7, 0x00000077, moveUp # w key is pressed
beq $t7, 0x00000073, moveDown # s key is pressed
beq $t7, 0x00000071, quit # q key is pressed
j moveLeft
moveUp:
lw $s7, snakeUp
jal drawHead
subi $s5, $s5, 1
Pause
lw $t7, 0xFFFF0004# Verifying which key is pressed
# OBS: This value stays on the register until another key is pressed
beq $t7, 0x00000061, moveLeft # a key is pressed
beq $t7, 0x00000064, moveRight # d key is pressed
beq $t7, 0x00000071, quit # q key is pressed
j moveUp
#————————————————————————————————————-#
drawHead: #local reg: t0, t1, t7
# Computing Address of (x, y) on the screen
sll $t1, $s5, 6 # t1 = s5 * (2^7) = s5 * 128(computing y)
add $t1, $t1, $s4 # t1 = s4(computing x)
sll $t1, $t1, 2# (coordenate -> address)
lw $t2, screenStart # Start address on the screen
add $t1, $t1, $t2 # Terminate couting address of new head
lw $t7, ($t1)# Takes data stored at new head for comparation
# checking if new head address is valid
bne $t7, 0xFFFF0000, checkBG # if next head add is not apple, check if it is BG
sw $s7, ($t1)# draw head on bitmap display
move $t9, $ra
j scoreUp
drawHead2:
move $ra, $t9
j generateApple# skip tail erasure, and generate apple
jr $ra
checkBG:
bne $t7, 0xBBBBFFFF, quit
sw $s7, ($t1) #draw head on bitmap display
# and proceed to erase tail
#————————————————————————————————————–#
eraseTail: #local reg: $t7, $t6, t3
lw $t6, ($s6)# save previous value of tail
lw $t7, arenaBG# load arenaBG color
sw $t7, ($s6)# Clear the tail on the screen (replace with arena color)
lw $t3, snakeRight
beq $t6, $t3, eraseRight
lw $t3, snakeDown
beq $t6, $t3, eraseDown
lw $t3, snakeLeft
beq $t6, $t3, eraseLeft
lw $t3, snakeUp
beq $t6, $t3, eraseUp
jr $ra
eraseRight:
addi $s6, $s6, 4 # next pixel to become the tail (x )
jr $ra
eraseDown:
addi $s6, $s6, 256 # next pixel to become the tail (y )
jr $ra
eraseLeft:
subi $s6, $s6, 4 # next pixel to become the tail (x–)
jr $ra
eraseUp:
subi $s6, $s6, 256 # next pixel to become the tail (y–)
jr $ra
#————————————————————————————————————–#
generateApple:
# Generate random number ———————————
li $a1, 1112 # Here $a1 configures the max value wich is the number of units on display (0 til 1023).
li $v0, 42 #generates the random number.
syscall
# Verify if it’s inside the playabe area —————–
move $t0, $a0#
sll $t0, $t0, 2# Computing new apple address
lw $t3, screenStart #
add $t3, $t3, $t0 #
lw $t0, ($t3)# get new add content
bne $t0, 0xBBBBFFFF, generateApple # if new apple address content is not arenaBG, try again
# Painting apple pixel ———————————–
lw $t0, appleColor
sw $t0, ($t3)
jr $ra
#———————————————————
################################################################################################################
#Calculate Score Units, Dozens and Hundreds ——————————————————————–
calcScoreDisp: #args: t0.
#results: t4, t5, t6
li $t1, 10
li $t2, 100
# Units
div $t0, $t1 # div score 10
mfhi $t4 # print (score mod 10)
# Dozens:
mflo $t7 # score/10
div $t7, $t1 # div (score/10) 10
mfhi $t5 # print ((score/10) mod 10)
# Hundreds:
div $t6, $t0, $t2 # print (score / 100)
jr $ra
###############################################################################################
scoreUp:
ScorePlusPlus# score
move $t0, $s0# move new score to calc Scores to be displayed
jal calcScoreDisp
beq $s0, 864, quitWin # max score
jal paintDisplay
SaveDispVal# save display numbers on s1 (units) , s2 (dozens) and s3 (hundreds).
j drawHead2
# Paint Switch —————————————————————————————————
paintDisplay:
move $t8, $ra # save link
# prepare Units ————————————————————
li $t7, 1# code 1: painting units
jal paintBlack
move $t2, $t4# pass the number to be painted (t4 have the Units)
lw $t1, scoreColor# Prepare to paint score color (load color)
jal chooseNumber
# prepare Dozens ————————————————————
# bne $t6, $s2, paintDoz
# jr $t8#only units changed, no need to paint anymore
paintDoz:
li $t7, 2# code 2: painting dozens
jal paintBlack
move $t2, $t5# pass the number to be painted (t5 = Dozens)
lw $t1, scoreColor # Prepare to paint score color (load color)
jal chooseNumber
# prepare Hundreds ————————————————————
# bne $t6, $s3, paintHun
# jr $t8# only changed till dozens, no need to paint anymore
paintHun:
li $t7, 3# code 3: painting hundreds
jal paintBlack
move $t2, $t6# pass the number to be painted (t6 = Hundred)
lw $t1, scoreColor # Prepare to paint score color (load color)
jal chooseNumber
jr $t8# finished painting display, go back.
# decide what to paint: ————————————————————
chooseNumber: #arg: t2, number to be painted
beq $t2, 0, paint0
beq $t2, 1, paint1
beq $t2, 2, paint2
beq $t2, 3, paint3
beq $t2, 4, paint4
beq $t2, 5, paint5
beq $t2, 6, paint6
beq $t2, 7, paint7
beq $t2, 8, paint8
j paint9
jr $ra
# Paint Number ——————————————————————————————–
paint0:
la $t0, dozen0_start # load address from score array start
j drawScore_compAdd
jr $ra
paint1:
la $t0, dozen1_start # load address from score array start
j drawScore_compAdd
jr $ra
paint2:
la $t0, dozen2_start # load address from score array start
j drawScore_compAdd
jr $ra
paint3:
la $t0, dozen3_start # load address from score array start
j drawScore_compAdd
jr $ra
paint4:
la $t0, dozen4_start # load address from score array start
j drawScore_compAdd
jr $ra
paint5:
la $t0, dozen5_start # load address from score array start
j drawScore_compAdd
jr $ra
paint6:
la $t0, dozen6_start # load address from score array start
j drawScore_compAdd
jr $ra
paint7:
la $t0, dozen7_start # load address from score array start
j drawScore_compAdd
jr $ra
paint8:
la $t0, dozen8_start # load address from score array start
j drawScore_compAdd
jr $ra
paint9:
la $t0, dozen9_start # load address from score array start
j drawScore_compAdd
jr $ra
# ——————
paintBlack:
la $t0, dozen_start
li $t1, 0
# Display painting ——————————————————————————————–
drawScore_compAdd: # args: (t0, t7, t1) t0 = array_begin_add; t7 = draw_code [1,3]; t1 = color
lw $t3, ($t0)# load *array address on t3
beq $t3, 0x1fffff0f , draw_quit # if t3 is end of array, quit
# now modify adress (t3) if needed:
beq $t7, 1, ds_Unt# it’s Untis. Then it’s 4 pixels ahead ( 16)
beq $t7, 2, drawScore_paint # it’s Dozens. Then maintin original address
subi $t3, $t3, 16# it’s Hundreds. Then it’s 4 pixels behind (-16)
j drawScore_paint
ds_Unt:
addi $t3, $t3, 16
drawScore_paint:
sw $t1, ($t3)# paint pixel *t3
addi $t0, $t0, 4# advance @array
j drawScore_compAdd
draw_quit:
jr $ra
################################################################################################################
quitWin:
# mensagem feliz
quit:
add $a0, $zero, $s0 #
li $v0, 1 # print score
syscall#
li $v0, 10 # safe quit
syscall#

done
Seen
4 mins ago[supanova_question]

complating 2 program design

Programming Assignment Help im gonna attach all 2 programs but because i cantr attach a zipfile now ill put it in word then ill send a zip file with all the c filesfor the book requests project:
in the project there is a add_to function that add the new book to the end of the list, i want you to change that so it is:
A daycare center would like to maintain a list of book requests from the teachers for their classroom libraries. Each book was stored with the title, author’s first name, last name, price, and classroom. Modify add_to_end function in book.c : a. Instead of adding to the end of the linked list, a book is added to an ordered linked list. A book is added to an ordered linked list by author’s last name and then by author’s first name. The list remains ordered after the new request is added. If two books have the same author, the order doesn’t matter. For example, a book by Ashley Spires should be before a book by Whee Winn in the list; a book by Elizabeth Spires should be after a book by Ashely Spires in the list.

For the second project( cars2.c):
Modify it so that it uses quick sort (qsort)to sorts the cars by city mpg. Name your program car2.c. Instead of using the sorting function i wrote in the program, use the quick sort library function and implement the comparison function.

[supanova_question]

assembly language

explain the code in details what does the code do how does it work how does it calculate the points
#################################################################
# Display Configuration#
#—————————————————————#
# Unit Width in pixels: 8#
# Unit Height in Pixels: 8#
# Display Width in Pixels: 512#
# Display Height in Piexels: 256#
#—————————————————————#
# Total units: (512/8) * (256/8) = 64 x 32 = 2048 pixels #
# Arena units: (256/8) * (216/8) = 32 x 27 = 864 pixels#
#################################################################
#########################################################################################
# Here we use the first byte of the color word to store other informations#
# 00 – moving Right | 01 – moving Down | 02 – moving Left | 03 moving Up#
# these flags are useful to erase the tail#
.data#————————
# Colors # FLAG | R | G | B #
scoreColor: .word 0x00FFFF00 # 00 | FF | FF | 00#
arenaBG: .word 0xBBBBFFFF # BB | B2 | 22 | 22 —-BACKGROUND COLOR #
appleColor: .word 0xFFFF0000 # FF (DM) | FF | 00 | 00#
snakeRight: .word 0x0000FF00 # 00 | 00 | FF | 00 –|#
snakeDown: .word 0x0100FF00 # 01 | 00 | FF | 00 |- MOVEMENT#
snakeLeft: .word 0x0200FF00 # 02 | 00 | FF | 00 |#
snakeUp: .word 0x0300FF00 # 03 | 00 | FF | 00 –|#
#————————##
#* DM = Dont matter#
# Addresses ————————————————————————
screenStart: .word 0x10010500
add_end_flag: .word 0x1fffff0f
# # # Numbers
dozen_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x10011394, 0x10011398, 0x1001139C,
0x10011494, 0x10011498, 0x1001149C,
0x10011594, 0x10011598, 0x1001159C,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen0_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x10011394, 0x1001139C,
0x10011494, 0x1001149C,
0x10011594, 0x1001159C,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen1_start: .word 0x1001129C,
0x1001139C,
0x1001149C,
0x1001159C,
0x1001169C, 0x1fffff0f
dozen2_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x1001139C,
0x10011494, 0x10011498, 0x1001149C,
0x10011594,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen3_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x1001139C,
0x10011494, 0x10011498, 0x1001149C,
0x1001159C,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen4_start: .word 0x10011294, 0x1001129C,
0x10011394, 0x1001139C,
0x10011494, 0x10011498, 0x1001149C,
0x1001159C,
0x1001169C, 0x1fffff0f
dozen5_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x10011394,
0x10011494, 0x10011498, 0x1001149C,
0x1001159C,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen6_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x10011394,
0x10011494, 0x10011498, 0x1001149C,
0x10011594, 0x1001159C,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen7_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x1001139C,
0x1001149C,
0x1001159C,
0x1001169C, 0x1fffff0f
dozen8_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x10011394, 0x1001139C,
0x10011494, 0x10011498, 0x1001149C,
0x10011594, 0x1001159C,
0x10011694, 0x10011698, 0x1001169C, 0x1fffff0f
dozen9_start: .word 0x10011294, 0x10011298, 0x1001129C,
0x10011394, 0x1001139C,
0x10011494, 0x10011498, 0x1001149C,
0x1001159C,
0x1001169C, 0x1fffff0f
#################################################################################################
#################################################################################################
# Macros:
# _____
.macro Pause
li $a0, 100 #
li $v0, 32 # Pause for 80 milisec
syscall#
.end_macro
.macro MegaPause
li $a0, 500 #
li $v0, 32 # Pause for 500 milisec
syscall#
.end_macro
#———————————————————————————————–#
# __________
.macro PaintArena
li $t0, 128 #starting line index [halved line size]
li $t1, 0 #starting pixel index
lw $t3, screenStart # load starting address on t3
lw $t2, arenaBG #load bg color on t2
drawline:
sw $t2, ($t3)# paint pixel_address
addi $t3, $t3, 4 # pixel_adress
addi $t1, $t1, 4 # pixel_i
blt $t1, $t0, drawline # if pixel_index < (line_size/2), keep painting line
addi $t3, $t3, 128 # else, jump pixel_adress to next beginning line.
addi $t1, $t1, 128 # jump pixel_i to next beginning line.
addi $t0, $t0, 256 # line_i .
ble $t0, 6784, drawline# if not finished painting line, do it again
# (27*line_size) (line_size/2)=6784
.end_macro
#———————————————————————————————–#
# _________
.macro ScorePlusPlus
addi $s0, $s0, 1
.end_macro
# _________
.macro SaveDispVal
move $s1, $t4 # save current unit value
move $s2, $t5 # save current dozen value
move $s3, $t6 # save current unit value
.end_macro
#################################################################################################
#################################################################################################
.text
PaintArena#Paint the arena
# Loading starting values…
li $s0, 3# load initial score (size of the initial snake)
li $s4, 3# Head x_pos
li $s5, 2# Head y_pos
li $s6, 0x10010704 # Tracking the tail to erase
lw $s7, snakeRight # Current movement
# for init
li $t0, 0x10010704 # Snake begin
li $t1, 0x10010710 # Snake end — total size: (end – begin)/4
li $t4, 0xFFFF0000 # Apple color
initialSnake:
sw $s7, ($t0) #
addi $t0, $t0, 4 # while SB < SE, fill the display with the snake body (size: 6/4??)
blt $t0, $t1, initialSnake # initial size will be 2.
jal generateApple
addi $ra, $ra, 20 # jumps to the line after addi to avoid verification
# of self collision (the instruction: beq $t0, 0x0000FF00, quit)
jr $ra
moveRight:
lw $s7, snakeRight
jal drawHead
addi $s4, $s4, 1
#init line 89 will jump here
Pause
lw $t7, 0xFFFF0004# Verifying which key is pressed
# OBS: This value stays on the register until another key is pressed
beq $t7, 0x00000077, moveUp # w key is pressed
beq $t7, 0x00000073, moveDown # s key is pressed
beq $t7, 0x00000071, quit # q key is pressed
j moveRight
moveDown:
lw $s7, snakeDown
jal drawHead
addi $s5, $s5, 1
Pause
lw $t7, 0xFFFF0004# Verifying which key is pressed
# OBS: This value stays on the register until another key is pressed
beq $t7, 0x00000061, moveLeft # a key is pressed
beq $t7, 0x00000064, moveRight # d key is pressed
beq $t7, 0x00000071, quit # q key is pressed
j moveDown
moveLeft:
lw $s7, snakeLeft
jal drawHead
subi $s4, $s4, 1
Pause
lw $t7, 0xFFFF0004# Verifying which key is pressed
# OBS: This value stays on the register until another key is pressed
beq $t7, 0x00000077, moveUp # w key is pressed
beq $t7, 0x00000073, moveDown # s key is pressed
beq $t7, 0x00000071, quit # q key is pressed
j moveLeft
moveUp:
lw $s7, snakeUp
jal drawHead
subi $s5, $s5, 1
Pause
lw $t7, 0xFFFF0004# Verifying which key is pressed
# OBS: This value stays on the register until another key is pressed
beq $t7, 0x00000061, moveLeft # a key is pressed
beq $t7, 0x00000064, moveRight # d key is pressed
beq $t7, 0x00000071, quit # q key is pressed
j moveUp
#————————————————————————————————————-#
drawHead: #local reg: t0, t1, t7
# Computing Address of (x, y) on the screen
sll $t1, $s5, 6 # t1 = s5 * (2^7) = s5 * 128(computing y)
add $t1, $t1, $s4 # t1 = s4(computing x)
sll $t1, $t1, 2# (coordenate -> address)
lw $t2, screenStart # Start address on the screen
add $t1, $t1, $t2 # Terminate couting address of new head
lw $t7, ($t1)# Takes data stored at new head for comparation
# checking if new head address is valid
bne $t7, 0xFFFF0000, checkBG # if next head add is not apple, check if it is BG
sw $s7, ($t1)# draw head on bitmap display
move $t9, $ra
j scoreUp
drawHead2:
move $ra, $t9
j generateApple# skip tail erasure, and generate apple
jr $ra
checkBG:
bne $t7, 0xBBBBFFFF, quit
sw $s7, ($t1) #draw head on bitmap display
# and proceed to erase tail
#————————————————————————————————————–#
eraseTail: #local reg: $t7, $t6, t3
lw $t6, ($s6)# save previous value of tail
lw $t7, arenaBG# load arenaBG color
sw $t7, ($s6)# Clear the tail on the screen (replace with arena color)
lw $t3, snakeRight
beq $t6, $t3, eraseRight
lw $t3, snakeDown
beq $t6, $t3, eraseDown
lw $t3, snakeLeft
beq $t6, $t3, eraseLeft
lw $t3, snakeUp
beq $t6, $t3, eraseUp
jr $ra
eraseRight:
addi $s6, $s6, 4 # next pixel to become the tail (x )
jr $ra
eraseDown:
addi $s6, $s6, 256 # next pixel to become the tail (y )
jr $ra
eraseLeft:
subi $s6, $s6, 4 # next pixel to become the tail (x–)
jr $ra
eraseUp:
subi $s6, $s6, 256 # next pixel to become the tail (y–)
jr $ra
#————————————————————————————————————–#
generateApple:
# Generate random number ———————————
li $a1, 1112 # Here $a1 configures the max value wich is the number of units on display (0 til 1023).
li $v0, 42 #generates the random number.
syscall
# Verify if it’s inside the playabe area —————–
move $t0, $a0#
sll $t0, $t0, 2# Computing new apple address
lw $t3, screenStart #
add $t3, $t3, $t0 #
lw $t0, ($t3)# get new add content
bne $t0, 0xBBBBFFFF, generateApple # if new apple address content is not arenaBG, try again
# Painting apple pixel ———————————–
lw $t0, appleColor
sw $t0, ($t3)
jr $ra
#———————————————————
################################################################################################################
#Calculate Score Units, Dozens and Hundreds ——————————————————————–
calcScoreDisp: #args: t0.
#results: t4, t5, t6
li $t1, 10
li $t2, 100
# Units
div $t0, $t1 # div score 10
mfhi $t4 # print (score mod 10)
# Dozens:
mflo $t7 # score/10
div $t7, $t1 # div (score/10) 10
mfhi $t5 # print ((score/10) mod 10)
# Hundreds:
div $t6, $t0, $t2 # print (score / 100)
jr $ra
###############################################################################################
scoreUp:
ScorePlusPlus# score
move $t0, $s0# move new score to calc Scores to be displayed
jal calcScoreDisp
beq $s0, 864, quitWin # max score
jal paintDisplay
SaveDispVal# save display numbers on s1 (units) , s2 (dozens) and s3 (hundreds).
j drawHead2
# Paint Switch —————————————————————————————————
paintDisplay:
move $t8, $ra # save link
# prepare Units ————————————————————
li $t7, 1# code 1: painting units
jal paintBlack
move $t2, $t4# pass the number to be painted (t4 have the Units)
lw $t1, scoreColor# Prepare to paint score color (load color)
jal chooseNumber
# prepare Dozens ————————————————————
# bne $t6, $s2, paintDoz
# jr $t8#only units changed, no need to paint anymore
paintDoz:
li $t7, 2# code 2: painting dozens
jal paintBlack
move $t2, $t5# pass the number to be painted (t5 = Dozens)
lw $t1, scoreColor # Prepare to paint score color (load color)
jal chooseNumber
# prepare Hundreds ————————————————————
# bne $t6, $s3, paintHun
# jr $t8# only changed till dozens, no need to paint anymore
paintHun:
li $t7, 3# code 3: painting hundreds
jal paintBlack
move $t2, $t6# pass the number to be painted (t6 = Hundred)
lw $t1, scoreColor # Prepare to paint score color (load color)
jal chooseNumber
jr $t8# finished painting display, go back.
# decide what to paint: ————————————————————
chooseNumber: #arg: t2, number to be painted
beq $t2, 0, paint0
beq $t2, 1, paint1
beq $t2, 2, paint2
beq $t2, 3, paint3
beq $t2, 4, paint4
beq $t2, 5, paint5
beq $t2, 6, paint6
beq $t2, 7, paint7
beq $t2, 8, paint8
j paint9
jr $ra
# Paint Number ——————————————————————————————–
paint0:
la $t0, dozen0_start # load address from score array start
j drawScore_compAdd
jr $ra
paint1:
la $t0, dozen1_start # load address from score array start
j drawScore_compAdd
jr $ra
paint2:
la $t0, dozen2_start # load address from score array start
j drawScore_compAdd
jr $ra
paint3:
la $t0, dozen3_start # load address from score array start
j drawScore_compAdd
jr $ra
paint4:
la $t0, dozen4_start # load address from score array start
j drawScore_compAdd
jr $ra
paint5:
la $t0, dozen5_start # load address from score array start
j drawScore_compAdd
jr $ra
paint6:
la $t0, dozen6_start # load address from score array start
j drawScore_compAdd
jr $ra
paint7:
la $t0, dozen7_start # load address from score array start
j drawScore_compAdd
jr $ra
paint8:
la $t0, dozen8_start # load address from score array start
j drawScore_compAdd
jr $ra
paint9:
la $t0, dozen9_start # load address from score array start
j drawScore_compAdd
jr $ra
# ——————
paintBlack:
la $t0, dozen_start
li $t1, 0
# Display painting ——————————————————————————————–
drawScore_compAdd: # args: (t0, t7, t1) t0 = array_begin_add; t7 = draw_code [1,3]; t1 = color
lw $t3, ($t0)# load *array address on t3
beq $t3, 0x1fffff0f , draw_quit # if t3 is end of array, quit
# now modify adress (t3) if needed:
beq $t7, 1, ds_Unt# it’s Untis. Then it’s 4 pixels ahead ( 16)
beq $t7, 2, drawScore_paint # it’s Dozens. Then maintin original address
subi $t3, $t3, 16# it’s Hundreds. Then it’s 4 pixels behind (-16)
j drawScore_paint
ds_Unt:
addi $t3, $t3, 16
drawScore_paint:
sw $t1, ($t3)# paint pixel *t3
addi $t0, $t0, 4# advance @array
j drawScore_compAdd
draw_quit:
jr $ra
################################################################################################################
quitWin:
# mensagem feliz
quit:
add $a0, $zero, $s0 #
li $v0, 1 # print score
syscall#
li $v0, 10 # safe quit
syscall#

done
Seen
8 mins ago[supanova_question]

IT401- Business Computer Languages – Maha

You must submit two separate copies (one Word file and one PDF file) using the Assignment Template on Blackboard via the allocated folder. These files must not be in compressed format.
Zero mark will be given if you try to bypass the SafeAssign (e.g. misspell words, remove spaces between words, hide characters, use different character sets, convert text into image or languages other than English or any kind of manipulation).
You are advised to make your work clear and well-presented. This includes filling your information on the cover page.
You must use this template, failing which will result in zero mark.
You MUST show all your work, and text must not be converted into an image, unless specified otherwise by the question.
The work should be your own, copying from students or other resources will result in ZERO mark.
Use Times New Roman font for all your answers[supanova_question]

Lab 4 in C programming

Lab 4 DirectionsWrite a C program called threadcircuit to run on ocelot which will provide a multithreaded solution to the circuit-satisfiability problem which will compute for what combinations of input values will the circuit output the value 1. This is the sequential solution, which is also attached. You should create 4 threads and divide the 65,536 test cases among them. For example, if p=4, each thread would be responsible for roughly 65,536/8 number of iterations (if it’s not divisible, some threads can end up with one more iteration than the others).
#include #include /* Return 1 if ‘i’th bit of ‘n’ is 1; 0 otherwise */#define EXTRACT_BIT(n,i) ((n[supanova_question]

C Programming

Programming Assignment Help the code just needs few changes in the code that i already have, i will send all the files once the request is accepted and will send hw09 as well
In HW09 you built a solver for mazes that returned the first solution to the maze. In this assignment, you will instead return all valid solutions to the maze. Because we don’t know how many solutions there are for the maze, we will use a linked list structure to store all of the solutions.
We don’t want to just store all of the paths, though. We want to order them so that the “best” path is first. We want to keep the paths in a sorted list. Paths should be sorted in ascending order, according to the following rules:
Shorter paths come before longer paths
If two paths are the same length, the path with fewer “turns” should be before the path with more turns (a turn is when a path changes direction: eenn has one turn, eene has two turns)
If two paths are the same length and have the same number of turns, sort in alphabetical order.
Learning GoalsYou will learn
Building a sorted linked list
Incremental development
BackgroundSORTED LINKED LISTS
In this homework, you want to write a linked list that will maintain all of its nodes in sorted order. The key to writing a sorted linked list is to maintain the invariant that the list is always sorted after you perform any operation (e.g., insert, remove) on it. We can think about this inductively:
An empty list is, by definition, sorted.
If you have a sorted list, and you insert a new node into the correct location (i.e., between the largest node that is smaller and the smallest node that is larger), the list will still be sorted.
If you have a sorted list and you remove a node, the list will remain sorted.
(We gave you the rules for ordering a linked list of paths above)
You might find the various linked list source code posted to Brightspace helpful for this assignment.
list.h defines a linked list class that works as follows: The head pointer is contained as a field of a structure that represents the linked list. It provides several helper methods to allocate/initialize and deallocate individual linked list nodes (PathNodes) or the linked list as a whole (PathLL). It also provides 3 key methods:
addNode, which inserts a new path into the linked list. Make sure this keeps the list sorted! addNode returns true if the addition succeeds, and false if it fails (which can happen if the path you are trying to add is already in the linked list — this is a good way to tell if you’re accidentally finding the same path twice).
removeNode, which removes a particular path from the linked list. It returns true if the remove succeeds, and false if it fails (which can happen if the path you are trying to remove isn’t in the linked list).
containsNode, which checks if a path is in the linked list.
INCREMENTAL DEVELOPMENT
When presented with a big development challenge, it is tempting to try to write all of your code and then see if it works. This is a path to frustrating bugs and possible failure. What you should do instead is:
Break the problem down into manageable chunks
Write code to solve each chunk
Test each chunk to make sure it works correctly before moving on to the next chunk.
This has several benefits: (i) it is a lot more manageable to think of a big project in terms of a lot of smaller steps you have to get done; (ii) because you test each step before moving on to the next one, you know that if something breaks, it must be either part of the last step, or because of some interaction between your chunks — you don’t have to search through all of your code.
For example, here is a proposed development plan for this programming assignment:
Implement a small function that compares two paths according to the criteria above, to make sure that you can sort paths correctly.
Implement your linked list, and test adding, removing, and finding paths in the linked list.
Use your now working linked list to implement the new solver.
Note that the key here is to test every piece of your code. When you implement a chunk of code, you should write a test file — another .c file that has its own main function. You can compile your new code with this test file to test the functionality of your chunk.
Another aspect of incremental development is to make sure that your program passes simple test cases first, before moving on to complex test cases. If your solver fails on a 10×10 maze, it may be hard to tell what’s going on. If your solver fails on a 2×2 maze, it’s often much easier to debug.
What you need to doThere are two things you need to do.
BUILD AND TEST YOUR LINKED LIST
Fill in and test the linked list methods, including making sure that you can insert, remove, and find paths in your linked list. We will test your linked list implementation separately from the maze solver.
Even if you do not use a particular linked list method in depthFirstSolve, make sure you implement it.
BUILD AND TEST YOUR UPDATED MAZE SOLVER
We have provided almost all of the code you need, other than the linked list methods themselves. The one missing piece is depthFirstSolve in solver.c. This needs to be modified so that when you find a solution to the maze, rather than returning that solution you just add the solution to the maze and keep going. (Make sure you keep track of visited correctly: a MazeSquare should count as visited if the current path you are exploring has visited that square, not if any path has visited that square in the past.)
Once the late submission deadline for HW9 has passed (11/10), we will post a version of solver.c that solves HW9.
We have provided you with a few test mazes, in the inputs directory. You should also write more of your own.
What you need to submitSubmit your version of list.c that contains working implementations of all the functions.
Submit your version of solver.c that generates all the solutions to a

done
Seen
2 mins ago[supanova_question]

Inspect a trace to answer the follow questions

Download the provided Trace, https://cdn.inst-fs-pdx-prod.inscloudgate.net/7fca…
Windows lacks driver support to gather 802.11 frames for most wireless NICs
Unlike promiscuous mode, which is also used for packet sniffing, monitor mode allows packets to be captured without having to associate with an AP.

Inspect the 802.11 Trace:Beacon, Data and Acknowledgement framesRadiotap record – displays physical layer parametersData rate
Frequencies
SSI Noise: The strength of the signal at the time that the packet was received. (Attenuation affects the propagation of waves and signals in circuits).

IEEE 802.11 record of the data frameFrame Control
BSS identifier (address of the wireless AP)

802.11 Physical LayerObserve data rates

802.11 Data Link LayerUse the Conversations tool to identify most active APs with the highest traffic

802.11 Management

Management frames – used to connect a computer to an AP so that it may send and receive messages

[supanova_question]

C programming

,the code just needs few changes in the code that i already have, i will send all the files once the request is accepted and will send hw09 as well
In HW09 you built a solver for mazes that returned the first solution to the maze. In this assignment, you will instead return all valid solutions to the maze. Because we don’t know how many solutions there are for the maze, we will use a linked list structure to store all of the solutions.
We don’t want to just store all of the paths, though. We want to order them so that the “best” path is first. We want to keep the paths in a sorted list. Paths should be sorted in ascending order, according to the following rules:
Shorter paths come before longer paths
If two paths are the same length, the path with fewer “turns” should be before the path with more turns (a turn is when a path changes direction: eenn has one turn, eene has two turns)
If two paths are the same length and have the same number of turns, sort in alphabetical order.
Learning GoalsYou will learn
Building a sorted linked list
Incremental development
BackgroundSORTED LINKED LISTS
In this homework, you want to write a linked list that will maintain all of its nodes in sorted order. The key to writing a sorted linked list is to maintain the invariant that the list is always sorted after you perform any operation (e.g., insert, remove) on it. We can think about this inductively:
An empty list is, by definition, sorted.
If you have a sorted list, and you insert a new node into the correct location (i.e., between the largest node that is smaller and the smallest node that is larger), the list will still be sorted.
If you have a sorted list and you remove a node, the list will remain sorted.
(We gave you the rules for ordering a linked list of paths above)
You might find the various linked list source code posted to Brightspace helpful for this assignment.
list.h defines a linked list class that works as follows: The head pointer is contained as a field of a structure that represents the linked list. It provides several helper methods to allocate/initialize and deallocate individual linked list nodes (PathNodes) or the linked list as a whole (PathLL). It also provides 3 key methods:
addNode, which inserts a new path into the linked list. Make sure this keeps the list sorted! addNode returns true if the addition succeeds, and false if it fails (which can happen if the path you are trying to add is already in the linked list — this is a good way to tell if you’re accidentally finding the same path twice).
removeNode, which removes a particular path from the linked list. It returns true if the remove succeeds, and false if it fails (which can happen if the path you are trying to remove isn’t in the linked list).
containsNode, which checks if a path is in the linked list.
INCREMENTAL DEVELOPMENT
When presented with a big development challenge, it is tempting to try to write all of your code and then see if it works. This is a path to frustrating bugs and possible failure. What you should do instead is:
Break the problem down into manageable chunks
Write code to solve each chunk
Test each chunk to make sure it works correctly before moving on to the next chunk.
This has several benefits: (i) it is a lot more manageable to think of a big project in terms of a lot of smaller steps you have to get done; (ii) because you test each step before moving on to the next one, you know that if something breaks, it must be either part of the last step, or because of some interaction between your chunks — you don’t have to search through all of your code.
For example, here is a proposed development plan for this programming assignment:
Implement a small function that compares two paths according to the criteria above, to make sure that you can sort paths correctly.
Implement your linked list, and test adding, removing, and finding paths in the linked list.
Use your now working linked list to implement the new solver.
Note that the key here is to test every piece of your code. When you implement a chunk of code, you should write a test file — another .c file that has its own main function. You can compile your new code with this test file to test the functionality of your chunk.
Another aspect of incremental development is to make sure that your program passes simple test cases first, before moving on to complex test cases. If your solver fails on a 10×10 maze, it may be hard to tell what’s going on. If your solver fails on a 2×2 maze, it’s often much easier to debug.
What you need to doThere are two things you need to do.
BUILD AND TEST YOUR LINKED LIST
Fill in and test the linked list methods, including making sure that you can insert, remove, and find paths in your linked list. We will test your linked list implementation separately from the maze solver.
Even if you do not use a particular linked list method in depthFirstSolve, make sure you implement it.
BUILD AND TEST YOUR UPDATED MAZE SOLVER
We have provided almost all of the code you need, other than the linked list methods themselves. The one missing piece is depthFirstSolve in solver.c. This needs to be modified so that when you find a solution to the maze, rather than returning that solution you just add the solution to the maze and keep going. (Make sure you keep track of visited correctly: a MazeSquare should count as visited if the current path you are exploring has visited that square, not if any path has visited that square in the past.)
Once the late submission deadline for HW9 has passed (11/10), we will post a version of solver.c that solves HW9.
We have provided you with a few test mazes, in the inputs directory. You should also write more of your own.
What you need to submitSubmit your version of list.c that contains working implementations of all the functions.
Submit your version of solver.c that generates all the solutions to a

done
Seen
4 mins ago[supanova_question]

Write an echo server using the Winsock code provided

On the client side, the program should accept text input
from the user and transmit that to the server. The server should then display
the text received and echo the message back to the client. The client should
display the received message and indicate that it is the received message.
attached requirement and code
[supanova_question]

1 Simple programming question

Programming Assignment Help You will write a simple program to simulate the routing decision taken at a router that we discussed in the lectures. You are given a text file (RoutingTable.txt) containing a routing table for a router (the five column generic routing table with mask, destination address, next hop, flag and interface). You will notice that this is almost the same routing table as the one that we discussed in the lectures. The first few lines of the text file are shown below:
192.168.1.0/24 ? Destination address/Number of ones in the mask – ? – means no next hop E0 ? Outgoing interface 192.168.2.0/24 ? Destination address/Number of ones in the mask 192.168.4.2 ? Next hop S0 ? Outgoing interface Etc.

done
Seen
1 min ago[supanova_question]

Use the link below to test out a number of parameters for a neural networks model and see what

Use the link below to test out a number of parameters for a neural networks model and see what happens. You can do two options:

1) Build a smart accurate model.

2) Go for weird and build a non-sensical model.

https://playground.tensorflow.org/

Take a screenshot of a model you created and write a summary of what is happening and why it may be working well or not.

Helpful resources:

https://ujjwalkarn.me/2016/08/09/quick-intro-neural-networks/

Chapter 10: https://web.stanford.edu/~hastie/ISLR2/ISLRv2_website.pdf
[supanova_question]