alter codes and create new study material

Author: PTHARRISH

Leet code.py

@@ -20,4 +20,50 @@
 #     if a == str(x):
 #         return True
 #     else:
-#         return False
+#         return False
+
+# class Solution:
+#     def threeSum(nums, List):
+#         res=[]
+#         nums.sort()
+#         length=len(nums)
+#         for i in range(length-2):
+#             if i>0 and nums[i]==nums[i-1]:
+#                 continue
+#             l=i+1
+#             r=length-1
+#             while l<r:
+#                 total=nums[i]+nums[l]+nums[r]
+#                 if total<0:
+#                     l=l+1
+#                 elif total>0:
+#                     r=r-1
+#                 else:
+#                     res.append([nums[i],nums[l],nums[r]])
+#                     while l<r and nums[l]==nums[l+1]:
+#                         l=l+1
+#                     while l<r and nums[r]==nums[r-1]:
+#                         r=r-1
+#                     l=l+1
+#                     r=r-1
+#         return res
+
+
+# import collections
+# def mindeletion(s):
+#     deletion=0
+#     freq=set()
+#     charco=collections.Counter(s)
+#     for chars,counts in charco.items():
+#         while counts>0 and counts in freq:
+#             counts-=1
+#             deletion+=1
+#         freq.add(counts)
+#     return deletion
+
+# a=input('enter: ')
+# result=mindeletion(a)
+# print(result)
+
+
+            

Python/firstclassfun.py

@@ -0,0 +1,41 @@
+# First class functions
+
+# First class objects in a language are handled uniformly throughout. 
+# They may be stored in data structures, passed as arguments, or used in control structures. 
+# A programming language is said to support first-class functions if it treats functions as first-class objects. 
+# Python supports the concept of First Class functions.
+
+# Properties of first class functions:
+
+#     A function is an instance of the Object type.
+#     You can store the function in a variable.
+#     You can pass the function as a parameter to another function.
+#     You can return the function from a function.
+#     You can store them in data structures such as hash tables, lists, …
+
+# Examples illustrating First Class functions in Python
+
+# 1. Functions are objects: 
+# Python functions are first class objects. 
+
+# Python program to illustrate functions 
+# can be treated as objects 
+def shout(text): 
+    return text.upper() # Print Uppercase
+
+  
+print (shout('Hello')) # HELLO
+print(shout) # Print the object of the function
+yell = shout # assign a function to a variable and can be treated as objects 
+print(yell) # print the object of the function shot and yell are same address yell -->shot
+print (yell('Hello')) # HELLO
+
+# In the above program we are assigning function to a variable
+# This assignment doesn’t call the function. (yell=shot)
+# It takes the function object referenced by shout and creates a second name pointing to it, yell.(yell -->shot)
+
+
+# 2. Functions can be passed as arguments to other functions: 
+# Because functions are objects we can pass them as arguments to other functions. 
+# Functions that can accept other functions as arguments are also called higher-order functions. 
+

basic.py

@@ -187,6 +187,9 @@
 #     print()
 #     space=space-1
 
+
+
+
 # Ratio of positive negative integer
 # def plusMinus(arr):
 #     arr = [1, -2, 0, 3, -4]

list.py

@@ -3,7 +3,7 @@
 # Problem Description
 # Create a program to create a list of odd numbers from a list of numbers using list comprehension.
 #
-# Create a list with the following data items 12, 17, 28, 19, 11, and assign it to the numbers variable.
+# 1. Create a list with the following data items 12, 17, 28, 19, 11, and assign it to the numbers variable.
 # Create a new list and only print 17, 19, 11 (odd numbers) using list comprehension.
 # Print newly created list.
 # # Replace ___ with your code
@@ -14,7 +14,7 @@
 # # print new list
 # print(newlist)
 #
-# 2Natural Numbers List
+# 2 Natural Numbers List
 # Easy
 # Problem Description
 # Create a program to create a list of first n natural numbers using list comprehension.

listfunctions.py

@@ -0,0 +1,123 @@
+# Variables
+a=10 # assign 10 to variable a
+b=10 # assign 10 to variable b
+
+# id():
+# id() function is a built-in function that returns the unique identifier of an object.
+# The identifier is an integer, which represents the memory address of the object.
+# The id() function is commonly used to check if two variables or objects refer to the same memory location.
+print(id(a))#a and b have same value the memory location will be same displayed.
+print(id(b))
+
+# class:
+# Python is an object oriented programming language.
+# Almost everything in Python is an object, with its properties and methods.
+# A Class is like an object constructor, or a "blueprint" for creating objects.
+# A class is a user-defined blueprint or prototype from which objects are created.
+# Classes provide a means of bundling data and functionality together. 
+# Creating a new class creates a new type of object, allowing new instances of that type to be made.
+
+class employee: 
+    # class is a keyword to create a class. class name is employee
+    #if you create a empty class it shows an error so ypu need to put pass statement on it
+    pass
+
+emp1=employee()# each unique employee that we create using our employee class will be an instance of the class
+emp2=employee()
+print(emp1)# <__main__.employee object at 0x7fc5ca05bfd0> emp1 object memory address
+print(emp2)# <__main__.employee object at 0x7fc5ca05beb0> emp2 object memory address
+
+
+# object:
+# An object is called an instance of a class.here emp1 and emp2 have unique employee classes
+
+
+# pass: 
+# The pass statement is used as a placeholder for future code. 
+# When the pass statement is executed, nothing happens, but you avoid getting an error 
+# when empty code is not allowed.
+# Empty code is not allowed in loops, function definitions, class definitions, or in if statements
+
+
+
+class my_class:
+    # global variable
+    strength='empty'
+    classroom='None'
+
+    def __init__(self,class_name="None",staff="Unallotted",fullname="None"):
+    # self : Pointer to Current Object. staff=None is default arguments
+        self.staff_name=staff # Instance variable creating automatically
+        self.fullname=fullname
+        self.classroom=class_name
+        print(self.staff_name,self.fullname,self.classroom)
+
+
+    def myclass(self,student): # without self keyword positional argument error occurs
+        global strength # access the global variable change inside a function
+        strength=student# it will work inside the 
+        return  "Total strength of the class is " +strength # return statement store the value in the the function on it 
+        
+    def myfunct(self,repname):
+        #local variable
+        rep=repname
+        print(self.classroom," incharge staff ",self.staff_name," full name ",self.fullname)
+        print(rep+" is representative for " +self.classroom)
+        print(self.strength+" students inside the class room ")
+        #self.strength show class variable strength if current obj not available it will take global variable
+
+
+
+
+obj=my_class("I MCA","HPT","Harrish PT") 
+# object creation for class (my_class is Class name).obj is instance of the class or object
+# you can't pass global variable inside class  
+
+# print(obj) 
+# print memory address of the object (obj)
+
+print(obj.strength) 
+# Print obj.name is Global Variable (my_class.name)
+
+obj.staff_name="KK"
+obj.fullname="Kishore" 
+# Manually created instance variable 
+
+print("Manually created staff name : "+obj.staff_name) 
+print("Manually created staff fullname : "+obj.fullname) 
+# printing Manually created instance variable 
+
+print(obj.myclass('16')) 
+# It will print inside the myfunc stored value //Roll16
+
+obj.myclass('15') 
+# It will not print anything if you call the function without print statement it will print Nothing
+
+obj.myfunct('Harrish')
+# Here It will print the value because in myfunct contain print statement inside on it so no need to again use print function
+
+obj2=my_class("I MCA",'Dk','Dineshkumar') # create a object and pass a value to the constructor or __init__ method
+obj2.myfunct('Santhosh')
+
+# Instance variable:
+# Instance variable contains data that is unique to each instance.
+# Instance variable can created manually and automatically. 
+# Manually set the variables every time its a lots of code and it also prone to mistake.
+
+
+# self
+# the term “self” refers to the instance of the class that is currently being used. 
+# It is customary to use “self” as the first parameter in instance methods of a class.
+# Whenever you call a method of an object created from a class, 
+# the object is automatically passed as the first argument using the “self” parameter. 
+# The self is always pointing to the Current Object. 
+# When you create an instance of a class, 
+# you’re essentially creating an object with its own set of attributes and methods.
+
+
+# constructor
+# a class constructor is a special method named __init__ that gets called when you create an instance (object) of a class. 
+# This method is used to initialize the attributes of the object. 
+# Keep in mind that the self parameter in the constructor refers to the instance being created and allows 
+# you to access and set its attributes. 
+