01 Warmup 1 CodingBat Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### front_back Challange Solution | Warmup-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ebcda'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given a string, return a new string where the first and last chars have been exchanged.\n",
    "str='abcde'\n",
    "\n",
    "def front_back(str):\n",
    "    if len(str)<=1:\n",
    "        return str\n",
    "    elif len(str)==2:\n",
    "        return str[: :-1]\n",
    "    else:\n",
    "        return str[-1]+str[1:-1]+str[0]\n",
    "    \n",
    "front_back(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### diff21 Challange Solution | Warmup-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given an int n, return the absolute difference between n and 21, except return double the absolute difference if n is over 21.\n",
    "\n",
    "n=25\n",
    "\n",
    "def diff21(n):\n",
    "    if n <= 21:\n",
    "        return 21 - n\n",
    "    else:\n",
    "        return (n - 21) * 2\n",
    "    \n",
    "diff21(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sum_double Challange Solution |  Warmup-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given two int values, return their sum. Unless the two values are the same, then return double their sum.\n",
    "\n",
    "def sum_double(a, b):\n",
    "    if a==b:\n",
    "        return 2*(a+b)\n",
    "    else:\n",
    "        return a+b\n",
    "\n",
    "sum_double(2, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### makes10 Challange Solution | Warmup-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given 2 ints, a and b, return True if one if them is 10 or if their sum is 10.\n",
    "\n",
    "def makes10(a, b):\n",
    "    if a == 10 or b == 10 or a+b == 10:\n",
    "        return True \n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "makes10(9, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### front3 Challange Solution | Warmup-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'gaggaggag'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given a string,the front is the first 3 chars of the string. If string length is less than 3, the front is whatever is there.\n",
    "# Return a new string which is 3 copies of the front.\n",
    "\n",
    "str='gaga'\n",
    "\n",
    "def front3(str):\n",
    "    if len(str)<1:\n",
    "        return str\n",
    "    elif len(str)==1:\n",
    "        return str+str+str\n",
    "    elif len(str)==2:\n",
    "        return str[0:2]+str[0:2]+str[0:2]\n",
    "    else:\n",
    "        return str[0:3]+str[0:3]+str[0:3]\n",
    "    \n",
    "front3(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sleep_in Challange Solution | Warmup-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The parameter weekday is True if it is a weekday, and the parameter vacation is True if we are on vacation. \n",
    "#We sleep in if it is not a weekday or we're on vacation. Return True if we sleep in.\n",
    "\n",
    "def sleep_in(weekday, vacation):\n",
    "    if weekday == True and vacation == False:\n",
    "        return False\n",
    "    else:\n",
    "        return True\n",
    "\n",
    "sleep_in(False, False) → True\n",
    "sleep_in(True, False) → False\n",
    "sleep_in(False, True) → True\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### diff21 Challange Solution | Warmup-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#We have two monkeys, a and b,a_smile and b_smile indicate if each is smiling. We are in trouble if they are both or \n",
    "#neither of them is smiling. Return True if we are in trouble.\n",
    "\n",
    "def monkey_trouble(a_smile, b_smile):\n",
    "    if a_smile==b_smile==True or a_smile==b_smile==False:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "monkey_trouble(True, False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### parrot_trouble Challange Solution | Warmup-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#We have a loud talking parrot. The \"hour\" parameter is the current hour time in the range 0..23. We are in trouble\n",
    "#if the parrot is talking and the hour is before 7 or after 20. Return True if we are in trouble.\n",
    "\n",
    "def parrot_trouble(talking, hour):\n",
    "    if (hour<7 or hour>20) and talking==True:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "\n",
    "parrot_trouble(True, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### not_string Challange Solution | Warmup-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not x\n",
      "not bad\n"
     ]
    }
   ],
   "source": [
    "#Given a string, return a new string where \"not \" has been added to the front.if the string already begins with \"not\",\n",
    "#return the string unchanged\n",
    "\n",
    "def not_string(str):\n",
    "    if str[:3]=='not':\n",
    "        return str\n",
    "    else:\n",
    "        return 'not '+str\n",
    "\n",
    "print(not_string('x'))\n",
    "print(not_string('not bad'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### missing_char Challange Solution | Warmup-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'kittn'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given a non-empty string and an int n, return a new string where the char at index n has been removed. The value of n\n",
    "#will be a valid index of a char in the original string (i.e. n will be in the range 0..len(str)-1 inclusive).\n",
    "\n",
    "def missing_char(str, n):\n",
    "    return str[0:n]+str[n+1:]\n",
    "  \n",
    "\n",
    "missing_char('kitten', 4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### near_hundred Challange Solution | Warmup-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given an int n, return True if it is within 10 of 100 or 200. Note: abs(num) computes the absolute value of a number.\n",
    "\n",
    "def near_hundred(n):\n",
    "    #if n in range(90,111) or n in range(190,211):\n",
    "    if ((abs(100 - n) <= 10) or (abs(200 - n) <= 10)):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "\n",
    "near_hundred(93)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### pos_neg Challange Solution | Warmup-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given 2 int values, return True if one is negative and one is positive. Except if the parameter \"negative\" is True,\n",
    "#then return True only if both are negative.\n",
    "\n",
    "def pos_neg(a, b, negative):\n",
    "    if negative==True and a<0 and b<0:\n",
    "        return True\n",
    "    elif negative==False and ((a>0 and b<0) or (a<0 and b>0)):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "    \n",
    "pos_neg(-1, 1, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}