Write a command-line app, ability_list.py, that takes a single argument that is the name of a pokemon.  It then uses the request library and pokeapi.co to query the pokemon and ability functions.  It will print out each ability of the supplied pokemon, and then the name of that ability in as many other languages as provided by the API. 

Part of the assignment will be digging around the API documentation to find the data you need.  Your program should work on ANY legal Pokemon name.

I’m Brazilian, so I’ve translated myself the assignment file, so if there’s any mistake or anything that’s confusing please let me know. The code should be written in C. The function names should be kept  in Portuguese.n Also, it would be better if the code came with a commented explanation of how it works.

Demonstrate the understanding of structures and arrays of structures, and  extensive use of functions; (C-Language)
Demonstrate clear and elegant programming style.
Get rid of all error messages.
The output produced must be EXACTLY the same for every spaces and words.
The solution should be saved as myass2.c
I have attached a copy of the assignment handbook and txt files for the assignment, and also a sample solution of how the solution should be roughly outlined (the example answer to the previous assignment).
the files that should be loaded and run is the lights0.tsv, lights1.tsv and lights2.tsv, the output produced of those 3 files are lights0-out.txt, lights1-out.txt and lights2-out.txt respectively. This will be provided in the attachments.

MARKING RUBRIC

Some subset of the following lines will be retained by the marker.
Stages 1 to 4 initial allocation, +5;

Deductions
Some subset of the following lines will be retained by the marker. Marks in each section won’t go below zero.
#defines not in upper case, -0.5;
multi-letter variables in upper case, -0.5;
absence of function prototypes, -0.5;
bad choice for function names, -0.5;
bad choices for variable names, -0.5;
excessive commenting, -0.5;
insufficient commenting, -0.5;
inconsistent bracket placement, -0.5;
inconsistent indentation, -0.5;
lack of whitespace (visual appeal), -0.5;
lines >80 chars, -0.5;
use of magic numbers, -0.5;
unhelpful #defines, -0.5;
use of constant subscripts in 2d arrays (not #define’d), -1.0;
other stylistic issue (minor), -0.5;
other stylistic issue (major), -1.0;
Additions (included in total mark *only* if marks lost within this first section)
comment at end of source code that says “programming is fun”, +0.5;
overall care and presentation, +0.5;
Other comments from marker:

Structure and Approach

Including: decomposition in to functions, development of data structures and declaration of them at the appropriate locations, choice of parameters to functions, use of appropriate struct and typedef declarations, choice of algorithms or methods, overall flow and high-level readability.

Some subset of the following lines will be retained by the marker.
Stage 1 initial allocation, +3;
Stage 2 initial allocation, +3;
Stage 3 initial allocation, +1;
Stage 4 initial allocation, +1;

Deductions
Some subset of the following lines will be retained by the marker. Marks in each section won’t go below zero.
duplicate code segments, -0.5;
main program too long or too complex, -0.5;
other functions too long or too complex, -0.5;
global variables, -0.5;
insufficient use of functions, -0.5;
overly complex algorithmic approach, -0.5;
unnecessary duplication/copying of data, -0.5;
overly complex function argument lists, -0.5;
avoidance of structs (eg, using skinny 2d arrays), -1.0;
avoidance of struct pointers (eg, using whole-struct arguments), -0.5;
inappropriate or over-complex structs, -0.5;
other abuses of structs, -0.5;
other structural issue (minor), -0.5;
other structural issue (major), -1.0;
Other comments from marker:

Program execution

Including: compilation, execution on test data, output presentation and readability.
Programs that do not compile in the test environment will lose all marks in this section. So be sure to verify your submission and check the output before you say “finished” to yourself.

Some subset of the following lines will be retained by the marker.
Stage 1 initial allocation, +2;
Stage 2 initial allocation, +2;
Stage 3 initial allocation, +2;
Stage 4 initial allocation, +1;

Deductions
Some subset of the following lines will be retained by the marker. Marks in each section won’t go below zero.
errors in compilation that prevent testing, -4.0;
runtime segmentation fault on any test with no output generated, -2.0;
runtime segmentation fault on any other test with no output generated, -2.0;
unnecessary warning messages in compilation, -1.0;
incorrect Stage 1 output on any test, -1.0;
differently incorrect Stage 1 output on any test, -1.0;
numerically incorrect Stage 2 output on any test, -1.0;
different numerically incorrect Stage 2 output on any test, -1.0;
visually incorrect Stage 3 output on any test, -1.0;
different visually incorrect Stage 3 output on any test, -1.0;
incorrect Stage 4 output on any test, -1.0;
other execution-time issue not already captured, -1.0;

Write in Java

Part A: Update the java file names to include your initials at the end, send .java file only.
1. Write in-place heapSort, which takes an array of data, convert it to max heap using bottom-up
algorithm. The expected run time should be O(n), where n is the total number of data.
BubbleDown method is provided. You may test it in this Sort.
2. Write complete code for a MinHeapPriorityQueue method removeThirdMin that efficiently
removes and returns the third minimum element from the data structure. It shouldnt have
more than 3 comparisons to find the third minimum element. Your solution can make use of
the methods bubbleUp, bubbleDown and swapData but must not apply the constructor or
either of the methods add/enqueue and removeMin/dequeue.
For example, if the array contains the following elements:
1, 2, 3, 4, 5, 6, 7
It should be changed by removeThirdMin to
1, 2, 6, 4, 5, 7
Extra Credit: Modify quickSort method, to use insertionSort if sub-problem is small. Check with size
4, 8, 16, which give the best runtime?
Part B
1. Show how an initially empty min heap looks like after inserting following elements in the given
order. Draw the min heap and the array.
5, 2, 7, 8, 6, 1, 7
2. Show how a bottom-up min heap construction looks like from the above given values. Draw the
min heap and the array.
3. What is the best-case and worst-case of insertionSort?
4. What is the best-case and worst-case of mergeSort?
5. What is the best-case and worst-case of quickSort?
6. What can we do to lower, if not eliminate completely, the chances of worst-case of quickSort?
Extra Credit:
If we can access the data of a min-heap, how do we find the k-th minimum value efficiently? That
means instead of O(log n), can we speed up to O(log k)?

– Create a unique physical solution for a multi-building campus
– You should use Microsoft Visio to draw the physical network design

You should use Microsoft Word to provide an, explanation
1. One-page explanation of the physical layout
2. One page discussing switching
3. One page discussing a topic that you would like to include to highlight some aspect of the design.

More instructions are on the Attached File

– Create a unique physical solution for a multi-building campus
– You should use Microsoft Visio to draw the physical network design

You should use Microsoft Word to provide an, explanation
1. One-page explanation of the physical layout
2. One page discussing switching
3. One page discussing a topic that you would like to include to highlight some aspect of the design.

More instructions are on the Attached File

– Create a unique physical solution for a multi-building campus
– You should use Microsoft Visio to draw the physical network design

You should use Microsoft Word to provide an, explanation
1. One-page explanation of the physical layout
2. One page discussing switching
3. One page discussing a topic that you would like to include to highlight some aspect of the design.

More instructions are on the Attached File

– Create a unique physical solution for a multi-building campus
– You should use Microsoft Visio to draw the physical network design

You should use Microsoft Word to provide an, explanation
1. One-page explanation of the physical layout
2. One page discussing switching
3. One page discussing a topic that you would like to include to highlight some aspect of the design.

More instructions are on the Attached File

It is an online test. I will give u account and password. Test will be taken from 1:45 to 3:15 pm on May 18. It is all about memory management of operating system. The attachment includes some examples of the test. Don’t use any resource from internet such as chegg.

Im copying the description,

Introduction
The game of Yacht (also known as Yot, and commercially marketed as
Yahtzee) is a game played with 5 dice. It is quite similar to the poker dice
program that is presented in the textbook, but with a more sophisticated
scoring system that makes it much more interesting to play. You can read
about the game in excruciating detail in this wikipedia entry: Yahtzee.
Our game will implement the “classic rules” that ignore things like yacht
bonuses and jokers. In my opinion, this actually makes it a more strategic,
skill-oriented game that is quite fun to play.

Rules
The game is played with 5 dice and proceeds in a series of 13 rounds. In
each round, the player starts by rolling all 5 dice. The player can then
choose some dice to re-roll up to a total of 3 rolls. In this respect, it is
exactly like the dice poker in Chapter 12.
After any roll (1, 2 or 3) the player can choose to score the dice, which
ends the round. Scoring is done by selecting which category on the
scorecard to fill in. The key is to make good choices. The player must
choose a category for the round, even if the score for that category ends
up being 0. One category is filled in each of the 13 rounds.
The scoring categories and the points scored are as follows:
Category Description / Points Scored
ones 1 point for each 1 thrown
twos 2 points for each 2 thrown
threes 3 points for each 3 thrown
fours 4 points for each 4 thrown
fives 5 points for each 5 thrown
sixes 6 points for each 6 thrown
3 of a Kind 3 of the same number. Scores the sum of the dice.
4 of a Kind 4 of the same number. Scores the sum of the dice.
Full House A 3-of-a-kind and 2-of-a-kind. Scores 25 points
Category Description / Points Scored
Small Straight 4 numbers in a row (any order). Scores 30 points
Big Straight 5 numbers in a row (any order). Scores 40 points
Yacht 5 of a kind. Scores 50 points
Chance No pattern needed. Scores the sum of the dice.
Bonus: If the “upper total” (the sum of the first six categories) is 63 or
above, then an additional 35 points is awarded.
The goal is to maximize the total points.

Program Modules
Starter code for the project can by found on our class web page under
handouts/yacht. There are 5 files:
dice.py: This file is a complete implementation of a Dice class. It is
just like the one in Chapter 12, but with the scoring method
removed, since scoring in Yacht is quite different.
yachtscore.py: This file contains class outlines for the objects that
will be responsible for handling scoring. The main class is the
ScoreCard that keeps track of the scoring as the game progresses.
yachtapp.py: This is a minimal outline for the top-level class that
will actually “play” the game. This corresponds to the PokerApp in the
dice poker example. Note, as in the PokerApp, the actual user
interface is separated from the application logic. This file can be
used with either a text-based or a graphics-based interface.
yachttext.py: This is a complete implementation of a very primitive
text-based interface for the game. This is analogous to the
textpoker.py file in the Poker example.
yachgui.py: This is the bare outline of the graphical interface for
the final game. This, combined with yachtapp.py, produces a fullfledged
graphical Yacht game.
In addition to these files, you will undoubtedly also want to make use of
the button.py and cdieview.py files from the Poker app when you get around
to completing the GUI portion of the project.

Project Phases
The work of the project will be completed and delivered in 4 phases.
These phases represent the C, B, A, and A+ levels of the project. Your
work is due on the last day of the term (at noon), but you must do the
phases in order. For example, I won’t grade a phase 2 project if you
haven’t turned in a sucessful phase 1 project. That means you should get
started right away and turn in each phase as soon as possible.

Phase 1 (C level): Scorers
In this phase you are to write and test 5 scorer classes.
In the yachtscore.py file you will find a class for a ScoreCard as well as 5
classes that perform the different kinds of scoring that are needed. These
5 helper classes are the “scorers.” Each scorer has a constructor and a
single score(dice) method. The score method returns the number of points
that the dice would be awarded by this particular scorer.
Let’s take a concrete example. The top 6 categories in the score card (the
ones, twos, threes, etc.) are handled with the ValueScorer class. For the
ones catagory, we would create a ValueScorer for ones like this:
ones = ValueScorer(1)
Then, when we want to see how much some dice would score in that
category, we call the score method:
ones.score([1, 3, 4, 5, 1])
That should return 2 (the sum of the 1’s in the list).
Each of the scorer classes has a detailed docstring that explains the
scorer and also shows some interactive examples. You have completed
phase 1 when you have manually tested each of your scorer classes and
they work as indicated in the docstrings.

Phase 2 (B level): ScoreCard
In this phase you will write and test the ScoreCard class. Consult the
documentation in the yachtscore.py file to learn exactly what the various
methods of the class do.
It is important that you test the scorcard to make sure that it works
properly. The testing function at the bottom of the file should be filled in
to do this. The completee program for this phase should read dice rolls
from a file and fill the resulting scores into the scorecard. Each line of the
file consists of 5 dice values separated by spaces. The first set should be
scored into catagory 0, the next into category 1, etc. The program should
print out the updated scorecard each time a line of the file is read. You
can use the printScorecard function from the yachttext.py file to print the
scorecard.
In the starter code directory you can find a file called maxrolls.txt that
contains the roles that should give you the highest possible score for you
test. Try your test program using this file for the input.

Phase 3 (A level): YachtApp
In this phase you should complete the yachtapp.py file. Start by looking at
the interface methods that have been implemented in the yachtext.py file.
All of your user interaction must be handled by calling on these methods.
The YachtApp class will take care of creating and running the game. It will
need to store the interface, dice, and scorecard as instance variables.

Phase 4 (A+ level): YachtGui
Create a complete graphical game by completing yachtgui.py. The exact
form of the interface is up to you. I would suggest starting with the Poker
app as a model and adding a graphical scorecard below it. In addition to
the buttons on the original poker game, you will want a button for each
scoring category. After the 3rd roll or when the user clicks the score
button, they should then be prompted to click a category to score.
A nice interface will make sure that only the buttons that are currently
available are active.

Grading
Since this is a more substantial project and delivered in phases, it is
worth 30 points. Most of the points will be determined by what phases
you complete. Good style is still appreciated, and will get you to a higher
level of the grade you earn. So a working phase 2 is some flavor of B. A