0CCS0CSE Introduction to CS Engineering

Introduction to CS & Engineering (0CCS0CSE)

Homework

Due Friday Feb. 7

th

, 11am

Activity

Chess is a two-player board game, played on a chequered board where pieces are moved

according to precise rules (see Table 1). The object of the game is to attack the opponent’s

king in such a way that escape is impossible (checkmate). Each square on a chess board

can be described by a letter (file) and number (rank). For example, in Figure 1, square

b4 is on file b and rank 4.

Figure 1: Chess board positions. (www.logicalchess.com)

For this homework assignment you will design and implement two functions. The first

function, position(piece, loc), takes the name of a chess piece and its position, and

returns all the squares that piece can reach after a single move is made. The second

function, getTo(piece, loc1, loc2), takes the name of a chess piece, two positions,

and returns true if the piece can reach the second position in exactly two moves. Assume

there are no other pieces on the board.

1Chess Pieces

Piece Moves

King Moves one square in any direction.

Queen Any number of squares diagonally, horizontally, or vertically.

Rook Any number of squares horizontally or vertically.

Bishop Any number of squares diagonally.

Knight In an ‘L-shape,’ two squares in a straight direction, and

then one square perpendicular to that.

Pawn One square forward

Table 1: Valid piece names and a description of how they move.

Requirements

1. The program should contain at least 3 functions. Furthermore, it should demonstrate

 an understanding how and when to use functions.

2. The program must contain and use the functions position(piece, loc) and getTo(piece,

loc1, loc2)

3. The program should be written without using the chr() function, the ord() function,

 tuples, list comprehension, or nested functions (i.e., closures & decorators)

4. All of your code should be within a function, i.e., no global variables

5. Follow all submission requirements

position(piece, loc)

1. The function accepts full piece names, e.g., King, Rook or Queen, as a string. The

function should be case insensitive, that is, King, king, and KING are treated the

same.

2. The function should accept positions, as a string, in file-rank format, e.g., b5, h8 or

f3. The function should be case insensitive, that is, b3 and B3 are treated same.

3. The function should return a list; the order of the chess squares in the list does not

matter.

4. If an invalid piece is passed to the function, i.e., a piece not found in Table 1, the

function should return an empty list

5. If the position of the piece is invalid, the function should return an empty list

6. If the piece is in a position where it has no valid moves, the function should return

an empty list

2getTo(piece, loc1, loc2)

1. The function accepts full piece names, e.g., King, Rook or Queen, as a string. The

function should be case insensitive, that is, King, king, and KING are treated the

same.

2. The function should accept positions, as a string, in file-rank format, e.g., b5, h8 or

f3. The function should be case insensitive, that is, b3 and B3 are treated same.

3. The function should return True or False. If the piece can get from position 1

to position 2 in exactly two moves, the function should return True, otherwise it

should return False.

4. If the piece can get from position 1 to position 2 in one move, return False

5. If the piece is already on position 2, return False

6. The function must use the position(piece, loc) function appropriately.

Sample Test Cases

For testing purposes, here are some of the test cases your submission must pass.

1 position ('King ', 'f3 ')

2 # Returns ['e4 ','f4 ','g4 ','e3 ','g3 ','e2 ','f2 ','g2 ']

3

4 position ('Rook ','i4 ')

5 # Returns []

6

7 position ('knight ','d4 ')

8 # Returns ['e6 ','f5 ','f3 ','e2 ','b3 ','c2 ','b5 ','c6 ']

9

10 getTo ('king ', 'e1 ', 'e3 ')

11 # Returns True

12

13 getTo ('pawn ', 'c2 ', 'c8 ')

14 # Returns False

15

16 getTo ('knight ', 'g1 ', 'e5 ')

17 # Returns True

3Submission Instructions

Failure to follow all submission instructions may result in a lower grade.

1. At the top of your program put the following comments:

# [Your Full Name]

# [Your K number]

# Homework 1

2. Name your solution hw1.py —exactly as you see it here. One word all lowercase,

with the *.py extension.

3. Submit the Python file (*.py) on KEATS —You do not need to include a cover

sheet

4. If asked for a submission title, enter your full name.

Marking

The mark is split 60% functionality and 40% implementation. Meaning, if your program

works and passes all test cases you automatically get a 60. The remaining 40% will be

given based on how well you implemented your solution., e.g., appropriate use of functions,

 use of descriptive variable names, following submission instructions, and meeting

program requirements.

Note:

• if your program crashes during testing, you will receive a 40 regardless

of the error that caused the crash

• if your program uses any of the following, chr() function, the ord() function,

 tuples, list comprehension, or nested functions (i.e., closures & decorators),

 you will receive a zero

• any submission that significantly deviates from the assignment will receive

 a zero.

Rubric for Implementation

• Requirements. All specified requirements have been met (15 points)

• Functions. The solution demonstrates good use of functions; the code is reusable;

the code is efficient without sacrificing readability; and the solution is well organised

and easy to understand (15 points)

• Variable & function names. The solution uses meaningful identifier names, i.e.,

good function and variables names (5 points)

• Comments. The solution contains function level comments; few in-line comments

are used; and comments do not make code difficult to read/understand (5 points)

4Late Submission Policy

All coursework must be submitted on time. If you submit coursework late and have not

applied for an extension or have not had a mitigating circumstances claim upheld, you

will have an automatic penalty applied. If you submit late, but within 24 hours of the

stated deadline, the work will be marked, and 10 raw marks will be deducted. All work

submitted more than 24 hours late will receive a mark of zero.

• Any program submitted within 24 hours after the deadline will lose 10 points

• Any program submitted after the 24 hour grace period will receive a 0