diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000..105ce2d --- /dev/null +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..a971a2c --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..4be24c6 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/python_learning.iml b/.idea/python_learning.iml new file mode 100644 index 0000000..909438d --- /dev/null +++ b/.idea/python_learning.iml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.ipynb_checkpoints/if_else_Condition-checkpoint.py b/.ipynb_checkpoints/if_else_Condition-checkpoint.py new file mode 100644 index 0000000..8d55000 --- /dev/null +++ b/.ipynb_checkpoints/if_else_Condition-checkpoint.py @@ -0,0 +1,8 @@ +x = int(input("enter a number")) + +if x % 2 == 0: + print("Even number") +else: + print("Odd number") + +print("If else condition example ") \ No newline at end of file diff --git a/.ipynb_checkpoints/test-checkpoint.ipynb b/.ipynb_checkpoints/test-checkpoint.ipynb new file mode 100644 index 0000000..1dce5e5 --- /dev/null +++ b/.ipynb_checkpoints/test-checkpoint.ipynb @@ -0,0 +1,1634 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "ml = [1,2,3,2,3,4,5,6]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nl = []\n", + "for i in ml:\n", + " if i not in nl:\n", + " nl.append(i)\n", + "\n", + "nl.sort()\n", + "nl[-2]" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "def rn(li):\n", + " nl=[]\n", + " for i in li:\n", + " if i not in nl:\n", + " nl.append(i)\n", + " \n", + " nl.sort()\n", + " return nl[-2]" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3]\n" + ] + } + ], + "source": [ + "if __name__ == '__main__':\n", + " n = int(input())\n", + " arr = map(int, input().split())\n", + " lst = list(arr)\n", + " score = list(lst)\n", + " print(score)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "list(set(ml)).sort()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (2420166799.py, line 7)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m Cell \u001b[0;32mIn[34], line 7\u001b[0;36m\u001b[0m\n\u001b[0;31m score =\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + "if __name__ == '__main__':\n", + " num = []\n", + " arr = []\n", + " ls = int(input())\n", + " for _ in range(ls):\n", + " name = input()\n", + " score = " + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Not weired\n" + ] + } + ], + "source": [ + "if __name__ == '__main__':\n", + " n = int(input(\"Enter a number\").strip())\n", + " if n % 2 != 0:\n", + " print(\"Weired\")\n", + " elif n in range(2,6):\n", + " print(\"Not weired\")\n", + " elif n in range (6,21):\n", + " print(\"weired\")\n", + " else:\n", + " print(\"Not weired\")" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "list index out of range", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[41], line 12\u001b[0m\n\u001b[1;32m 10\u001b[0m first_multiple_input \u001b[39m=\u001b[39m \u001b[39minput\u001b[39m()\u001b[39m.\u001b[39mrstrip()\u001b[39m.\u001b[39msplit()\n\u001b[1;32m 11\u001b[0m a \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(first_multiple_input[\u001b[39m0\u001b[39m])\n\u001b[0;32m---> 12\u001b[0m b \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(first_multiple_input[\u001b[39m1\u001b[39;49m])\n\u001b[1;32m 13\u001b[0m x \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(first_multiple_input[\u001b[39m2\u001b[39m])\n\u001b[1;32m 14\u001b[0m y \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(first_multiple_input[\u001b[39m3\u001b[39m])\n", + "\u001b[0;31mIndexError\u001b[0m: list index out of range" + ] + } + ], + "source": [ + "def solve(a,b,x,y):\n", + " if math.gcd(a,b) == math.gcd(x,y):\n", + " return \"YES\"\n", + " return \"NO\"\n", + "\n", + "if __name__ == '__main__':\n", + " t = int(input().strip())\n", + "\n", + " for _ in range (int(input())):\n", + " first_multiple_input = input().rstrip().split()\n", + " a = int(first_multiple_input[0])\n", + " b = int(first_multiple_input[1])\n", + " x = int(first_multiple_input[2])\n", + " y = int(first_multiple_input[3])\n", + "\n", + " result = solve(a,b,x,y)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "invalid literal for int() with base 10: ''", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[43], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39m__name__\u001b[39m \u001b[39m==\u001b[39m \u001b[39m'\u001b[39m\u001b[39m__main__\u001b[39m\u001b[39m'\u001b[39m:\n\u001b[0;32m----> 2\u001b[0m x \u001b[39m=\u001b[39m \u001b[39mint\u001b[39;49m(\u001b[39minput\u001b[39;49m())\n\u001b[1;32m 3\u001b[0m y \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(\u001b[39minput\u001b[39m())\n\u001b[1;32m 4\u001b[0m z \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(\u001b[39minput\u001b[39m())\n", + "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: ''" + ] + } + ], + "source": [ + "if __name__ == '__main__':\n", + " x = int(input())\n", + " y = int(input())\n", + " z = int(input())\n", + " n = int(input())\n", + " l =[]\n", + " for i in range(x+1):\n", + " for j in range(y+1):\n", + " for k in range(z+1):\n", + " if i + j + k == n:\n", + " continue\n", + " l.append([i,j,k])\n", + " \n", + " print(l)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "def my_function():\n", + " print(\"Hello from a function\")" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello from a function\n" + ] + } + ], + "source": [ + "my_function()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "def my_fun_par(fname):\n", + " print(fname + \" Refsnes\")" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Naveen Refsnes\n" + ] + } + ], + "source": [ + "my_fun_par(\"Naveen\")" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reddy Refsnes\n" + ] + } + ], + "source": [ + "my_fun_par(\"Reddy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "def my_fun(fn,ln):\n", + " ft = fn + ln\n", + " print(ft)\n", + "\n", + " # return fn" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_fun(\"Naveen\",\"Reddy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "def fnf(**kid):\n", + " print(\"his last name is \" + kid[\"lname\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "his last name is Ganta\n" + ] + } + ], + "source": [ + "fnf(fname= \"Tobiad\", lname=\"Ganta\")" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "def myf(food):\n", + " for x in food:\n", + " print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "apple\n", + "banana\n", + "cherry\n" + ] + } + ], + "source": [ + "fr = ['apple','banana','cherry']\n", + "myf(fr)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "s = 'AABCAAADA'\n", + "k = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "n = len(s)/3" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.0" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "word = s[0:k]" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'AAB'" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "word" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "string = s[k:]" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'CAAADA'" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [], + "source": [ + "while s:\n", + " word = s[0:k]\n", + " s= s[k:]\n", + "\n", + " print(''.join(help(word)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "def merge_tl(s,k):\n", + " n = len(s)\n", + "\n", + " def help(items):\n", + " seen = set()\n", + " for i in items:\n", + " if i not in seen:\n", + " yield i\n", + " seen.add(i)\n", + " while s:\n", + " word = s[0:k]\n", + " s= s[k:]\n", + "\n", + " print(''.join(help(word)))\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], + "source": [ + "print(merge_tl(s,k))" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], + "source": [ + "def merge_the_tools(string, k):\n", + " n = len(string)\n", + "\n", + " def help_fun(items):\n", + " seen = set()\n", + " for i in items:\n", + " if i not in seen:\n", + " yield i\n", + " seen.add(i)\n", + "\n", + " while string:\n", + " word = string[0:k]\n", + " string = string[k:]\n", + " \n", + " print (''.join(help_fun(word)))\n", + "\n", + "\n", + "if __name__ == '__main__':\n", + " string, k = s,k\n", + " merge_the_tools(string, k)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "abcd\n", + "efgh\n", + "ijkl\n", + "mn\n" + ] + } + ], + "source": [ + "def wrap(st,n):\n", + " con = list(st)\n", + "\n", + " ls=[]\n", + " l=\"\"\n", + " for i in con:\n", + " if len(l) < n:\n", + " l+=i\n", + " \n", + " else:\n", + " ls.append(l)\n", + " l = i\n", + "\n", + " ls.append(l)\n", + "\n", + " return \"\\n\".join(ls)\n", + "\n", + "\n", + "\n", + "if __name__ == '__main__':\n", + " st, n = input(),int(input())\n", + " rs = wrap(st,n)\n", + " print(rs)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'g'" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "min('stringsjhs')" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "t = \"The rain 59 in Spain\"\n", + "x = re.search(\"^The.*Spains$\",t)" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], + "source": [ + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['i', 'i', 'i']\n" + ] + } + ], + "source": [ + "v = re.findall(\"[i]\",t)\n", + "print(v)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['5', '9']\n" + ] + } + ], + "source": [ + "n= re.findall(\"\\d\",t)\n", + "print(n)" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['rain']" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "re.findall(\"r..n\",t)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def swapList(newList):\n", + " n = len(newList)\n", + "\n", + " temp = newList[0]\n", + " newList[0] = newList[n-1]\n", + " newList[n-1] = temp\n", + "\n", + " return newList" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[5, 2, 3, 4, 1]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l =[1,2,3,4,5]\n", + "swapList(l)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def swapPosition(list,pos1,pos2):\n", + "\n", + " list[pos1],list[pos2] = list[pos2],list[pos1]\n", + " \n", + " return list" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[5, 2, 4, 3, 1]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "swapPosition(l,2,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def swapEle(list,e1,e2):\n", + "\n", + " \n", + " for sub in list:\n", + " temp = '-'\n", + " sub.replace(e1,temp).replace(e2,e1).replace(temp,e2)\n", + "\n", + " return sub\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Geeks'" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sl = ['Gfg', 'is', 'best', 'for', 'Geeks']\n", + "swapEle(sl,'e','G')" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "ls = \", \".join(sl)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gfg, is, best, for, Geeks\n" + ] + } + ], + "source": [ + "print(ls)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['efg', 'is', 'bGst', 'for', 'eGGks']\n" + ] + } + ], + "source": [ + "res = ls.replace('G','-').replace('e','G').replace('-','e').split(', ')\n", + "print(res)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def max(a,b):\n", + " if a>b:\n", + " return a\n", + " else:\n", + " return (\"maximum of numbers is \" + str(b))" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'maximum of numbers is 4'" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "max(2,4)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "min(3,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[5, 2, 4, 3, 1]" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "def elemList(l,n):\n", + " if n in l:\n", + " return \"exist\"\n", + " else:\n", + " return \"not present\"" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'exist'" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "elemList(l,5)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[5, 2, 4, 3, 1]" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "def reveseL(l):\n", + " nl = []\n", + " ln = len(l)-1\n", + " for i in l:\n", + " nl.insert(0,i)\n", + "\n", + " return nl" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5, 2, 4, 3, 1]\n", + "[1, 3, 4, 2, 5]\n" + ] + } + ], + "source": [ + "print(l)\n", + "print(reveseL(l))" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "l\n", + "m = l[:]" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[5, 2, 4, 3, 1]" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "def counl(l,e):\n", + " c = 0\n", + " for i in l:\n", + " if i == e:\n", + " c += 1\n", + " return c" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ls = [1,2,3,2,1,3,5,3,4,2,1,2]\n", + "counl(ls,2)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "def sumav(l):\n", + " sc = 0\n", + " for i in l:\n", + " sc += 1\n", + "\n", + " sm = sum(l)\n", + " avg = sm/len(l)\n", + "\n", + " return sm,avg" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'sumav' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[3], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m ll \u001b[39m=\u001b[39m [\u001b[39m1\u001b[39m,\u001b[39m2\u001b[39m,\u001b[39m3\u001b[39m]\n\u001b[0;32m----> 2\u001b[0m sumav(ll)\n", + "\u001b[0;31mNameError\u001b[0m: name 'sumav' is not defined" + ] + } + ], + "source": [ + "ll = [1,2,3]\n", + "sumav(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [], + "source": [ + "def sumnu(l):\n", + " res = []\n", + " for i in l:\n", + " sum = 0\n", + " for d in str(i):\n", + " sum += int(d)\n", + " res.append(sum)\n", + " \n", + " return res" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[3, 13, 17, 7]" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sn = [12,67,98,34]\n", + "sumnu(sn)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [], + "source": [ + "def mulp(l):\n", + " rs = 1\n", + " for i in l:\n", + " rs *= i\n", + " \n", + " return rs" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mulp(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [], + "source": [ + "def smaln(l):\n", + " sm = l[0]\n", + " for i in range(len(l)):\n", + " if l[i] < sm:\n", + " sm = l[i]\n", + " \n", + " return sm" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "smaln(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "def larg(l):\n", + " sm = l[0]\n", + " for i in range(len(l)):\n", + " if l[i]> sm:\n", + " sm = l[i]\n", + "\n", + " return sm" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "larg(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def secondLar(l):\n", + " larg = l[0]\n", + " secondlarge = 0\n", + " for i in range(len(l)):\n", + " if l[i] > l[0]:\n", + " larg = l[i]\n", + " else:\n", + " secondlarge = max(secondlarge,l[i])\n", + " \n", + " return secondlarge" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# print(ll)\n", + "secondLar(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "def evenl(l):\n", + " result = []\n", + " for n in l:\n", + " if n % 2 ==0 :\n", + " return n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "evenl(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "def oddl(l):\n", + " result = []\n", + " for i in l:\n", + " if i % 2 != 0:\n", + " result.append(i)\n", + "\n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 3]" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "oddl(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "def evelr(l):\n", + " for i in range(l):\n", + " if i % 2 == 0:\n", + " print(i)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "2\n", + "4\n" + ] + } + ], + "source": [ + "evelr(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "def eoc(l):\n", + " ec = 0\n", + " oc = 0\n", + " for i in l:\n", + " if i % 2== 0:\n", + " ec += 1\n", + " else:\n", + " oc += 1\n", + " \n", + " return ec,oc" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 2)" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eoc(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "def longest_Common_Prefix(str1):\n", + " \n", + " if not str1:\n", + " return \"\"\n", + "\n", + " short_str = min(str1,key=len)\n", + "\n", + " for i, char in enumerate(short_str):\n", + " for other in str1:\n", + " if other[i] != char:\n", + " return short_str[:i]\n", + "\n", + " return short_str " + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'abcdefgh'" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "la = [\"abcdefgh\",\"abcefgh\"]\n", + "min(la)\n", + "# print(longest_Common_Prefix([\"abcdefgh\",\"abcefgh\"]))\n", + "# print(longest_Common_Prefix([\"w3r\",\"w3resource\"]))\n", + "# print(longest_Common_Prefix([\"Python\",\"PHP\", \"Perl\"]))\n", + "# print(longest_Common_Prefix([\"Python\",\"PHP\", \"Java\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "def longpre(a):\n", + " le = len(a)\n", + "\n", + " if le == 0 :\n", + " return \"\"\n", + " \n", + " if le == 1:\n", + " return a[0]\n", + " \n", + "\n", + " min_str = min(len(a[0]),len(a[le - 1]))\n", + " i = 0\n", + " while (i < min_str and a[0][i] == a[le - 1][i]):\n", + " i += 1\n", + "\n", + " pre = a[0][0:i]\n", + " return pre" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'abc'" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "longpre(la)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n" + ] + } + ], + "source": [ + "i = 0\n", + "while i < 10:\n", + " print(i)\n", + " i +=1" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "def twoSUm(l,tg):\n", + " for i in range(len(l)):\n", + " for j in range(i+1,len(l)):\n", + " if l[j] == tg - l[i]:\n", + " return [i,j]" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 3]" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l = [1,2,3,4,5]\n", + "tg = 5\n", + "twoSUm(l,tg)" + ] + }, + { + "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.11.1" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "949777d72b0d2535278d3dc13498b2535136f6dfe0678499012e853ee9abcab1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/100Days_of_Python/Day1/main.py b/100Days_of_Python/Day1/main.py new file mode 100644 index 0000000..33a7ce2 --- /dev/null +++ b/100Days_of_Python/Day1/main.py @@ -0,0 +1,22 @@ +# To print the data we can use the print function +print("hello world!") + + +# To make manipulate the code of the string we can use the "+" to add different strings together +print("Hello " + "world!") +print("Hello"+" "+"world!") + + +# To take the input from the user we use the input function +print("Hello" + input("what is your name?")) + +# we can use the variables to store the data and use these variables for our reference +name = input("what is your name?") +print("Hello " + name) + +# Project : Read different values from the user and merge it in to a string to create as a band +print("welcome to Band!") +city = input("what is the city are you from?") +pet = input("what pet do you have?") +print("Hello am from "+ city + " and my pet is" + pet) + diff --git a/ArrayPrograms/SumOfArray.py b/ArrayPrograms/SumOfArray.py new file mode 100644 index 0000000..ce5689b --- /dev/null +++ b/ArrayPrograms/SumOfArray.py @@ -0,0 +1,13 @@ +#Python 3 program to find the sum of array + + +def _sumofArray(arr): + return(sum(arr)) + +arr = [1,2,3,4] + +n = len(arr) + +ans = _sumofArray(arr) + +print("sum of the array is ",ans) \ No newline at end of file diff --git a/ArrayPrograms/largetsNumer.py b/ArrayPrograms/largetsNumer.py new file mode 100644 index 0000000..7901f4b --- /dev/null +++ b/ArrayPrograms/largetsNumer.py @@ -0,0 +1,16 @@ +#Find the largest number from the array + +def largest(arr,n): + + max = arr[0] + + for i in range(1,n): + if arr[i] > max: + max = arr[i] + return max + + +arr = [1,5,2,3,4] +n = len(arr) +ans = largest(arr,n) +print(ans) \ No newline at end of file diff --git a/ArrayPrograms/smallestNumber.py b/ArrayPrograms/smallestNumber.py new file mode 100644 index 0000000..046f92c --- /dev/null +++ b/ArrayPrograms/smallestNumber.py @@ -0,0 +1,15 @@ +# Find the smallest number in an array + +def smallestNum(arr, n): + small = arr[0] + for i in range(1, n): + if arr[i] < small: + small = arr[i] + return small + + +arr = [1, 3, 4, 2, 54, -3] +n = len(arr) +ans = smallestNum(arr, n) + +print("smallest number of array {0} is {1}".format(arr, ans)) diff --git a/Functions/Functions.txt b/Functions/Functions.txt new file mode 100644 index 0000000..9f037fe --- /dev/null +++ b/Functions/Functions.txt @@ -0,0 +1,16 @@ +Functions: + Function is the block of code that will be used to run the code when called and we can use to run multple purpose + + Defining a function: + Function always starts with a keyword def and with some name of functio then the paranthesis() + Every function is indented to be used with colon : + +# def a function +# def a function with parameters +# function with unlimited arguments *arg +# function with keywords +# function with arbitraty keywords **kwargs +# function with default values +# passing the list as an argument +# return a value to the function +# function with passing a stmt pass \ No newline at end of file diff --git a/Functions/arbitraryFunction.py b/Functions/arbitraryFunction.py new file mode 100644 index 0000000..6810daa --- /dev/null +++ b/Functions/arbitraryFunction.py @@ -0,0 +1,5 @@ +#arbitrary function that which will be used to call number of parameters +def func(*arg): + print("fname" + fname + "last name" + lname) + +func() \ No newline at end of file diff --git a/Functions/funct.py b/Functions/funct.py new file mode 100644 index 0000000..c475c61 --- /dev/null +++ b/Functions/funct.py @@ -0,0 +1,6 @@ +#function definition +def func(): + print("Inside the function") + +#calling function +func() \ No newline at end of file diff --git a/Functions/functionWithParameters.py b/Functions/functionWithParameters.py new file mode 100644 index 0000000..1d77c15 --- /dev/null +++ b/Functions/functionWithParameters.py @@ -0,0 +1,7 @@ +#definiting a function with parameter +def my_func(name): + print("Hello " + name) + + +#calling a function with the arguments +my_func("naveen") \ No newline at end of file diff --git a/Functions/test.py b/Functions/test.py new file mode 100644 index 0000000..cb2532e --- /dev/null +++ b/Functions/test.py @@ -0,0 +1,3 @@ +def greet(): + print("Hello world") + print("Welcome abord") \ No newline at end of file diff --git a/Hacker_Rank/print.py b/Hacker_Rank/print.py new file mode 100644 index 0000000..558b9d5 --- /dev/null +++ b/Hacker_Rank/print.py @@ -0,0 +1,14 @@ +def summingSeries(n): + return (n*n) % 10000007 + + +if __name__ == '__main__': + t = int(input().strip()) + for t_itr in range(t): + n = int(input().strip()) + + result = summingSeries(n) + print(result) + + # for i in range(1, n + 1): + # print(i, end=' ') diff --git a/Hacker_Rank/write_a_function.py b/Hacker_Rank/write_a_function.py new file mode 100644 index 0000000..045008e --- /dev/null +++ b/Hacker_Rank/write_a_function.py @@ -0,0 +1,27 @@ +def is_leap(year): + # variable to check the leap year + leap = False + + # divided by 100 means century year + # century year divided by 400 is leap year + if (year % 400 == 0) and (year % 100 == 0): + + # change leap to True + leap = True + + # not divided by 100 means not a century year + # year divided by 4 is a leap year + elif (year % 4 == 0) and (year % 100 != 0): + + # Change leap to true + leap = True + + # else not a leap year + else: + pass + + return leap + + + +is_leap(2017) \ No newline at end of file diff --git a/HelloWorld.py b/HelloWorld.py deleted file mode 100644 index b0f51fd..0000000 --- a/HelloWorld.py +++ /dev/null @@ -1,6 +0,0 @@ -def test: - return naveen - -if __name__=="__main__": - test - diff --git a/ListFunctions.txt b/ListFunctions.txt new file mode 100644 index 0000000..a9b79c7 --- /dev/null +++ b/ListFunctions.txt @@ -0,0 +1,38 @@ +Important functions + +l = [12,43,23,49,53,24] + +1) len(list) + len(l) +2) count(x) ---> element in list + l.count(43) +3) index(x) ---> get the x element index from list + l.index(23) + + +Manipulating list + +1) append() + l.append(30) +2) insert() ---> To insert element at specific index + l.insert(1,20) --> 1 index and 20 value + append vs insert() --> append only inserts at the end but insert adds based on index +3) extend() ---> adds all elemts + l = ['a','b','c'] + l2 = ['w','q'] + l.extend(l2) --> ['a',b','c','w','q'] +4) remove(x) and pop(index) or pop() + +5) reverse() +6) sort() +7) copy() +8) clear() + +CompareList objects +1) ==, != +2) <,>,>=,<= + + +Nested Lists: + + diff --git a/ListPrograms/CheckIfElementExist.py b/ListPrograms/CheckIfElementExist.py new file mode 100644 index 0000000..2486b0c --- /dev/null +++ b/ListPrograms/CheckIfElementExist.py @@ -0,0 +1,14 @@ +# find the element in a list +def elementInList(lis,n): + for i in lis: + if i == n: + print("Element exists in list") + + +list = [1,2,4,5,6,7] +n = 2 +elementInList(list,n) + +# Second way +if n in list: + print("Element exists") \ No newline at end of file diff --git a/ListPrograms/LengthOflist.py b/ListPrograms/LengthOflist.py new file mode 100644 index 0000000..64f0d05 --- /dev/null +++ b/ListPrograms/LengthOflist.py @@ -0,0 +1,16 @@ +# python the list length + +def lengthOfList(lis): + + count = 0 + for i in lis: + count = count +1 + + return print(count) + +list = ['a','b','c','d','e'] +lengthOfList(list) + +count2 = print(len(list)) + +#for performence wise len() is better than \ No newline at end of file diff --git a/ListPrograms/SwappingFirstLastElementsinList.py b/ListPrograms/SwappingFirstLastElementsinList.py new file mode 100644 index 0000000..4df3d98 --- /dev/null +++ b/ListPrograms/SwappingFirstLastElementsinList.py @@ -0,0 +1,14 @@ +#Swap the elements in the list first and last + +def SwapFirstLastElement(arr): + + temp = arr[0] + arr[0] = arr[-1] + arr[-1] = temp + + return arr + +arr = [1,2,3,4,5] +ans = SwapFirstLastElement(arr) + +print("after swapping from the list",ans) \ No newline at end of file diff --git a/ListPrograms/listDoc.md b/ListPrograms/listDoc.md new file mode 100644 index 0000000..6a75fc8 --- /dev/null +++ b/ListPrograms/listDoc.md @@ -0,0 +1,93 @@ +# List + +List is the collection of similar or different types of data. we use square brackets to store data as list and python lists are mutable that means +we can change the values in the list. +suppose we want to store a group of numbers in list we can store lie + e.g: [1,2,3,4] + we can use list to store different data type values as well like + e.g: ["naveen",3,4,4.5] + +we can create a list like below +1) num = [1,2,3] + +## Access values from list: + + we can access the elements of a list by using the index from the list. index is basically location where the + elements store + e.g: to access the number 3 from the above variable num is n[2] here we are using index 2 because in list + the index numbers starts from 0 and increments by 1 from left to right. + We can even access data from right to left as well by using the negative index where the index will starts + from -1. We can get the result 3 by using num[-1] + +## Slicing of python list: + + We can get the group of values by slicing the list, and also we can get the group of words by slicing the list like below + + suppose we have a list with couple of letters + + str = ['h','e','l','l','o','w','o','r','l','d'] + + we can get the first 5 letters from the above list by using the str[0:4] ===> ['h','e','l','l','o'] + and we can also use the negative index i.e we can get the values from the right side. + +## Adding element to the list: + python provides different methods to add the elements to the list, where we can use this by add elements to the list + + append() + By using the append() method we can add the element at the end of the list + e.g: test = [1,2,3,4] + + we can add the number 5 to the list by using the append method like + test.append(5) + + output: [1,2,3,4,5] + + extend() + By using the extend() method we can add all the elements of one list to another + But the elements will be added at the end of initial list + e.g: even_numbers = [2,4,6,8] + odd_numbers = [1,3,5,7] + whole_numbers = even_number.extend(odd_numbers) + output: + [2,4,6,8,1,3,5,7] + + +## Changing the Values in the list + + As we know python lists are mutable so we can change the values of the list by using the index and replace with other items. + + e.g: fruits = ['apple','banana','grapes'] + + here we want to replace the banana fruit with melon like below + fruits[1] = 'melon' + + finally when we print the fruits we get the below values + output: fruits = ['apple','melon','grapes'] + + +## Removing an element from the list + +we have different methods available to delete the values from the list. + + del() + By using the del() method we can delete one or more elements from the list. + e.g: fruits = ['apple','banana','grapes'] + to delete the banana fruit we can use the index like below + del fruits[1] + the result of the above statement gives the belo list + ['apple','grapes'] + + We can also delete the multiple elements from the list + e.g: fruits = ['apple','banana','grapes','berries'] + del fruits[2:3] + the result list will be ['apple','banana'] + + + remove() + Unline the del() method where we delete the element from the list by using the index, here we use the actual element to + delete from the list. + e.g: fruits = ['apple','banana','grapes'] + fruits.remove('banana') + the result list will be ==> ['apple','grapes'] + + diff --git a/ListPrograms/stringOccuranceRemove.py b/ListPrograms/stringOccuranceRemove.py new file mode 100644 index 0000000..c97d6c7 --- /dev/null +++ b/ListPrograms/stringOccuranceRemove.py @@ -0,0 +1,27 @@ +#Remove nth occurance of the given word + +def removenthOccurance(lis,n,word): + newList = [] + count = 0 + + for i in lis: + if i == word: + count = count + 1 + if count != n: + newList.append(i) + else: + newList.append(i) + + lis = newList + + if count == 0: + print("Item not found") + else: + print("Updated list",lis) + + return newList + +list = ['geeks','for','geeks'] +n = 2 +word = 'geeks' +removenthOccurance(list,n,word) \ No newline at end of file diff --git a/ML/.ipynb_checkpoints/test_ml-checkpoint.ipynb b/ML/.ipynb_checkpoints/test_ml-checkpoint.ipynb new file mode 100644 index 0000000..363fcab --- /dev/null +++ b/ML/.ipynb_checkpoints/test_ml-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ML/test_ml.ipynb b/ML/test_ml.ipynb new file mode 100644 index 0000000..8d1aa48 --- /dev/null +++ b/ML/test_ml.ipynb @@ -0,0 +1,409 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "39c424d4-81d2-4da6-8a23-04715b9dfe73", + "metadata": {}, + "outputs": [], + "source": [ + "speed = [99,86,87,88,111,86,103,87,94,78,77,85,86]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d5240e04-e8bf-4fc3-9c41-97ec78acafa6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of the speed is 89.76923076923077\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "x = np.mean(speed)\n", + "\n", + "print(\"Mean of the speed is\", x)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "09e6a59a-4911-4b0d-a8d2-e9fd83f0077b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Median of the speed is 87.0\n" + ] + } + ], + "source": [ + "#Median\n", + "\n", + "y = np.median(speed)\n", + "\n", + "print(\"Median of the speed is\", y)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "3b4a4739-d20a-450c-b1ce-2ad90933b174", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mode of the numbers is ModeResult(mode=array([86]), count=array([3]))\n" + ] + } + ], + "source": [ + "# mode\n", + "# the values that are appears more number of times\n", + "from scipy import stats\n", + "\n", + "\n", + "z = stats.mode(speed)\n", + "\n", + "print(\"mode of the numbers is\", z)" + ] + }, + { + "cell_type": "markdown", + "id": "2b0953e1-3d09-4198-abb9-4b5f310670fe", + "metadata": {}, + "source": [ + "Standard deviation\n", + "\n", + "sd is a number that describes how spread out the values are.\n", + "\n", + "A low standard deviation means that th most of the numbers are close to the mean (avg) value\n", + "\n", + "A high standard deviation means that the valuess are spread out over a wide range" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "eb93ef79-f730-4679-940b-f747a4f54df1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "standard deviation of speed of cars is 9.258292301032677\n" + ] + } + ], + "source": [ + "speed\n", + "\n", + "sd = np.std(speed)\n", + "print(\"standard deviation of speed of cars is\", sd)" + ] + }, + { + "cell_type": "markdown", + "id": "14d1f53f-e80e-4d73-85a3-b340f2bc0f90", + "metadata": {}, + "source": [ + "Variance\n", + "\n", + "Variance is another number that indicates how spread out the values are.\n", + "\n", + "In fact, if you take the square root of the variance, you gte the standard deviation!\n", + "Or the other way around\n", + "if. you multiply the standard deviation by itself, you get the variance!\n", + "\n", + "to calculate the variance you have to do as follows" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "8cdd60df-2157-438a-994e-09e1bb3ba0c4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "variance of speed of cars is 85.71597633136093\n" + ] + } + ], + "source": [ + "x = np.var(speed)\n", + "\n", + "print(\"variance of speed of cars is\", x)" + ] + }, + { + "cell_type": "markdown", + "id": "6c05c2ea-793d-4689-ad3f-c7d991363918", + "metadata": {}, + "source": [ + "Percentile\n", + "\n", + "Percentiles are used in statistics to give you the number that scribes\n", + "the values that a given percent of the values are lower than" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "361d8891-bbe8-4873-8c5e-c84bda358eb1", + "metadata": {}, + "outputs": [], + "source": [ + "ages = [5,31,43,48,50,41,7,11,15,39,80,82,32,2,8,6,25,36,27,61,31]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "c50b841e-93bf-4c83-8798-842783e794cf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "75th percentaile of ages is 43.0\n" + ] + } + ], + "source": [ + "ages\n", + "x = np.percentile(ages,75)\n", + "print(\"75th percentaile of ages is\", x)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "4614238e-a138-4b06-be48-a56d97109315", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.25693562 1.88360614 3.74815805 0.22441519 2.89721867 2.42257601\n", + " 1.4027281 3.82776686 4.25485369 1.06743161 0.14639262 2.36409342\n", + " 2.83416846 0.02718292 3.38988053 0.68776825 2.4835643 1.41616999\n", + " 0.02148168 0.35378003 0.69718049 4.15257817 4.00580517 2.52152922\n", + " 2.93299295 1.41059357 3.76081024 2.37743421 2.7946524 1.62413627\n", + " 4.05801073 0.08926419 2.25662045 2.96487237 0.92865141 0.48107178\n", + " 4.59349052 1.84182245 3.84028347 0.42913201 1.5800562 2.71431086\n", + " 1.22547108 2.04302336 0.80201508 3.92707369 0.28856735 2.87023194\n", + " 1.59515045 1.77958231 0.57015682 4.33221093 4.69750411 3.46863655\n", + " 4.43493923 3.36606561 0.11580425 1.67814825 3.55991927 1.30133378\n", + " 3.70322249 4.47495169 0.41239236 1.49337976 4.26594765 3.38202161\n", + " 1.3075207 3.66487056 3.00481039 3.40482158 2.00226627 3.02806605\n", + " 2.62558626 3.55292547 1.82225588 2.42019146 0.3853975 1.07263847\n", + " 2.64872425 3.92925846 4.9787802 2.36777345 2.82083545 1.60746263\n", + " 0.46815085 2.40806441 1.07730951 4.73650698 0.54841932 4.83190234\n", + " 0.42987996 3.93867397 2.38551031 0.82865684 1.01755132 3.54138935\n", + " 3.50990853 3.68598844 2.59704735 4.60626891 3.91532135 0.95524025\n", + " 3.55621246 4.87604455 4.35070753 4.51226109 1.99629578 4.43290052\n", + " 1.15738153 2.58744178 4.08985829 3.88737161 1.35128586 2.3825869\n", + " 3.65439788 3.0722588 0.88991502 0.3409112 2.71598243 0.01457549\n", + " 2.85932507 2.33121488 4.63243229 0.63812945 4.25561007 1.88884002\n", + " 2.19456333 2.35292761 3.03252524 2.77813655 2.48736144 2.84135383\n", + " 3.77376049 1.61142825 3.59470526 3.03245026 0.27406066 0.03549873\n", + " 4.92893987 0.3529784 0.06393865 1.65432306 4.93506046 0.21509757\n", + " 0.83665759 4.50984465 1.38566549 1.35407243 1.35916265 3.26671944\n", + " 4.02119226 3.48240485 2.18327052 1.54097476 0.60139707 0.45838235\n", + " 4.98260637 4.71192262 1.07581568 1.26916685 0.13099547 0.94480837\n", + " 3.8186142 2.30353368 0.9603667 1.22707574 3.2884331 2.1125411\n", + " 3.40173672 3.16598903 2.07885429 3.35522175 3.14803512 0.9977724\n", + " 0.41425514 2.14441058 2.26315456 4.56935716 1.05898582 4.71078522\n", + " 2.61414637 2.06725573 0.67629288 4.89308458 3.94747402 4.58943237\n", + " 2.49123307 0.57808394 4.6685098 2.50821825 4.58770777 2.1361246\n", + " 0.24280593 4.30831691 2.81473736 2.92336348 0.26217991 1.97964061\n", + " 1.73689896 0.99571151 4.51285376 1.12824434 1.45268417 4.00483688\n", + " 1.16084921 3.73783488 1.1997375 1.44413612 1.51934621 1.3630307\n", + " 4.33244623 0.72965204 1.25309971 2.48291799 3.77840877 1.16822768\n", + " 3.76226992 3.19884543 4.94994101 0.09357882 2.41213801 4.94187177\n", + " 2.76052769 2.05021711 2.95199524 1.213877 4.73592522 1.49020893\n", + " 0.27535151 4.52418955 4.33308499 4.87217207 0.2034202 1.12901273\n", + " 2.33577346 3.43608049 3.07705389 0.08720636 2.76259113 4.31134249\n", + " 3.65980865 3.7322099 2.29509227 2.71721541 3.93435657 3.78013367\n", + " 1.07277338 1.30062459 3.67410008 1.91655967]\n" + ] + } + ], + "source": [ + "x = np.random.uniform(0.0,5.0,250)\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "10db940e-ac32-4588-b1b5-afdeb4b252dd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.hist(x,5)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "3f678310-7289-4f90-bb0e-2007ad6f59ef", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "y = np.random.uniform(0.0,5.0,1000000)\n", + "plt.hist(y,50)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8811b5d4-b8de-466b-af88-d8af9813c607", + "metadata": {}, + "source": [ + "Scatterplot" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "4e49bc4d-f143-46ec-a6c8-4eff145bb3b1", + "metadata": {}, + "outputs": [], + "source": [ + "x = [5,7,8,7,2,17,2,9,4,11,12,9,6]\n", + "\n", + "y = [99,86,87,88,111,86,103,87,94,78,77,85,86]" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "95136001-5b9d-4747-9e83-7720ecc3d6bd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.scatter(x,y)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "6c43d696-3f17-43f1-8b6a-432a4e665137", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.random.normal(5.0, 1.0, 1000)\n", + "y = np.random.normal(10.0, 2.0, 1000)\n", + "\n", + "plt.scatter(x, y)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "182d4fda-1df8-4bbd-b5e5-ee96af7e85ff", + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Operator/inOperator.py b/Operator/inOperator.py new file mode 100644 index 0000000..47dcc44 --- /dev/null +++ b/Operator/inOperator.py @@ -0,0 +1,18 @@ +#Operator examples +#identity operators +#is and is not(which shows the identity of operators) +n = 123 +b = 123 +v = 122 +print( n is b) # gives true because n and b values same so address also same +print(n is v) # false +print(n is not v) + +#membership operators +#in and not in +s = "Hello World" +print("Hello" in s) +print("naveen" not in s) +lis = [1,2,3] +print(1 in lis) + diff --git a/document.txt b/document.txt new file mode 100644 index 0000000..77375bd --- /dev/null +++ b/document.txt @@ -0,0 +1,64 @@ +String Methods + +s.find(substring) --> find the index of the sub string from string string + +Strip the strings + +strip --> removes the white spaces from both left and right sides +lstrip --> removes the spaces at the begining of String +rstrip --> removes the spaces at the begining of String + +count string + +s.count(substring) --> counts the occurence of substring in string string +s.count(substring,begin,end) --> from begin index to the end-1 index substring + +replace string + +s.replace(oldstring,new string) --> replaces old string with new string +eg: s = "Durga sof" +s.replace("sof","soft") +Durga soft + +splitting of String: + +s.split(separator) --> split the string based on separator +eg: +s = "Durga sof sol" +l = s.split() +print(l) --> ['Durga','sof','sol'] + +s.rsplit(separator) --> split the string based on separator in reverse + +s.split(separator, num) --> splits the string based on separator till the number + + +join() --> will use to join the separator in the list +eg: +s = ['durga','soft','sol'] +l = "-".join(s) +print(l) --> durga-soft-sol + + +changing case of a strings + +upper() ==> to convert to upper case +lower() +swapcase() --> lower to upper and upper to lower case +title() ==> The Python Classes By Durga +capitalize() --> The python classes by durga + + +Checking starting and ending part of the string + +s.startswith('learning') --> check the string starts with substring +s.endswith('learning') --> check the string ends witg substring + + + + + + + + + diff --git a/practice/EvenOddNumber.py b/practice/EvenOddNumber.py new file mode 100644 index 0000000..1ac8af4 --- /dev/null +++ b/practice/EvenOddNumber.py @@ -0,0 +1,9 @@ +# FInd the even number of odd number + +num = int(input("enter a number ")) + +if num % 2 == 0: + print( " the {0} is Even number".format(num)) +else: + print("the {0} is Odd number".format(num)) + diff --git a/practice/FactorialNum.py b/practice/FactorialNum.py new file mode 100644 index 0000000..8f262fc --- /dev/null +++ b/practice/FactorialNum.py @@ -0,0 +1,10 @@ +# Find the factorial of numbers + +num = int(input("Enter number")) + +def factorial(n): + return 1 if (n ==0 or n ==1) else n * factorial(n - 1) + + +fact = factorial(num) +print("the factorial of {0} is {1} ".format(num,fact)) \ No newline at end of file diff --git a/printTest.py b/practice/HelloWorld.py similarity index 100% rename from printTest.py rename to practice/HelloWorld.py diff --git a/practice/InputExample.py b/practice/InputExample.py new file mode 100644 index 0000000..a5c340b --- /dev/null +++ b/practice/InputExample.py @@ -0,0 +1,14 @@ +#Input part +# 1) input +# 2) typecast to required type int(),float(),bool() +# 3) eval() + + +# commandline argumnets +# argv and sys module + +from sys import argv +print(int(argv[1])+int(argv[2])) + + + diff --git a/practice/commandLineArgExample.py b/practice/commandLineArgExample.py new file mode 100644 index 0000000..13ebd3a --- /dev/null +++ b/practice/commandLineArgExample.py @@ -0,0 +1,13 @@ +# command line argument examples +# predefined variable--argv +# argv-- will be list type + +from sys import argv +print(type(argv)) +print(argv) +print(argv[1:]) +print(argv[0]) +print(argv[1]) + + + diff --git a/practice/commandLineArgExample2.py b/practice/commandLineArgExample2.py new file mode 100644 index 0000000..b1d0a32 --- /dev/null +++ b/practice/commandLineArgExample2.py @@ -0,0 +1,7 @@ +from sys import argv +print("The number of values in argv:",len(argv)) +print("the list of command line arguments",argv) +print("command line arguments one by one") +for x in argv: + print(x) +print("slice operator example",argv[1:3]) diff --git a/practice/commandLineArgExampleSum.py b/practice/commandLineArgExampleSum.py new file mode 100644 index 0000000..ceb8e5d --- /dev/null +++ b/practice/commandLineArgExampleSum.py @@ -0,0 +1,9 @@ +# read group of command line arguments and sum of these values +from sys import argv +args = argv[1:] +sum = 0 +for x in args: + n = int(x) + sum += n + +print("The sum of argv is:",sum) \ No newline at end of file diff --git a/practice/delKeywordExample.py b/practice/delKeywordExample.py new file mode 100644 index 0000000..7097e89 --- /dev/null +++ b/practice/delKeywordExample.py @@ -0,0 +1,22 @@ +# del keyword used to delete the object for garbage collection if we no need to use + +x = 10 +print(x) +del x +#print(x) # gives error + +s = 'naveen' +#del s[1] # wont support item in string + +#but it support delete entire s + +del s +print(s) # give error + + +#NOne +# if you want to delet the object but not variable then we can use None + +n = "kumar" +n = None +print(n) \ No newline at end of file diff --git a/practice/evalexample.py b/practice/evalexample.py new file mode 100644 index 0000000..4864ba8 --- /dev/null +++ b/practice/evalexample.py @@ -0,0 +1,10 @@ +# Evaluate the values type automatically + +ex = input("Enter an expression") +print(type(eval(ex))) + +# ex = 12 +# class int + +x = eval(input("enter a number")) +print(x) diff --git a/practice/findsqrt.py b/practice/findsqrt.py new file mode 100644 index 0000000..4e28348 --- /dev/null +++ b/practice/findsqrt.py @@ -0,0 +1,8 @@ +# Python Program to calculate the square root + +num = 8 + +sqrtOfNum = 8 ** 0.5 +print("Sqrt of %0.2f is %0.3f"%(num,sqrtOfNum)) + +# output Sqrt of 8.00 is 2.828 \ No newline at end of file diff --git a/practice/flowControlLoopExample.py b/practice/flowControlLoopExample.py new file mode 100644 index 0000000..badf7a8 --- /dev/null +++ b/practice/flowControlLoopExample.py @@ -0,0 +1,63 @@ +#Flow control +# 2) Iterative Statement +# loops +# +# for loop +s = input("Enter a string") +count = 0 +index = 0 +for i in s: + print("the index of {} is".format(i),end=" ") + print(index) + index += 1 + count += 1 +print(count) + +l =[10,20,30] +for x in l: + print(x) + +for y in range(1,10): + print(y) + +# while loop +# iteration know in advance then we should go for loop +# if we dont know then we can use while loop +# while condition: +# body + +# Example 1 print 1 to 10 numbers +x = 1 +while x<= 5: + print(x) + x+=1 + +#example 2 + +name ="" +pwd = "" +while (name != 'naveen') and (pwd != 1234): + name= input("enter name:") + pwd = eval(input("enter password")) + +print("Hello",name,"Good morning") + +# Example 3 infinite loop +# i = 0 +# while True: +# print(i) +# i+=1 + +#nested loops +#loop inside another loop + +for i in range(4): + for j in range(4): + print(1,j) + +#example +n = eval(input("enter number of rows:")) +for i in range(1,n+1): # i represents rows number + for j in range(1,i+1): # j represents the number of * + print("*",end= " ") + print() \ No newline at end of file diff --git a/practice/flowControlTransferExample.py b/practice/flowControlTransferExample.py new file mode 100644 index 0000000..2649566 --- /dev/null +++ b/practice/flowControlTransferExample.py @@ -0,0 +1,63 @@ +# 3) Transfer statement +# break +# continue +# pass +#break examples +# we can use else with for loop in break +i = 0 +while True: + print("Hello") + i += 1 + if i == 5: + break + +#example2 +cart = [12,30,50,302,500,900] +for i in cart: + if i > 500: + break; + print(i) +else: + print("Congrts all processed") + + +#Continue examples + +for i in range(10): + if i%2 == 0: + continue + print(i) + +#example2 +cart = [12,30,50,302,500,900] +for i in cart: + if i >= 500: + print("Sorry we cant process this item",i) + continue + print(i) + + +#pass statement examples +# it is a keyword in python +# it is a empty stmt +# it won't do anything + +if True: + pass +else: + print("Hello") + +#example 2 +def f1(): + print("Hello") +def f2(): + pass + +f1() + +#example 3 +for i in range(100): + if i % 10 == 0: + print(i) + else: + pass \ No newline at end of file diff --git a/practice/flowControlconditionExample.py b/practice/flowControlconditionExample.py new file mode 100644 index 0000000..c79e97a --- /dev/null +++ b/practice/flowControlconditionExample.py @@ -0,0 +1,29 @@ +# Flow control decided at run time such as if else +# 3 types + +# 1)conditional statement/selection statements +# if +# if-else +# if-elif-else +# switch not available + +#Example 1 +name = input("Enter name:") +if name == "naveen": + print("Hello {} Good morning good to see you".format(name)) +else: + print("Hello {} Good Morning".format(name)) +print("How are you") + +#Example 2 +brand = input("Enter your brand:") +if brand == "RC": + print("It is children brand") +elif brand == "RM": + print("It is not that much good") +elif brand == "sh": + print(" buy one get one") +else: + print("not available") + + diff --git a/for_loop.py b/practice/for_loop.py similarity index 100% rename from for_loop.py rename to practice/for_loop.py diff --git a/hackerrank.py b/practice/hackerrank.py similarity index 100% rename from hackerrank.py rename to practice/hackerrank.py diff --git a/if_else_Condition.py b/practice/if_else_Condition.py similarity index 57% rename from if_else_Condition.py rename to practice/if_else_Condition.py index b0d8f8a..8d55000 100644 --- a/if_else_Condition.py +++ b/practice/if_else_Condition.py @@ -3,4 +3,6 @@ if x % 2 == 0: print("Even number") else: - print("Odd number") \ No newline at end of file + print("Odd number") + +print("If else condition example ") \ No newline at end of file diff --git a/practice/inputMul.py b/practice/inputMul.py new file mode 100644 index 0000000..9c93232 --- /dev/null +++ b/practice/inputMul.py @@ -0,0 +1,4 @@ +#read multiple values from keyboard + +a,b=[int(x) for x in input("enter two numbers:").split()] +print("the sum of {} and {} is ".format(a,b),a+b) \ No newline at end of file diff --git a/practice/inputMultiplevalues.py b/practice/inputMultiplevalues.py new file mode 100644 index 0000000..b1b34b7 --- /dev/null +++ b/practice/inputMultiplevalues.py @@ -0,0 +1,4 @@ +#read two float valiues from the keyboard which are specified with , separation and print sum + +x,y = [float(x) for x in input("enter 2 values:").split(",")] +print("the mul of {} and {} is".format(x,y),x*y) \ No newline at end of file diff --git a/practice/inputoutstmt.py b/practice/inputoutstmt.py new file mode 100644 index 0000000..ee29469 --- /dev/null +++ b/practice/inputoutstmt.py @@ -0,0 +1,8 @@ +# input and output statements + +# read dynamic data from the keyboard + +x = int(input("enter a number")) +y = int(input("enter the second number")) +print("the sum is ",x+y) + diff --git a/practice/largestOfThreeNumbers.py b/practice/largestOfThreeNumbers.py new file mode 100644 index 0000000..ec16a31 --- /dev/null +++ b/practice/largestOfThreeNumbers.py @@ -0,0 +1,16 @@ +# find the largest of three numbers + +num1 = float(input("Enter a number")) +num2 = float(input("Enter a number")) +num3 = float(input("Enter a number")) + +if num1 > num2 and num1 > num3: + largerNumber = num1 + +elif num2 > num3 and num2 > num1: + largerNumber = num2 + +else: + largerNumber = num3 + +print("THe largest number is ",largerNumber) diff --git a/practice/module.py b/practice/module.py new file mode 100644 index 0000000..a50add6 --- /dev/null +++ b/practice/module.py @@ -0,0 +1,37 @@ +#library example + +import math +print(math.sqrt(9)) + +# same as above code(aliasing) + +import math as m +print(m.sqrt(9)) + +#same as above + +from math import sqrt +from math import pi + +print(sqrt(9)) + +# also works + +from math import * # not advised to use +print(sqrt(9)) + + +# sqrt() +# ceil() +# floor() +# pow(x,y) +# factorial() +# gcd() +# sin() +# cos() +# ...... + +# pi = 3.12 +# e = 2.71 +# inf = infinity +#nan = not a number diff --git a/practice/outputExample.py b/practice/outputExample.py new file mode 100644 index 0000000..e379bc8 --- /dev/null +++ b/practice/outputExample.py @@ -0,0 +1,41 @@ +# Output values +# using sep operator(sep ===> space by deafult) +a,b,c = 10,20,30 +print(a,b,c,sep=" < ", end=" ") +print(40,50,60,sep="-") + +# using end operator (instead of printing in the next line we can use end) +# (end ===> default new line) +print("Hello World",end=" ") +print("python") + +# print(object) + +l = [10,20,30,40] +t = (10,20,30,40) +s = {10,20,30,40} +print(l,t,s) + +#print (formatted string) +# %i == int type +# %d == int type +# %f == float type +# %s == Str type +# print("formatted string",%(variable list)) + +m,n,o = 10,20,30 +print("m value is %i" %m) +print("n value %i and o value is %d" %(n,o)) + +# print() function with replacement operator +# {} ==> replacement operator + +name = "Naveen" +salary = 85000 +city = "Hyd" +print("Hello {0} your salary is {1} " + "and your city is {2}".format(name,salary,city)) +print("Hello {} your salary is {} " + "and your city is {}".format(name,salary,city)) +print("Hello {x} your salary is {z} " + "and your city is {y}".format(x=name,z=salary,y =city)) \ No newline at end of file diff --git a/practice/positiveNegativeNumber.py b/practice/positiveNegativeNumber.py new file mode 100644 index 0000000..d47cf64 --- /dev/null +++ b/practice/positiveNegativeNumber.py @@ -0,0 +1,12 @@ +# FInd the positive and negative number + +num = float(input("Enter a number")) + +if num > 0: + print("number {0} is Positive number".format(num)) + +elif num == 0: + print("the number {0} is Zero".format(num)) + +else: + print("The number {0} is negative number".format(num)) \ No newline at end of file diff --git a/practice/primeNumber.py b/practice/primeNumber.py new file mode 100644 index 0000000..20b8ce6 --- /dev/null +++ b/practice/primeNumber.py @@ -0,0 +1,15 @@ +#FInd the number prime number + +num = int(input("Enter number")) + +if num > 1: + for i in range(2,num): + if num % i == 0: + print(" number is not prime") + break + else: + print("The number is prime number") + +else: + print("Num is not prime number") + diff --git a/practice/printTest.py b/practice/printTest.py new file mode 100644 index 0000000..19051ea --- /dev/null +++ b/practice/printTest.py @@ -0,0 +1 @@ +print("Hello World") \ No newline at end of file diff --git a/practice/sumOfTwoNumbers.py b/practice/sumOfTwoNumbers.py new file mode 100644 index 0000000..948dbc6 --- /dev/null +++ b/practice/sumOfTwoNumbers.py @@ -0,0 +1,18 @@ +# first process static addition of two numbers + +num1 = 12.2 +num2 = 17.8 + +sum = float(num1) + float(num2) + +print('the sum of {0} and {1} is {2}'.format(num1,num2,sum)) + +# Taking numbers form the user + +num3 = input("Enter a number") +num4 = input("Enter a number") + +sum2 = float(num3) + float(num4) + +print("the sum of {0} and {1} is {2}".format(num3,num4,sum2)) + diff --git a/practice/swapVariables.py b/practice/swapVariables.py new file mode 100644 index 0000000..b5a8baf --- /dev/null +++ b/practice/swapVariables.py @@ -0,0 +1,12 @@ +# Python program to swap two variables + +val1 = int(input("Enter a number ")) +val2 = int(input("Enter a number ")) + +temp = val1 +val1 = val2 +val2 = temp + +print("The values of val1 after swapping: {0}".format(val1)) +print("The vale of val2 after swapping: {0}".format(val2)) + diff --git a/python_learning b/python_learning new file mode 100644 index 0000000..9c2dbe7 --- /dev/null +++ b/python_learning @@ -0,0 +1,14 @@ +# Databricks notebook source +print("Hello WOrld") + +# COMMAND ---------- + +a = 10 +b = 20 +x = a+b +print(x) + +# COMMAND ---------- + +n = "Naveen" +print(n) \ No newline at end of file diff --git a/test.ipynb b/test.ipynb new file mode 100644 index 0000000..12b8c93 --- /dev/null +++ b/test.ipynb @@ -0,0 +1,1639 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "ml = [1,2,3,2,3,4,5,6]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nl = []\n", + "for i in ml:\n", + " if i not in nl:\n", + " nl.append(i)\n", + "\n", + "nl.sort()\n", + "nl[-2]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def rn(li):\n", + " nl=[]\n", + " for i in li:\n", + " if i not in nl:\n", + " nl.append(i)\n", + " \n", + " nl.sort()\n", + " return nl[-2]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "if __name__ == '__main__':\n", + " n = int(input())\n", + " arr = map(int, input().split())\n", + " lst = list(arr)\n", + " score = list(lst)\n", + " print(score)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "list(set(ml)).sort()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (2420166799.py, line 7)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m Input \u001b[0;32mIn [8]\u001b[0;36m\u001b[0m\n\u001b[0;31m score =\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + "if __name__ == '__main__':\n", + " num = []\n", + " arr = []\n", + " ls = int(input())\n", + " for _ in range(ls):\n", + " name = input()\n", + " score = " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter a number 44\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Not weired\n" + ] + } + ], + "source": [ + "if __name__ == '__main__':\n", + " n = int(input(\"Enter a number\").strip())\n", + " if n % 2 != 0:\n", + " print(\"Weired\")\n", + " elif n in range(2,6):\n", + " print(\"Not weired\")\n", + " elif n in range (6,21):\n", + " print(\"weired\")\n", + " else:\n", + " print(\"Not weired\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 3,4,5\n" + ] + }, + { + "ename": "ValueError", + "evalue": "invalid literal for int() with base 10: '3,4,5'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [10]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNO\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;18m__name__\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m__main__\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[0;32m----> 7\u001b[0m t \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstrip\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m (\u001b[38;5;28mint\u001b[39m(\u001b[38;5;28minput\u001b[39m())):\n\u001b[1;32m 10\u001b[0m first_multiple_input \u001b[38;5;241m=\u001b[39m \u001b[38;5;28minput\u001b[39m()\u001b[38;5;241m.\u001b[39mrstrip()\u001b[38;5;241m.\u001b[39msplit()\n", + "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: '3,4,5'" + ] + } + ], + "source": [ + "def solve(a,b,x,y):\n", + " if math.gcd(a,b) == math.gcd(x,y):\n", + " return \"YES\"\n", + " return \"NO\"\n", + "\n", + "if __name__ == '__main__':\n", + " t = int(input().strip())\n", + "\n", + " for _ in range (int(input())):\n", + " first_multiple_input = input().rstrip().split()\n", + " a = int(first_multiple_input[0])\n", + " b = int(first_multiple_input[1])\n", + " x = int(first_multiple_input[2])\n", + " y = int(first_multiple_input[3])\n", + "\n", + " result = solve(a,b,x,y)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "invalid literal for int() with base 10: ''", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[43], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39m__name__\u001b[39m \u001b[39m==\u001b[39m \u001b[39m'\u001b[39m\u001b[39m__main__\u001b[39m\u001b[39m'\u001b[39m:\n\u001b[0;32m----> 2\u001b[0m x \u001b[39m=\u001b[39m \u001b[39mint\u001b[39;49m(\u001b[39minput\u001b[39;49m())\n\u001b[1;32m 3\u001b[0m y \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(\u001b[39minput\u001b[39m())\n\u001b[1;32m 4\u001b[0m z \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(\u001b[39minput\u001b[39m())\n", + "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: ''" + ] + } + ], + "source": [ + "if __name__ == '__main__':\n", + " x = int(input())\n", + " y = int(input())\n", + " z = int(input())\n", + " n = int(input())\n", + " l =[]\n", + " for i in range(x+1):\n", + " for j in range(y+1):\n", + " for k in range(z+1):\n", + " if i + j + k == n:\n", + " continue\n", + " l.append([i,j,k])\n", + " \n", + " print(l)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "def my_function():\n", + " print(\"Hello from a function\")" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello from a function\n" + ] + } + ], + "source": [ + "my_function()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "def my_fun_par(fname):\n", + " print(fname + \" Refsnes\")" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Naveen Refsnes\n" + ] + } + ], + "source": [ + "my_fun_par(\"Naveen\")" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reddy Refsnes\n" + ] + } + ], + "source": [ + "my_fun_par(\"Reddy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "def my_fun(fn,ln):\n", + " ft = fn + ln\n", + " print(ft)\n", + "\n", + " # return fn" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_fun(\"Naveen\",\"Reddy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "def fnf(**kid):\n", + " print(\"his last name is \" + kid[\"lname\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "his last name is Ganta\n" + ] + } + ], + "source": [ + "fnf(fname= \"Tobiad\", lname=\"Ganta\")" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "def myf(food):\n", + " for x in food:\n", + " print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "apple\n", + "banana\n", + "cherry\n" + ] + } + ], + "source": [ + "fr = ['apple','banana','cherry']\n", + "myf(fr)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "s = 'AABCAAADA'\n", + "k = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "n = len(s)/3" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.0" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "word = s[0:k]" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'AAB'" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "word" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "string = s[k:]" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'CAAADA'" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [], + "source": [ + "while s:\n", + " word = s[0:k]\n", + " s= s[k:]\n", + "\n", + " print(''.join(help(word)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "def merge_tl(s,k):\n", + " n = len(s)\n", + "\n", + " def help(items):\n", + " seen = set()\n", + " for i in items:\n", + " if i not in seen:\n", + " yield i\n", + " seen.add(i)\n", + " while s:\n", + " word = s[0:k]\n", + " s= s[k:]\n", + "\n", + " print(''.join(help(word)))\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], + "source": [ + "print(merge_tl(s,k))" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], + "source": [ + "def merge_the_tools(string, k):\n", + " n = len(string)\n", + "\n", + " def help_fun(items):\n", + " seen = set()\n", + " for i in items:\n", + " if i not in seen:\n", + " yield i\n", + " seen.add(i)\n", + "\n", + " while string:\n", + " word = string[0:k]\n", + " string = string[k:]\n", + " \n", + " print (''.join(help_fun(word)))\n", + "\n", + "\n", + "if __name__ == '__main__':\n", + " string, k = s,k\n", + " merge_the_tools(string, k)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "abcd\n", + "efgh\n", + "ijkl\n", + "mn\n" + ] + } + ], + "source": [ + "def wrap(st,n):\n", + " con = list(st)\n", + "\n", + " ls=[]\n", + " l=\"\"\n", + " for i in con:\n", + " if len(l) < n:\n", + " l+=i\n", + " \n", + " else:\n", + " ls.append(l)\n", + " l = i\n", + "\n", + " ls.append(l)\n", + "\n", + " return \"\\n\".join(ls)\n", + "\n", + "\n", + "\n", + "if __name__ == '__main__':\n", + " st, n = input(),int(input())\n", + " rs = wrap(st,n)\n", + " print(rs)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'g'" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "min('stringsjhs')" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "t = \"The rain 59 in Spain\"\n", + "x = re.search(\"^The.*Spains$\",t)" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], + "source": [ + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['i', 'i', 'i']\n" + ] + } + ], + "source": [ + "v = re.findall(\"[i]\",t)\n", + "print(v)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['5', '9']\n" + ] + } + ], + "source": [ + "n= re.findall(\"\\d\",t)\n", + "print(n)" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['rain']" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "re.findall(\"r..n\",t)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def swapList(newList):\n", + " n = len(newList)\n", + "\n", + " temp = newList[0]\n", + " newList[0] = newList[n-1]\n", + " newList[n-1] = temp\n", + "\n", + " return newList" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[5, 2, 3, 4, 1]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l =[1,2,3,4,5]\n", + "swapList(l)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def swapPosition(list,pos1,pos2):\n", + "\n", + " list[pos1],list[pos2] = list[pos2],list[pos1]\n", + " \n", + " return list" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[5, 2, 4, 3, 1]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "swapPosition(l,2,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def swapEle(list,e1,e2):\n", + "\n", + " \n", + " for sub in list:\n", + " temp = '-'\n", + " sub.replace(e1,temp).replace(e2,e1).replace(temp,e2)\n", + "\n", + " return sub\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Geeks'" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sl = ['Gfg', 'is', 'best', 'for', 'Geeks']\n", + "swapEle(sl,'e','G')" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "ls = \", \".join(sl)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gfg, is, best, for, Geeks\n" + ] + } + ], + "source": [ + "print(ls)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['efg', 'is', 'bGst', 'for', 'eGGks']\n" + ] + } + ], + "source": [ + "res = ls.replace('G','-').replace('e','G').replace('-','e').split(', ')\n", + "print(res)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def max(a,b):\n", + " if a>b:\n", + " return a\n", + " else:\n", + " return (\"maximum of numbers is \" + str(b))" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'maximum of numbers is 4'" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "max(2,4)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "min(3,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[5, 2, 4, 3, 1]" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "def elemList(l,n):\n", + " if n in l:\n", + " return \"exist\"\n", + " else:\n", + " return \"not present\"" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'exist'" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "elemList(l,5)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[5, 2, 4, 3, 1]" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "def reveseL(l):\n", + " nl = []\n", + " ln = len(l)-1\n", + " for i in l:\n", + " nl.insert(0,i)\n", + "\n", + " return nl" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5, 2, 4, 3, 1]\n", + "[1, 3, 4, 2, 5]\n" + ] + } + ], + "source": [ + "print(l)\n", + "print(reveseL(l))" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "l\n", + "m = l[:]" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[5, 2, 4, 3, 1]" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "def counl(l,e):\n", + " c = 0\n", + " for i in l:\n", + " if i == e:\n", + " c += 1\n", + " return c" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ls = [1,2,3,2,1,3,5,3,4,2,1,2]\n", + "counl(ls,2)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "def sumav(l):\n", + " sc = 0\n", + " for i in l:\n", + " sc += 1\n", + "\n", + " sm = sum(l)\n", + " avg = sm/len(l)\n", + "\n", + " return sm,avg" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'sumav' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[3], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m ll \u001b[39m=\u001b[39m [\u001b[39m1\u001b[39m,\u001b[39m2\u001b[39m,\u001b[39m3\u001b[39m]\n\u001b[0;32m----> 2\u001b[0m sumav(ll)\n", + "\u001b[0;31mNameError\u001b[0m: name 'sumav' is not defined" + ] + } + ], + "source": [ + "ll = [1,2,3]\n", + "sumav(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [], + "source": [ + "def sumnu(l):\n", + " res = []\n", + " for i in l:\n", + " sum = 0\n", + " for d in str(i):\n", + " sum += int(d)\n", + " res.append(sum)\n", + " \n", + " return res" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[3, 13, 17, 7]" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sn = [12,67,98,34]\n", + "sumnu(sn)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [], + "source": [ + "def mulp(l):\n", + " rs = 1\n", + " for i in l:\n", + " rs *= i\n", + " \n", + " return rs" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mulp(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [], + "source": [ + "def smaln(l):\n", + " sm = l[0]\n", + " for i in range(len(l)):\n", + " if l[i] < sm:\n", + " sm = l[i]\n", + " \n", + " return sm" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "smaln(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "def larg(l):\n", + " sm = l[0]\n", + " for i in range(len(l)):\n", + " if l[i]> sm:\n", + " sm = l[i]\n", + "\n", + " return sm" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "larg(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def secondLar(l):\n", + " larg = l[0]\n", + " secondlarge = 0\n", + " for i in range(len(l)):\n", + " if l[i] > l[0]:\n", + " larg = l[i]\n", + " else:\n", + " secondlarge = max(secondlarge,l[i])\n", + " \n", + " return secondlarge" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# print(ll)\n", + "secondLar(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "def evenl(l):\n", + " result = []\n", + " for n in l:\n", + " if n % 2 ==0 :\n", + " return n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "evenl(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "def oddl(l):\n", + " result = []\n", + " for i in l:\n", + " if i % 2 != 0:\n", + " result.append(i)\n", + "\n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 3]" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "oddl(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "def evelr(l):\n", + " for i in range(l):\n", + " if i % 2 == 0:\n", + " print(i)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "2\n", + "4\n" + ] + } + ], + "source": [ + "evelr(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "def eoc(l):\n", + " ec = 0\n", + " oc = 0\n", + " for i in l:\n", + " if i % 2== 0:\n", + " ec += 1\n", + " else:\n", + " oc += 1\n", + " \n", + " return ec,oc" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 2)" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eoc(ll)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "def longest_Common_Prefix(str1):\n", + " \n", + " if not str1:\n", + " return \"\"\n", + "\n", + " short_str = min(str1,key=len)\n", + "\n", + " for i, char in enumerate(short_str):\n", + " for other in str1:\n", + " if other[i] != char:\n", + " return short_str[:i]\n", + "\n", + " return short_str " + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'abcdefgh'" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "la = [\"abcdefgh\",\"abcefgh\"]\n", + "min(la)\n", + "# print(longest_Common_Prefix([\"abcdefgh\",\"abcefgh\"]))\n", + "# print(longest_Common_Prefix([\"w3r\",\"w3resource\"]))\n", + "# print(longest_Common_Prefix([\"Python\",\"PHP\", \"Perl\"]))\n", + "# print(longest_Common_Prefix([\"Python\",\"PHP\", \"Java\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "def longpre(a):\n", + " le = len(a)\n", + "\n", + " if le == 0 :\n", + " return \"\"\n", + " \n", + " if le == 1:\n", + " return a[0]\n", + " \n", + "\n", + " min_str = min(len(a[0]),len(a[le - 1]))\n", + " i = 0\n", + " while (i < min_str and a[0][i] == a[le - 1][i]):\n", + " i += 1\n", + "\n", + " pre = a[0][0:i]\n", + " return pre" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'abc'" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "longpre(la)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n" + ] + } + ], + "source": [ + "i = 0\n", + "while i < 10:\n", + " print(i)\n", + " i +=1" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "def twoSUm(l,tg):\n", + " for i in range(len(l)):\n", + " for j in range(i+1,len(l)):\n", + " if l[j] == tg - l[i]:\n", + " return [i,j]" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 3]" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l = [1,2,3,4,5]\n", + "tg = 5\n", + "twoSUm(l,tg)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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.4" + }, + "vscode": { + "interpreter": { + "hash": "949777d72b0d2535278d3dc13498b2535136f6dfe0678499012e853ee9abcab1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/test.py b/test.py index e23d386..369254a 100644 --- a/test.py +++ b/test.py @@ -1 +1,31 @@ -print("Naveen") \ No newline at end of file +# if __name__ == '__main__': +# nm = [] +# ls = [] +# +# for _ in range(int(input())): +# name = input() +# score = float(input()) +# +# print(name,score) + +if __name__ == '__main__': + num = [] + arr = [] + for _ in range(int(input())): + name = input() + score = float(input()) + arr.append([name, score]) + num.append(score) + + num.sort() + second_min = 0 + mini = num[0] + arr.sort() + for i in num: + if i != mini: + second_min = i + break + + for i in arr: + if i[1] == second_min: + print(i[0]) diff --git a/test2.ipnb b/test2.ipnb new file mode 100644 index 0000000..e69de29 diff --git a/test2.ipynb b/test2.ipynb new file mode 100644 index 0000000..bf9380b --- /dev/null +++ b/test2.ipynb @@ -0,0 +1,306 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello\n" + ] + } + ], + "source": [ + "print(\"Hello\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def greet():\n", + " print(\"Hello World\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World\n" + ] + } + ], + "source": [ + "greet()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def add(x,y):\n", + " z = x+y\n", + " return z" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "result = add(2,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], + "source": [ + "print(result)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "class Test:\n", + "\n", + " def config(self):\n", + " print(\"i5\",\"16GB\",\"1TB\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "i5 16GB 1TB\n" + ] + } + ], + "source": [ + "com1 = Test()\n", + "\n", + "\n", + "com1.config()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "class Computer:\n", + "\n", + " def __init__(self, cpu=\"I7\", ram=\"16GB\") -> None:\n", + " self.cpu = cpu\n", + " self.ram = ram\n", + " \n", + " def config(self):\n", + " print(\"Configuration is \", self.cpu, self.ram)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "com1 = Computer(\"I5\", \"12GB\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Configuration is I5 12GB\n" + ] + } + ], + "source": [ + "com1.config()" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello world\n" + ] + } + ], + "source": [ + "print(\"Hello world\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def larg(lst):\n", + " if not lst:\n", + " return None\n", + " max_element = lst[0]\n", + " for i in lst:\n", + " if i > max_element:\n", + " max_element = i\n", + " return max_element\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "43\n" + ] + } + ], + "source": [ + "ml = [1,20,1,2,43]\n", + "print(larg(ml))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def rem_dup(lst):\n", + " ul = []\n", + " for i in lst:\n", + " if i not in ul:\n", + " ul.append(i)\n", + " return ul" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 3, 33, 14]\n" + ] + } + ], + "source": [ + "ml = [1,3,3,33,14]\n", + "print(rem_dup(ml))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def rev_lst(lst):\n", + " rlst = []\n", + " for i in lst:\n", + " rlst = [i] + rlst\n", + " return lst\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'>' not supported between instances of 'int' and 'list'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[17], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m ml \u001b[39m=\u001b[39m [\u001b[39m1\u001b[39m]\n\u001b[0;32m----> 2\u001b[0m \u001b[39mprint\u001b[39m(rev_lst(ml))\n", + "Cell \u001b[0;32mIn[16], line 4\u001b[0m, in \u001b[0;36mrev_lst\u001b[0;34m(lst)\u001b[0m\n\u001b[1;32m 2\u001b[0m lst \u001b[39m=\u001b[39m []\n\u001b[1;32m 3\u001b[0m i \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m\n\u001b[0;32m----> 4\u001b[0m \u001b[39mwhile\u001b[39;00m i \u001b[39m>\u001b[39;49m lst:\n\u001b[1;32m 5\u001b[0m lst\u001b[39m.\u001b[39mappend(i)\n\u001b[1;32m 6\u001b[0m i \u001b[39m=\u001b[39m i \u001b[39m-\u001b[39m\u001b[39m1\u001b[39m\n", + "\u001b[0;31mTypeError\u001b[0m: '>' not supported between instances of 'int' and 'list'" + ] + } + ], + "source": [ + "ml = [1]\n", + "print(rev_lst(ml))" + ] + } + ], + "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.11.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "949777d72b0d2535278d3dc13498b2535136f6dfe0678499012e853ee9abcab1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/test2.py b/test2.py new file mode 100644 index 0000000..db1a2b7 --- /dev/null +++ b/test2.py @@ -0,0 +1 @@ +print("Hello world from pycharm") \ No newline at end of file