03 String 1 CodingBat Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### hello_name Challange Solution | String-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello Bob!'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given a string name, e.g. \"Bob\", return a greeting of the form \"Hello Bob!\".\n",
    "\n",
    "def hello_name(name):\n",
    "    return 'Hello '+name+'!'\n",
    "\n",
    "hello_name('Bob')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### first_half Challange Solution | String-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Given a string of even length, return the first half. So the string \"WooHoo\" yields \"Woo\".\n",
    "\n",
    "str='HelloThere'\n",
    "\n",
    "def first_half(str):\n",
    "    return str[ :len(str)/2]\n",
    "\n",
    "first_half(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### first_two Challange Solution | String-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'he'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given a string,return string made of its first 2 chars, so the String \"Hello\" yields \"He\".If the string is shorter than \n",
    "#length 2, return whatever there is, so \"X\" yields \"X\", and the empty string \"\" yields the empty string \"\".\n",
    "\n",
    "def first_two(str):\n",
    "    if len(str)<3:\n",
    "        return str\n",
    "    else:\n",
    "        return str[:2]\n",
    "    \n",
    "first_two('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### combo_string Challange Solution | String-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hiHellohi'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given 2 strings, a and b, return a string of the form short+long+short, with the shorter string on the outside and the longer\n",
    "#string on the inside. The strings will not be the same length, but they may be empty (length 0).\n",
    "\n",
    "def combo_string(a, b):\n",
    "    if len(a)==0:\n",
    "        return b\n",
    "    elif len(b)==0:\n",
    "        return a\n",
    "    elif len(a)>len(b):\n",
    "        return b+a+b\n",
    "    else:\n",
    "        return a+b+a\n",
    "    \n",
    "\n",
    "\n",
    "combo_string('Hello', 'hi')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### extra_end Challange Solution | String-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lololo'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given a string,return new string made of 3 copies of the last 2 chars of original string.The string length will be at least 2.\n",
    "\n",
    "def extra_end(str):\n",
    "    return str[-2:]*3\n",
    "\n",
    "extra_end('Hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### without_end Challange Solution | String-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'odin'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given a string,return without the first and last char, so \"Hello\" yields \"ell\". The string length will be at least 2.\n",
    "\n",
    "def without_end(str):\n",
    "    return str[1:-1]\n",
    "\n",
    "without_end('coding')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### non_start Challange Solution | String-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ellohere'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given 2 strings, return their concatenation, except omit the first char of each. The strings will be at least length 1.\n",
    "\n",
    "def non_start(a, b):\n",
    "    if len(a)==1:\n",
    "        return b[1:]\n",
    "    elif len(b)==1:\n",
    "        return a[1:]\n",
    "    else:\n",
    "        return a[1:]+b[1:]\n",
    "     \n",
    "non_start('Hello', 'There') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### make_out_word Challange Solution | String-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<<Yay>>'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given an \"out\" string length 4, such as \"<<>>\", and a word, return a new string where the word is in the middle of the \n",
    "#out string, e.g. \"<<word>>\".\n",
    "\n",
    "def make_out_word(out, word):\n",
    "    return out[:2]+word+out[2:]\n",
    "  \n",
    "\n",
    "\n",
    "make_out_word('<<>>', 'Yay')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### left2 Challange Solution | String-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lloHe'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given a string, return a \"rotated left 2\" version where the first 2 chars are moved to the end. The length will be at least 2.\n",
    "\n",
    "def left2(str):\n",
    "    if len(str)==2:\n",
    "        return str\n",
    "    else:\n",
    "        return str[2:]+str[0:2]\n",
    "\n",
    "left2('Hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### make_tags Challange Solution | String-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<i>Hello</i>'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#The web is built with HTML strings like \"<i>Yay</i>\" which draws Yay as italic text. In this example, the \"i\" tag makes <i> \n",
    "#and </i> which surround the word \"Yay\". Given tag and word strings, create the HTML string with tags around the word,\n",
    "#e.g. \"<i>Yay</i>\".\n",
    "\n",
    "def make_tags(tag, word):\n",
    "    return '<'+tag+'>'+word+'</'+tag+'>'\n",
    "\n",
    "make_tags('i', 'Hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### make_abba Challange Solution | String-1 | CodingBat | Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HiByeByeHi'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given two strings,a and b,return them putting together in the order abba, e.g. \"Hi\" and \"Bye\" returns \"HiByeByeHi\".\n",
    "\n",
    "def make_abba(a, b):\n",
    "    return a+b+b+a\n",
    "\n",
    "make_abba('Hi', 'Bye') "
   ]
  },
  {
   "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
}