26-June-19.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kth largest frequency based on kth largest rank\n",
    "## 1.largest number in a list\n",
    "## 2.second largest number in a list\n",
    "## 3.kth largest number in alist\n",
    "\n",
    "### 1.Elements with highest frequency\n",
    "### 2.second largest frequency\n",
    "### 3.kth highest frequency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 : 1\n",
      "3 : 1\n",
      "4 : 1\n",
      "5 : 2\n",
      "22 : 2\n"
     ]
    }
   ],
   "source": [
    "#identify the highest frequency element \n",
    "#many elements having the hihest frequency return smallest element\n",
    "\n",
    "def highestfreelement(li):\n",
    "    for j in set(li):\n",
    "        x=li.count(j)\n",
    "        print(j, ':',x)\n",
    "        if x==len(li):\n",
    "            return li[0]\n",
    "        else:\n",
    "            return -1\n",
    "    \n",
    "highestfreelement([3,4,5,22,1,22,5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# highest frequency of max  element "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 2, 2: 2, 3: 2, 5: 1, 6: 1}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def hihestelefre(li):\n",
    "    u={}\n",
    "    for i in li:\n",
    "        if i in u:\n",
    "            u[i]+=1\n",
    "        else:\n",
    "            u[i]=1\n",
    "    print(u)\n",
    "# get all frequencies into a list and get highest freqency value\n",
    "    fre=u.values() # get a values list\n",
    "    maxfre=max(fre) # get max value in list\n",
    "    maxfreq=[]\n",
    "    #identify smallest number with max frequency\n",
    "    for item in u.items():\n",
    "        if item[1] == maxfre:\n",
    "            maxfreq.append(item[0])\n",
    "    #select the minimum from keys with\n",
    "    #maxfreq=sorted(maxfreq,reverse=True)\n",
    "   # print(maxfreq)\n",
    "    return max(maxfreq)\n",
    "hihestelefre([1,2,3,5,6,3,2,1]) # 1,2,3 having 2 frequency so max number with 2 fre display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Minimum frequency small element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def minimunelefre1(li):\n",
    "    u={}\n",
    "    for i in li:\n",
    "        if i in u:\n",
    "            u[i]+=1\n",
    "        else:\n",
    "            u[i]=1\n",
    "    #return u\n",
    "    maxfr=max(u.values())# to get only keys in dict\n",
    "    maxkeys=[]\n",
    "    for j in u.items():\n",
    "        if j[1]==maxfr:\n",
    "            maxkeys.append(j[0])\n",
    "    return min(maxkeys)\n",
    "minimunelefre1([1,2,3,5,6,3,2,1])   #minimum element with max frequency     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to identify second hihest frequency element ,if there are many elements return the smallest\n",
    "### li=[1,2,3,2,1,4,4,9]---3(1,2,4 are having 2 fre and 3 ,9 have 1 fre in that small element is 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2]\n",
      "[2, 1]\n",
      "[3, 9]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def secondlargestfreqsmallnumber(li):\n",
    "    u={}\n",
    "    for i in li:\n",
    "        if i in u:\n",
    "            u[i]+=1\n",
    "        else:\n",
    "            u[i]=1\n",
    "    #return u\n",
    "    values=u.values()# to get only keys in dict\n",
    "    valfre=[]\n",
    "    for i in values:\n",
    "        if i not in valfre:\n",
    "            valfre.append(i)\n",
    "            print(valfre)\n",
    "    valfre=sorted(valfre,reverse=True)\n",
    "    values=valfre[1] # we want 2nd largest that is in 1 index in list\n",
    "    keys=[]\n",
    "    for j in u.items():\n",
    "        if j[1]==values:\n",
    "            keys.append(j[0])\n",
    "    print(keys)\n",
    "    return min(keys)\n",
    "secondlargestfreqsmallnumber([1,2,3,4,2,1,4,9])   #minimum element with max frequency     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kth largest frequency element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n",
      "s\n",
      "25\n",
      "g\n",
      "24\n",
      "h\n",
      "27\n",
      "e\n",
      "27\n",
      "w\n",
      "26\n",
      "r\n",
      "25\n",
      "n\n",
      "26\n",
      "k\n",
      "25\n",
      "-1\n",
      "26\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "def kthlargest(s,k):\n",
    "    freq={}\n",
    "    for i in s:\n",
    "        if i not in freq.keys():\n",
    "            freq[i]=s.count(i)\n",
    "    values=sorted(freq.values(),reverse=True)\n",
    "    uniquevalues=list(set(values))\n",
    "    uniquevalues=sorted(uniquevalues,reverse=True)\n",
    "    print(len(uniquevalues))\n",
    "    if k<len(uniquevalues):\n",
    "        kvalue=uniquevalues[k-1]\n",
    "    else:\n",
    "        return -1\n",
    "   \n",
    "    li=[]\n",
    "    for item in freq.items():\n",
    "        if item[1]==kvalue:\n",
    "            li.append(item[0])\n",
    "    return min(li)\n",
    "with open('data files/kthlarge.txt','r') as f:\n",
    "        t=int(f.readline()) # read 1st line from file input.txt file\n",
    "        for i in range(t):\n",
    "            s=f.readline()\n",
    "            k=int(f.readline())\n",
    "            print(kthlargest(s,k))\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kth minimum frequency  problem by using file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n",
      "g\n",
      "h\n",
      "e\n",
      "w\n",
      "r\n",
      "n\n",
      "k\n",
      "-1\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "def khighfre(s,k):\n",
    "    #unique charcters and frequiences\n",
    "    u={}\n",
    "    for i in s:\n",
    "        if i not in u:\n",
    "            u[i]=1\n",
    "        else:\n",
    "            u[i]+=1\n",
    "    #print(u)\n",
    "    #create all unique frequenices as list \n",
    "    #list of unique frequency only available finally in uniquefre\n",
    "    uniquefre=[]\n",
    "    for value in u.values():\n",
    "        if value not in uniquefre:\n",
    "            uniquefre.append(value)\n",
    "    uniquefre=sorted(uniquefre,reverse=True)\n",
    "    if len(uniquefre) >k:\n",
    "        kthfreq=uniquefre[k-1]\n",
    "    else:\n",
    "        return -1\n",
    "    #print(kthfreq)\n",
    "    kfrekeys=[] #to get a keys from a dict add it to list\n",
    "    for key in u.items():# for keys checking\n",
    "        if key[1]==kthfreq: # 1 represents key 0 for value\n",
    "            kfrekeys.append(key[0])\n",
    "    return min(kfrekeys)  #return 1 frequency keys if k=2\n",
    "with open('data files/kthlarge.txt','r') as f:\n",
    "        t=int(f.readline()) # read 1st line from file input.txt file\n",
    "        for i in range(t):\n",
    "            s=f.readline()\n",
    "            k=int(f.readline())\n",
    "            print(khighfre(s,k))"
   ]
  },
  {
   "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
}