Python Program Help

HW7P_problem1.ipynb

{ "cells": [ { "cell_type": "markdown", "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "markdown", "checksum": "7b47b6d141b4a60d79c2a115b8a69043", "grade": false, "grade_id": "cell-568582423fb764a7", "locked": true, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "source": [ "# INSTRUCTIONS:\n", "Before you turn this Lab in, make sure everything runs as expected. First, **restart the kernel** (in the menubar, select Kernel$\\rightarrow$Restart) and then **run all cells** (in the menubar, select Cell$\\rightarrow$Run All).\n", "\n", "**TIP**: Open another jupyter notebook to try out your code and experiment with your answers. You can then copy your answer into the Lab notebook for your final submission. This will reduce the chance that your submitted Lab will not be correctly graded.\n", "\n", "Make sure you fill in any place that says `YOUR CODE HERE` or \"YOUR ANSWER HERE\", and follow the instructions carefully.\n", "Also enter your name in the markdown cell below:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NAME = \"\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "# CS1411-Introduction to Programming with Python\n", "## Homework 7" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "**SUBMISSION GUIDELINES**\n", "\n", "1. First design, develop and test your code in a Jupyter notebook or other development environment\n", " - You can expirement and try different things in that notebook\n", "2. Then copy your final code and markdown cells into the Jupyter Notebook file (.ipynb) provided for the assignment and submit to Canvas\n", " - **Your submission file should be named the same as the download file**\n", " - I must be able to open and run your notebook in order to grade it\n", "3. Note that the Jupyter notebook provided for final submission may contain testing code to help you check that your output and expected match. \n", " - Follow the instructions in the notebook for copying your code and running the testing code\n", " - The instructor may run additional tests to check that your code runs correctly\n", "4. If asked, also provide any supporting files or images requested in the assignment\n", "\n", "**GRADING CRITERIA:**\n", "1. Good documentation/comments and program readability using both markdown cells and code comments\n", "2. Algorithm/pseudo-code is explained in a markdown cell and is efficiently written\n", "3. Program runs correctly for test cases with no syntax errors or logical errors\n", "\n", "***The instructor should be able to reproduce your work from your notebook.***" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "1ae4de9780340bb521b73fe1f95e2689", "grade": true, "grade_id": "Instructor_test_setup", "locked": true, "points": 0, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test setup and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**NOTE: SOME THINGS I WILL BE LOOKING FOR:**\n", "\n", "After each part of the assignment you will see a cell with a summary of the \"Instructor tests\" I will be doing.\n", "\n", "....And, of course I will be looking for efficient, well-written, readable code." ] }, { "attachments": { "image-2.png": { "image/png": "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" } }, "cell_type": "markdown", "metadata": {}, "source": [ "### Problem 1: Lo Shu Magic Square (3 questions)\n", "\n", "The Lo Shu Magic Square is a grid with 3 rows and 3 columns. The Lo Shu Magic Square has the following properties:\n", "```\n", "- The grid contains the integers 1 through 9 exactly (no duplicates)\n", "- The sum of each row, each column, and each diagonal all add up to the same number. \n", "```\n", "An example of a Lo Shu Magic Square is shown in the figure below:\n", "\n", "\n", "\n", "For your program simulate a magic square using a **two-dimensional list of integers**. \n", "\n", "**Q1**. Write a function called ```read_square(filename)``` that takes ```filename``` and reads the contents of the file into a 2D list of integers called ```list_2D``` with values for the magic square. \n", "\n", "Use a try-except statement in your function to check for any ```Exception``` error (e.g. if the file is not found or could not be opened, or if the file has non-numbers such as '-'). Capture the error if it occurs in a variable called ```err``` and display the error message. \n", "\n", "The function should return ```list_2D```. If there is an error ```list_2D``` should be returned as an empty list. \n", "\n", "Your function should give the following output when run with the following files (the files have been provided for you):\n", "```\n", "read_square('valid_lo_shu.txt')\n", "Filename: valid_lo_shu.txt\n", "Result> Ok\n", "\n", "read_square('no_file.txt')\n", "Filename: no_file.txt\n", "Got an Error> [Errno 2] No such file or directory: 'no_file.txt'\n", "\n", "read_square('invalid_lo_shu_input.txt')\n", "Filename: invalid_lo_shu_input.txt\n", "Got an Error> invalid literal for int() with base 10: '-'\n", "```\n", "\n", "**Q2**. Write a function called ```is_magic_square(list_2D)``` that accepts a two-dimensional list as an argument and returns two values 1) True(False) if the list is(is not) a Lo Shu Magic and 2) the row sum or ```None```.\n", "\n", "Follow the algorithm that has been provide below for the ```is_magic_square(list_2D)``` function. The function should call the following \"helper\" boolean functions (i.e.functions that return True or False):\n", "```\n", "in_range(list_2D): \n", "- Returns True if the values in the square are between 1 and 9, inclusive, else False\n", "\n", "has_unique_values(list_2D): \n", "- Returns True if the values are are unique, i.e. NO duplicates, else False\n", "\n", "row_sums_equal(list_2D):\n", "- Returns True AND the row sum if all the row sums are equal, else returns False, and None for the sum\n", "\n", "col_sums_equal(list_2D):\n", "- Returns True AND the column sum if all the column sums are equal, else returns False, and None for the sum\n", "\n", "diag_sums_equal(list_2D)\n", "- Returns True AND the diagonal sum if all the diagonal sums are equal, else returns False, and None for the sum\n", "```\n", "Test each of your helper functions and the ```is_magic_square(list_2D)``` function in the indicated cells below:\n", "\n", "**Q3**. Finally, test that your code works by calling the ```read_square(filename)``` and ```is_magic_square(list_2D)``` functions in the ```main(filename)``` function provided to you. \n", "\n", "Run the ```main(filename)``` function with valid and invalid Lo Shu Square Input and check that your output matches. The file ```valid_lo_shu.txt``` has a valid square, and the file ```invalid_lo_shu.txt``` has an invalid square for you to use to test your function.\n", "\n", "Your ```main(filename)``` program should give the following output when run with the following files (the files have been provided to you):\n", "```\n", "main('valid_lo_shu.txt')\n", "Filename: valid_lo_shu.txt\n", "Result> Ok\n", "Result : Valid Magic Square! The sum = 15\n", "\n", "main('invalid_lo_shu_1.txt')\n", "Filename: invalid_lo_shu.txt\n", "Result> Ok\n", "Result : Not a valid magic square!\n", "```" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### Points: 24 - read_square(filename) function\n", "\n", "**Q1** Write and test the ```read_square(filename)``` function as indicated in the instructions above. \n", "\n", "Here's possible a possible algorithm in pseudocode:\n", "```\n", "try\n", " Set list_2D = []\n", " Open file\n", " for line in file\n", " read in row - A list comprehension is one way to select the integers from the line\n", " append the row to the list_2D\n", " close file\n", " print ok message\n", "if exception capture err\n", " print error message\n", "\n", "return list_2D\n", "```\n", "\n", "(**DO NOT split your solution across cells**. Your complete code should be in the indicated answer cell)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [], "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "9e54fdaefbccff35f2957aac39e6c1d3", "grade": false, "grade_id": "Q1_answer", "locked": false, "schema_version": 3, "solution": true, "task": false }, "tags": [] }, "outputs": [], "source": [ "#Q1 [DO NOT DELETE!]\n", "\n", "# YOUR CODE HERE\n", "raise NotImplementedError()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# test for your answer - Try various cases for input file and check that your printout and list_2D match the scenarios\n", "# TEST CODE HERE\n", "list_2D = read_square('valid_lo_shu.txt')\n", "print(f'2D list = {list_2D}')\n", "assert list_2D == [[4, 9, 2], [3, 5, 7], [8, 1, 6]], \"Error: 2D list not correct\"\n", "print(\"Ok - list output matches, check that printout matches\")\n", "print()\n", "\n", "list_2D = read_square('no_file.txt')\n", "print(f'2D list = {list_2D}')\n", "assert list_2D == [], \"Error: 2D list should be []\"\n", "print(\"Ok - list output matches, check that printout matches\")\n", "print()\n", "\n", "list_2D = read_square('invalid_lo_shu_input.txt')\n", "print(f'2D list = {list_2D}')\n", "assert list_2D == [], \"Error: 2D list should be []\"\n", "print(\"Ok - list output matches, check that printout matches\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# Instructor Tests\n", "# Check read_square returns 2D integer list and correct print output for valid_lo_shu.txt\n", "# Check read_square returns 2D list = [] and correct print output for no_file.txt\n", "# Check read_square returns 2D list = [] and correct print output for invalid_lo_shu_input.txt" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "75f8b6c0fa48d4794a876b5437ff47ef", "grade": true, "grade_id": "Q1_test_1", "locked": true, "points": 8, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "ae936e02d7c4fc717008b9dbc27dac7d", "grade": true, "grade_id": "Q1_test_2", "locked": true, "points": 8, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "eb9106c2618b91fb8e9f7322b4d73875", "grade": true, "grade_id": "Q1_test_3", "locked": true, "points": 8, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "69a7fd7b2ee240c2bcc71ef8032c1a32", "grade": true, "grade_id": "Q1_test_summary", "locked": true, "points": 0, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### Points: 56 - is_magic_square(list_2D)\n", "\n", "**Q2** Write and test the ```is_magic_square(list_2D)``` function as indicated in the instructions above.\n", "\n", "Here's possible pseudocode for the algorithm:\n", "```\n", "Write and then use the boolean functions that take list_2D as paramenter:\n", "\n", "in_range(list_2D): \n", "- Returns True if the values in the square are between 1 and 9, inclusive, else False\n", "\n", "has_unique_values(list_2D): \n", "- Returns True if the values are are unique, i.e. NO duplicates, else False\n", "\n", "row_sums_equal(list_2D):\n", "- Returns True AND the row sum if all the row sums are equal, else returns False, and None for the sum\n", "\n", "col_sums_equal(list_2D):\n", "- Returns True AND the column sum if all the column sums are equal, else returns False, and None for the sum\n", "\n", "diag_sums_equal(list_2D)\n", "- Returns True AND the diagonal sum if all the diagonal sums are equal, else returns False, and None for the sum\n", "\n", "with these functions you can then check: \n", "\n", "if (in_range and has_unique_values and row_sums_equal and col_sums_equal and diag_sums_equal)\n", " valid_magic = True\n", "else \n", " valid_magic = False\n", " \n", "Return valid_magic, row sum\n", "```\n", "\n", "(**DO NOT split your solution across cells**. Your complete code should be in the indicated answer cell)" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### Points: 8 - in_range(list_2D)\n", "\n", "**Q2.01** Write and test the ```in_range(list_2D)``` function as indicated in the instructions above.\n", "\n", "```\n", "in_range(list_2D): \n", "- Returns True if the values in the square are between 1 and 9, inclusive, else False\n", "```\n", "\n", "(**DO NOT split your solution across cells**. Your complete code should be in the indicated answer cell)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [], "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "0f9fdd84d85a36a12dd50097594aacf6", "grade": false, "grade_id": "Q2_answer_1", "locked": false, "schema_version": 3, "solution": true, "task": false }, "tags": [] }, "outputs": [], "source": [ "#Q2.01 [DO NOT DELETE!]\n", "\n", "# YOUR CODE HERE\n", "raise NotImplementedError()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# test for your answer - Try a square with numbers in range and outside of range\n", "# YOUR CODE HERE\n", "# try a square with numbers between 1 through 9\n", "list_2D = [[4, 9, 2], [3, 5, 7], [8, 1, 6]]\n", "assert in_range(list_2D) == True, \"Error: expected function to return True\"\n", "print(\"Ok - passed this test\")\n", "\n", "# try a square with numbers outside of 1 to 9\n", "list_2D = [[0, 10, 2], [3, 15, 7], [8, 1, 12]]\n", "assert in_range(list_2D) == False, \"Error: expected function to return False\"\n", "print(\"Ok - passed this test\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# Instructor Tests\n", "# Check that in_range(list_2D) returns True for square with valid numbers and false otherwise" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "8ec40876899322361a2e9927dd1236c3", "grade": true, "grade_id": "Q2_test_1", "locked": true, "points": 8, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### Points: 8 - has_unique_values(list_2D)\n", "\n", "**Q2.02** Write and test the ```has_unique_values(list_2D)``` function as indicated in the instructions above.\n", "\n", "```\n", "has_unique_values(list_2D): \n", "- Returns True if the values have NO duplicates, else False\n", "```\n", "\n", "(**DO NOT split your solution across cells**. Your complete code should be in the indicated answer cell)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [], "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "c3cc5ea628a166fa2617a054b54a2a0d", "grade": false, "grade_id": "Q2_answer_2", "locked": false, "schema_version": 3, "solution": true, "task": false }, "tags": [] }, "outputs": [], "source": [ "#Q2.02 [DO NOT DELETE!]\n", "\n", "# YOUR CODE HERE\n", "raise NotImplementedError()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ] }, "outputs": [], "source": [ "# test for your answer - Try a square with unique and non-unique numbers\n", "# YOUR CODE HERE\n", "# try a square with unique numbers\n", "list_2D = [[4, 9, 2], [3, 5, 7], [8, 1, 6]]\n", "assert has_unique_values(list_2D) == True, \"Error: expected function to return True\"\n", "print(\"Ok - passed this test\")\n", "\n", "# try a square with non-unique numbers\n", "list_2D = list_2D = [[0, 0, 2], [3, 15, 15], [8, 1, 6]]\n", "assert has_unique_values(list_2D) == False, \"Error: expected function to return False\"\n", "print(\"Ok - passed this test\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# Instructor Tests\n", "# Check that has_unique_values(list_2D) returns True for square with unique numbers and false otherwise" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "314a58c1757a291051f191ed3f0e9bcd", "grade": true, "grade_id": "Q2_test_2", "locked": true, "points": 8, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### Points: 8 - row_sums_equal(list_2D)\n", "\n", "**Q2.03** Write and test the ```row_sums_equal(list_2D)``` function as indicated in the instructions above.\n", "\n", "```\n", "row_sums_equal(list_2D):\n", "- Returns True AND the row sum if all the row sums are equal, else returns False, and None for the sum\n", "```\n", "\n", "(**DO NOT split your solution across cells**. Your complete code should be in the indicated answer cell)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "bc7e13ff90dada82c56a82a10a45665c", "grade": false, "grade_id": "Q2_answer_3", "locked": false, "schema_version": 3, "solution": true, "task": false }, "tags": [] }, "outputs": [], "source": [ "#Q2.03 [DO NOT DELETE!]\n", "\n", "# YOUR CODE HERE\n", "raise NotImplementedError()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# test for your answer - Try a square with rows sums equal and unequal\n", "# YOUR CODE HERE\n", "# try a square with unique numbers\n", "list_2D = [[4, 9, 2], [3, 5, 7], [8, 1, 6]]\n", "valid,row_sum = row_sums_equal(list_2D)\n", "print(f'Row sum = {row_sum}')\n", "assert valid == True, \"Error: expected function to return True\"\n", "print(\"Ok - passed this test\")\n", "\n", "# try a square with non-unique numbers\n", "list_2D = list_2D = [[0, 0, 2], [3, 15, 15], [8, 1, 6]]\n", "valid,row_sum = row_sums_equal(list_2D)\n", "print(f'Row sum = {row_sum}')\n", "assert valid == False, \"Error: expected function to return False\"\n", "print(\"Ok - passed this test\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# Instructor Tests\n", "# Check that row_sums_equal(list_2D) returns True for square with equal row sums and false otherwise" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "01f280ed6be98b4db282d87c27e4c6d9", "grade": true, "grade_id": "Q2_test_3", "locked": true, "points": 8, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### Points: 8 - col_sums_equal(list_2D)\n", "\n", "**Q2.04** Write and test the ```col_sums_equal(list_2D)``` function as indicated in the instructions above.\n", "\n", "```\n", "col_sums_equal(list_2D):\n", "- Returns True AND the column sum if all the column sums are equal, else returns False, and None for the sum\n", "```\n", "\n", "(**DO NOT split your solution across cells**. Your complete code should be in the indicated answer cell)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "72543a0e5aa5705dfcad492192f2e4ff", "grade": false, "grade_id": "Q2_answer_4", "locked": false, "schema_version": 3, "solution": true, "task": false }, "tags": [] }, "outputs": [], "source": [ "#Q2.04 [DO NOT DELETE!]\n", "\n", "# YOUR CODE HERE\n", "raise NotImplementedError()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# test for your answer - Try a square with rows sums equal and unequal\n", "# YOUR CODE HERE\n", "# try a square with unique numbers\n", "list_2D = [[4, 9, 2], [3, 5, 7], [8, 1, 6]]\n", "valid,col_sum = col_sums_equal(list_2D)\n", "print(f'Column sum = {col_sum}')\n", "assert valid == True, \"Error: expected function to return True\"\n", "print(\"Ok - passed this test\")\n", "\n", "# try a square with non-unique numbers\n", "list_2D = list_2D = [[0, 0, 2], [3, 15, 15], [8, 1, 6]]\n", "valid,col_sum = col_sums_equal(list_2D)\n", "print(f'Column sum = {col_sum}')\n", "assert valid == False, \"Error: expected function to return False\"\n", "print(\"Ok - passed this test\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# Instructor Tests\n", "# Check that col_sums_equal(list_2D) returns (True,col sum) for square with equal column sums and false otherwise" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "beb2a6d8a5db7d98ed9217892cd2e1f0", "grade": true, "grade_id": "Q2_test_4", "locked": true, "points": 8, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### Points: 8 - diag_sums_equal(list_2D)\n", "\n", "**Q2.05** Write and test the ```diag_sums_equal(list_2D)``` function as indicated in the instructions above.\n", "\n", "```\n", "diag_sums_equal(list_2D):\n", "- Returns True AND the diagonal sum if all the diagonal sums are equal, else returns False, and None for the sum\n", "```\n", "\n", "(**DO NOT split your solution across cells**. Your complete code should be in the indicated answer cell)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "30ba11cdd3470bcde6f8cba6a62aa86f", "grade": false, "grade_id": "Q2_answer_5", "locked": false, "schema_version": 3, "solution": true, "task": false }, "tags": [] }, "outputs": [], "source": [ "#Q2.05 [DO NOT DELETE!]\n", "\n", "# YOUR CODE HERE\n", "raise NotImplementedError()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ] }, "outputs": [], "source": [ "# test for your answer - Try a square with rows sums equal and unequal\n", "# YOUR CODE HERE\n", "# try a square with unique numbers\n", "list_2D = [[4, 9, 2], [3, 5, 7], [8, 1, 6]]\n", "valid,diag_sum = diag_sums_equal(list_2D)\n", "print(f'Diagonal sum = {diag_sum}')\n", "assert valid == True, \"Error: expected function to return True\"\n", "print(\"Ok - passed this test\")\n", "\n", "# try a square with non-unique numbers\n", "list_2D = list_2D = [[0, 0, 2], [3, 15, 15], [8, 1, 6]]\n", "valid,diag_sum = diag_sums_equal(list_2D)\n", "print(f'Column sum = {diag_sum}')\n", "assert valid == False, \"Error: expected function to return False\"\n", "print(\"Ok - passed this test\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# Instructor Tests\n", "# Check that diag_sums_equal(list_2D) returns (True,diag sum) for square with equal diagonal sums and false otherwise" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "174abbf823f7585b07aa32dcc12835c1", "grade": true, "grade_id": "Q3_test_5", "locked": true, "points": 8, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### Points: 16 - is_magic_square(list_2D)\n", "\n", "**Q2.06**. Write and test the ```is_magic_square(list_2D)``` function as indicated in the instructions above.\n", "\n", "(**DO NOT split your solution across cells**. Your complete code should be in the indicated answer cell)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [], "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "67b4d9e92f18076eb9125a67a99d312d", "grade": false, "grade_id": "Q2_answer_6", "locked": false, "schema_version": 3, "solution": true, "task": false }, "tags": [] }, "outputs": [], "source": [ "#Q2.06 [DO NOT DELETE!]\n", "\n", "# YOUR CODE HERE\n", "raise NotImplementedError()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# test for your answer - Try a square with rows sums equal and unequal\n", "# YOUR CODE HERE\n", "# try a square with unique numbers\n", "list_2D = [[4, 9, 2], [3, 5, 7], [8, 1, 6]]\n", "valid,magic_sum = is_magic_square(list_2D)\n", "print(list_2D)\n", "print(f'Magic square = {valid}')\n", "print(f'Magic sum = {magic_sum}')\n", "assert valid == True, \"Error: expected function to return True\"\n", "print(\"Ok - passed this test\")\n", "print()\n", "\n", "# try a square with non-unique numbers\n", "list_2D = list_2D = [[0, 0, 2], [3, 15, 15], [8, 1, 6]]\n", "valid,magic_sum = is_magic_square(list_2D)\n", "print(list_2D)\n", "print(f'Magic square = {valid}')\n", "print(f'Magic sum = {magic_sum}')\n", "assert valid == False, \"Error: expected function to return False\"\n", "print(\"Ok - passed this test\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# Instructor Tests\n", "# Check that is_magic_square(list_2D) return True,Sum for valid square and False,None for invalid square\n", "# Check that is_magic_square(list_2D) calls the 5 boolean functions" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "d8d8d821920e958b148da98b4082b4dc", "grade": true, "grade_id": "Q2_test_6", "locked": true, "points": 8, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "54b3ac47209d3bcb58c8f338d6dfca53", "grade": true, "grade_id": "Q2_test_7", "locked": true, "points": 8, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [ 0 ], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "3a63e25e71bc528807b907d0de2783c2", "grade": true, "grade_id": "Q2_test_sumary", "locked": true, "points": 0, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### Points: 8 - main(list_2D)\n", "\n", "**Q3.01**. Test the ```main(list_2D)``` function (provided below for you) as indicated in the instructions above.\n", "\n", "Your ```main(filename)``` program should give the following output when run with the following files (the files have been provided to you):\n", "```\n", "main('valid_lo_shu.txt')\n", "Filename: valid_lo_shu.txt\n", "Result> Ok\n", "Result : Valid Magic Square! The sum = 15\n", "\n", "main('invalid_lo_shu_1.txt')\n", "Filename: invalid_lo_shu.txt\n", "Result> Ok\n", "Result : Not a valid magic square!\n", "```\n", "\n", "(**DO NOT split your solution across cells**. Your complete code should be in the indicated answer cell)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "tags": [] }, "outputs": [], "source": [ "#Q3.01 [DO NOT DELETE!]\n", "\n", "def main(filename):\n", " \n", " # read the square from the file called filename\n", " list_2D = read_square(filename)\n", " \n", " # check if it is a magic square\n", " valid, magic_sum = is_magic_square(list_2D)\n", " \n", " if valid:\n", " print(f'Result : Valid Magic Square! The sum = {magic_sum}')\n", " else:\n", " print(f'Result : Not a valid magic square!') " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# test for your answer - run the main() program for valid and invalid files\n", "# YOUR CODE HERE\n", "# try valid square file\n", "filename = 'valid_lo_shu.txt'\n", "main(filename)\n", "print()\n", "\n", "# try invalid square file\n", "filename = 'invalid_lo_shu.txt'\n", "main(filename)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# Instructor Tests\n", "# Check that main(filename) return the expected output" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "code_folding": [], "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "feba34afb0962eca08420d579b6d5bb8", "grade": true, "grade_id": "Q3_test_1", "locked": true, "points": 8, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "#\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] }, { "cell_type": "markdown", "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "markdown", "checksum": "341bee125d6ef7458f56a25fd03b7bc7", "grade": false, "grade_id": "Q4_style_check", "locked": true, "points": 12, "schema_version": 3, "solution": false, "task": true }, "tags": [] }, "source": [ "### Points: 12 - Style\n", "**Q4**. Manually graded. Is code well written, readable?" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "861b7f37d8e18e9c2c972896561a93b1", "grade": true, "grade_id": "Summary_points", "locked": true, "points": 0, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "outputs": [], "source": [ "\"\"\" This cell has the instructors test and is hidden - DO NOT copy/duplicate this cell\"\"\"" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.7" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "oldHeight": 122.85, "position": { "height": "174.85px", "left": "888.08px", "right": "20px", "top": "116px", "width": "225.72px" }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "varInspector_section_display": "block", "window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }