DSA
DSA
DATA STRUCTUTRE AND ALGORITHM
1.Printing
Printing and then moving cursor to next line
JS
console.log("hello sharpnerians");
Python
print("hello sharpnerians")
C++
cout<<"hello sharpnerians"<<endl;
Java
System.out.println("hello sharpnerians");
Printing and cursor remaining same line
JS
not possible
Python
print("hello sharpnerians", end="")
C++
cout<<"hello sharpnerians";
Java
System.out.print("hello sharpnerians");
2.Variables
its a placeholder to store values
x=3 //x is the variable
Datatype
its defined type of the data to be stored
primitive data type=it has value
Static defined datatype:
In some language, datatype should be mention
e.g. int x=5 //java
Dynamic defined datatype:
e.g. x=5 //python
Getting input from user:
def calculate(a,b, c): 5 """write the code inside this block to calculate a+b-c""" 6 print(a+b-c) 7 8 9 10 11 """Dont change anything below. If changed click on reset.""" 12 13def main(): 14 a = int(input()) 15 b = int(input()) 16 c = int(input()) 17 calculate(a,b,c) 18main()
x=8
y=3
print(x)
operator in python
print(x/y)
o/p=2.8
print(x//y)
o/p=2
--------------------------------------------------------------------------------------------
swap two numbers:
def swap(a,b): 5 """write the code inside this block to swap two numbers""" 6 x=b 7 b=a 8 a=x 9 10 11 """Dont change anything below. If changed click on reset.""" 12 print("a value is =",a) 13 print("b value is =",b) 14 15def main(): 16 a = int(input()) 17 b = int(input()) 18 swap(a,b) 19main()
IF ELIF ELSE
x=3
if x==3:
print("true")
else:
print("false")
IF ELSE LADDER
def print_cost(distance): 5 """ 6 write the code below to print the cost 7 if the distance is given 8 """ 9 if distance<=100: 10 print("5") 11 elif distance>100 and distance<=500: 12 print("8") 13 elif distance>500 and distance<=1000: 14 print("10") 15 elif distance>1000: 16 print("12") 17
TERNERY OPERATOR
(if else statement in a single line)
java:
x = a<10 ? 5 :10
if(a<10)
x=5;
else
x=10;
python:
syntax: opt1 if condition else opt2
e.g. 5 if a<10 else 10
a = "xxx" if x<6 else "yyy"
e.g. x=6
print(10 if x>0 else 1)e.g. x=5 a = "xxx" if x<6 else "yyy" print(a)
SWITCH STATEMENT
LOOP
Execute particular statement continuously till the condition will reach
While loop:
initialization
condition
incrementation
e.g.
i=1
while i<=5:
print("Hello world")
i=i+1
e.g. Print all even numbers from 1 to n
def print_even(n): 5 6 i=2 7 while i<=n: 8 print(i) 9 i=i+2 10 11def main(): 12 n=int(input()) 13 print_even(n) 14 15main()
--------------------------------------------------------------------------------------------
FOR LOOP
Syntax:
for i in range(start, end inc/dec)
e.g.
for i in range(2, 11, 2):
print(n);
o/p
2 4 6 8 10
for i in range(10,1, -2):
print(n)
o/p 10 8 6 4 2
for i in range(25, -1,-5):
print(n)
o/p 25 20 15 10 5 0
e.g. for loop used with list
x=["sumi",34,1223]
for i in x:
print(x)
o/p sumi 34 1223
x="sumi"
for i in x:
print(i)
o/p s u m i
for i in x["sumi",23,455]
print(i)
o/p sumi 23 455
for i in range(10):
print(i)
o/p 012345678910
pattern
1st loop ------ pointing no. of lines
2nd loop-------pointing details of each line
for(10,
m=-1
y=mx+c
y=-1x+c
14=-1*2+c
c=16
formula =16-i
inner loop(10,16-i,1)
def print_message(message): 13 14 print(message) 15 16def main(): 17 while True: 18 try: 19 message = input() 20 21 except EOFError: 22 break 23main()
-------------------------------------------------------------------------------------------
Array
Dynamic Array
O/P: i
7️⃣ Tuples: Ordered, Unchangeable, and Allow Duplicates
A tuple is similar to a list but immutable (cannot be modified).
💡 Creating a Tuple
🔹 Output:
8️⃣ Accessing Elements in a Tuple
9️⃣ Tuple Unpacking
🔹 Output:
BIT MANIPULATION
*1 byte = 8 bits
* Decimal to Octal conversion
Right shift and Left shift
use of Right shift:
Find maximum of array without using inbuilt fun max():
Time Complexity
return-1unit
= O(1)
***************
**************
****************
****************
****************
--------------------------------------------------------------------------------
| Method | Description |
|---|---|
| capitalize() | Converts the first character to upper case |
| casefold() | Converts string into lower case |
| center() | Returns a centered string |
| count() | Returns the number of times a specified value occurs in a string |
| encode() | Returns an encoded version of the string |
| endswith() | Returns true if the string ends with the specified value |
| expandtabs() | Sets the tab size of the string |
| find() | Searches the string for a specified value and returns the position of where it was found |
| format() | Formats specified values in a string |
| format_map() | Formats specified values in a string |
| index() | Searches the string for a specified value and returns the position of where it was found |
| isalnum() | Returns True if all characters in the string are alphanumeric |
| isalpha() | Returns True if all characters in the string are in the alphabet |
| isascii() | Returns True if all characters in the string are ascii characters |
| isdecimal() | Returns True if all characters in the string are decimals |
| isdigit() | Returns True if all characters in the string are digits |
| isidentifier() | Returns True if the string is an identifier |
Sislower() | Returns True if all characters in the string are lower case |
| isnumeric() | Returns True if all characters in the string are numeric |
| isprintable() | Returns True if all characters in the string are printable |
| isspace() | Returns True if all characters in the string are whitespaces |
| istitle() | Returns True if the string follows the rules of a title |
| isupper() | Returns True if all characters in the string are upper case |
| join() | Joins the elements of an iterable to the end of the string |
| ljust() | Returns a left justified version of the string |
| lower() | Converts a string into lower case |
| lstrip() | Returns a left trim version of the string |
| maketrans() | Returns a translation table to be used in translations |
| partition() | Returns a tuple where the string is parted into three parts |
| replace() | Returns a string where a specified value is replaced with a specified value |
| rfind() | Searches the string for a specified value and returns the last position of where it was found |
| rindex() | Searches the string for a specified value and returns the last position of where it was found |
| rjust() | Returns a right justified version of the string |
| rpartition() | Returns a tuple where the string is parted into three parts |
| rsplit() | Splits the string at the specified separator, and returns a list |
| rstrip() | Returns a right trim version of the string |
| split() | Splits the string at the specified separator, and returns a list |
| splitlines() | Splits the string at line breaks and returns a list |
| startswith() | Returns true if the string starts with the specified value |
| strip() | Returns a trimmed version of the string |
| swapcase() | Swaps cases, lower case becomes upper case and vice versa |
| title() | Converts the first character of each word to upper case |
| translate() | Returns a translated string |
| upper() | Converts a string into upper case |
| zfill() | Fills the string with a specified number of 0 values at the beginning |
File "demo_string_format_error.py", line 2, in <module>
txt = "My name is John, I am " + age
TypeError: must be str, not int
To extract a specific word from a string in Python, you can use the split() method to split the string into a list of words, and then access the desired word using its index.
Here's an example:
- text = "The quick brown fox jumps over the lazy dog."
- word_index = 3
- extracted_word = text.split()[word_index]
- print(extracted_word) # Output: "fox"
In this example, text.split() returns a list of words ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.'], and word_index = 3 selects the 4th word in the list, which is "fox".
-------------------------------------------------------------------------------
Functions help avoid repetition and make the code more organized.
Namespace: It is an area where you create and store variables/objects
Two Types:
i) Class namespace
The place where stored classes
ii) Object/instance namespace
Change values in both class and instance variables:
A class inherits from another class
Polymorphism
Static and Non Static:
Dictionaries in Python
A Python dictionary is a data structure that stores the value in key: value pairs. Values in a dictionary can be of any data type and can be duplicated, whereas keys can’t be repeated and must be immutable.
Example: Here, The data is stored in key:value pairs in dictionaries, which makes it easier to find values.
d = {1: 'Geeks', 2: 'For', 3: 'Geeks'}
print(d)
Output
{1: 'Geeks', 2: 'For', 3: 'Geeks'}
How to Create a Dictionary
In Python, a dictionary can be created by placing a sequence of elements within curly {} braces, separated by a ‘comma’.
# create dictionary using { }
d1 = {1: 'Geeks', 2: 'For', 3: 'Geeks'}
print(d1)
# create dictionary using dict() constructor
d2 = dict(a = "Geeks", b = "for", c = "Geeks")
print(d2)
Output
{1: 'Geeks', 2: 'For', 3: 'Geeks'}
{'a': 'Geeks', 'b': 'for', 'c': 'Geeks'}
- From Python 3.7 Version onward, Python dictionary are Ordered.
- Dictionary keys are case sensitive: the same name but different cases of Key will be treated distinctly.
- Keys must be immutable: This means keys can be strings, numbers, or tuples but not lists.
- Keys must be unique: Duplicate keys are not allowed and any duplicate key will overwrite the previous value.
- Dictionary internally uses Hashing. Hence, operations like search, insert, delete can be performed in Constant Time.
Table of Content
Accessing Dictionary Items
d = { "name": "Alice", 1: "Python", (1, 2): [1,2,4] } # Access using key print(d["name"]) # Access using get() print(d.get("name"))
OutputAlice Alice
Adding and Updating Dictionary Items
We can add new key-value pairs or update existing keys by using assignment.
d = {1: 'Geeks', 2: 'For', 3: 'Geeks'} # Adding a new key-value pair d["age"] = 22 # Updating an existing value d[1] = "Python dict" print(d)
Output{1: 'Python dict', 2: 'For', 3: 'Geeks', 'age': 22}Removing Dictionary Items
We can remove items from dictionary using the following methods:
- del: Removes an item by key.
- pop(): Removes an item by key and returns its value.
- clear(): Empties the dictionary.
- popitem(): Removes and returns the last key-value pair.
d = {1: 'Geeks', 2: 'For', 3: 'Geeks', 'age':22} # Using del to remove an item del d["age"] print(d) # Using pop() to remove an item and return the value val = d.pop(1) print(val) # Using popitem to removes and returns # the last key-value pair. key, val = d.popitem() print(f"Key: {key}, Value: {val}") # Clear all items from the dictionary d.clear() print(d)
Output{1: 'Geeks', 2: 'For', 3: 'Geeks'} Geeks Key: 3, Value: Geeks {}Iterating Through a Dictionary
We can iterate over keys [using keys() method] , values [using values() method] or both [using item() method] with a for loop.
d = {1: 'Geeks', 2: 'For', 'age':22} # Iterate over keys for key in d: print(key) # Iterate over values for value in d.values(): print(value) # Iterate over key-value pairs for key, value in d.items(): print(f"{key}: {value}")
Output1 2 age Geeks For 22 1: Geeks 2: For age: 22
Read in detail – Ways to Iterating Over a Dictionary
Nested Dictionaries
Example of Nested Dictionary:
d = {1: 'Geeks', 2: 'For', 3: {'A': 'Welcome', 'B': 'To', 'C': 'Geeks'}} print(d)
Output{1: 'Geeks', 2: 'For', 3: {'A': 'Welcome', 'B': 'To', 'C': 'Geeks'}}
Check if a Key Exists in a Python Dictionary
Python dictionary can not contain duplicate keys, so it is very crucial to check if a key is already present in the dictionary. If you accidentally assign a duplicate key value, the new value will overwrite the old one.
To check if given Key exists in dictionary, you can use either in operator or get() method. Both are easy are use and work efficiently.
Using IN operator
# Example dictionary
d = {'a': 1, 'b': 2, 'c': 3}
# Key to check
key = 'b'
print(key in d) # Output: True
key = 'g'
print(key in d) # Output: False
Output
True False
Sets in Python
Last Updated : 04 Feb, 2025A Set in Python is used to store a collection of items with the following properties.
- No duplicate elements. If try to insert the same item again, it overwrites previous one.
- An unordered collection. When we access all items, they are accessed without any specific order and we cannot access items using indexes as we do in lists.
- Internally use hashing that makes set efficient for search, insert and delete operations. It gives a major advantage over a list for problems with these operations.
- Mutable, meaning we can add or remove elements after their creation, the individual elements within the set cannot be changed directly.
Example of Python Sets
Output{10, 50, 20} <class 'set'>Note : There is no specific order for set elements to be printed
Type Casting with Python Set method
The Python set() method is used for type casting.
Output{'c', 'b', 'a'} {'d', 'c', 'b', 'a'}Check unique and Immutable with Python Set
Python sets cannot have duplicate values. While you cannot modify the individual elements directly, you can still add or remove elements from the set.
The first code explains that the set cannot have a duplicate value. Every item in it is a unique value.
The second code generates an error because we cannot assign or change a value once the set is created. We can only add or delete items in the set.
{'Geeks', 'for'}
TypeError: 'set' object does not support item assignmentHeterogeneous Element with Python Set
Python sets can store heterogeneous elements in it, i.e., a set can store a mixture of string, integer, boolean, etc datatypes.
Output{True, 'for', 'Geeks', 10, 52.7}Python Frozen Sets
Frozen sets in Python are immutable objects that only support methods and operators that produce a result without affecting the frozen set or sets to which they are applied. It can be done with frozenset() method in Python.
While elements of a set can be modified at any time, elements of the frozen set remain the same after creation.
If no parameters are passed, it returns an empty frozenset.
OutputNormal Set set(['a', 'c', 'b']) Frozen Set frozenset(['e', 'g', 'f'])Internal working of Set
This is based on a data structure known as a hash table. If Multiple values are present at the same index position, then the value is appended to that index position, to form a Linked List.
In, Python Sets are implemented using a dictionary with dummy variables, where key beings the members set with greater optimizations to the time complexity.
Set Implementation:
Hash Table
Sets with Numerous operations on a single HashTable:
Hashing
Methods for Sets
Adding elements to Python Sets
Insertion in the set is done through the set.add() function, where an appropriate record value is created to store in the hash table. Same as checking for an item, i.e., O(1) on average. However, in worst case it can become O(n).
OutputPeople: {'Idrish', 'Archi', 'Jay'} Set after adding element: {1, 2, 3, 4, 5, 'Daxit', 'Archi', 'Jay', 'Idrish'}Union operation on Python Sets
Two sets can be merged using union() function or | operator. Both Hash Table values are accessed and traversed with merge operation perform on them to combine the elements, at the same time duplicates are removed. The Time Complexity of this is O(len(s1) + len(s2)) where s1 and s2 are two sets whose union needs to be done.
OutputUnion using union() function {'Idrish', 'Arjun', 'Jay', 'Karan', 'Archil'} Union using '|' operator {'Idrish', 'Deepanshu', 'Raju', 'Jay', 'Archil'}Intersection operation on Python Sets
This can be done through intersection() or & operator. Common Elements are selected. They are similar to iteration over the Hash lists and combining the same values on both the Table. Time Complexity of this is O(min(len(s1), len(s2)) where s1 and s2 are two sets whose union needs to be done.
OutputIntersection using intersection() function {3, 4} Intersection using '&' operator {3, 4}Finding Differences of Sets in Python
To find differences between sets. Similar to finding differences in the linked list. This is done through difference() or – operator. Time complexity of finding difference s1 – s2 is O(len(s1))
OutputDifference of two sets using difference() function {0, 1, 2} Difference of two sets using '-' operator {0, 1, 2}Clearing Python Sets
Set Clear() method empties the whole set inplace.
OutputInitial set {1, 2, 3, 4, 5, 6} Set after using clear() function set()
Comments
Post a Comment