Day 1 - Programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5ad41b28",
   "metadata": {},
   "source": [
    "# SELECTION SORT     \n",
    "#### Time Complexity O(n^2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "25b785f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "A = [4,1,6,8,10,2,3]\n",
    "for i in range(len(A)): # starts from 4 to 3 ---- index(0-6)----- len(7)\n",
    "    mini = i\n",
    "    for j in range(i+1,len(A)): # starts from 1 to 3 ---- index(1-6)----- len(7)\n",
    "        if(A[mini]>A[j]): # 4>1 1>6 1>8 1>10 1>2 1>3 ---- 4>6 4>8 4>10 4>2 ---- 2>6 2>8 2>10 2>2 2>3\n",
    "            mini = j      #1 4 2\n",
    "    A[i],A[mini] = A[mini],A[i] # 4,1 = 1,4 -- 4,2 = 2,4\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d4c4d86",
   "metadata": {},
   "source": [
    "### For small data sets, simpler algorithms like Insertion sort or Bubble sort can be efficient."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c94603b",
   "metadata": {},
   "source": [
    "### For large data sets, quicksort, mergesort, or heapsort are often preferred."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0587737",
   "metadata": {},
   "source": [
    "### Selection sort is not very efficient, especially for large data sets. \n",
    "#### For sorting very small data sets, selection sort may be a reasonable choice due to its simplicity. However, in practical applications, it is usually not the preferred sorting algorithm for larger data sets because of its poor performance "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1635610b",
   "metadata": {},
   "source": [
    "# INSERTION SORT\n",
    "#### TC Best case - O(n) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f1fc0af4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 6, 8, 19, 55]\n"
     ]
    }
   ],
   "source": [
    "B = [3,19,1,6,8,2,55]\n",
    "\n",
    "for i in range(1,len(B)):\n",
    "    temp = B[i] #19 1\n",
    "    j = i-1     #3\n",
    "    while(j>=0 and B[j]>temp): \n",
    "        B[j+1] = B[j] #shift 1 = 19\n",
    "        j=j-1 #0-1=-1 \n",
    "    B[j+1] = temp;    # Assign temp in right place\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e638d964",
   "metadata": {},
   "source": [
    "# Reverse the digits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "22081736",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60789\n"
     ]
    }
   ],
   "source": [
    "b = 98706\n",
    "temp = 0\n",
    "while(b>0):\n",
    "    rem = b%10\n",
    "    temp = (temp *10) +rem\n",
    "    b = b//10\n",
    "print(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3de1c0ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "234\n",
      "432"
     ]
    }
   ],
   "source": [
    "j = int(input())\n",
    "rem = 0\n",
    "while(j>0):\n",
    "    rem = j%10\n",
    "    j = j//10\n",
    "    print(rem,end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59e9a9a8",
   "metadata": {},
   "source": [
    "#### Find Fibonacci Series upto n terms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a00e338f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "Fibo Series is 0 1 1 2 3 5 8 \n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "n1,n2=0,1\n",
    "print(\"Fibo Series is\",n1,n2,end=\" \")\n",
    "for i in range(2,n):\n",
    "    n3 = n1+n2\n",
    "    n1 = n2\n",
    "    n2 = n3\n",
    "    print(n3,end=\" \")\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa2f4af4",
   "metadata": {},
   "source": [
    "# GCD of 2 numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "05ccb42a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36 60\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "def gcdf(a,b):\n",
    "    k = 1\n",
    "    if a<b:\n",
    "        small = a\n",
    "    else:\n",
    "        small = b\n",
    "    for i in range(1,small):\n",
    "        if(a%i==0 and b%i==0):\n",
    "            k = i  # 1 2 3 4 6 12 \n",
    "    return k\n",
    "        \n",
    "\n",
    "m,n = map(int,input().split())\n",
    "print(gcdf(m,n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe666aab",
   "metadata": {},
   "source": [
    "# To find Perfect Number\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0580f7ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "496\n",
      "Yohoo Perfect Number!\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "s=0\n",
    "for i in range(1,n-1):\n",
    "    if n%i ==0:\n",
    "        s = s+i\n",
    "if s==n:\n",
    "    print(\"Yohoo Perfect Number!\")\n",
    "else:\n",
    "    print(\"not really...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a6b7b19",
   "metadata": {},
   "source": [
    "# Check if 2 strings are Anagram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b6403bde",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "qwe klo\n",
      "oh no...\n"
     ]
    }
   ],
   "source": [
    "q,w = map(str,input().split())\n",
    "if(len(q)!=len(w)):\n",
    "    print(\"Not a anagram\")\n",
    "else:\n",
    "    if sorted(q)== sorted(w):\n",
    "        print(\"Yes it is\")\n",
    "    else:\n",
    "        print(\"oh no...\")\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1b314705",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len of q is 3\n"
     ]
    }
   ],
   "source": [
    "# without using len function find length of a str\n",
    "count = 0\n",
    "for i in q:\n",
    "    count+=1\n",
    "print(\"len of q is\", count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "045bb281",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'g', 'l', 'w', 'z']\n"
     ]
    }
   ],
   "source": [
    "# insertion sort\n",
    "B = ['w','a', 'b', 'c', 'l', 'z','g']\n",
    "\n",
    "for i in range(1,len(B)):\n",
    "    temp = B[i] # a\n",
    "    j = i-1     # w 0\n",
    "    while(j>=0 and B[j]>temp): \n",
    "        B[j+1] = B[j] #shift ,'w',\n",
    "        j=j-1 \n",
    "    B[j+1] = temp;    # Assign temp in right place 'a'\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c51e8b93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ghu uhj\n",
      "['h', 'u', 'j']\n",
      "['h', 'j', 'u']\n",
      "no no....\n"
     ]
    }
   ],
   "source": [
    "# Anagram without using len and sorted function\n",
    "q,w = map(str,input().split())\n",
    "\n",
    "count1 = 0\n",
    "for i in q:\n",
    "    count1+=1\n",
    "    count2 = 0\n",
    "for i in w:\n",
    "    count2+=1\n",
    "\n",
    "k,l=[],[]\n",
    "if count1==count2:\n",
    "    \n",
    "    k = list(q)\n",
    "    \n",
    "    for i in range(1,count1):\n",
    "        temp = k[i]\n",
    "        j = i-1\n",
    "        while(j>=0 and k[j]>temp):\n",
    "            k[j+1] = k[j]\n",
    "            j = j-1\n",
    "        k[j+1] = temp \n",
    "        #print(k)\n",
    "        \n",
    "if count1==count2:\n",
    "    \n",
    "    l = list(w)\n",
    "    for i in range(1,count2):\n",
    "        temp = l[i] #h  j\n",
    "        j = i-1     #u  u\n",
    "        while(j>=0 and l[j]>temp):\n",
    "            l[j+1] = l[j] # ,u  ,u\n",
    "            j = j-1       # -1  0\n",
    "        l[j+1] = temp     # u temp = h   j\n",
    "        print(l)\n",
    "\n",
    "if k == l:\n",
    "    print(\"Anagram\")\n",
    "else:\n",
    "    print(\"no no....\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9640cbe",
   "metadata": {},
   "source": [
    "# Palindrome or not?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c3b388d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mam mam\n",
      "Palindrome\n"
     ]
    }
   ],
   "source": [
    "# check if 2 strings are palindrome or not\n",
    "z,x = map(str,input().split())\n",
    "if(z==z[::-1]):\n",
    "    print(\"Palindrome\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f6aa062a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "emadam\n"
     ]
    }
   ],
   "source": [
    "#To reverse without using fn and indexing method\n",
    "d = 'madame'\n",
    "rev=''\n",
    "o = len(d)\n",
    "while(o>0):\n",
    "    rev = rev + d[o-1] \n",
    "    o=o-1\n",
    "print(rev)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c29a2da3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "madam madam\n",
      "Yay it is a P\n"
     ]
    }
   ],
   "source": [
    "# check palindrome\n",
    "s1,s2=map(str,input().split())\n",
    "leng = len(s1)\n",
    "rev = ''\n",
    "while(leng>0):\n",
    "    rev = rev + s1[leng-1]\n",
    "    leng = leng-1\n",
    "if(rev==s2):\n",
    "    print(\"Yay it is a P\")\n",
    "else:\n",
    "    print(\"Oh no :(\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "745ac7e9",
   "metadata": {},
   "source": [
    "# check frequency of characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c7265663",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "whwwkj\n",
      "w  is repeated  3 times\n",
      "h  is repeated  1 times\n",
      "w  is repeated  3 times\n",
      "w  is repeated  3 times\n",
      "k  is repeated  1 times\n",
      "j  is repeated  1 times\n"
     ]
    }
   ],
   "source": [
    "# Frequency of characters\n",
    "ll = input()\n",
    "for h in ll:\n",
    "    print(h, \" is repeated \",ll.count(h),\"times\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e0fcd5c",
   "metadata": {},
   "source": [
    "# Leap year or not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "81255002",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1900\n",
      "Not really\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "if(n%400 == 0):\n",
    "    print(\"Leap Year\")\n",
    "elif(n%100 != 0 and n%4 ==0): #1900\n",
    "    print(\"Leap Year\")\n",
    "else:\n",
    "    print(\"Not really\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6118501c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "727b6e8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "2000"
   ]
  }
 ],
 "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}