Misc.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ad01a575-e6b7-4f3c-8a26-41e18cc170a4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "def test(n):\n",
    "        x = sqrt(n * (n + 1) / 2)\n",
    "        \n",
    "        if x % 1 != 0:\n",
    "            return -1\n",
    "        else:\n",
    "            return int(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7c402020-e533-471b-9251-78a3daa88a79",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n"
     ]
    }
   ],
   "source": [
    "print(test(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5adebadf-c1d9-4ccd-a275-e95681f08f01",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n=8\n",
    "x = sqrt(n * (n + 1) / 2)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "04e0fbf2-ac8c-46a7-afa4-1a56ca469fed",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.5"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0248b02f-0023-4670-adda-227af8d80e06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pawan'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "x='pawan'\n",
    "x.capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8f719559-b62f-4ea6-8156-5906d1772539",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b0df681-7482-447c-9e9f-584659999ae2",
   "metadata": {},
   "outputs": [],
   "source": [
    "df=pd.read_csv('G:/Coding/Git Uploads/Project/Crop Predictions/main.csv')\n",
    "print((df['item'].unique()))\n",
    "y=df['area'].unique()\n",
    "# type(x\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b0f6f8f-b8de-4ae8-93a9-65af5f0ee42f",
   "metadata": {},
   "outputs": [],
   "source": [
    "df1=pd.read_csv('G:/Coding/Git Uploads/Project/Crop Predictions/test.csv')\n",
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad0983fa-4c9c-4831-a470-c3db61ee5d01",
   "metadata": {},
   "outputs": [],
   "source": [
    "z=df['item'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "825cf1ee-2e09-4017-b848-f2104545a368",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42de7620-9cae-42c2-a115-2a703ce52032",
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import*\n",
    "x=[1,2,3,4]\n",
    "p=x.copy()\n",
    "z=[]\n",
    "for i in x:\n",
    "    p.remove(i)\n",
    "    z.append(reduce(lambda x,y: x*y,p))\n",
    "    p=x.copy()\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "898d8901-3060-4c3c-b72b-a7ed68b5d8e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "encode = {'team1': {'MI':1,'KKR':2,'RCB':3,'DC':4,'CSK':5,'RR':6,'DD':7,'GL':8,'KXIP':9,'SRH':10,'RPS':11,'KTK':12,'PW':13},'team2': {'MI':1,'KKR':2,'RCB':3,'DC':4,'CSK':5,'RR':6,'DD':7,'GL':8,'KXIP':9,'SRH':10,'RPS':11,'KTK':12,'PW':13},'toss_winner': {'MI':1,'KKR':2,'RCB':3,'DC':4,'CSK':5,'RR':6,'DD':7,'GL':8,'KXIP':9,'SRH':10,'RPS':11,'KTK':12,'PW':13},'winner': {'MI':1,'KKR':2,'RCB':3,'DC':4,'CSK':5,'RR':6,'DD':7,'GL':8,'KXIP':9,'SRH':10,'RPS':11,'KTK':12,'PW':13,'Draw':14},'toss_decision':{'field':0,'bat':1},\n",
    "'city':{'Hyderabad':0, 'Pune':1, 'Rajkot':2, 'Indore':3, 'Bangalore':4, 'Mumbai':5,'Kolkata':6, 'Delhi':7, 'Chandigarh':8, 'Kanpur':9, 'Jaipur':10, 'Chennai':11,'Cape Town':12, 'Port Elizabeth':13, 'Durban':14, 'Centurion':15,'East London':16, 'Johannesburg':17, 'Kimberley':18, 'Bloemfontein':19,'Ahmedabad':20, 'Cuttack':21, 'Nagpur':22, 'Dharamsala':23, 'Kochi':24,'Visakhapatnam':25, 'Raipur':26, 'Ranchi':27, 'Abu Dhabi':28, 'Sharjah':29,'Dubai':30},'venue':{'Rajiv Gandhi International Stadium, Uppal':0,'Maharashtra Cricket Association Stadium':1,'Saurashtra Cricket Association Stadium':2, 'Holkar Cricket Stadium':3,'M Chinnaswamy Stadium':4, 'Wankhede Stadium':5, 'Eden Gardens':6,'Arun Jaitley Stadium':7,'Punjab Cricket Association IS Bindra Stadium, Mohali':8,'Green Park':9, 'Punjab Cricket Association Stadium, Mohali':8,'Sawai Mansingh Stadium':10, 'MA Chidambaram Stadium, Chepauk':11,'Dr DY Patil Sports Academy':5, 'Newlands':12, \"St George's Park\":13,'Kingsmead':14, 'SuperSport Park':15, 'Buffalo Park':16,'New Wanderers Stadium':17, 'De Beers Diamond Oval':18,'OUTsurance Oval':19, 'Brabourne Stadium':19,'Narendra Modi Stadium, Motera':20, 'Barabati Stadium':21,'Vidarbha Cricket Association Stadium, Jamtha':22,'Himachal Pradesh Cricket Association Stadium':23, 'Nehru Stadium':24,'Dr. Y.S. Rajasekhara Reddy ACA-VDCA Cricket Stadium':25,'Subrata Roy Sahara Stadium':1,'Shaheed Veer Narayan Singh International Stadium':26,'JSCA International Stadium Complex':27, 'Sheikh Zayed Stadium':28,'Sharjah Cricket Stadium':29, 'Dubai International Cricket Stadium':30}}  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "365f40af-443f-4aa5-8afa-c74a01bc1c33",
   "metadata": {},
   "outputs": [],
   "source": [
    "z=encode['team1'].keys()\n",
    "encode['team1'].items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b84a9341-c59f-4bdb-a87d-e244780e854b",
   "metadata": {},
   "outputs": [],
   "source": [
    "encode['team1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec8e140f-18a8-4522-b8e3-2f535f91d5c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "encode['team2'].keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e4fca99-0e2c-48c9-8e66-ee85cc0af7fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "value_to_find=5\n",
    "key = next(key for key, value in encode['team1'].items() if value == value_to_find)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "452d09af-6783-4bd7-8c91-11ff6aee6667",
   "metadata": {},
   "outputs": [],
   "source": [
    "key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56502e98-3974-4c75-9e44-567db650f40e",
   "metadata": {},
   "outputs": [],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b25a995b-013d-4628-b04a-47f4a38c9c6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=[170,45,75,90,802,24,2,66]\n",
    "y=[[],[],[],[],[],[],[],[],[],[]]\n",
    "z=max(x)\n",
    "p=1\n",
    "while (z)//p>0:\n",
    "    while len(x)>0:\n",
    "        v=x.pop()\n",
    "        l=(v//p)%10\n",
    "        y[l].append(v)\n",
    "    for i in y:\n",
    "        while len(i)>0:\n",
    "            v=i.pop()\n",
    "            x.append(v)\n",
    "    p*=10\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9449aeeb-e2b0-496c-a77f-c6dfde3a79f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=[170,45,75,90,802,24,2,66]\n",
    "x.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0adff8a-0551-4e3f-b1b9-452130f8f36c",
   "metadata": {},
   "outputs": [],
   "source": [
    "(802//10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6769555-2c28-4f46-bf86-d8667b372719",
   "metadata": {},
   "outputs": [],
   "source": [
    "[[90, 75, 66, 45, 24, 2], [170], [], [], [], [], [], [], [802], []]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1bb4b044-971e-4af3-acb4-2fc092054780",
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_sort(arr):\n",
    "    if len(arr)<=1:\n",
    "        return arr\n",
    "    mid=len(arr)//2\n",
    "    left=arr[:mid]\n",
    "    right=arr[mid:]\n",
    "    s_left=merge_sort(left)\n",
    "    s_right=merge_sort(right)\n",
    "    return merge(s_left,s_right)\n",
    "def merge(left,right):\n",
    "    result=[]\n",
    "    i=j=0\n",
    "    while i<len(left) and j<len(right):\n",
    "        if left[i]<right[j]:\n",
    "            result.append(left[i])\n",
    "            i+=1\n",
    "        else:\n",
    "            result.append(right[j])\n",
    "            j+=1\n",
    "    result.extend(left[i:])\n",
    "    result.extend(right[j:])\n",
    "    return result\n",
    "arr=[3,7,6,-10,15,23.5,55,-13]\n",
    "sorted_arr=merge_sort(arr)\n",
    "print(sorted_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1380776e-5a78-4e9b-8d7a-2d39659ee087",
   "metadata": {},
   "outputs": [],
   "source": [
    "s =\"Hello World\"\n",
    "str1=s.rstrip()\n",
    "x=''\n",
    "for i in str1[-1::-1]:\n",
    "    if i==' ':\n",
    "        break\n",
    "    else:\n",
    "        x+=i\n",
    "print(len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a196a262-6c87-4490-9f60-331b49915e97",
   "metadata": {},
   "outputs": [],
   "source": [
    "a=10\n",
    "b=5\n",
    "a,b=b,a\n",
    "print(a)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c486d12f-56b0-47f8-b40f-c8ee50ab9c4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "x='Pawan'\n",
    "if 'a' in x:\n",
    "    print(True)\n",
    "else:\n",
    "    print(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59870d47-2908-4410-8b59-84593ec257b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "x={'a':10,'b':20,'c':30}\n",
    "for i in x.items():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e41020b-4ea8-427b-8939-6842bec66a32",
   "metadata": {},
   "outputs": [],
   "source": [
    "s=\"leEeetcode\"\n",
    "q=[s]\n",
    "p=[i for i in s]\n",
    "z=''\n",
    "for i in range(0,len(p)-2):\n",
    "    if p[i]==p[i+1].lower() and p[i+1].isupper():\n",
    "        z+=p[i]+p[i+1]\n",
    "if z in q[0]:\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de4dd47a-a523-410e-8a8c-4dfa74070f25",
   "metadata": {},
   "outputs": [],
   "source": [
    "[0]*7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "810421e5-b988-4e5a-80cf-4d8d6ce42ec2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5a1654c-441f-4d48-9831-9a5cb1331076",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums=[-1,2,-3,3]\n",
    "nums.sort(reverse=True)\n",
    "nums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cfeb61d-dbfe-4422-839d-b6d01c33285f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def findMaxK(nums):\n",
    "    nums.sort(reverse=True)\n",
    "    for i in nums:\n",
    "        if -i in nums:\n",
    "            return i\n",
    "nums=[-1,10,6,7,-7,1]\n",
    "print(findMaxK(nums))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70043154-a907-4bc4-b82d-74a69548cd14",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ask in interview 29-04-2024\n",
    "# [-1,0,1,-1,2,3,0,4,4]  it is output\n",
    "x=[8,16,24,1,25,3,10,65,55]\n",
    "a=[]\n",
    "y=[]\n",
    "for i,j in enumerate(x):\n",
    "    a.append(x[i])\n",
    "    a.sort(reverse=True)\n",
    "    for k in a:\n",
    "        if j>k:\n",
    "            y.append(x.index(k))\n",
    "            break\n",
    "    else:\n",
    "        y.append(-1)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32f970e8-6387-4ba3-a3b9-af6af8f1bd90",
   "metadata": {},
   "outputs": [],
   "source": [
    "version1 = \"1.1.1\"\n",
    "version2 = \"1\"\n",
    "if '.' in version1 and '.' in version2:\n",
    "    x=version1.split('.')\n",
    "    y=version2.split('.')\n",
    "    if x[0]==y[0]:\n",
    "        print(0)\n",
    "    elif x[0]<y[0]:\n",
    "        print(-1)\n",
    "    else:\n",
    "        print(1)\n",
    "elif version1[0]==version2[0]:\n",
    "    if x[0]==y[0]:\n",
    "        print(0)\n",
    "    elif x[0]<y[0]:\n",
    "        print(-1)\n",
    "    else:\n",
    "        print(1)\n",
    "else:\n",
    "    if x[0]==y[0]:\n",
    "        print(0)\n",
    "    elif x[0]<y[0]:\n",
    "        print(-1)\n",
    "    else:\n",
    "        print(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a63a7ab1-c036-46ae-b668-e2d35c3fe208",
   "metadata": {},
   "outputs": [],
   "source": [
    "version1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b8c7fb3-4d87-4fa2-82ca-a7a2ee3b4691",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Solution:\n",
    "    def numRescueBoats(self, p, limit):\n",
    "        p.sort()\n",
    "        x=0\n",
    "        l, r=0, len(p)-1\n",
    "        while l<=r:\n",
    "            x+=1\n",
    "            if p[l]+p[r]<=limit:\n",
    "                l+=1\n",
    "            r-=1\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43f991ff-d1a0-4ba9-a0fb-7d00c745b7e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=Solution()\n",
    "result=x.numRescueBoats([5,4,2],3)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ce3595b-3b10-4cbc-b41b-c104c1d0cfb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "score = [10,3,8,9,4]\n",
    "x=[i for i in sorted(score,reverse=True)]\n",
    "y=[i for i in range(4,len(score)+1)]\n",
    "l=[]\n",
    "c=0\n",
    "for i in score:\n",
    "    if i==x[0]:\n",
    "        l.append('Gold Medal')\n",
    "    elif i==x[1]:\n",
    "        l.append('Silver Medal')\n",
    "    elif i==x[2]:\n",
    "        l.append('Bronze Medal')\n",
    "    elif i==x[-1]:\n",
    "        l.append(y[-1])\n",
    "    elif i==x[-2]:\n",
    "        l.append(y[-2])\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5d75002-e3b8-42fd-aaaf-3ac310997bf3",
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a53a20c-2dca-4ee1-b2de-2667f246d331",
   "metadata": {},
   "outputs": [],
   "source": [
    "[\"Gold Medal\",\"5\",\"Bronze Medal\",\"Silver Medal\",\"4\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cf5ee78-5c66-408e-9ae9-56d9b6cf51ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "x= [[9,9,8,1],[5,6,2,6],[8,2,6,4],[6,2,2,2]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "350c290e-aa7b-47a5-affc-737893f8ce39",
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[]+[[1]]\n",
    "l+[[2]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e6739a6-da07-4095-92e2-ed9bc0505384",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import libraries of python OpenCV    \n",
    "import cv2  \n",
    "  \n",
    "# import Numpy by alias name np  \n",
    "import numpy as np  \n",
    "  \n",
    "# capture frames from a camera   \n",
    "cap = cv2.VideoCapture(0)  \n",
    "  \n",
    "# loop runs if capturing has been initialized   \n",
    "while (1):  \n",
    "  \n",
    "    # reads frames from a camera   \n",
    "    ret, frame = cap.read()  \n",
    "  \n",
    "    # converting BGR to HSV   \n",
    "    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)  \n",
    "    # define range of red color in HSV   \n",
    "    lower_red = np.array([30, 150, 50])  \n",
    "    upper_red = np.array([255, 255, 180])  \n",
    "  \n",
    "    # create a red HSV colour boundary and    \n",
    "    # threshold HSV image   \n",
    "    mask = cv2.inRange(hsv, lower_red, upper_red)  \n",
    "  \n",
    "    # Bitwise-AND mask and original image   \n",
    "    res = cv2.bitwise_and(frame, frame, mask=mask)  \n",
    "  \n",
    "    # Display an original image   \n",
    "    cv2.imshow('Original', frame)  \n",
    "  \n",
    "    # discovers edges in the input image image and   \n",
    "    # marks them in the output map edges   \n",
    "    edges = cv2.Canny(frame, 100, 200)  \n",
    "  \n",
    "    # Display edges in a frame   \n",
    "    cv2.imshow('Edges', edges)  \n",
    "  \n",
    "    # Wait for Esc key to stop   \n",
    "    k = cv2.waitKey(5) & 0xFF  \n",
    "    if k == 27:   \n",
    "        break  \n",
    "  \n",
    "# Close the window   \n",
    "cap.release()  \n",
    "  \n",
    "# De-allocate any associated memory usage   \n",
    "cv2.destroyAllWindows()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f7171c8-4c45-48af-a357-0731abe2909c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2  \n",
    "import numpy as np  \n",
    "  \n",
    "cap = cv2.VideoCapture(0)  \n",
    "  \n",
    "while(True):  \n",
    "    # Capture image frame-by-frame  \n",
    "    ret, frame = cap.read()  \n",
    "  \n",
    "    # Our operations on the frame come here  \n",
    "    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  \n",
    "  \n",
    "    # Display the resulting frame  \n",
    "    cv2.imshow('frame',gray)  \n",
    "    if cv2.waitKey(1) & 0xFF == ord('q'):  \n",
    "        break  \n",
    "        \n",
    "  \n",
    "# When everything done, release the capture  \n",
    "cap.release()  \n",
    "cv2.waitKey(3)\n",
    "cv2.destroyAllWindows()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afc09f8a-c587-483a-9ead-465dbef4bfa1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing Libraries \n",
    "import cv2 \n",
    "import mediapipe as mp \n",
    "\n",
    "# Used to convert protobuf message to a dictionary. \n",
    "from google.protobuf.json_format import MessageToDict \n",
    "\n",
    "# Initializing the Model \n",
    "mpHands = mp.solutions.hands \n",
    "hands = mpHands.Hands( \n",
    "\tstatic_image_mode=False, \n",
    "\tmodel_complexity=1, \n",
    "\tmin_detection_confidence=0.75, \n",
    "\tmin_tracking_confidence=0.75, \n",
    "\tmax_num_hands=2) \n",
    "\n",
    "# Start capturing video from webcam \n",
    "cap = cv2.VideoCapture(0) \n",
    "\n",
    "while True: \n",
    "\t# Read video frame by frame \n",
    "\tsuccess, img = cap.read() \n",
    "\n",
    "\t# Flip the image(frame) \n",
    "\timg = cv2.flip(img, 1) \n",
    "\n",
    "\t# Convert BGR image to RGB image \n",
    "\timgRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) \n",
    "\n",
    "\t# Process the RGB image \n",
    "\tresults = hands.process(imgRGB) \n",
    "\n",
    "\t# If hands are present in image(frame) \n",
    "\tif results.multi_hand_landmarks: \n",
    "\n",
    "\t\t# Both Hands are present in image(frame) \n",
    "\t\tif len(results.multi_handedness) == 2: \n",
    "\t\t\t\t# Display 'Both Hands' on the image \n",
    "\t\t\tcv2.putText(img, 'Both Hands', (250, 50), \n",
    "\t\t\t\t\t\tcv2.FONT_HERSHEY_COMPLEX, \n",
    "\t\t\t\t\t\t0.9, (0, 255, 0), 2) \n",
    "\n",
    "\t\t# If any hand present \n",
    "\t\telse: \n",
    "\t\t\tfor i in results.multi_handedness: \n",
    "\t\t\t\t\n",
    "\t\t\t\t# Return whether it is Right or Left Hand \n",
    "\t\t\t\tlabel = MessageToDict(i)['classification'][0]['label'] \n",
    "\n",
    "\t\t\t\tif label == 'Left': \n",
    "\t\t\t\t\t\n",
    "\t\t\t\t\t# Display 'Left Hand' on \n",
    "\t\t\t\t\t# left side of window \n",
    "\t\t\t\t\tcv2.putText(img, label+' Hand', \n",
    "\t\t\t\t\t\t\t\t(20, 50), \n",
    "\t\t\t\t\t\t\t\tcv2.FONT_HERSHEY_COMPLEX, \n",
    "\t\t\t\t\t\t\t\t0.9, (0, 255, 0), 2) \n",
    "\n",
    "\t\t\t\tif label == 'Right': \n",
    "\t\t\t\t\t\n",
    "\t\t\t\t\t# Display 'Left Hand' \n",
    "\t\t\t\t\t# on left side of window \n",
    "\t\t\t\t\tcv2.putText(img, label+' Hand', (460, 50), \n",
    "\t\t\t\t\t\t\t\tcv2.FONT_HERSHEY_COMPLEX, \n",
    "\t\t\t\t\t\t\t\t0.9, (0, 255, 0), 2) \n",
    "\n",
    "\t# Display Video and when 'q' \n",
    "\t# is entered, destroy the window \n",
    "\tcv2.imshow('Image', img) \n",
    "\tif cv2.waitKey(1) & 0xff == ord('q'): \n",
    "\t\tbreak\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e5cdb30-a8e7-47f1-b5f8-2c2c4b1b0938",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing Libraries \n",
    "import cv2 \n",
    "import mediapipe as mp \n",
    "from math import hypot \n",
    "import screen_brightness_control as sbc \n",
    "import numpy as np \n",
    "\n",
    "# Initializing the Model \n",
    "mpHands = mp.solutions.hands \n",
    "hands = mpHands.Hands( \n",
    "\tstatic_image_mode=False, \n",
    "\tmodel_complexity=1, \n",
    "\tmin_detection_confidence=0.75, \n",
    "\tmin_tracking_confidence=0.75, \n",
    "\tmax_num_hands=2) \n",
    "\n",
    "Draw = mp.solutions.drawing_utils \n",
    "\n",
    "# Start capturing video from webcam \n",
    "cap = cv2.VideoCapture(0) \n",
    "\n",
    "while True: \n",
    "\t# Read video frame by frame \n",
    "\t_, frame = cap.read() \n",
    "\n",
    "\t# Flip image \n",
    "\tframe = cv2.flip(frame, 1) \n",
    "\n",
    "\t# Convert BGR image to RGB image \n",
    "\tframeRGB = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) \n",
    "\n",
    "\t# Process the RGB image \n",
    "\tProcess = hands.process(frameRGB) \n",
    "\n",
    "\tlandmarkList = [] \n",
    "\t# if hands are present in image(frame) \n",
    "\tif Process.multi_hand_landmarks: \n",
    "\t\t# detect handmarks \n",
    "\t\tfor handlm in Process.multi_hand_landmarks: \n",
    "\t\t\tfor _id, landmarks in enumerate(handlm.landmark): \n",
    "\t\t\t\t# store height and width of image \n",
    "\t\t\t\theight, width, color_channels = frame.shape \n",
    "\n",
    "\t\t\t\t# calculate and append x, y coordinates \n",
    "\t\t\t\t# of handmarks from image(frame) to lmList \n",
    "\t\t\t\tx, y = int(landmarks.x*width), int(landmarks.y*height) \n",
    "\t\t\t\tlandmarkList.append([_id, x, y]) \n",
    "\n",
    "\t\t\t# draw Landmarks \n",
    "\t\t\tDraw.draw_landmarks(frame, handlm, \n",
    "\t\t\t\t\t\t\t\tmpHands.HAND_CONNECTIONS) \n",
    "\n",
    "\t# If landmarks list is not empty \n",
    "\tif landmarkList != []: \n",
    "\t\t# store x,y coordinates of (tip of) thumb \n",
    "\t\tx_1, y_1 = landmarkList[4][1], landmarkList[4][2] \n",
    "\n",
    "\t\t# store x,y coordinates of (tip of) index finger \n",
    "\t\tx_2, y_2 = landmarkList[8][1], landmarkList[8][2] \n",
    "\n",
    "\t\t# draw circle on thumb and index finger tip \n",
    "\t\tcv2.circle(frame, (x_1, y_1), 7, (0, 255, 0), cv2.FILLED) \n",
    "\t\tcv2.circle(frame, (x_2, y_2), 7, (0, 255, 0), cv2.FILLED) \n",
    "\n",
    "\t\t# draw line from tip of thumb to tip of index finger \n",
    "\t\tcv2.line(frame, (x_1, y_1), (x_2, y_2), (0, 255, 0), 3) \n",
    "\n",
    "\t\t# calculate square root of the sum of \n",
    "\t\t# squares of the specified arguments. \n",
    "\t\tL = hypot(x_2-x_1, y_2-y_1) \n",
    "\n",
    "\t\t# 1-D linear interpolant to a function \n",
    "\t\t# with given discrete data points \n",
    "\t\t# (Hand range 15 - 220, Brightness \n",
    "\t\t# range 0 - 100), evaluated at length. \n",
    "\t\tb_level = np.interp(L, [15, 220], [0, 100]) \n",
    "\n",
    "\t\t# set brightness \n",
    "\t\tsbc.set_brightness(int(b_level)) \n",
    "\n",
    "\t# Display Video and when 'q' is entered, destroy \n",
    "\t# the window \n",
    "\tcv2.imshow('Image', frame) \n",
    "\tif cv2.waitKey(1) & 0xff == ord('q'): \n",
    "\t\tbreak\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fe3be1c-92b3-4da3-a17f-6ce6576862aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [2,4,6]\n",
    "k = 2\n",
    "x=[]\n",
    "for i in nums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cddfd1a1-d304-428b-b7da-46ca0d369cb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums=[3,5]\n",
    "nums.sort()\n",
    "n=len(nums)\n",
    "for x in range(n+1):\n",
    "    c=sum(1 for num in nums if num>=x)\n",
    "    if c==x:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92428fae-7b00-4ec9-ab77-3554b632780f",
   "metadata": {},
   "outputs": [],
   "source": [
    "c=sum(1 for num in nums if num>=x)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f6cc922-fd7f-4cf1-b052-e67ac508462c",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"1\"\n",
    "y=int(s,2)\n",
    "# c=0\n",
    "# while y>0:\n",
    "#     if y%2==0:\n",
    "#         y=y//2\n",
    "#     else:\n",
    "#         y+=1\n",
    "#     c+=1\n",
    "# c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "947ba46c-66fa-4007-be94-c572361f2109",
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fbb55a3-9ccd-4356-b96a-fc0408c8acad",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'Hello World'\n",
    "y = ''\n",
    "z = 'aeiouAEIOU'\n",
    "# Extract vowels from the string x and store them in y\n",
    "for i in x:\n",
    "    if i in z:\n",
    "        y += i\n",
    "# Reverse the string of vowels\n",
    "p = y[::-1]\n",
    "# Create a list from the string x\n",
    "l = [i for i in x]\n",
    "# Replace the vowels in the list l with the reversed vowels from p\n",
    "j = 0\n",
    "for k in range(len(l)):\n",
    "    if l[k] in y:\n",
    "        l[k] = p[j]\n",
    "        j += 1\n",
    "vowels=''\n",
    "for i in l:\n",
    "    vowels+=i\n",
    "vowels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e99ded53-6160-4612-bb50-5ecb4b1c18e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverse_vowels(str):\n",
    "    vowel='aeiouAEIOU'\n",
    "    extract_vowel=''\n",
    "    for i in str:\n",
    "        if i in vowel:\n",
    "            extract_vowel+=i\n",
    "    reverse_extract_vowel=extract_vowel[::-1]\n",
    "    list_str=[i for i in str]\n",
    "    j=0\n",
    "    for k in range(len(list_str)):\n",
    "        if list_str[k] in extract_vowel:\n",
    "            list_str[k]=reverse_extract_vowel[j]\n",
    "            j+=1\n",
    "    result=''\n",
    "    for i in list_str:\n",
    "        result+=i\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa04f3c6-1970-45f5-8502-0a877b898b59",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(reverse_vowels('Hello World'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "254cf76f-f0b8-47cb-bee5-b62d7d13b051",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(reverse_vowels('Education'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92fcd92e-fe29-4a17-ab23-6f2cdf83f9df",
   "metadata": {},
   "outputs": [],
   "source": [
    "s='hello'\n",
    "l=[]\n",
    "for i in s:\n",
    "    l.append(ord(i))\n",
    "m=0\n",
    "for i in range(len(l)-1):\n",
    "    n=abs(l[i]-l[i+1])\n",
    "    m+=n\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa8c7e78-1cea-4974-927d-25658df13e35",
   "metadata": {},
   "outputs": [],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4724f49b-08a3-487b-a714-28111b6517ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "data = [[1, 'Vote for Biden'], [2, 'Let us make America great again!']]\n",
    "df = pd.DataFrame(data, columns=['tweet_id', 'content']).astype({'tweet_id':'Int64', 'content':'object'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47f0df61-b8b3-4c46-a828-9e4f3bf8fa19",
   "metadata": {},
   "outputs": [],
   "source": [
    "df1=pd.DataFrame(df['tweet_id'][df['content'].str.len()<15])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e9a8791-06a9-45ae-a633-8d7448b8dd5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def invalid_tweets(df: pd.DataFrame) -> pd.DataFrame:\n",
    "    df=df[df['content'].str.len()>15]\n",
    "    df=df[['tweet_id']]\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44ef0b45-6de2-4df5-aa93-53d7a159eb3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "digits='23'\n",
    "x={'2':'abc','3':'def','4':'ghi','5':'jkl','6':'mno','7':'pqrs','8':'tuv','9':'wxyz'}\n",
    "c=[]\n",
    "l=[]\n",
    "for i in digits:\n",
    "    c.append(x[i])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7161979c-1e0e-41e6-85cc-9cebdc442d33",
   "metadata": {},
   "outputs": [],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "247e456d-f4cc-40e4-9b16-ada42b8ebb90",
   "metadata": {},
   "outputs": [],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f00e7468-e998-483a-8843-2b6a1f611e10",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums1=[1,2,3,0,0,0]\n",
    "nums2=[2,5,6]\n",
    "m=3\n",
    "n=3\n",
    "x=[nums1[i] for i in range(m)]\n",
    "y=[nums2[i] for i in range(n)]\n",
    "z=x+y\n",
    "z.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b381326f-db6e-4925-a408-4028c0477cc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums1.clear()\n",
    "z=x+y\n",
    "for i in z:\n",
    "    nums1.append(i)\n",
    "nums1.sort()\n",
    "nums1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5faea9a9-8563-48a7-b34d-8bc965d8e147",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [0,1,2,2,3,0,4,2]\n",
    "val = 2\n",
    "nums.sort()\n",
    "for i in nums:\n",
    "    if i == val:\n",
    "        nums.remove(i)\n",
    "nums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e04d736e-d8ea-420e-9eb1-617fb8ff9b0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"the sky is blue\"\n",
    "print(s)\n",
    "l=s.split()\n",
    "l=l[::-1]\n",
    "x=''\n",
    "for i in l:\n",
    "    x+=i\n",
    "    x+=' '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70f86e0a-c195-45eb-8c96-15b73007f68c",
   "metadata": {},
   "outputs": [],
   "source": [
    "x\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77f1b8ab-531e-4d7c-86a0-20abc97cc41b",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab8a41bf-97c1-4c0a-9182-39af26a6de24",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb09cfa7-a4ef-4760-a19e-8c87a465fca1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Solution:\n",
    "    def commonChars(self, words):\n",
    "        # Initialize a list to store common characters\n",
    "        common_chars = []\n",
    "\n",
    "        # Iterate through each character of the first word\n",
    "        for char in words[0]:\n",
    "            # Check if the character is present in all other words\n",
    "            if all(char in word for word in words):\n",
    "                # Count the minimum occurrences of the character across all words\n",
    "                min_count = min(word.count(char) for word in words)\n",
    "                \n",
    "                # Add the character to the result as many times as its minimum count\n",
    "                common_chars.extend([char] * min_count)\n",
    "\n",
    "                # Remove the character from each word the minimum number of times to handle duplicates correctly\n",
    "                words = [word.replace(char, '', min_count) for word in words]\n",
    "\n",
    "        return common_chars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3672d0f5-8aa8-417b-8ee8-ab28f51428ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "solution = Solution()\n",
    "words = [\"bella\", \"label\", \"roller\"]\n",
    "print(solution.commonChars(words))  # Output: ['e', 'l', 'l']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f744c33-f2ba-4c29-b07e-2f1db75551ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [[1, 'Daniel', 'YFEV COUGH'], [2, 'Alice', ''], [3, 'Bob', 'DIAB100 MYOP'], [4, 'George', 'ACNE DIAB100'], [5, 'Alain', 'DIAB201']]\n",
    "df = pd.DataFrame(data, columns=['patient_id', 'patient_name', 'conditions']).astype({'patient_id':'int64', 'patient_name':'object', 'conditions':'object'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b950f355-6e80-492b-881a-c9ca30da0c48",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df['conditions'].str.contains('DIAB1')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49cbfa67-c83d-4c25-b576-a7c9b42161b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [1,2,3,4,5,6,7] \n",
    "k = 3\n",
    "print(id(nums))\n",
    "nums=nums[k+1::]+nums[:k+1:]\n",
    "# nums.clear()\n",
    "# print(id(nums))\n",
    "# nums=[i for i in nums]\n",
    "# nums\n",
    "nums\n",
    "print(id(nums))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1eb1d1d8-6a12-4538-a5ea-2a4a8657a9d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [1,2,3,4,5,6,7] \n",
    "print(id(nums))\n",
    "k = 3\n",
    "nums[:] = nums[-k % len(nums):] + nums[:-k % len(nums)]\n",
    "print(id(nums))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1bece7bc-9e05-4b99-9964-09f6c6bdfbc4",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [0, 1, 2, 0, 3, 0, 4]\n",
    "nums.sort(key=lambda x: x == 0)\n",
    "nums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4b64fe9-ba96-4999-b93d-7ecc5c95ea86",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [\"cat\",\"bat\",\"rat\"]\n",
    "y = \"the cattle was rattled by the battery\"\n",
    "z=y.split(' ')\n",
    "for i in x:\n",
    "    for j in z:\n",
    "        if i in j:\n",
    "            c=z.index(j)\n",
    "            z.remove(j)\n",
    "            z.insert(c,i)\n",
    "sentences=' '.join(i for i in z)\n",
    "sentences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed0e24bb-ba6f-47ce-9052-6960ee8b9204",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [\"cat\",\"bat\",\"rat\"]\n",
    "y='cattel'\n",
    "for i in x:\n",
    "    if i in y:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c185d34d-a31a-4f29-9783-601698060287",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=float('inf')\n",
    "y=5\n",
    "x<y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73e04422-1f1a-4a56-bcb0-e9d004980055",
   "metadata": {},
   "outputs": [],
   "source": [
    "# if len(nums)<2:\n",
    "#             return False\n",
    "#         cumulative_sum = 0\n",
    "\n",
    "#         remainder_index_map = {0: -1}\n",
    "        \n",
    "#         for i in range(len(nums)):\n",
    "#             cumulative_sum += nums[i]\n",
    "#             remainder = cumulative_sum % k\n",
    "            \n",
    "#             if remainder in remainder_index_map:\n",
    "#                 if i - remainder_index_map[remainder] > 1:\n",
    "#                     return True\n",
    "#             else:\n",
    "#                 remainder_index_map[remainder] = i\n",
    "        \n",
    "#         return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca8ef12c-e9dd-4789-b8bd-82dc4b27d910",
   "metadata": {},
   "outputs": [],
   "source": [
    "height = [1,8,6,2,5,4,8,3,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "865390c9-2880-4ebf-9ddd-8a1f973cd5b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "data = [[1, 'Joe', 70000, 1], [2, 'Jim', 90000, 1], [3, 'Henry', 80000, 2], [4, 'Sam', 60000, 2], [5, 'Max', 90000, 1]]\n",
    "df= pd.DataFrame(data, columns=['id', 'name', 'salary', 'departmentId']).astype({'id':'Int64', 'name':'object', 'salary':'Int64', 'departmentId':'Int64'})\n",
    "data = [[1, 'IT'], [2, 'Sales']]\n",
    "df1= pd.DataFrame(data, columns=['id', 'name']).astype({'id':'Int64', 'name':'object'})\n",
    "df2=pd.merge(df,df1,how='left',left_on='departmentId',right_on='id')\n",
    "df2=df2.rename(columns={'name_x':'Employee','salary':'Salary','name_y':'Department'})\n",
    "# df2 = df2.groupby('Department')['Salary'].max().reset_index()\n",
    "# result = pd.merge(max_values, df2, on=['Department', 'Salary'])\n",
    "# result.iloc[:,[0,3,1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d473977-d22a-4d99-8d73-647524d7d3a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42f588ea-1de1-42eb-be1f-6d2d0679080e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "235af6fb-e639-4a5e-929a-f165df920158",
   "metadata": {},
   "outputs": [],
   "source": [
    "df= pd.DataFrame( columns=['id', 'name', 'salary', 'departmentId']).astype({'id':'Int64', 'name':'object', 'salary':'Int64', 'departmentId':'Int64'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "602a1022-68ad-4cd5-86b6-e873bbe13308",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc7c6a50-b87e-4bba-94d7-0ed1af505c39",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "s='abc'\n",
    "a=re.match('0-9',s)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06bc77c6-5414-43f4-8f17-4489bf517275",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "class Solution:\n",
    "    def findWinningPlayer(self, skills, k):\n",
    "        n = len(skills)\n",
    "        queue = deque(range(n))\n",
    "        consecutive_wins = [0] * n\n",
    "        \n",
    "        current_winner = queue.popleft()\n",
    "        while True:\n",
    "            current_player = queue.popleft()\n",
    "            \n",
    "            if skills[current_winner] > skills[current_player]:\n",
    "                consecutive_wins[current_winner] += 1\n",
    "                queue.append(current_player)\n",
    "                \n",
    "                if consecutive_wins[current_winner] == k:\n",
    "                    return current_winner\n",
    "            else:\n",
    "                consecutive_wins[current_winner] = 0\n",
    "                current_winner = current_player\n",
    "                consecutive_wins[current_winner] += 1\n",
    "                queue.append(queue.popleft())\n",
    "                \n",
    "                if consecutive_wins[current_winner] == k:\n",
    "                    return current_winner\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b91ade2-67f8-4c7d-8e50-8df6c3d79c1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "sol = Solution()\n",
    "print(sol.findWinningPlayer([4,2,6,3,9], 2))  # Output: 2\n",
    "print(sol.findWinningPlayer([2,5,4], 3))     # Output: 1\n",
    "print(sol.findWinningPlayer([3,1,5,7,2], 4)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a060a3a8-4fb0-4b7a-b5b0-6710f06c90ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Solution:\n",
    "    def maximumLength(self, nums,k):\n",
    "        n = len(nums)\n",
    "        max_length = 0\n",
    "        start = 0\n",
    "        diff_count = 0\n",
    "\n",
    "        for end in range(n):\n",
    "            if end > 0 and nums[end] != nums[end - 1]:\n",
    "                diff_count += 1\n",
    "\n",
    "            while diff_count > k:\n",
    "                if start + 1 < n and nums[start] != nums[start + 1]:\n",
    "                    diff_count -= 1\n",
    "                start += 1\n",
    "\n",
    "            max_length = max(max_length, end - start + 1)\n",
    "\n",
    "        return max_length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe3b2866-4afc-4372-b728-5a9a8df6296b",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums =[1,2,3,4,5,1]\n",
    "k=0\n",
    "solution = Solution()\n",
    "print(solution.maximumLength(nums,k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c06d51d0-08a1-4f73-af30-3b02e7276fe9",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [3, 1, 3, 4, 3]\n",
    "k = 6\n",
    "c = 0\n",
    "i = 0\n",
    "while i < len(nums):\n",
    "    found_pair = False\n",
    "    for j in range(i + 1, len(nums)):\n",
    "        if nums[i] + nums[j] == k:\n",
    "            nums.pop(j)\n",
    "            nums.pop(i)\n",
    "            c += 1\n",
    "            found_pair = True\n",
    "            break\n",
    "    if not found_pair:\n",
    "        i += 1\n",
    "\n",
    "print(c)\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54495fa9-ae8b-43fa-8686-716a15f930b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84052f0a-e492-416e-8bbf-9bff9f19a96c",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [[1, 3.5], [2, 3.65], [3, 4.0], [4, 3.85], [5, 4.0], [6, 3.65]]\n",
    "df = pd.DataFrame(data, columns=['id', 'score']).astype({'id':'Int64', 'score':'Float64'})\n",
    "df['rank'] = df['score'].rank(method='dense', ascending=False).astype(int)\n",
    "df = df.sort_values(by='score', ascending=False)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb96670a-7a2e-4b37-88f5-9ff3f560a580",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Solution:\n",
    "    def merge(self,nums1, nums2):\n",
    "        nums3 = nums1 + nums2\n",
    "        nums3.sort()\n",
    "        n = len(nums3)\n",
    "        \n",
    "        if n % 2 != 0:\n",
    "            return nums3[n // 2]\n",
    "        else:\n",
    "            mid1 = n // 2\n",
    "            mid2 = mid1 - 1\n",
    "            return (nums3[mid1] + nums3[mid2]) / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0389563-3a69-4656-9704-908b1cd4f586",
   "metadata": {},
   "outputs": [],
   "source": [
    "result=Solution()\n",
    "print(result.merge([1,3],[2]))\n",
    "print(result.merge([1,2],[3,4]))\n",
    "print(result.merge([],[1,2,3,4,5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0a27efb-63a3-420f-afe1-212fac342926",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [2,3,1,1,4]\n",
    "n=1\n",
    "while n<len(nums):\n",
    "    if nums[]==nums[-1]:\n",
    "        print(True)\n",
    "    else:\n",
    "        print(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69da2d5d-a98e-4f76-bfd7-4dcf6923257a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "data = [[1, 'john@example.com'], [2, 'bob@example.com'], [3, 'john@example.com']]\n",
    "df= pd.DataFrame(data, columns=['id', 'email']).astype({'id':'int64', 'email':'object'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "476dcd62-0b0c-4dea-920d-c103d9b629fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71a456bd-3acc-4912-a1c3-2e6fad918f08",
   "metadata": {},
   "outputs": [],
   "source": [
    "df=df.drop_duplicates(subset=['email'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "320c364b-4c50-4b1f-9c53-0557dff47e90",
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d869d1c0-6eb2-477d-b3cb-e4ab4efeee8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# x=''\n",
    "# for i in df['email']:\n",
    "#     if i not in x:\n",
    "#         x.append(i)\n",
    "#     else:\n",
    "#         df['email'].drop(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eaabbfe1-3237-47f3-8cd7-929e69840a1d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "arr1 = [2,3,1,3,2,4,6,7,9,2,19]\n",
    "arr2 = [2,1,4,3,9,6]\n",
    "a=[i for i in arr1 if i in arr2]\n",
    "order_map = {value: index for index, value in enumerate(arr2)}\n",
    "sorted_a = sorted(a, key=lambda x: order_map.get(x, len(arr2)))\n",
    "print(sorted_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af1a4fd7-2120-4dc4-9da4-bada76140193",
   "metadata": {},
   "outputs": [],
   "source": [
    "Output: [2,2,2,1,4,3,3,9,6,7,19]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2ed8d0b-163e-4ce7-9f3e-10b6339b1091",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "data = [[0, 95, 100, 105], [1, 70, None, 80]]\n",
    "df= pd.DataFrame(data, columns=['product_id', 'store1', 'store2', 'store3']).astype({'product_id':'Int64', 'store1':'Int64', 'store2':'Int64', 'store3':'Int64'})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be9603c2-6e59-419a-bbdf-733ff461d4bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the melt function to reshape the DataFrame\n",
    "melted_df = pd.melt(df, id_vars=['product_id'], value_vars=['store1', 'store2', 'store3'],\n",
    "                    var_name='store', value_name='price')\n",
    "\n",
    "# Filter out the rows with null values in the 'price' column\n",
    "result_df = melted_df.dropna(subset=['price'])\n",
    "\n",
    "# Reset index for better readability\n",
    "result_df.reset_index(drop=True, inplace=True)\n",
    "\n",
    "print(result_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b2a146b-4363-4237-81b1-c10e7954873d",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [5,7,7,8,8,10]\n",
    "target = 8\n",
    "class Solution:\n",
    "    def searchRange(self, nums, target):\n",
    "        l=[]\n",
    "        for _ in range(0,2):\n",
    "            if target not in nums:\n",
    "                l.append(-1)\n",
    "        for _ in range(0,2):\n",
    "            if target in nums:\n",
    "                l.append(nums.index(target))\n",
    "                nums.remove(target)\n",
    "        return l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2633a298-7b9a-4cd9-9e6a-eed2b49e3e87",
   "metadata": {},
   "outputs": [],
   "source": [
    "r=Solution()\n",
    "r.searchRange(nums,target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67a58cf2-35b9-4dc4-a323-4d7b9f6b4589",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Solution:\n",
    "    def searchRange(self, nums, target):\n",
    "        def findFirst(nums, target):\n",
    "            left, right = 0, len(nums) - 1\n",
    "            while left <= right:\n",
    "                mid = (left + right) // 2\n",
    "                if nums[mid] >= target:\n",
    "                    right = mid - 1\n",
    "                else:\n",
    "                    left = mid + 1\n",
    "            return left\n",
    "\n",
    "        def findLast(nums, target):\n",
    "            left, right = 0, len(nums) - 1\n",
    "            while left <= right:\n",
    "                mid = (left + right) // 2\n",
    "                if nums[mid] <= target:\n",
    "                    left = mid + 1\n",
    "                else:\n",
    "                    right = mid - 1\n",
    "            return right\n",
    "\n",
    "        start = findFirst(nums, target)\n",
    "        end = findLast(nums, target)\n",
    "\n",
    "        # Check if the target is not present in the array\n",
    "        if start <= end and 0 <= start < len(nums) and nums[start] == target:\n",
    "            return [start, end]\n",
    "        else:\n",
    "            return [-1, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6939646-371d-4050-acca-923208746e00",
   "metadata": {},
   "outputs": [],
   "source": [
    "r=Solution()\n",
    "r.searchRange(nums,target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "995cda29-c4fc-48a4-a72a-2e7f0a328d65",
   "metadata": {},
   "outputs": [],
   "source": [
    "+--------+------------+---------+----------+\n",
    "Output: \n",
    "+------------+--------+------------+\n",
    "| day        | emp_id | total_time |\n",
    "+------------+--------+------------+\n",
    "| 2020-11-28 | 1      | 173        |\n",
    "| 2020-11-28 | 2      | 30         |\n",
    "| 2020-12-03 | 1      | 41         |\n",
    "| 2020-12-09 | 2      | 27         |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71fdc91d-56c3-4301-9b6d-376112570202",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "data = [['1', '2020-11-28', '4', '32'], ['1', '2020-11-28', '55', '200'], ['1', '2020-12-3', '1', '42'], ['2', '2020-11-28', '3', '33'], ['2', '2020-12-9', '47', '74']]\n",
    "df = pd.DataFrame(data, columns=['emp_id', 'event_day', 'in_time', 'out_time']).astype({'emp_id':'Int64', 'event_day':'datetime64[ns]', 'in_time':'Int64', 'out_time':'Int64'})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "919a9f9f-9d26-43b3-8ed4-9142276a6bab",
   "metadata": {},
   "outputs": [],
   "source": [
    "df['time_spent'] = df['out_time'] - df['in_time']\n",
    "    \n",
    "# # Group by emp_id and event_day and sum the time spent for each group\n",
    "result = df.groupby(['emp_id', 'event_day'], as_index=False)['time_spent'].sum()\n",
    "    \n",
    "# # Rename columns to match the required output format\n",
    "result.rename(columns={'event_day': 'day', 'time_spent': 'total_time'}, inplace=True)\n",
    "    \n",
    "# return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be3679dd-c9b6-4f99-97cf-0c43da7e6b98",
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b98b040-8f10-4b9d-be11-89ba921141cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d0c6b774-c3a8-48d4-8b1c-d1f728179770",
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e3db4623-f976-4c9a-a09e-997be6c564a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nums=[3,2,1,2,1,7]\n",
    "nums.sort()\n",
    "l=set(nums)\n",
    "m=min(nums)\n",
    "x=max(nums)\n",
    "c=len(nums)-len(l)\n",
    "n=[i for i in range(m,x+1)]\n",
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "af87d86f-27d4-4f0d-baab-a4bfdb1add06",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "cfd1c3f9-fae3-4882-91fe-ae679f592fa2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>player_id</th>\n",
       "      <th>device_id</th>\n",
       "      <th>event_date</th>\n",
       "      <th>games_played</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>2016-03-01</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>2016-05-02</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>2017-06-25</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>2016-03-02</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>2018-07-03</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   player_id  device_id event_date  games_played\n",
       "0          1          2 2016-03-01             5\n",
       "1          1          2 2016-05-02             6\n",
       "2          2          3 2017-06-25             1\n",
       "3          3          1 2016-03-02             0\n",
       "4          3          4 2018-07-03             5"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = [[1, 2, '2016-03-01', 5], [1, 2, '2016-05-02', 6], [2, 3, '2017-06-25', 1], [3, 1, '2016-03-02', 0], [3, 4, '2018-07-03', 5]]\n",
    "df = pd.DataFrame(data, columns=['player_id', 'device_id', 'event_date', 'games_played']).astype({'player_id':'Int64', 'device_id':'Int64', 'event_date':'datetime64[ns]', 'games_played':'Int64'})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "7eba2366-92a5-400e-bfe1-d52c99b2e6eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "def game_analysis(df: pd.DataFrame) -> pd.DataFrame:\n",
    "    df['event_date'] = pd.to_datetime(df['event_date'])\n",
    "    first_login_df = df.groupby('player_id')['event_date'].min().reset_index()\n",
    "    first_login_df = first_login_df.rename(columns={'event_date': 'first_login'})\n",
    "    return first_login_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "4e4aee66-41a9-4d6b-a0fa-959f2718e254",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>player_id</th>\n",
       "      <th>first_login</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2016-03-01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>2017-06-25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>2016-03-02</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   player_id first_login\n",
       "0          1  2016-03-01\n",
       "1          2  2017-06-25\n",
       "2          3  2016-03-02"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game_analysis(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "05907fea-7961-4247-99d3-faeee2f9e0d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "781"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gain =[44,32,-9,52,23,-50,50,33,-84,47,-14,84,36,-62,37,81,-36,-85,-39,67,-63,64,-47,95,91,-40,65,67,92,-28,97,100,81]\n",
    "l=[]\n",
    "c=0\n",
    "for i in gain:\n",
    "    l.append(c)\n",
    "    c+=i\n",
    "l.append(c)\n",
    "max(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "41f7edeb-713c-4e6d-9d85-e88d2c8e60da",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Solution:\n",
    "    def judgeSquareSum(self, c: int) -> bool:\n",
    "        for i in range(0, int(c**0.5) + 1):\n",
    "            j = c - i**2\n",
    "            if int(j**0.5)**2 == j:\n",
    "                return True\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "26a5e350-af0e-4a88-bb6b-2deb826f4bcb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "x=Solution()\n",
    "y=int(input())\n",
    "print(x.judgeSquareSum(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "9eb6445d-22b3-4965-9789-711ce4204d58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>order_number</th>\n",
       "      <th>customer_number</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   order_number  customer_number\n",
       "0             1                1\n",
       "1             2                2\n",
       "2             3                3\n",
       "3             4                3"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "data = [[1, 1], [2, 2], [3, 3], [4, 3]]\n",
    "df = pd.DataFrame(data, columns=['order_number', 'customer_number']).astype({'order_number':'Int64', 'customer_number':'Int64'})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "1f0c7346-3aa2-4754-82a4-24f5d6a88713",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>customer_number</th>\n",
       "      <th>order_count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   customer_number  order_count\n",
       "2                3            2"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Step 1: Group by customer_number and count the orders\n",
    "order_counts = df.groupby('customer_number').size().reset_index(name='order_count')\n",
    "order_counts\n",
    "\n",
    "# # Step 2: Find the maximum order count\n",
    "max_order_count = order_counts['order_count'].max()\n",
    "max_order_count\n",
    "\n",
    "# # Step 3: Filter for the customer(s) with the maximum order count\n",
    "customers_with_max_orders = order_counts[order_counts['order_count'] == max_order_count]\n",
    "customers_with_max_orders\n",
    "# # Display the result\n",
    "# print(customers_with_max_orders[['customer_number']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "e0ed6219-6caa-4041-9199-c83b84b4eed1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "cnt=Counter(df['customer_number'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "797fbfca-3f96-4b0a-a111-21b5d307c1b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cntmax(cnt.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "72d988c1-3fbb-4d4f-ab38-c2687b259c7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "l='kl'\n",
    "l.index('k')\n",
    "l=[]\n",
    "l.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e622c080-72d6-4a00-99b9-6245c7a1bfe5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*\n",
      "*\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'lecod*e'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=\"leet**cod*e\"\n",
    "l=[i for i in s]\n",
    "c=''\n",
    "for i in l:\n",
    "    if i =='*':\n",
    "        print(i)\n",
    "        x=l.index(i)-1\n",
    "        l.remove(l[x])\n",
    "        l.remove(i)\n",
    "for i in l:\n",
    "    c+=i\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f014c329-0f80-41cc-97cf-0be8608fea61",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>unique_id</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>11</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>90</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   id  unique_id\n",
       "0   3          1\n",
       "1  11          2\n",
       "2  90          3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "data = [[1, 'Alice'], [7, 'Bob'], [11, 'Meir'], [90, 'Winston'], [3, 'Jonathan']]\n",
    "df= pd.DataFrame(data, columns=['id', 'name']).astype({'id':'int64', 'name':'object'})\n",
    "data = [[3, 1], [11, 2], [90, 3]]\n",
    "df1 = pd.DataFrame(data, columns=['id', 'unique_id']).astype({'id':'int64', 'unique_id':'int64'})\n",
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "82a4607f-4ec0-4ed4-95f6-fad65a659e4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>name</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Alice</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>7</td>\n",
       "      <td>Bob</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>11</td>\n",
       "      <td>Meir</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>90</td>\n",
       "      <td>Winston</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>Jonathan</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   id      name\n",
       "0   1     Alice\n",
       "1   7       Bob\n",
       "2  11      Meir\n",
       "3  90   Winston\n",
       "4   3  Jonathan"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "1104a0c0-63ef-48cb-b8e8-384dbfa0cead",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\panka\\AppData\\Local\\Temp\\ipykernel_17272\\1799007193.py:2: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise in a future error of pandas. Value 'null' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n",
      "  df3['unique_id'].fillna('null',inplace=True)\n"
     ]
    }
   ],
   "source": [
    "df3=pd.merge(df,df1,on='id',how='left')\n",
    "df3['unique_id'].fillna('null',inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "576f46eb-3c19-4852-8951-fd444fc074a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>name</th>\n",
       "      <th>unique_id</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Alice</td>\n",
       "      <td>null</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>7</td>\n",
       "      <td>Bob</td>\n",
       "      <td>null</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>11</td>\n",
       "      <td>Meir</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>90</td>\n",
       "      <td>Winston</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>Jonathan</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   id      name unique_id\n",
       "0   1     Alice      null\n",
       "1   7       Bob      null\n",
       "2  11      Meir       2.0\n",
       "3  90   Winston       3.0\n",
       "4   3  Jonathan       1.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7b3988e7-72a1-48cf-b21a-47ac0f244b7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "s =\"3[a]2[bc]\"\n",
    "x=''\n",
    "y='[]'\n",
    "l=[i for i in s if i not in y]\n",
    "z=''.join(l)\n",
    "for i in range(len(s)-1):\n",
    "    if s[i].isdigit() and s[i+1].islower():\n",
    "        x+=int(l[i])*l[i+1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "efb7b66b-4fad-4646-8a8e-f9345e8494cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=''\n",
    "y='[]'\n",
    "l=[i for i in s if i not in y]\n",
    "z=''.join(l)\n",
    "for i in range(len(s)-1):\n",
    "    if s[i].isdigit() and s[i+1].islower():\n",
    "        x+=int(l[i])*l[i+1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0a1746cc-46c9-4f61-a4b6-d2ec0cd3e89a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "x = \"sadbutsad\" \n",
    "y = \"sad\"\n",
    "# x=len(needle)\n",
    "# y=[haystack[i:i+x] for i in range(0, len(haystack), x)]\n",
    "z=[i for i in x]\n",
    "if y in x:\n",
    "    print( z.index(y[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "4f82155e-de14-4707-831f-51967e2a4f43",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 5\n",
    "roads = [[0,1],[1,2],[2,3],[0,2],[1,3],[2,4]]\n",
    "l=[]\n",
    "for i in roads:\n",
    "    for j in i:\n",
    "        if j not in l:\n",
    "            l.append(j)\n",
    "x=[i for i in range(1,n+1)]\n",
    "z={i:j for i,j in zip(l,x)}\n",
    "c=0\n",
    "n=[i for j in roads for i in j]\n",
    "for i in n:\n",
    "    c+=z[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fef6f098-48ac-480f-b0c2-f09ff46023d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "s ='0P'\n",
    "x=''\n",
    "for i in s:\n",
    "    if i.isalpha():\n",
    "        x+=i\n",
    "x=x.lower()\n",
    "if x==x[-1::-1]:\n",
    "    print(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "64d1a625-47a7-4fc5-9d06-5d53324fc85f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'amanaplanacanalpanama'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[-1::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fe25cfea-78c6-469f-804b-5fe7b45c135c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=9\n",
    "x//2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ec7cdf8a-9a80-427a-8a0e-b12808287f4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Solution:\n",
    "    def maximumGain(self, s: str, x: int, y: int) -> int:\n",
    "        score = 0\n",
    "        if x > y:\n",
    "            stack = []\n",
    "            for char in s:\n",
    "                if stack and stack[-1] == 'a' and char == 'b':\n",
    "                    stack.pop()\n",
    "                    score += x\n",
    "                else:\n",
    "                    stack.append(char)\n",
    "            remaining_s = ''.join(stack)\n",
    "            stack = []\n",
    "            for char in remaining_s:\n",
    "                if stack and stack[-1] == 'b' and char == 'a':\n",
    "                    stack.pop()\n",
    "                    score += y\n",
    "                else:\n",
    "                    stack.append(char)\n",
    "        else:\n",
    "            stack = []\n",
    "            for char in s:\n",
    "                if stack and stack[-1] == 'b' and char == 'a':\n",
    "                    stack.pop()\n",
    "                    score += y\n",
    "                else:\n",
    "                    stack.append(char)\n",
    "            remaining_s = ''.join(stack)\n",
    "            stack = []\n",
    "            for char in remaining_s:\n",
    "                if stack and stack[-1] == 'a' and char == 'b':\n",
    "                    stack.pop()\n",
    "                    score += x\n",
    "                else:\n",
    "                    stack.append(char)\n",
    "        return score\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d412e43a-228f-45be-b449-e218a849efe0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6a1b82a3-a000-44a6-b340-eb93b084407f",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums=[5,3,2,1]\n",
    "li=[]\n",
    "p=0\n",
    "for i in nums:\n",
    "    if i<=p:\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e40d2ed5-f1e5-46dc-abd8-492b088d0bb4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "s=10\n",
    "g=7\n",
    "z=bin(s)\n",
    "print(type(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "c605d592-2ad1-410d-9ff1-9ef2a18cc321",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr =[37,12,28,9,100,56,80,5,12]\n",
    "li=[i for i in arr]\n",
    "arr=set(arr)\n",
    "arr=list(arr)\n",
    "arr.sort()\n",
    "li\n",
    "arr\n",
    "x=[]\n",
    "for i in li:\n",
    "    x.append(list(arr).index(i)+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "f150f43c-4406-4a70-a139-02ac7c1fc5d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# class Solution:\n",
    "#     def arrayRankTransform(self, arr: List[int]) -> List[int]:\n",
    "#         # Sort the array and create a rank dictionary for unique values\n",
    "#         rank = {val: i + 1 for i, val in enumerate(sorted(set(arr)))}\n",
    "#         # Replace each value in the original array with its rank\n",
    "#         return [rank[val] for val in arr]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b464d0c4-e634-4f64-9165-fa11dc95f502",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3), (1, 3)]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "skill = [1,1,2,3]\n",
    "s=max(skill)+min(skill)\n",
    "z=[]\n",
    "for i in range(0,len(skill)):\n",
    "    for j in range(i+1,len(skill)):\n",
    "        if skill[i]+skill[j]==s:\n",
    "            z.append((skill[i],skill[j]))\n",
    "# x=[reduce(lambda x, y: x * y, i) for i in z]\n",
    "# sum(x)\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "befcf5ef-45ab-4ab9-a574-f115c922218f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.11.7"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}