programming_assignment_advance_17.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f26e72d4",
   "metadata": {},
   "source": [
    "#Question : 01\n",
    "\n",
    "Create a function that transposes a 2D matrix.\n",
    "\n",
    "Examples\n",
    "\n",
    "\n",
    "transpose_matrix([\n",
    "[1, 1, 1],\n",
    "\n",
    "[2, 2, 2],\n",
    "\n",
    "[3, 3, 3]\n",
    "\n",
    "\n",
    "]) ➞ [\n",
    "\n",
    "[1, 2, 3],\n",
    "\n",
    "\n",
    "[1, 2, 3],\n",
    "\n",
    "[1, 2, 3]\n",
    "\n",
    "]\n",
    "\n",
    "transpose_matrix([\n",
    "\n",
    "[5, 5],\n",
    "\n",
    "[6, 7],\n",
    "\n",
    "[9, 1]\n",
    "\n",
    "]) ➞ [\n",
    "\n",
    "[5, 6, 9],\n",
    "\n",
    "[5, 7, 1]\n",
    "\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "1aae639d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#code\n",
    "def transpose_matrix(value):\n",
    "    for i in range(len(value)):\n",
    "        for j in range(i+1,len(value[i])):\n",
    "            value[i][j],value[j][i] = value[j][i],value[i][j]\n",
    "    return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "972cbf18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [1, 2, 3], [1, 2, 3]]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "transpose_matrix([ [1, 1, 1],[2, 2, 2],[3, 3, 3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "ba8875c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[5, 6], [5, 7], [9, 1]]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "transpose_matrix([[5, 5],[6, 7],[9, 1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edff65fc",
   "metadata": {},
   "source": [
    "#Question : 02\n",
    "\n",
    "Create a function that determines whether a string is a valid hex code.\n",
    "A hex code must begin with a pound key # and is exactly 6 characters in\n",
    "length. Each character must be a digit from 0-9 or an alphabetic character\n",
    "from A-F. All alphabetic characters may be uppercase or lowercase.\n",
    "\n",
    "Examples\n",
    "\n",
    "is_valid_hex_code(\"#CD5C5C\") ➞ True\n",
    "\n",
    "is_valid_hex_code(\"#EAECEE\") ➞ True\n",
    "\n",
    "is_valid_hex_code(\"#eaecee\") ➞ True\n",
    "\n",
    "is_valid_hex_code(\"#CD5C58C\") ➞ False\n",
    "\n",
    "* Length exceeds 6\n",
    "\n",
    "is_valid_hex_code(\"#CD5C5Z\") ➞ False\n",
    "\n",
    "\n",
    "* Not all alphabetic characters in A-F\n",
    "\n",
    "is_valid_hex_code(\"#CD5C&amp;C\") ➞ False\n",
    "\n",
    "* Contains unacceptable character\n",
    "\n",
    "is_valid_hex_code(\"CD5C5C\") ➞ False\n",
    "\n",
    "# Missing #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "a397f011",
   "metadata": {},
   "outputs": [],
   "source": [
    "#code\n",
    "def is_valid_hex_code(value):\n",
    "    check=\"#1234567890AaBbCcDdEeFf\"\n",
    "    if len(value)<1 or len(value)>7 or value[0] != \"#\":\n",
    "        return False\n",
    "    for i in value:\n",
    "        if i not in check:\n",
    "            return False\n",
    "    else:\n",
    "        return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "55180793",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_valid_hex_code(\"#CD5C5C\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "0a4d12b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_valid_hex_code(\"#EAECEE\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "ec554a33",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_valid_hex_code(\"#eaecee\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "480e9579",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_valid_hex_code(\"#CD5C58C\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "0ddc3df1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_valid_hex_code(\"#CD5C5Z\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "0b6d0ffb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_valid_hex_code(\"#CD5C&C\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "654e7b1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_valid_hex_code(\"CD5C5C\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ca4d316",
   "metadata": {},
   "source": [
    "#Question : 03\n",
    "\n",
    "Given a list of math equations (given as strings), return the percentage of\n",
    "correct answers as a string. Round to the nearest whole number.\n",
    "\n",
    "Examples\n",
    "\n",
    "mark_maths([\"2+2=4\", \"3+2=5\", \"10-3=3\", \"5+5=10\"]) ➞ \"75%\"\n",
    "\n",
    "mark_maths([\"1-2=-2\"]), \"0%\"\n",
    "\n",
    "mark_maths([\"2+3=5\", \"4+4=9\", \"3-1=2\"]) ➞ \"67%\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "bcec3922",
   "metadata": {},
   "outputs": [],
   "source": [
    "#code\n",
    "def mark_maths(li):\n",
    "    count=0\n",
    "    for i in li:\n",
    "        S=i.split(\"=\")\n",
    "        if \"+\" in i:\n",
    "            value = S[0].split(\"+\")\n",
    "            Ans = int(value[0])+int(value[1])\n",
    "            if int(S[1])==Ans:\n",
    "                count+=1\n",
    "        elif \"-\" in i:\n",
    "            value = S[0].split(\"-\")\n",
    "            Ans = int(value[0])-int(value[1])\n",
    "            if int(S[1])==Ans:\n",
    "                count+=1\n",
    "    return str(int((count/len(li))*100))+\"%\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "bb6beec2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'75%'"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mark_maths([\"2+2=4\", \"3+2=5\", \"10-3=3\", \"5+5=10\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "bd056f00",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0%'"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mark_maths([\"1-2=-2\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "c04baf98",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'66%'"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mark_maths([\"2+3=5\", \"4+4=9\", \"3-1=2\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42c629ea",
   "metadata": {},
   "source": [
    "#Question : 04\n",
    "\n",
    "There are two players, Alice and Bob, each with a 3-by-3 grid. A referee\n",
    "tells Alice to fill out one particular row in the grid (say the second row) by\n",
    "putting either a 1 or a 0 in each box, such that the sum of the numbers in that\n",
    "row is odd. The referee tells Bob to fill out one column in the grid (say the first\n",
    "column) by putting either a 1 or a 0 in each box, such that the sum of the\n",
    "numbers in that column is even.\n",
    "\n",
    "Alice and Bob win the game if Alice’s numbers give an odd sum, Bob’s give\n",
    "an even sum, and (most important) they’ve each written down the same\n",
    "number in the one square where their row and column intersect.\n",
    "\n",
    "Examples\n",
    "\n",
    "magic_square_game([2, \"100\"], [1, \"101\"]) ➞ False\n",
    "\n",
    "magic_square_game([2, \"001\"], [1, \"101\"]) ➞ True\n",
    "\n",
    "magic_square_game([3, \"111\"], [2, \"011\"]) ➞ True\n",
    "\n",
    "magic_square_game([1, \"010\"], [3, \"101\"]) ➞ False\n",
    "\n",
    "* Two lists, Alice [row, \"her choice\"], Bob [column, \"his choice\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "c3e5efe3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#code\n",
    "\n",
    "def my_sum(s):\n",
    "    c=0\n",
    "    for i in s:\n",
    "        c+=int(i)\n",
    "    return c\n",
    "    \n",
    "def magic_square_game(alice,bob):\n",
    "    row=alice[0]-1\n",
    "    column=bob[0]-1\n",
    "    ac=alice[1]\n",
    "    bc=bob[1]\n",
    "\n",
    "    if my_sum(ac)%2 != 0 and my_sum(bc)%2 == 0:\n",
    "        if ac[column]==bc[row]:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "9c28f570",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "magic_square_game([2, \"100\"], [1, \"101\"]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "680f3642",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "magic_square_game([2, \"001\"], [1, \"101\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "c8523433",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "magic_square_game([2, \"001\"], [1, \"101\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "85b68017",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "magic_square_game([1, \"010\"], [3, \"101\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58bbe84d",
   "metadata": {},
   "source": [
    "#Question : 05\n",
    "\n",
    "From point A, an object is moving towards point B at constant velocity va\n",
    "(in km/hr). From point B, another object is moving towards point A at constant\n",
    "velocity vb (in km/hr). Knowing this and the distance between point A and B\n",
    "(in km), write a function that returns how much time passes until both objects\n",
    "meet.\n",
    "Format the output like this:\n",
    "\n",
    "\"2h 23min 34s\"\n",
    "\n",
    "Examples\n",
    "\n",
    "lets_meet(100, 10, 30) ➞ \"2h 30min 0s\"\n",
    "\n",
    "lets_meet(280, 70, 80) ➞ \"1h 52min 0s\"\n",
    "\n",
    "lets_meet(90, 75, 65) ➞ \"0h 38min 34s\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "1306ab7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#code\n",
    "\n",
    "def lets_meet(km,a,b):\n",
    "    time = km/(a+b)\n",
    "    hour=km//(a+b)\n",
    "    minu = (time*60)%60\n",
    "    sec = (time*3600)%60\n",
    "    return \"%02dh:%02dmin:%02ds\" % (hour, minu, sec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "ad7e2692",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'02h:30min:00s'"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lets_meet(100, 10, 30) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "9c7589a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'01h:52min:00s'"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lets_meet(280, 70, 80)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "61e906f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'00h:38min:34s'"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lets_meet(90, 75, 65)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "798b95a4",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}