15 June.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ab\n",
      "bc\n",
      "ca\n",
      "ab\n",
      "bc\n",
      "cd\n",
      "dd\n",
      "da\n",
      "ab\n",
      "b\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "#Function to find the number of occarences of substring in string\n",
    "#\"abcabcddcba\",\"ab\"-->\n",
    "def ab(a,b):\n",
    "    count=0\n",
    "    for i in range(0,len(a)):\n",
    "        c=a[i:i+len(b)]\n",
    "        print(c)\n",
    "        if c==b:\n",
    "            count=count+1\n",
    "    print(count)\n",
    "ab(\"abcabcddab\",\"ab\")           \n",
    "       \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# problem closest to Zero\n",
    "  i/p=-1 0 2 3 4 5       o/p=0  we have a  list l1=[3 ,2 ,-1 ,-3]\n",
    "   # # 1.sort the data==[-3,-1,3 2]  2.convert u r list into + list=abs(list)=[1,2,3,3](all +ve value's in sorting order=pl)\n",
    " ## 2.find the number closet to zero=equal to 0th index in a sorted list pl[0] check number is +ve /-ve in a orginal list of sorted  ,it is -ve.\n",
    "  ## 3.if pl[0]is in li: then return p1[0]      else: return -pl[0]\n",
    "      \n",
    "      \n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sorted +ve list pl [1, 2, 2, 3]\n",
      "not in l1 -1\n",
      "in l1 -1\n",
      "in l1 3\n"
     ]
    }
   ],
   "source": [
    "l1=[-1,-2,2,3]\n",
    "l1.sort()\n",
    "pl=[]  \n",
    "for i in l1:\n",
    "    pl.append(abs(i))   #add the +ve values to pl(+ve list)\n",
    "pl.sort()  #sort the +ve list\n",
    "print(\"sorted +ve list pl\", pl)\n",
    "if pl[0] in l1:   #lesser number closetto Zero \n",
    "    print(\"in l1\",pl[0])\n",
    "else:\n",
    "    print(\"not in l1\",-pl[0])\n",
    "if -pl[0] in l1:  # closet grater number to zero\n",
    "    print(\"in l1\",-pl[0])\n",
    "else:\n",
    "    print(\"not in l1\",pl[0])\n",
    "if pl[-1] in l1: #number having far distance from zero\n",
    "    print(\"in l1\",pl[-1])\n",
    "else:\n",
    "    print(\"not in l1\",-pl[1])\n",
    "    \n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l=[1,3,4,8,1]\n",
    "l[0]\n",
    "l[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "you are given 3 nums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "def calculation(a,b,c):\n",
    "    for i in range(c,a-1,-1):\n",
    "        if i%a==b:\n",
    "            return i\n",
    "    return -1\n",
    "print(calculation(3,2,9))\n",
    "print(calculation(1,2,4))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-27-4eaa3afeaaaa>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-27-4eaa3afeaaaa>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    farest from zero\u001b[0m\n\u001b[1;37m              ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "farest from zero\n",
    "li=[-1,-2,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "asEDS\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'ASeds'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def toggle1(s):\n",
    "    s1=''\n",
    "    for i in range(len(s)):\n",
    "        if s[i].islower():\n",
    "            s1+=s[i].upper()\n",
    "            #print(s1)\n",
    "        elif s[i].isupper():\n",
    "            s1+=s[i].lower()\n",
    "            #print(s1)\n",
    "    return s1\n",
    "s=input()\n",
    "toggle1(s)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'GH'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=\"gh\"\n",
    "s.islower()\n",
    "s.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('a')#gives ascii values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter upper limit: 9\n",
      "2 3 5 7 "
     ]
    }
   ],
   "source": [
    "r=int(input(\"Enter upper limit: \"))\n",
    "for a in range(1,r+1):\n",
    "    c=0\n",
    "    for i in range(1,a+1):\n",
    "        if(a%i==0):\n",
    "            c+=1\n",
    "    if c==2:\n",
    "        print(i,end=\" \")\n",
    "    \n",
    "    \n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "def samestrings(s):\n",
    "    s1=input()\n",
    "    s1=s1.split()\n",
    "    print(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def arePermutation(str1, str2): \n",
    "      \n",
    "    # Get lenghts of both strings \n",
    "    n1 = len(str1) \n",
    "    n2 = len(str2)\n",
    "  \n",
    "    # Sort both strings \n",
    "    a = sorted(str1) \n",
    "    str1 = \" \".join(a) \n",
    "    b = sorted(str2) \n",
    "    str2 = \" \".join(b) \n",
    "  \n",
    "    # Compare sorted strings \n",
    "    for i in range(0, n1, 1): \n",
    "        if (str1[i] != str2[i]): \n",
    "            return False\n",
    "  \n",
    "    return True\n",
    "  \n",
    "# Driver Code \n",
    "if __name__ == '__main__': \n",
    "    str1 = \"test\"\n",
    "    str2 = \"tsew\"\n",
    "    if (arePermutation(str1, str2)): \n",
    "        print(\"Yes\") \n",
    "    else: \n",
    "        print(\"No\") \n",
    "        \n",
    "arePermutation(\"hii\", \"ihi\")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arePermutation(\"hii\", \"ihi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wer\n",
      "rwe\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def samestrings(s1,s2):\n",
    "   \n",
    "    n1=len(s1)\n",
    "    n2=len(s2)\n",
    "    if n1!=n2:\n",
    "        return 1\n",
    "    return -1\n",
    "    for i in range(0,n1,1):\n",
    "        if s1[i]==s2[i]:\n",
    "            print(s1[i])\n",
    "            print(s2[i])\n",
    "s1=input()\n",
    "s2=input()\n",
    "samestrings(s1,s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'test' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-87-4e1243bd22c6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtest\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'test' is not defined"
     ]
    }
   ],
   "source": [
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=\"0abcdefghijklmnopqrstuvwxyz\"\n",
    "s1=s.index(\"a\")+s.index(\"b\")+s.index(\"a\")\n",
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.index(\"b\")+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdefghijklmnopqrstuvwxyz'"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.index(\"a\")+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aba\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def charsum(s):\n",
    "    s1=s.index(\"a\")+s.index(\"b\")+s.index(\"a\")\n",
    "    return s1\n",
    "s=input()\n",
    "charsum(s)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "228\n"
     ]
    }
   ],
   "source": [
    "def strScore(str, s, n):  \n",
    "    score = 0\n",
    "    index = 0\n",
    "    for i in range(n):  \n",
    "        if (str[i] == s): \n",
    "            for j in range(len(s)): \n",
    "                score += (ord(s[j]) - \n",
    "                          ord('a') + 1) \n",
    "            index = i + 1\n",
    "            break\n",
    "    score = score * index \n",
    "    return score \n",
    "  \n",
    "# Driver code  \n",
    "str = [\"sahil\", \"shashanak\", \"sanjit\",  \n",
    "                  \"abhinav\", \"mohit\" ]  \n",
    "s = \"abhinav\"\n",
    "n = len(str) \n",
    "score = strScore(str, s, n);  \n",
    "print(score) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=ord('a')-96+ord('b')-96+ord('a')-96\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bba\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def charsum(s):\n",
    "    s1=ord('a')-96+ord('b')-96+ord('a')-96\n",
    "    return s1\n",
    "s=input()\n",
    "charsum(s)\n"
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}