Inft1004作业代做、代写Python实验作业、代做Electrical Engineering作业、Python语言程序作业代写
School of Electrical Engineering and Computing
Inft1004 Introduction to Programming – Assignment
Due 11.59pm on Sunday 11 November
Weighting 30%
Paired work Students are strongly encouraged to work in pairs on this assignment
Your assessment task
For this assignment you are to write a Python program in JES that turns an image into a slidingblock
puzzle and allows the user to solve that puzzle.
In a sliding-block puzzle, a square image is divided into a 4x4 grid and one piece (typically the top
left piece) is removed. The pieces are called blocks, and the player can slide any block into the
empty space. Of course this also moves the empty space, and another piece can then be moved into
it. The game is played by shuffling the blocks somewhat arbitrarily, then trying to get them back
into their starting order.
For convenience, we can describe the four possible moves as up, down, left, and right, meaning that
a block is slid up, down, left, or right, into the empty space. Here are some images that should help
you to understand the process. They show a puzzle in its solved state, then what it looks like after
moves left, up, right, and down in that order. Note that the empty space seems to move in the
opposite direction to the sliding block, so the empty space appears to have moved right, down, left,
and up; but with the physical puzzle, the user slides a block, not the space, so it is the movement of
the block that we describe.
The assignment can be loosely broken into five tasks, although some of them will have subtasks:
1. Crop the image to make it square.
2. Draw lines on the image to form the 16 blocks.
3. Implement block slides up, down, left, and right into the empty space.
4. Keep track of where each block is.
5. Allow user input to control the block slides.
6. Shuffle the puzzle arbitrarily.
7. Check whether the puzzle is solved.
Each of these tasks is described in more detail on the following pages.
Inft1004 Introduction to Programming Assignment 2
Journal
As programming is a complex task, you are required to maintain and submit a journal, a separate
word-processed document in which you
record when and for how long you work on which aspects of the assignment, and which bits
are done by which member of the pair;
briefly list questions that arise, difficulties that you encounter, and how you overcome them;
summarise lessons that you learn.
By the time you’ve finished the program your journal will probably be many pages long. The
journal is intended to record your design thoughts, your programming thoughts, and the time you
spend on the task, so you must keep it up to date at all times. A ‘journal’ that is thrown together the
day before the assignment is due is not a journal at all.
When you hand in your files, your journal must be a pdf file.
Cover sheet
With the assignment you are required to hand in an official cover sheet (a group cover sheet if you
work in a pair), indicating that what you are handing in is your own work, and that you have not
given or shown it to anyone else in the class (excluding your partner if you worked as a pair). This
sheet is intended to be signed. However, if you do not wish to print it, sign it, and scan it, you may
type your names where the signatures are expected. The fact of submitting it from your user account
will serve as a signature.
When you hand in your files, your cover sheet must be a pdf file.
Files and folders
When you hand in the assignment you will be handing in three files: your Python program, your pdf
journal, and your pdf cover sheet. There is a particular structure that you are required to follow.
All three files (and no other files) will be in a folder whose name is your names, without spaces,
followed by the abbreviation Assgt2. If Abby Archer and Zeke Zammit are working together, their
folder will be called AbbyArcherZekeZammitAssgt2.
Within that folder, your Python program will have your names followed by Assgt2.py (eg
AbbyArcherZekeZammitAssgt2.py); your journal will have your names followed by Journal.pdf, (eg
AbbyArcherZekeZammitJournal.pdf); and your cover sheet will have your names followed by
CoverSheet.pdf, eg AbbyArcherZekeZammitCoverSheet.pdf. Remember that both the journal and the
cover sheet are to be pdf files.
Problem-solving
Several aspects of this assignment involve problem-solving. This is not unusual: it is difficult to
specify programming tasks that do not require problem-solving. While you might be tempted to just
write some code and hope that it will eventually do what you want it to do, in the end it will be far
more effective to first work out exactly what you want the code to do, and only then start writing
the code.
Based on past experience, students who believe that they are having trouble with their program
code are generally having trouble with their program design, their algorithm. If your program isn’t
doing what you want it to do, this is probably because you haven’t solved the problem and clearly
worked out how the program should do what you want it to do. You are most unlikely to get the
program working correctly if you haven’t correctly solved the problems and designed the solutions.
When you need to problem-solve, the key is not to search the web for inspiration, it is not to
randomly try things in the hope that one of them will work: it is to write down what you have, to
Inft1004 Introduction to Programming Assignment 3
write down what you want, and to think about how to get from the first to the second. It often helps
to draw diagrams. It definitely helps to discuss the problem, and possible solutions, with your
partner. If you actually solve the problem for yourself, rather than finding something somewhere
that you might be able to bend into a solution, it will be a huge step in your development as a
programmer.
Some general suggestions
It’s really important to tackle one task, one function, at a time. At first the whole assignment will
seem overwhelming. But by doing one function at a time you will find it much easier to come to
grips with – although of course some functions are tougher than others. So long as you start early
enough, you should complete most of the functions.
Assignment tasks
puzzle(picfile) – 5 marks
When we mark your assignment, the first thing we will do is run a function called puzzle() with
an appropriate argument. This function will call functions for the other tasks in turn. Be sure that
you name this function exactly the way it is named here; if the name is even slightly different, JES
will not find the function when we try to run it. Also be sure that you define it as having exactly one
parameter.
The parameter is the file in which the original image is stored. For example, if we want to make a
puzzle of the beach picture, the argument will be the file in which that picture is stored. In the
command area you might have entered beachFile = pickAFile() and then selected the file
beach.jpg; you would then be able to use beachFile as the argument.
Of course it would be possible to program all of the assignment tasks within the single puzzle()
function, but you know by now that it makes more sense to write a separate function for each task,
and then call those functions appropriately from puzzle(). Before calling any of your own
functions, this function should make a picture from the file.
Task 1: crop the image to make it square – 10 marks
You now have a picture that might be square, but probably isn’t. Your job here is to produce a
square picture from what you have been given. The side of the square should be whichever is
smaller, the width or height of the original picture. If the original is wider than it is high, it should
lose equal amounts from its left side and its right side, so that the new image represents its middle.
Likewise, if it is higher than it is wide, it should lose equal amounts from the top and bottom.
Here are the square versions of a couple of familiar pictures.
Inft1004 Introduction to Programming Assignment 4
Task 2: draw the grid on the image – 5 marks
It’s possible to represent a sliding-block puzzle without gridlines, but there are clear lines on the
physical version of the puzzle, and lines help us to see where the blocks are in parts of the picture
that are in the right locations. So now draw lines on the image, just one pixel wide, to divide it into
16 blocks.
Do you remember the problem we had with integer division in the week 5 lecture? Could that
problem arise here when you’re drawing the lines? If so, what can you do about it?
Task 3: implement block slides into the empty space – 15 marks
Now you need to move blocks up, down, left, or right into the empty space. There isn’t an empty
space yet, but that’s not a problem. By default, the empty space is in the top left of the puzzle, so
you can put one there.
Moving a block is then as simple as copying the pixels from that block into the empty space – and
remembering to empty the place that the block moved from.
You might need to consider what to do if the move doesn’t make sense. For example, if the empty
space is at the top left of the puzzle, what should your program do with a request to move a block
down into that space?
Did you deal with the rounding error problem while working on task 2? If not, you might start to
see strange lines appear at the edges of blocks, and the grid lines might no longer line up properly:
Inft1004 Introduction to Programming Assignment 5
What’s happening here is that the blocks are not all exactly the same size. When you copy the
pixels from one block into a block that’s a slightly different size, it’s not quite going to work.
Clearly, you need every block to be exactly the same size.
You should eventually work out that it’s not enough for the picture to be square; it must also be of a
suitable size to accommodate four blocks and five single-pixel lines in each dimension. This is one
place where you need to apply your problem-solving skills to work out how to implement that.
Don’t think that you need to scale the picture in any way; just go back to task 1 and take slightly
less of the original picture. But don’t guess this step: work it out!
At this stage you will probably be testing your program by making a series of calls to the
function(s) that move the blocks. This is tedious, but tasks 4 and 5 will make it easier.
Task 4: keep track of where each block is – 10 marks
The moves in a sliding-block puzzle are just up, down, left, and right. But if the user wants to move
a block in one of those directions, the program has to know where the empty block currently is. In
fact, it’s a good idea for the program to know where every block is (see task 7). This could be done
in various ways: here’s a relatively simple one.
Create a list of the numbers from 0 to 15, representing the blocks in their original order. The initial
list will be [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]; 0 represents the empty space at the top
left, 3 represents the top right block, and 12 represents the bottom left block (see the numbered
picture on p7). Every time you make a move, you will need to change the order of numbers in the
list to reflect the blocks’ new positions in the puzzle.
For example, an initial move left would change the list to [1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 15], indicating that the empty space (0) is now in position 1 and block 1 (1) is now in position 0.
Following this, a move up would give the list [1, 5, 2, 3, 4, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], as
block 5 moves into the spot where the empty space was, and the empty space moves to where block
5 was.
We might not have covered this in lectures, but lis.index(value) returns the index of value in lis. For
example, if order is the list [1, 5, 2, 3, 4, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], order.index(0) will be
5. So, given a list like this, you can find where the empty space is; and, given a move such as up or
right, you can work out which block needs to move, and swap the positions of the two.
You’ll probably need to read those paragraphs several times over before you fully understand what
they’re saying. When you do understand it, if you decide to use this method to keep track of which
blocks are where, you’ll still need to do some problem solving.
For example, how do you swap two elements in a list, given their indexes? You might be able to
find somebody else’s solution to this online, but you might struggle to understand it. It would be far
better to work out your own approach, using pen and paper, and to implement that. Remember,
you’ve known how to swap two variables since about week 2. Perhaps you can use that knowledge.
When you work that out, you’ll need to keep the list up to date. Every time you make a move, the
list will need to change to reflect that move. If you have a function that moves a block in the
picture, the function will also have to change the list.
This leads to a new problem. A function can only return one thing. If you have a function that
moves a block, it can’t return both the new list and the new picture. Well, there are ways of doing
this, but we haven’t covered them. So even though we’ve advised you not to rely on the side effects
of functions, you may, if you wish, use side effects to directly change the picture, the list, or both.
But if you write any functions that use side effects to change their arguments, be sure to say so in
the comments, so that we can see that you’re aware that you’re doing this.
Inft1004 Introduction to Programming Assignment 6
Task 5: allow user input to control the block slides – 10 marks
If you haven’t already done this as part of tasks 3 and 4, it’s time to allow the user to control the
puzzle. Compared with task 4, this should be simple.
One possible approach would be to ask the user to input a single letter, u / d / l / r, and to use that
input to make the move. How will you let users know what these letters mean?
Of course this should be in a loop, so that the user can make more than one move before the
program ends. What kind of loop? How, if at all, should it end? Should the user be given an
additional input option, such as q for quit?
Task 6: shuffle the puzzle arbitrarily – 15 marks
To get the puzzle into a jumbled state, you might be tempted just to shift blocks arbitrarily into new
locations. Unfortunately, that won’t work: there are many arrangements of the blocks that cannot be
solved by sliding individual blocks. Here is just one of them:
So what you need to do now is to jumble the blocks in such a way that they can definitely be solved
by a sequence of sliding moves. If you’re really good at mathematics, you might be able to work
that out in some other way, but probably the easiest way is simply to apply a random sequence of
moves to the puzzle. Depending on how you decided to deal with moves that don’t make sense, this
might be relatively easy.
A potential problem is that because the empty square is initially in the top left corner, a random
sequence of moves is likely to affect mainly the top left part of the puzzle, and might never reach
into the lower right. There are various ways of adjusting for this; see what you can come up with.
Even though it might make some sense, don’t have your program shuffle the puzzle immediately; a
user might want to explore the individual direction controls first. So add an s option to the possible
user inputs, and shuffle the puzzle when the user enters s.
Task 7: check whether the puzzle is solved – 5 marks
Because you’re using a list to keep track of the block positions, it's very easy to check whether the
puzzle is solved: just check whether the list is the same as the starting list.
Once the puzzle is solved, you should congratulate the user and end the input loop.
When you’re actually solving the problem yourself, as a user, you might find that with some
pictures it’s not obvious which blocks belong where. Even though you’re quite familiar with the
beach picture, can you look at this shuffled version and know where each block belongs? If not, it’s
going to be harder to solve.
Inft1004 Introduction to Programming Assignment 7
For this reason, we’ve provided the image numbers.jpg, which should be a great deal easier to
solve. Indeed, while some sliding-block puzzles do have an image on them, many have either the
numbers from 1 to 15 or the letters from A to O, to make them easier to work with.
Assessment criteria
Your work will be assessed out of 100 marks. In addition to the 75 marks listed above with the task
descriptions, there will be marks for
your journal, as specified above, clearly showing the design and development process (12)
well-named variables and appropriate and useful comments in the code (13)
Once these marks have been allocated, marks will be deducted for the following:
failure to follow instructions/requirements, eg with file names
syntax errors or runtime errors in your program
Inft1004 Introduction to Programming Assignment 8
failure to fully and clearly reference any material from external sources, such as code
written by other people or code with which other people have assisted you
late submission – see below
If you get code from other people or sources, or if other people help you with your own code, you
must add comments making this clear, and explain it in your journal. If the marker uncovers
evidence that you have cheated in any way, for example, by sharing your code with others in the
class, or by getting help from anyone other than your partner and not referencing it, the matter will
be reported to the Student Academic Conduct Officer as a potential case of academic misconduct.
(See Academic integrity below.)
Handing in your work
You are to hand in the assignment electronically using Blackboard’s Assignment facility. Because
you need to hand in a whole folder and its contents, you are required to zip the files together.
Remember, you are to hand in a folder containing exactly three files: your Python program, your
pdf journal, and your pdf cover sheet.
When you zip your folder and its contents, in way that preserves their directory structure, be sure
that you produce a .zip file, not some other format such as a .rar file. (If you’re at all unsure about
this, tell your operating system to display file extensions as well as file names.) There are many
zipping software packages, some commercially available, some free, and some provided with
operating systems. Well before you submit your assignment, be sure that you have access to
appropriate software and know how to use it. Once you have zipped your files together, be sure to
unzip them to a new location to check that they unzip correctly. Also be sure that the zip file has the
same name as the folder, your names without spaces followed by Assgt2; for example,
AbbyArcherZekeZammitAssgt2.zip.
When you are ready to submit your zipped file, log in to Blackboard, go to the site for this course,
and follow these steps . . .
Select the Assessment folder.
Click the Assignment 2 link, which will take you to the appropriate upload page.
Under Assignment submission, click Browse my computer (next to Attach files), and navigate
to your zip file. In the comments field put your name if you worked alone, or both of your
names if you worked as a pair.
In the bottom right corner, click the Submit button (not the Save draft button).
If you don’t see a message saying the assignment is complete, go back and check that you’ve
done all these steps. If there’s still a problem, try Blackboard’s help under Course tools,
search for assignment, and select the help page on submitting assignments.
If you want to submit an updated version of the assignment, go back to the Assignment link
and click Start new submission on the assignment’s Review submission history page. Make
sure you’re aware of the deadline: the final marking will be applied only to the most recent
submission, and if it’s submitted late it will be marked as late.
You might be required to demonstrate your program, and to explain aspects of your code, in a
subsequent lab class.
Paired work
When two students work as a pair, all folders and files (as described above) should clearly indicate
the names of both students in the pair. Only one copy of the work needs to be handed in, only one
journal needs to be handed in (a combined journal for the pair), and both students in the pair will
Inft1004 Introduction to Programming Assignment 9
normally get the same mark for the assignment, regardless of who did how much of the work,
unless it is clear that this would be a serious injustice.
Deadline and consequences for late submission
The assignment is due by 11.59pm on Sunday 11 November, the end of week 9 of classes. Work
will be penalised 10% for every day or part day by which it is late.
Students are encouraged to aim to complete the assignment well before the deadline, as
programming assignments are well known for taking far longer than the students expect.
Inft1004 Introduction to Programming Assignment 10
Academic integrity – getting assistance or code
This assignment is your chance to gain an understanding of fundamental concepts of program
structure and coding syntax on which later learning will be based. It is important that you master
these concepts yourself.
Since you are mastering fundamental skills, you are permitted to work from the textbook and course
examples, but you must acknowledge assistance from other textbooks or classmates. In particular,
you should try not to use code or algorithms from external sources, and not to obtain help from
people other than your instructors, as this can prevent you from mastering these concepts. However,
if you do get code or assistance from these external sources, you must ‘attribute’ it: both in your
journal, and in comments in your code, you must clearly explain where or who the code or
assistance came from, and how much help or code was provided.
Here is a detailed guide to who you can get help from, and where you can get code from. Please pay
careful attention to it.
Assistance: who might you want help from? Status
Yourself, your partner Highly encouraged
Your lecturer, your tutor Encouraged
Classmates, other tutors Attribution required
Online forums, relatives, friends, other students not in this course Not acceptable
Any other sources Ask the lecturer
Resources: where might you want to get code from? Status
Course textbook, course notes and examples, your partner Encouraged
Other textbooks Attribution required
Online programs, hired coders, relatives, friends, other students Not acceptable
Any other sources Ask the lecturer
Obtaining code or assistance for which attribution is required without attributing it, or obtaining any
code or assistance from sources marked ‘Not acceptable’, is a breach of academic integrity, and can
be referred to the Student Academic Conduct Officer for investigation. Furthermore, providing such
code or assistance is also a breach of academic integrity, and can be treated as such.
If you do receive code or assistance for any of the assignment, there is a specific way in which you
must provide the attribution in your program. We call this a reference comment.
The reference should say whether it is for externally sourced code, an externally sourced algorithm,
or personal assistance. It should be given a unique identifier so that its end can be clearly marked.
The beginning and end of each reference should be marked in a particular way that stands out from
the code. In the examples below we use lines of hash symbols to do this.
Each reference should include:
its purpose: why was external code or assistance sought?
the date the code or assistance was used;
the source of the code or assistance;
the author of the code, if known, or the person providing assistance;
the url, if applicable;
Inft1004 Introduction to Programming Assignment 11
any adaptation that was required to incorporate external code;
a brief description of assistance that was provided, if applicable.
Here are some examples.
#############################################
# Reference A3: externally sourced algorithm
# Purpose: sort a list of sublists by the second element in each sublist, descending
# Date: 25 Sep 2018
# Source: Python documentation
# Author: Andrew Dalke and Raymond Hettinger
# url: https://docs.python.org/3/howto/sorting.html
# Adaptation required: changed variable names; saw need to assign result to original list name
#############################################
freqList = sorted(freqList, key = lambda wordFreq: wordFreq[1], reverse = True)
#############################################
# End reference A3
#############################################
#############################################
# Reference C5: externally sourced code
# Purpose: make a collage with various colour transformations because I didn’t understand the one in the book
# Date: 12 Oct 2018
# Source: stackoverflow
# Author: Gauthier Boaglio
# url: https:#stackoverflow.com/questions/15693938/how-do-i-change-image-colors-with-jes-programing
# Adaptation required: changed variable names
#############################################
This is where the copied code goes
#############################################
# End reference C5
#############################################
#############################################
# Reference P7: personal assistance
# Purpose: deal with 'inappropriate argument' error
# Date: 25 Oct 2018
# Source: fellow student Susan Piperhttp://www.6daixie.com/contents/3/2102.html
# Assistance: explained that these errors arise if we try to access pixels beyond the edge of the picture
#############################################
This is where the newly modified code goes
#############################################
# End reference P7
#############################################
因为专业，所以值得信赖。如有需要，请加QQ：99515681 或邮箱：[email protected]
微信：codinghelp