DAY - 19

Today’s Learning :-

For more Tech content Join us on linkedin click here

All the code snippets in this journey are available on my GitHub repository. 📂 Feel free to explore and collaborate: Git Repository

Time and Space Complexity :-

Time Complexity:
Time complexity refers to the amount of time an algorithm takes to execute as a function of the size of its input.

It measures how the runtime of an algorithm grows with the size of the input.

Time complexity is typically expressed using big O notation (O()), which describes the upper bound on the running time of an algorithm in the worst-case scenario.

Common time complexities include O(1) (constant time), O(log n) (logarithmic time), O(n) (linear time), O(n log n) (linearithmic time), O(n^2) (quadratic time), and so on.

Algorithms with lower time complexity are more efficient and desirable.

Space Complexity:

Space complexity refers to the amount of memory space an algorithm uses as a function of the size of its input.

It measures how the memory usage of an algorithm grows with the size of the input.

Space complexity is also expressed using big O notation (O()), which describes the upper bound on the amount of memory space required by an algorithm in the worst-case scenario.

Common space complexities include O(1) (constant space), O(n) (linear space), O(n^2) (quadratic space), and so on.
Algorithms with lower space complexity are more memory-efficient and desirable.

Relationship:

While time complexity focuses on the runtime efficiency of an algorithm, space complexity focuses on its memory usage.

An algorithm may have good time complexity but high space complexity, or vice versa.

It's often necessary to balance time and space complexities based on the specific requirements of a problem and the available resources.

Understanding time and space complexity helps in designing efficient algorithms, optimising code, and analysing the scalability of software systems.

Python : -

Python, a dictionary is an unordered collection of key-value pairs. Dictionaries are mutable, meaning you can add, remove, and modify key-value pairs dynamically. Each key in a dictionary must be unique and immutable (such as strings, numbers, or tuples), while values can be of any data type and mutable.

Here's how you can work with dictionaries in Python:

Creating Dictionaries:

You can create a dictionary using curly braces {} and specifying key-value pairs, or by using the dict() constructor.

Accessing Elements:

You can access the value associated with a key in a dictionary using square brackets [] or the get() method.

Adding and Updating Elements:

You can add new key-value pairs to a dictionary or update existing ones using square brackets [] or the update() method.

Removing Elements:

You can remove key-value pairs from a dictionary using the del keyword or the pop() method.

Iterating Over Dictionaries:

You can iterate over the keys, values, or key-value pairs of a dictionary using loops or dictionary methods.

Dictionary Methods:

Dictionaries support various methods for common operations, such as keys(), values(), items(), clear(), copy(), update(), get(), pop(), popitem(), and more.

Dictionaries are widely used in Python for mapping between keys and values, storing data in a structured manner, and performing efficient lookups. They are versatile data structures suitable for various applications.

Feel free to reshare this post to enhance awareness and understanding of these fundamental concepts.
Code snippets are in the Git repository.

🙏 Thank you all for your time and support! 🙏