ILO CHARITY DATA SCIENCE CLASS E EXERCISE 3 2 (1).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4df91c8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# QUESTION 1 Write a program that finds the maximum value of the given list, assuming that the list contains at least one element.\n",
    "#Try your program with the following array\n",
    "#2 4 7 4 23 5 1 4 8 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "05c3e5f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 7, 4, 23, 5, 1, 4, 8, 9]\n",
      "maximum value is 23\n"
     ]
    }
   ],
   "source": [
    "# method 1 as a callable function\n",
    "\n",
    "#writing a function\n",
    "\n",
    "def largest_value(lst):\n",
    "    largest = lst[0]\n",
    "\n",
    "    for num in lst:\n",
    "        if num > largest:\n",
    "            largest = num\n",
    "    print(lst)\n",
    "    \n",
    "    print(\"maximum value is\", largest)\n",
    "    \n",
    "#trying out the program  \n",
    " \n",
    "interger_list = [2,4,7,4,23,5,1,4,8,9] \n",
    "\n",
    "largest_value(interger_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "fdf69eac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 7, 4, 23, 5, 1, 4, 8, 9]\n",
      "Maximum value is 23\n"
     ]
    }
   ],
   "source": [
    "#method 2\n",
    "\n",
    "#Given list\n",
    "\n",
    "interger_list = [2,4,7,4,23,5,1,4,8,9]\n",
    "print(interger_list)\n",
    "\n",
    "# finding the maximum value\n",
    "max_value = max(interger_list)\n",
    "\n",
    "# printing the result \n",
    "\n",
    "print(\"Maximum value is\", max_value)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63b603fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# QUESTION 2 Write a program that calculates the average value of the given list.\n",
    "#Try your program with the following list 4,7,1,5,11,53,12,46,84,23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c24c19ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "# method 1 as a callable function\n",
    "\n",
    "def Average_value(numbers):\n",
    "        \n",
    "        total = sum(numbers)\n",
    "        average = total/len(numbers)\n",
    "    \n",
    "        print(numbers)\n",
    "    \n",
    "        print(\"Average value is\", average)\n",
    "        \n",
    "#trying out the program  \n",
    "    \n",
    "Av_list = [4,7,1,5,11,53,12,46,84,23]\n",
    "\n",
    "Average_value(Av_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4496252d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 7, 1, 5, 11, 53, 12, 46, 84, 23]\n",
      "Average value is 24.6\n"
     ]
    }
   ],
   "source": [
    "#method 2\n",
    "\n",
    "#Given list\n",
    "\n",
    "Av_list = [4,7,1,5,11,53,12,46,84,23]\n",
    "print(Av_list)\n",
    "\n",
    "# finding the Average value\n",
    "Average_value = sum(Av_list)/len(Av_list)\n",
    "\n",
    "# printing the result \n",
    "\n",
    "print(\"Average value is\", Average_value)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa4d1faf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 3 Write a program that prints the given list of integers in reverse order.\n",
    "#Try your program with the following list 2,6,7,45,23,53,14,45,89,5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "6a956c1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The orginal list is [4, 7, 1, 5, 11, 53, 12, 46, 84, 23]\n",
      "The list is reverse order is [23, 84, 46, 12, 53, 11, 5, 1, 7, 4]\n"
     ]
    }
   ],
   "source": [
    "# method 1\n",
    "\n",
    "def list_reversal(lst):\n",
    "    print(\"The orginal list is\",lst)\n",
    "    \n",
    "# reversing the order\n",
    "    lst.reverse()\n",
    "\n",
    "# printing the result \n",
    "\n",
    "    print(\"The list is reverse order is\",lst)\n",
    "    \n",
    "#trying out the program\n",
    "order_list = [4,7,1,5,11,53,12,46,84,23]\n",
    "\n",
    "list_reversal(order_list)\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "d1067c72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The orginal list is [4, 7, 1, 5, 11, 53, 12, 46, 84, 23]\n",
      "The list is reverse order is [23, 84, 46, 12, 53, 11, 5, 1, 7, 4]\n"
     ]
    }
   ],
   "source": [
    "# method 2\n",
    "#Given list\n",
    "\n",
    "order_list = [4,7,1,5,11,53,12,46,84,23]\n",
    "print(\"The orginal list is\", order_list)\n",
    "\n",
    "# reversing the order\n",
    "order_list.reverse()\n",
    "\n",
    "# printing the result \n",
    "\n",
    "print(\"The list is reverse order is\", order_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ec0494c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# QUESTION 4 Write a program that accepts two lists of integers and prints true if each element in the first list is less than\n",
    "# the element at the same index in the second list. Your program should print false if the lists are not the same length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "6f332149",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True of same length\n",
      "False\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def list_comparism(lst1,lst2):\n",
    "    \n",
    "    if len(lst1) != len(lst2):  # this checks if they are of the same length\n",
    "        print(\"False not same length\")\n",
    "    else:\n",
    "        print(\"True of same length\")\n",
    "    \n",
    "    for elem in range(len(lst1)):  # this checks if each element in the first list is less than the element at the same index in the second list\n",
    "        if lst1[elem] < lst2[elem]:\n",
    "            print(\"True\")\n",
    "        else:\n",
    "            print(\"False\")\n",
    "\n",
    "    \n",
    "#trying out the program\n",
    "list1 = [4,7,1,5,11,53,12,46,84,23]\n",
    "list2 = [2,4,7,4,23,5,1,4,8,9]\n",
    "\n",
    "list_comparism(list1, list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9d77e38",
   "metadata": {},
   "outputs": [],
   "source": [
    "# QUESTION 5 Write a program that accepts a list of integers and two indexes and swaps the elements at those indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "b6eee77f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original list [4, 7, 1, 5, 11, 53, 12, 46, 84, 23]\n",
      "Enter first index to swap:5\n",
      "Enter second index to swap:4\n",
      "original value at index 53 11\n",
      "Swapped list is [4, 7, 1, 5, 53, 11, 12, 46, 84, 23]\n"
     ]
    }
   ],
   "source": [
    "#method 1\n",
    "def indexSwap(lst):\n",
    "    print(\"original list\", lst)\n",
    "    \n",
    "    #This allows the user to interact with the program by inputing index\n",
    "    \n",
    "    index1 = int(input(\"Enter first index to swap:\"))  \n",
    "    index2 = int(input(\"Enter second index to swap:\"))\n",
    "    \n",
    "    # this tries to notify user when inputed index is invalid or out of range\n",
    "    \n",
    "    if index1 and index2 > len(lst):\n",
    "        print(\"out of range\")            \n",
    "    else:\n",
    "        print(\"original value at index\", lst[index1],lst[index2])\n",
    "\n",
    "    # Carrying out the swap\n",
    "    \n",
    "    lst[index1],lst[index2] = lst[index2],lst[index1]\n",
    "    print(\"Swapped list is\", lst)\n",
    "    \n",
    "# trying out the code\n",
    "\n",
    "swaplist = [4,7,1,5,11,53,12,46,84,23]\n",
    "indexSwap(swaplist)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67325c5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# QUESTION 6 Write a program that accepts two lists of integers and prints a new list containing all elements of the first \n",
    "#list followed by all elements of the second."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "a4058c99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 7, 1, 5, 11, 53, 12, 46, 84, 23]\n",
      "[2, 4, 7, 4, 23, 5, 1, 4, 8, 9]\n",
      "The new merged list is\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[4, 7, 1, 5, 11, 53, 12, 46, 84, 23, 2, 4, 7, 4, 23, 5, 1, 4, 8, 9]"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " def combined_list(lst1, lst2):\n",
    "        print(lst1)\n",
    "        print(lst2)\n",
    "        new_list = lst1 + lst2\n",
    "        print(\"The new merged list is\")\n",
    "        return new_list\n",
    "    \n",
    "#trying the code\n",
    "list1 = [4,7,1,5,11,53,12,46,84,23]\n",
    "list2 = [2,4,7,4,23,5,1,4,8,9]\n",
    "\n",
    "combined_list(list1,list2)\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81778b7c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93af43a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#QUESTIN 8 Write a program that prints the range of values in a list of integers.The range is defined as 1 more than the\n",
    "#difference between the maximum and minimum values in the list. For example, if a list contains the values \n",
    "#[36, 12, 25, 19, 46, 31, 22], the program should return 35. You may assume that the list has at least one element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "31f650a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximium value is 46\n",
      "minimum value is 12\n",
      "The range of value is 35\n"
     ]
    }
   ],
   "source": [
    "#method 1 as a function\n",
    "\n",
    "def range_value(lst):\n",
    "    maximum_value = max(lst)\n",
    "    print(\"maximium value is\", maximum_value)\n",
    "        \n",
    "    minimun_value = min(lst)\n",
    "    print(\"minimum value is\",minimun_value)\n",
    "    \n",
    "    value = (maximum_value - minimun_value) + 1\n",
    "    print(\"The range of value is\", value)\n",
    "    \n",
    "# trying out the program\n",
    "rangeLIST = [36, 12, 25, 19, 46, 31, 22]\n",
    "range_value(rangeLIST)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "37b54946",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximium value is 46\n",
      "minimum value is 12\n",
      "The range of value is 35\n"
     ]
    }
   ],
   "source": [
    "#method 2\n",
    "\n",
    "#given List\n",
    "\n",
    "rangeLIST = [36, 12, 25, 19, 46, 31, 22]\n",
    "maximum_value = max(rangeLIST)\n",
    "print(\"maximium value is\", maximum_value)\n",
    "        \n",
    "minimun_value = min(rangeLIST)\n",
    "print(\"minimum value is\",minimun_value)\n",
    "\n",
    "# carrying out the operation\n",
    "    \n",
    "range_value = (maximum_value - minimun_value) + 1\n",
    "print(\"The range of value is\", range_value)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7085caa5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# QUESTION 9 Write a program that accepts a list of integers, a minimum value, and a maximum value and prints the count of how \n",
    "#many elements from the list fall between the minimum and maximum (inclusive). For example, in the list [14, 1, 22, 17, 36, \n",
    "#7, -43, 5], for minimum value 4 and maximum value 17, there are four elements whose values fall between 4 and 17."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "33d95994",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a maximium number of choice:17\n",
      "Enter a minimun number of choice4\n",
      "There are 1 elements whose values fall between 4 and 17\n",
      "There are 1 elements whose values fall between 4 and 17\n",
      "There are 1 elements whose values fall between 4 and 17\n",
      "There are 2 elements whose values fall between 4 and 17\n",
      "There are 2 elements whose values fall between 4 and 17\n",
      "There are 3 elements whose values fall between 4 and 17\n",
      "There are 3 elements whose values fall between 4 and 17\n",
      "There are 4 elements whose values fall between 4 and 17\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def appearance_count(lst):\n",
    "    maxValue = int(input(\"Enter a maximium number of choice:\"))\n",
    "    minValue = int(input(\"Enter a minimun number of choice\"))\n",
    "    count = 0\n",
    "    \n",
    "    for elem in (lst):\n",
    "        if minValue <= elem <= maxValue:\n",
    "            count += 1\n",
    "        print(\"There are\", count,\"elements whose values fall between\", minValue, \"and\", maxValue)\n",
    "    \n",
    "#trying out the code\n",
    "elementlist = [14, 1, 22, 17, 36, 7, -43, 5]\n",
    "appearance_count(elementlist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "93b506a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 1 elements whose values fall between 4 and 17\n",
      "There are 1 elements whose values fall between 4 and 17\n",
      "There are 1 elements whose values fall between 4 and 17\n",
      "There are 2 elements whose values fall between 4 and 17\n",
      "There are 2 elements whose values fall between 4 and 17\n",
      "There are 3 elements whose values fall between 4 and 17\n",
      "There are 3 elements whose values fall between 4 and 17\n",
      "There are 4 elements whose values fall between 4 and 17\n"
     ]
    }
   ],
   "source": [
    "# method 2\n",
    "\n",
    "def appearance_count(lst, maxValue, minValue):\n",
    "    count = 0\n",
    "\n",
    "    for elem in (lst):\n",
    "        if minValue <= elem <= maxValue:\n",
    "            count += 1\n",
    "        print(\"There are\", count,\"elements whose values fall between\", minValue, \"and\", maxValue)\n",
    "    \n",
    "#trying out the code\n",
    "elementlist = [14, 1, 22, 17, 36, 7, -43, 5]\n",
    "appearance_count(elementlist, 17,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64954fd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# QUESTION 10 Write a program that accepts a list of real numbers and prints true if the list is in sorted (nondecreasing) order\n",
    "#and false otherwise. For example, if lists named list1 and list2 store [16.1, 12.3, 22.2, 14.4] and \n",
    "#[1.5, 4.3, 7.0, 19.5, 25.1, 46.2] respectively, the program should print false for list1 and true for list2 respectively.\n",
    "#Assume the list has at least one element. A one-element list is sorted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "a3ba2fa5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# method 1\n",
    "numlist1 = [16.1, 12.3, 22.2, 14.4]\n",
    "numlist2 = [1.5, 4.3, 7.0, 19.5, 25.1, 46.2]\n",
    "if numlist1 == sorted(numlist1):\n",
    "    print(\"True\")\n",
    "else:\n",
    "    print(\"false\")\n",
    "    \n",
    "if numlist2 == sorted(numlist2):\n",
    "    print(\"True\")\n",
    "else:\n",
    "    print(\"false\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "b31af6ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[16.1, 12.3, 22.2, 14.4]\n",
      "false\n",
      "[1.5, 4.3, 7.0, 19.5, 25.1, 46.2]\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# method 2 as a function\n",
    "\n",
    "def is_it_sorted(lst):\n",
    "    print(lst)\n",
    "    if lst == sorted(lst):\n",
    "        print(\"True\")\n",
    "    else:\n",
    "        print(\"false\")\n",
    "\n",
    "# trying the program\n",
    "numlist1 = [16.1, 12.3, 22.2, 14.4]\n",
    "numlist2 = [1.5, 4.3, 7.0, 19.5, 25.1, 46.2]\n",
    "\n",
    "is_it_sorted(numlist1)\n",
    "is_it_sorted(numlist2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a96ea7e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}