20241037_MashrurSafirShabab_06_CSE110 Assignment06 (Sorting).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oMYzsTcnHEll"
   },
   "source": [
    "# CSE110 Assignment 6\n",
    "\n",
    "\n",
    "## Write the Python code of the following problems:\n",
    "**<font color='red'>[MUST MAINTAIN VARIABLE NAMING CONVENTIONS FOR ALL THE TASKS]</font>**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jT-t2zlnHEll"
   },
   "source": [
    "### Task 1\n",
    "\n",
    "Given a list named my_list. <br/>\n",
    "my_list=[10,1,20,3,6,2,5,11,15,2,12,14,17,18,29] <br/>\n",
    "Now use bubble sort to sort my_list into ascending order.\n",
    "\n",
    "**Output**<br/>\n",
    "[1, 2, 2, 3, 5, 6, 10, 11, 12, 14, 15, 17, 18, 20, 29]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "executionInfo": {
     "elapsed": 3026,
     "status": "ok",
     "timestamp": 1607519486474,
     "user": {
      "displayName": "Nadia Rubaiyat",
      "photoUrl": "",
      "userId": "06231355892473397655"
     },
     "user_tz": -360
    },
    "id": "7qXVakLgHElm"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 2, 3, 5, 6, 10, 11, 12, 14, 15, 17, 18, 20, 29]\n"
     ]
    }
   ],
   "source": [
    "my_list=[10,1,20,3,6,2,5,11,15,2,12,14,17,18,29] \n",
    "length = len(my_list)\n",
    "\n",
    "for i in range (0,length) :\n",
    "    for j in range (0,length-1-i) :\n",
    "        if my_list[j] > my_list[j+1] :\n",
    "            temp = my_list[j]\n",
    "            my_list[j] = my_list[j+1]\n",
    "            my_list[j+1] = temp\n",
    "\n",
    "print (my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w1QgeWd2HElp"
   },
   "source": [
    "### Task 2\n",
    "\n",
    "Given a list named my_list. <br/>\n",
    "my_list=[10,1,20,3,6,2,5,11,15,2,12,14,17,18,29] <br/>\n",
    "Now use selection sort to sort my_list into ascending order.\n",
    "\n",
    "**Output**<br/>\n",
    "[1, 2, 2, 3, 5, 6, 10, 11, 12, 14, 15, 17, 18, 20, 29]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "executionInfo": {
     "elapsed": 2243,
     "status": "ok",
     "timestamp": 1607519505131,
     "user": {
      "displayName": "Nadia Rubaiyat",
      "photoUrl": "",
      "userId": "06231355892473397655"
     },
     "user_tz": -360
    },
    "id": "am0B_8ICHElq"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 2, 3, 5, 6, 10, 11, 12, 14, 15, 17, 18, 20, 29]\n"
     ]
    }
   ],
   "source": [
    "my_list=[10,1,20,3,6,2,5,11,15,2,12,14,17,18,29] \n",
    "length = len(my_list)\n",
    "\n",
    "for i in range (length) :\n",
    "    min_value = my_list[i]\n",
    "    min_index = i\n",
    "    for j in range (i,length) :\n",
    "        if min_value > my_list[j] :\n",
    "            min_value = my_list[j]\n",
    "            min_index = j\n",
    "    temp = my_list[i]\n",
    "    my_list[i] = my_list[min_index]\n",
    "    my_list[min_index] = temp\n",
    "\n",
    "print (my_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "j4ffr2CAHElt"
   },
   "source": [
    "### Task  3\n",
    "\n",
    "Given a list named my_list. <br/>\n",
    "my_list=[10,1,20,3,6,2,5,11,15,2,12,14,17,18,29] <br/>\n",
    "Now use any of the two sorts used above to sort the list in descending order.\n",
    "\n",
    "**Output**<br/>\n",
    "[29, 20, 18, 17, 15, 14, 12, 11, 10, 6, 5, 3, 2, 2, 1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "n2X3YR-_HElt"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[29, 20, 18, 17, 15, 14, 12, 11, 10, 6, 5, 3, 2, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "my_list=[10,1,20,3,6,2,5,11,15,2,12,14,17,18,29] \n",
    "length = len(my_list)\n",
    "\n",
    "for i in range (length) :\n",
    "    min_value = my_list[i]\n",
    "    min_index = i\n",
    "    for j in range (i,length) :\n",
    "        if min_value < my_list[j] :\n",
    "            min_value = my_list[j]\n",
    "            min_index = j\n",
    "    temp = my_list[i]\n",
    "    my_list[i] = my_list[min_index]\n",
    "    my_list[min_index] = temp\n",
    "\n",
    "print (my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9iYiiTWWHElw"
   },
   "source": [
    "### Task 4\n",
    "\n",
    "Suppose you have a sitting arrangement of the students of the final exam in a list. The list contains the last two digits of their roll number.<br/>\n",
    "\n",
    "sitting_list=[10,30,20,70,11,15,22,16,58,100,12,56,70,80] <br/>\n",
    "\n",
    "Now you want to organize the sitting arrangement. You decided to sort all the students in the even indices into ascending order and all the students in the odd indices  into descending order.  <br/>\n",
    "\n",
    "So write a python program that organizes the list for you the way you decided.<br/>\n",
    "\n",
    "\n",
    "**Sample Output**<br/>\n",
    "[10, 100, 11, 80, 12, 70, 20, 56, 22, 30, 58, 16, 70, 15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "nPdUAKDJHElw"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "even list : [10, 11, 12, 20, 22, 58, 70]\n",
      "odd list : [100, 80, 70, 56, 30, 16, 15]\n",
      "desired output : [10, 100, 11, 80, 12, 70, 20, 56, 22, 30, 58, 16, 70, 15]\n"
     ]
    }
   ],
   "source": [
    "sitting_list = [10,30,20,70,11,15,22,16,58,100,12,56,70,80] \n",
    "even_list = []\n",
    "odd_list = []\n",
    "\n",
    "for index in range (len(sitting_list)) :\n",
    "    if index%2 == 0 :\n",
    "        even_list.append(sitting_list[index])\n",
    "    else :\n",
    "        odd_list.append(sitting_list[index])\n",
    "    \n",
    "even_list.sort()\n",
    "print ('even list :',even_list)\n",
    "odd_list.sort(reverse = True)\n",
    "print ('odd list :',odd_list)\n",
    "\n",
    "notun_list = []\n",
    "for index in range (len(even_list)) :\n",
    "    notun_list.append(even_list[index])\n",
    "    notun_list.append(odd_list[index])\n",
    "print ('desired output :',notun_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oVR1Tsa0HElz"
   },
   "source": [
    "### Task 5\n",
    "\n",
    "Suppose a list contains the final exam results of CSE110, PHY111, and MAT110 of each student in a listed form. Your task is to sort the list based on a course name that will be given by the user and print the names after sorting. <br/>\n",
    "\n",
    "For example, a list looks like <br/>\n",
    "lst = [ [\"Farzad\",95,87,91] , [\"Mahjabin\",92,90,83], [\"Sadman\",87,92,80], [\"Nakhla\",85,94,90] ] <br/>\n",
    "where for each list, 1st index is name, 2nd index is CSE110, 3rd index is PHY111 and 4th index is MAT110. \n",
    "\n",
    "=====================================================\n",
    "\n",
    "**Hint:**<br/>\n",
    "create a function for sorting, then call it everytime instead of rewriting the code.\n",
    "\n",
    "Get the data in the individual lists from the given nested list.\n",
    "\n",
    "=====================================================\n",
    "\n",
    "**Sample Input**<br/>\n",
    "MAT110\n",
    "\n",
    "**Sample Output**<br/>\n",
    "Farzad <br/>\n",
    "Nakhla <br/>\n",
    "Mahjabin <br/>\n",
    "Sadman\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "539b2P1NHElz"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Course_name : MAT110\n",
      "[['Farzad', 95, 87, 91], ['Nakhla', 85, 94, 90], ['Mahjabin', 92, 90, 83], ['Sadman', 87, 92, 80]]\n",
      "Farzad\n",
      "Nakhla\n",
      "Mahjabin\n",
      "Sadman\n"
     ]
    }
   ],
   "source": [
    "my_list = [ [\"Farzad\",95,87,91] , [\"Mahjabin\",92,90,83], [\"Sadman\",87,92,80], [\"Nakhla\",85,94,90] ] \n",
    "course_name = input('Course_name : ')\n",
    "Course_index = None\n",
    "if course_name == 'CSE110':\n",
    "    course_index = 1\n",
    "elif course_name == 'PHY111':\n",
    "    course_index = 2\n",
    "elif course_name == 'MAT110':\n",
    "    course_index = 3\n",
    "\n",
    "for outer_index in range (len(my_list)-1):\n",
    "    max_value = my_list[outer_index][course_index]\n",
    "    max_index = outer_index\n",
    "    max_list = my_list[outer_index]\n",
    "\n",
    "    for inner_index in range(outer_index+1,len(my_list)):\n",
    "        if my_list[inner_index][course_index] > max_value:\n",
    "            max_value = my_list[inner_index][course_index]\n",
    "            max_index = inner_index\n",
    "            max_list = my_list[inner_index]\n",
    "\n",
    "    temp = max_list\n",
    "    my_list[max_index] = my_list[outer_index] \n",
    "    my_list[outer_index] = temp\n",
    "\n",
    "print (my_list)\n",
    "for index in my_list:\n",
    "    print (index[0])\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B0Rqbyi4HEl2"
   },
   "source": [
    "### Task 6\n",
    "\n",
    "Suppose you have a list named my_list. Your task is to sort the list and print the count of numbers that have changed their position. <br/>\n",
    "my_list = [4,2,3,1,6,5] <br/>\n",
    "Sorted list would be [1,2,3,4,5,6] where 4 numbers have changed their position.\n",
    "\n",
    "\n",
    "**Sample Output**<br/>\n",
    "4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "AMc8jAa7HEl2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "my_list = [4,2,3,1,6,5] \n",
    "count = 0\n",
    "length = len(my_list)\n",
    "\n",
    "for i in range (length) :\n",
    "    min_value = my_list[i]\n",
    "    min_index = i\n",
    "    old_index = i\n",
    "    for j in range (i,length) :\n",
    "        if min_value > my_list[j] :\n",
    "            min_value = my_list[j]\n",
    "            min_index = j\n",
    "    if min_index != old_index :\n",
    "        temp = my_list[i]\n",
    "        my_list [i] = my_list[min_index]\n",
    "        my_list[min_index] = temp\n",
    "        count += 2\n",
    "\n",
    "print (count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iIH5n0sJHEl5"
   },
   "source": [
    "### Task 7\n",
    "\n",
    "Write a python program that takes two lists from the user, merges the two lists, sorts the list, and find the median of the elements of the two lists.\n",
    "\n",
    "=====================================================\n",
    "\n",
    "\n",
    "**Sample Input 1**<br/>\n",
    "list_one = [1,2,1,4] <br/>\n",
    "list_two = [5,4,1]\n",
    "\n",
    "\n",
    "**Sample Output 1**<br/>\n",
    "Sorted list = [1, 1, 1, 2, 4, 4, 5] <br/>\n",
    "Median = 2\n",
    "\n",
    "=====================================================\n",
    "\n",
    "\n",
    "**Sample Input 2**<br/>\n",
    "list_one= [1,7,9,10] <br/>\n",
    "list_two= [2,7,6,5]\n",
    "\n",
    "\n",
    "**Sample Output 2**<br/>\n",
    "Sorted list=[1, 2, 5, 6, 7, 7, 9, 10] <br/>\n",
    "Median=6.5\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "KsFxC7XbHEl6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no. of elements in list_one : 4\n",
      "elements : 1\n",
      "elements : 2\n",
      "elements : 1\n",
      "elements : 4\n",
      "no. of elements in list_two :3\n",
      "elements : 5\n",
      "elements : 4\n",
      "elements : 1\n",
      "Sorted list =  [1, 1, 1, 2, 4, 4, 5]\n",
      "Median =  2\n"
     ]
    }
   ],
   "source": [
    "list_one = []\n",
    "list_two = []\n",
    "size1 = int(input('no. of elements in list_one : '))\n",
    "for index in range (size1) :\n",
    "    list1 = int(input('elements : '))\n",
    "    list_one.append(list1)\n",
    "size2 = int(input('no. of elements in list_two :'))\n",
    "for index in range (size2) :\n",
    "    list2 = int(input('elements : '))\n",
    "    list_two.append(list2)\n",
    "\n",
    "new_list = list_one + list_two\n",
    "new_list.sort()\n",
    "print ('Sorted list = ',new_list)\n",
    "\n",
    "if len(new_list)%2 == 0 :\n",
    "    median = ( (new_list[(len(new_list)//2)-1]) + (new_list[(len(new_list)//2)]) ) / 2\n",
    "else :\n",
    "    median = new_list[len(new_list)//2]\n",
    "\n",
    "print ('Median = ',median)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-XKiwBR1HEl8"
   },
   "source": [
    "### Task 8\n",
    "\n",
    "\n",
    "Write a python program that takes a list from user containing both positive and negative numbers. The program then finds two pairs of values whose summation is closest to zero.\n",
    "\n",
    "=====================================================\n",
    "\n",
    "**Sample Input 1**<br/>\n",
    "list_one = [-10,15,2,4,-4,7,-8] \n",
    "\n",
    "\n",
    "**Sample Output 1**<br/>\n",
    "Two pairs which have the smallest sum = 4 and -4\n",
    "\n",
    "=====================================================\n",
    "\n",
    "\n",
    "**Sample Input 2**<br/>\n",
    "list_one = [1,-8,4,-7,-20,26,70,-85]\n",
    "\n",
    "\n",
    "**Sample Output 2**<br/>\n",
    "Two pairs which have the smallest sum = 4 and -7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "size : 8\n",
      "1\n",
      "-8\n",
      "4\n",
      "-7\n",
      "-20\n",
      "26\n",
      "70\n",
      "-85\n",
      "Two pairs which have the smallest sum = 4 and -7\n"
     ]
    }
   ],
   "source": [
    "list_one = []\n",
    "list1 = int(input('size : '))\n",
    "for index in range (list1) :\n",
    "    list_a = int(input())\n",
    "    list_one.append(list_a)\n",
    "\n",
    "minimum_first = ''\n",
    "minimum_last = ''\n",
    "minimum_sum = abs(list_one[0] + list_one[1])\n",
    "for i in range (len(list_one)-1) :\n",
    "    for j in range (i+1,len(list_one)) :\n",
    "        if minimum_sum > abs(list_one[i] + list_one[j]) :\n",
    "            minimum_sum = abs(list_one[i] + list_one[j])\n",
    "            minimum_first = list_one[i]\n",
    "            minimum_last = list_one[j]\n",
    "\n",
    "print ('Two pairs which have the smallest sum =',minimum_first,'and',minimum_last)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "CSE110 Assignment06 (Sorting).ipynb",
   "provenance": []
  },
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}