Sum of numbers 1 to N

Problem: We need the sum of the number 1 to N. The N could be anything (100,200,500,33,21) like anything. What is the best approach to solve this little problem ?

so there are multiple way to solve this problem. We will discuss 3 solution .

1. Recursive way :

Using recursion we can solve this problem. Here is the solution

The time complexity of this code is O(n) because it makes n recursive calls, each of which takes constant time. The space complexity is also O(n) because each recursive call adds a level to the call stack. The maximum depth of the recursion is n, so the maximum amount of space on the call stack is proportional to n.

2. Using loop

Here we need 2 different variables in our code -- a variable where we can store the sum as we iterate through the values and add them (my_sum in my code), and another variable (i in my code) to iterate over the numbers from 0 to n.

The time complexity of this code is O(n). The while loop runs n+1 times, and each iteration takes constant time, resulting in a linear time complexity. The space complexity is O(1). The space used by the code does not increase with the size of the input n. The variables my_sum and i take constant space, and there are no data structures like arrays or lists that would take space proportional to n.

3. Arithmetic (Best Approach)

Our Recursive approach and Loop approach is correct and it will give us the sum of numbers from 1 to n. However, Recursion and Loop can be expensive in terms of time and space complexity, especially for large values of n.

A more efficient approach would be to use the formula for the sum of an arithmetic series. The sum of the first n natural numbers can be found using the formula n*(n+1)/2.

This approach has a time complexity of O(1), which is more efficient than the recursive approach.

Comments

Implementing Advance Query Optimization in Django ORM

Django's ORM makes database interactions seamless, allowing developers to write queries in Python without raw SQL. However, as applications scale, inefficient queries can slow down performance, leading to high latency and database load. This guide explores advanced query optimization techniques in Django ORM to go beyond basic CRUD (Create, Read, Update, Delete) operations and improve efficiency. 1. Use QuerySet Caching to Avoid Repeated Queries Using cache reduces redundant queries for frequently accessed data. Caching helps reduce repeated database hits. 2. Avoid .count() on Large Datasets Using .count() on large tables can be expensive Inefficient way: Optimized way ( .exists() is Faster) 3. Use Indexes for Faster Lookups Indexes speed up queries on frequently filtered fields. Add db_index=True for frequently queried fields: 4. Optimize Bulk Inserts and Updated Performing operations on multiple records one by one is inefficient. Use bulk_create() for mass insert...

Django select_related and prefetch_related

Difference between select_related and prefetch_related Reducing SQL queries is one of the first steps when optimizing a Django project. There are two powerful methods included in the Django ORM to help us that can boost performance by creating a single more complex QuerySet rather than multiple, smaller queries. In this project we will understand about select_related and prefetch_related. Django use these two orm method to reduce sql queries in database based on different scenario. select_related Lets assume this two model we have. class Author ( models . Model ): name = models . CharField ( max_length = 200 ) def __str__ ( self ): return self . name class Courses ( models . Model ): name = models . CharField ( max_length = 200 ) author = models . ForeignKey ( Author , on_delete = models . CASCADE , related_name = 'courses' ) def __str__ ( self ): return self . name Here we have two mode. ...

Python Closure

Imagine you have a function called outer_function that defines another function called inner_function inside it. Now, inner_function can access variables from the outer_function . When inner_function is returned from outer_function , it still remembers those variables even though outer_function has finished executing. This is the essence of a closure in Python. Example Code: In this example, outer_function takes a parameter x and defines inner_function inside it. inner_function can access x from the outer_function . When outer_function(10) is called, it returns inner_function , effectively creating a closure. Now, closure_example holds a reference to inner_function along with the value x (which is 10 in this case). When closure_example(5) is called, it adds 5 to the value of x (which is 10), resulting in 15. So, a closure "closes over" the environment in which it was defined, allowing it to access variables from its enclosing scope even after that scope has fi...

Django Interview Preparation

Search This Blog