06 Logic 2 CodingBat Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### no_teen_sum Challange Solution | Logic-2 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given 3 int values, a b c, return their sum.if any of the values is a teen -- in the range 13..19 inclusive -- then that\n",
    "#value counts as 0, except 15 and 16 do not count as a teens. \n",
    "\n",
    "def no_teen_sum(a, b, c):\n",
    "    selection=[13,14,17,18,19]\n",
    "    flag1=flag2=flag3=0\n",
    "    \n",
    "    if a in selection:\n",
    "        flag1=1\n",
    "    if b in selection:\n",
    "        flag2=1\n",
    "    if c in selection:\n",
    "        flag3=1\n",
    "\n",
    "    if flag1==1 and flag2==1 and flag3==1:\n",
    "        return 0\n",
    "    elif flag1==1 and flag2==1 and flag3==0:\n",
    "        return c\n",
    "    elif flag1==1 and flag2==0 and flag3==0:\n",
    "        return b+c\n",
    "    elif flag1==0 and flag2==0 and flag3==0:\n",
    "        return a+b+c\n",
    "    elif flag1==0 and flag2==1 and flag3==0:\n",
    "        return a+c\n",
    "    elif flag1==1 and flag2==0 and flag3==1:\n",
    "        return b\n",
    "    elif flag1==0 and flag2==1 and flag3==1:\n",
    "        return a\n",
    "    elif flag1==0 and flag2==0 and flag3==1:\n",
    "        return a+b\n",
    "    else:\n",
    "        return 0\n",
    "no_teen_sum(17, 18, 16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### lone_sum Challange Solution | Logic-2 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given 3 int values, a b c,return their sum. if one of the values is the same as the another,it does'nt count towards the sum.\n",
    "\n",
    "def lone_sum(a, b, c):\n",
    "  \n",
    "  if a==b and b==c and a==c:\n",
    "    return 0\n",
    "  elif a==c:\n",
    "    return b\n",
    "  elif b==c:\n",
    "    return a\n",
    "  elif a==b:\n",
    "    return c\n",
    "  else:\n",
    "    return a+b+c\n",
    "\n",
    "lone_sum(2, 9, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### lucky_sum Challange Solution | Logic-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given 3 int values, a b c, return their sum. if one of the values is 13 then it does not count towards the sum and values to \n",
    "#its right do not count. So for example, if b is 13, then both b and c do not count.\n",
    "\n",
    "def lucky_sum(a, b, c):\n",
    "    if a==13:\n",
    "        return 0\n",
    "    elif b==13:\n",
    "        return a\n",
    "    elif c==13:\n",
    "        return a+b\n",
    "    else:\n",
    "        return a+b+c \n",
    "\n",
    "lucky_sum(1, 13, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### make_chocolate Challange Solution | Logic-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def make_chocolate(small, big, goal):\n",
    "    #no of minimum big chocolates required to comple global\n",
    "    bigRequired = goal//5   # 10//5 -> 2  #11//5 -> 2(2 big + 1 small)\n",
    "\n",
    "    #do we have that much big chocolates?\n",
    "    if (big - bigRequired) >= 0:  #yes we have ample of larges\n",
    "    #lets use our smalls to reach goal\n",
    "        smallRequired = goal - (bigRequired*5)\n",
    "    #if we have that much smalls then make chocolate and return number of smalls used\n",
    "        if (small - smallRequired) >= 0:  #yes we can make_chocolate\n",
    "            return smallRequired\n",
    "        else:   #oops not ample of smalls\n",
    "            return -1\n",
    "    else: # no we dont have ample of larges to reach goal or near goal, we need to see if we can make up using our smalls\n",
    "            smallRequired = goal - (big*5)\n",
    "    #if we have that much smalls then make chocolate and return number of smalls used\n",
    "            if (small - smallRequired) >= 0:  #yes we can make_chocolate\n",
    "                return smallRequired\n",
    "            else:   #oops not ample of smalls\n",
    "                return -1\n",
    "        \n",
    "make_chocolate(4, 1, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### close_far Challange Solution | Logic-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given three ints, a b c, return True if one of b or c is \"close\" (differing from a by at most 1), while the other is \"far\", \n",
    "#differing from both other values by 2 or more. Note: abs(num) computes the absolute value of a number.\n",
    "\n",
    "def close_far(a, b, c):\n",
    "    if abs(a-b)<=1:\n",
    "        if abs(a-c)>=2 and abs(b-c)>=2:\n",
    "            return True\n",
    "    elif abs(a-c)<=1:\n",
    "        if abs(a-b)>=2 and abs(b-c)>=2:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "close_far(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### round_sum Challange Solution | Logic-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#we'll round an int value up to the next multiple of 10 if its rightmost digit is 5 or more, so 15 rounds up to 20. Alternately,\n",
    "#round down to the previous multiple of 10 if its rightmost digit is less than 5, so 12 rounds down to 10. Given 3 ints, a b c,\n",
    "#return the sum of their rounded values. To avoid code repetition, write a separate helper \"def round10(num):\" and call it 3 \n",
    "#times. Write the helper entirely below and at the same indent level as round_sum().\n",
    "\n",
    "def round_sum(a, b, c):\n",
    "      \n",
    "    def round10(num):\n",
    "        if (num%10)>=5:\n",
    "            num=num+(10-(num%10))\n",
    "        else:\n",
    "            num=num-(num%10)\n",
    "        return num\n",
    "\n",
    "    return round10(a)+round10(b)+round10(c)\n",
    "\n",
    "round_sum(26, 3, 15) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### make_bricks Challange Solution | Logic-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def make_bricks(small, big , goal):\n",
    "    #no of minimum big chocolates required to comple global\n",
    "    bigRequired = goal//5   # 10//5 -> 2  #11//5 -> 2(2 big + 1 small)\n",
    "\n",
    "    #do we have that much big chocolates?\n",
    "    if (big - bigRequired) >= 0:  #yes we have ample of larges\n",
    "    #lets use our smalls to reach goal\n",
    "        smallRequired = goal - (bigRequired*5)\n",
    "    #if we have that much smalls then make chocolate and return number of smalls used\n",
    "        if (small - smallRequired) >= 0:  #yes we can make_chocolate\n",
    "            return True\n",
    "        else:   #oops not ample of smalls\n",
    "            return False\n",
    "    else: # no we dont have ample of larges to reach goal or near goal, we need to see if we can make up using our smalls\n",
    "            smallRequired = goal - (big*5)\n",
    "    #if we have that much smalls then make chocolate and return number of smalls used\n",
    "            if (small - smallRequired) >= 0:  #yes we can make_chocolate\n",
    "                return True\n",
    "            else:   #oops not ample of smalls\n",
    "                return False\n",
    "\n",
    "make_bricks(3, 2, 10)"
   ]
  },
  {
   "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
}