06_Workshop6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Workshop 7 Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">Read and examine the text below and then answer the 8 questions that follow. Note: not all of the answers require a coded solution</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parity of a number <i>(is not the same as the value)</i>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you store binary data or send information over a communication line, some errors might occur.  A simple method for detecting errors is based on parity.  Usually the data is divided into relatively short sequences of bits, called codewords or packets.  \n",
    "\n",
    "The term parity refers to the evenness or oddness of the number of bits set to ‘1’ in a packet.  If this number is even, we say that the packet has even parity; otherwise we say it has odd parity.\n",
    "\n",
    "When a chunk of data is transmitted, the transmitter computes the parity of data and adds one bit (called parity bit), so that the total parity of the packet including the parity bit is even.  Then, if the receiver gets a packet with odd parity, it reports an error.  (The transmitter and receiver may “agree” to use odd parity instead of even parity.)  When parity is used, all data packets usually have the same length.  For example, seven data bits plus one parity bit or 31 data bits plus one parity bit.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Example 1:</b><br>\n",
    "The following sequence of seven-bit codes encodes the word “parity” in ASCII:\n",
    "<code>\n",
    "\t1110000 1100001 1110010 1101001 1110100 1111001\n",
    "</code>\n",
    "We want to add a parity bit to each code so that it gets even parity.  What are the resulting eight-bit packets?\n",
    "\n",
    "<b>Solution:</b>\n",
    "<code>\n",
    "\t1110000<font color=\"red\"><b>1</b></font> 1100001<font color=\"red\"><b>1</b></font> 1110010<font color=\"red\"><b>0</b></font> 1101001<font color=\"red\"><b>0</b></font> 1110100<font color=\"red\"><b>0</b></font> 1111001<font color=\"red\"><b>1</b></font>\n",
    "</code>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can happen, of course, that two errors occur in the same packet — two bits are flipped from 0 to 1 or from 1 to 0.  Then the parity of the packet remains unchanged, and the error goes undetected.  The parity method relies on the assumption that the likelihood of two errors in the same packet is really low.  If errors are frequent, then a small number of bits require a parity bit for error checking.  The more reliable a communication channel or a storage system is, the longer the data packets that can be used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we swap two consecutive bits in a data packet, its parity does not change.  Luckily such transposition errors are very rare when the packet is generated by a computer or another device.  Not so with us humans.  When we type words or numbers, transposition errors are common.  So parity-type error detection does not work well when humans are involved.  For example, when a cashier gives up on the scanner that cannot read the UPC from a crumpled bag of chips, he enters it manually.  The cashier may mistype a digit or transpose two digits.  There must be a mechanism that detects such errors.  Such a mechanism uses checksums and check digits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Example 2:</b><br>\n",
    "Driver’s licenses on the island of Azkaban have six digits.  The sixth digit is the check digit: it is calculated as follows: we add up the first five digits, take the resulting sum modulo 10 (the remainder when the sum is divided by 10), and subtract that number from 10.  For example, if the first five digits of a driver’s license are 95873, the check digit is 10 - ((9 + 5 + 8 + 7 + 3) mod 10) = 10 - (32 mod 10) = 10 - 2 = 8.  So 958738 is a valid driver’s license number on Azkaban.  Note that if we add all six digits and take the result modulo 10, we get 0.  Does this system detect all single-digit substitution errors? All transposition errors?\n",
    "\n",
    "<b>Solution:</b><br>\n",
    "This system detects all single-digit substitution errors, because if you change one digit, the sum of the digits modulo 10 is no longer 0.  However, the sum does not depend on the order of digits, so transposition errors are not detected.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "Now try to write the Python code to answer the following questions in the cells below. <i>You may use Python built-in or library functions that might help but <b>not</b> third-party libraries such as Numpy.</i> </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"red\"><b>1.</b></font> Which of the following bit packets have even parity? Odd parity? \n",
    "(a) 01100010<br> \n",
    "(b) 11010111<br> \n",
    "(c) 10110001<br> \n",
    "(d) 11100001<br>"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "(a) odd parity as total numbe rof 1 is 3, which is an odd number.\n",
    "(b) even parity as total numbe rof 1 is 6, which is an even number.\n",
    "(c) even parity as total numbe rof 1 is 4, which is an even number.\n",
    "(d) even parity as total numbe rof 1 is 4, which is an even number."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"red\"><b>2.</b></font> How many bytes (all possible eight-bit combinations of 0s and 1s) have even parity? Odd parity? "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "even parity - 128\n",
    "odd parity - 127 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"red\"><b>3.</b></font> Write and test a Python function, call it <i>parityCheck</i>, that takes a string of binary digits and returns its parity  <font color=\"blue\"><i>(as an integer, 0 for even, 1 for odd).</i></font> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def parityCheck(st): # calling a function parityCheck.\n",
    "    count = 0  # initializing a variable count to 0.\n",
    "    for d in st: # for loop to iterate through the string st.\n",
    "        if d=='1': # if statement to check if the character is 1.\n",
    "             count+=1 # if the character is 1, count will be incremented by 1.\n",
    "    return count %2 # return the value of count modulo 2.\n",
    "parityCheck('110101001') # calling the function parityCheck with the string 110101001."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"red\"><b>4.</b></font> Consider the following table of binary digits:\n",
    "<code>\n",
    "\n",
    "    0 1 1 0 1 1\n",
    "\n",
    "    1 0 0 0 1 0\n",
    "\n",
    "    1 0 1 0 0 1\n",
    "    \n",
    "    0 1 0 1 0 0\n",
    "</code>\n",
    "    \n",
    "<b>It was supposed to have even parity in all rows and all columns, but an error occurred and one bit got flipped. Which one?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "In second row and in third column there is an error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"red\"><b>5.</b></font> The UPC (Universal Product Code) barcode has 12 decimal digits. The checksum is calculated as follows: we take the sum of all the digits in odd positions, starting from the left (first, third, fifth, etc.), multiply it by 3, then add the sum of all the digits in even positions (second, fourth, etc.). In a valid UPC, the checksum must be evenly divisible by 10. For example, 072043000187 is a valid UPC, because , which is evenly divisible by 10. Write and test a Python function isValidUPC(s) that takes a string of 12 digits and returns True if it represents a valid UPC; otherwise it returns False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def isValidUPC(s): #calling a function .\n",
    "    odd=0 # initializing a variable odd to 0.\n",
    "    even=0 # initializing a variable even to 0.\n",
    "    for i in range(0,len(s),2): # using for loop. \n",
    "        odd+=int(s[i]) # incrementing odd by the value of the character at index i.\n",
    "    sum_odd=odd*3 # sum_odd is equal to odd multiplied by 3.\n",
    "    for j in range(1,len(s),2): #using for loop.\n",
    "        even+=int(s[j]) # incrementing even by the value of the character at index j.\n",
    "    if(sum_odd+even)%10==0: # if statement to check if the sum of odd and even is divisible by 10.\n",
    "        return True # return True.\n",
    "    else: # else statement. \n",
    "        return False # return False.     \n",
    "isValidUPC('072043000187') # calling the function isValidUPC with the string 072043000187."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"red\"><b>6.</b></font> Write and test a Python function correctError(t), which takes a table, such as described in Question 4 (but not necessarily 4 by 6), with a possible single-bit error, checks whether it has an error, and, if so, corrects it. The table t is represented as a list of its rows; each row is represented as a string of 0s and 1s (all the strings have the same length). For example, the table from Question 4 would be represented as</b>\n",
    "<code>\n",
    "    ['011011', '100010', '101001', '010100']\n",
    "</code>\n",
    "<br><b>Hint: It might be simpler to keep the sting data as strings, you can also use the answer to question 3 and some of what you have learned in previous workshops for this one</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['011011', '100010', '101001', '010100']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def correctError(t): #calling a function correctError.\n",
    "    row=column=-1 #initializing row and column to -1.\n",
    "    for i in range(len(t)): #using for loop.\n",
    "        if parityCheck(t[i])=='1': #using if statement to check if the parityCheck is 1.\n",
    "            row=i #if it is 1, row will be i.\n",
    "    print(row) #printing row.\n",
    "    for j in range(len(t[0])): #using for loop to check column.\n",
    "        count=0 #initializing count to 0.\n",
    "    for k in range(len(t)): #using for loop to check row.\n",
    "        if t[k][j]=='1': #using if statement to check if the t[k][j] is 1.\n",
    "            count+=1 #if it is 1, count will be 1.\n",
    "        if count%2==1: #using if statement to check if the count is 1.\n",
    "            column=j #if it is 1, column will be j.\n",
    "    if row>=0 and column>=0: #using if statement to check if row and column are greater than or equal to 0.\n",
    "        if t[row][column]=='0': #using if statement to check if the t[row][column] is 0.\n",
    "            t[row]=t[row][:column]+'1'+t[row][column+1:] #if it is 0, t[row] will be t[row][:column]+'1'+t[row][column+1:].\n",
    "        else: #if it is not 0.\n",
    "            t[row]=t[row][:column]+'0'+t[row][column+1:] #t[row] will be t[row][:column]+'0'+t[row][column+1:].\n",
    "    return t #returning t.\n",
    "\n",
    "b=['011011', '100010', '101001', '010100'] #initializing b to ['011011', '100010', '101001', '010100'].\n",
    "correctError(b) #calling correctError function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Downloading your workbook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please note even if you are Jupyter on your computer (ie. not on a network) the Jupyter notebook runs as a server, so you are editing and running a file that is not easily accessed on your filing system. So to obtain your workbook (to use on a different computer or upload as an assignment, etc.) it must be downloaded to your file system. To do this..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">Goto the <b>\"File\"</b> menu and select the <b>\"Download as\"</b> item. You can then select <b>\"notebook (ipynb)\"</b> to download.</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}