Given a range and element K, generate K float values that are evenly spaced.
Input : i = 4, j = 6, K = 10
Output : [4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0]
Explanation : The difference 0.2 is added after 4 to produce 10 elements till 6.Input : i = 10, j = 20, K = 2
Output : [15.0, 20.0]
Explanation : 5 is difference and is added each time.
Method #1: Using loop
This is one of the ways in which this task can be performed. In this, we iterate till K while increasing the counter for difference between successive elements.
Python3
# Python3 code to demonstrate working of# Produce K evenly spaced float values# Using loop# initializing rangei, j = 2, 10# Initialize KK = 15# computing differencediff = (j - i) / Kres = []# using loop to add numbers to resultfor idx in range(1, K + 1): res.append(i + (diff * idx))# printing resultprint("The constructed list : " + str(res)) |
The constructed list : [2.533333333333333, 3.0666666666666664, 3.6, 4.133333333333333, 4.666666666666666, 5.2, 5.733333333333333, 6.266666666666667, 6.8, 7.333333333333333, 7.866666666666666, 8.4, 8.933333333333334, 9.466666666666667, 10.0]
Time Complexity: O(n) where n is the number of elements
Auxiliary Space: O(n) where n is the number of elements in the new list.
Method #2: Using list comprehension
The working of this method is similar to above method. The difference being compact way in which this solution is formulated using list comprehension.
Python3
# Python3 code to demonstrate working of# Produce K evenly spaced float values# Using loop# initializing rangei, j = 2, 10# Initialize KK = 15# computing differencediff = (j - i) / K# using list comprehension to formulate elementsres = [i + (diff * idx) for idx in range(1, K + 1)]# printing resultprint("The constructed list : " + str(res)) |
The constructed list : [2.533333333333333, 3.0666666666666664, 3.6, 4.133333333333333, 4.666666666666666, 5.2, 5.733333333333333, 6.266666666666667, 6.8, 7.333333333333333, 7.866666666666666, 8.4, 8.933333333333334, 9.466666666666667, 10.0]
Time Complexity: O(n) where n is the number of elements in the list
Auxiliary Space: O(n) where n is the number of elements in the list
Method #3 : Using recursion+round()
In this method, we use list comprehension to produce k evenly spaced values between i and j. We calculate the step size by dividing the difference between j and i by k-1. We use this step size to generate k values using a for loop inside the list comprehension. Finally, we round the values to 1 decimal place using the round() function.
Python3
def evenly_spaced_floats(i, j, k): # Calculate the step size between each float value step = (j - i) / (k - 1) # Generate a list of K evenly spaced float values # by adding a multiple of the step size to the start value i # for each value in the range [0, K-1] # and rounding each value to 1 decimal place return [round(i + n*step, 1) for n in range(k)]# Example usagei = 4j = 6k = 10result = evenly_spaced_floats(i, j, k)print(result) |
[4.0, 4.2, 4.4, 4.7, 4.9, 5.1, 5.3, 5.6, 5.8, 6.0]
Time complexity: O(k)
Auxiliary Space: O(k)
Method #4: Using numpy:
- Calculate the step size between each float value by subtracting the start value i from the end value j, and then dividing by the number of values to generate k minus 1. This will give us the increment between each value in the sequence.
- Generate a 1D array of k evenly spaced float values. We can use a generator expression to compute each value by adding a multiple of the step size to the start value i for each value in the range [0, k-1], and rounding each value to 1 decimal place. Then, we can use the np.fromiter function to create a numpy array from the generator expression.
- Return the resulting numpy array of evenly spaced float values.
Python3
import numpy as npdef evenly_spaced_floats(i, j, k): # Calculate the step size between each float value step = (j - i) / (k - 1) # Generate a 1D array of K evenly spaced float values # by adding a multiple of the step size to the start value i # for each value in the range [0, K-1] # and rounding each value to 1 decimal place return np.fromiter((i + n*step for n in range(k)), dtype=float)# Example usagei = 4j = 6k = 10result = evenly_spaced_floats(i, j, k)print(result)#This code is contributed by Jyothi Pinjala. |
Output:
[4. 4.22222222 4.44444444 4.66666667 4.88888889 5.11111111 5.33333333 5.55555556 5.77777786. ]
Time complexity: O(k) since it involves generating a list of K evenly spaced float values, which requires iterating over a range of K values.
Auxiliary space: O(k) since it involves creating a list of K float values to store the generated values.
Method #5: Using map function with lambda expression
- Define a function named “evenly_spaced_floats”
- Calculate the step size between each float value
- Generate a list of K integers from 0 to K-1 using the range function
- Use the map function with lambda expression to generate a list of K evenly spaced float values
- Round each value to 1 decimal place using the round function
- Return the list of evenly spaced float values
Python3
def evenly_spaced_floats(i, j, k): # Calculate the step size between each float value step = (j - i) / (k - 1) # Generate a list of K integers from 0 to K-1 indices = range(k) # Use the map function with lambda expression to generate a list of K evenly spaced float values values = map(lambda n: round(i + n*step, 1), indices) # Convert the map object to a list and return it return list(values)# Example usagei = 4j = 6k = 10result = evenly_spaced_floats(i, j, k)print(result) |
[4.0, 4.2, 4.4, 4.7, 4.9, 5.1, 5.3, 5.6, 5.8, 6.0]
Time complexity: O(k), as we need to iterate over the K values to generate the list of evenly spaced float values.
Auxiliary space: O(k), as we need to store the list of K integers and the list of K evenly spaced float values.
