Strictly increasing difference between adjacent elements in a list

Question

Write a function expanding(l) that takes as input a list of integer l and returns True if the absolute difference between each adjacent pair of elements strictly increases.

I tried to execute this code but this isn't returning correct value for some lists.

def expanding(l):
 for i in range(0,len(l)-3):
  if (abs(l[i+2]-l[i+1])>abs(l[i+1]-l[i])):
   Answer=True
  else:
   Answer=False
 return Answer

expanding([1,3,7,2,-3]) should be False but the output is True.

Answer 1

Use a temporary variable to store the difference, and exit once you reach a non-increasing difference.

def expanding(l):

    dif = abs(l[1] - l[0])

    for i in range(1, len(l)-1):
        temp = abs(l[i+1] - l[i])

        # Non-increasing difference, return
        if temp < dif:
            return False
        else:
            dif = temp

    # All differences are increasing
    return True

Answer 2

Yet another solution using iterators:

from itertools import tee, islice, starmap
from operator import lt, sub

def pairwise(x):
    a, b = tee(x, 2)
    return zip(a, islice(b, 1, None))

a = [1,3,7,2,-3]

pairs = pairwise(a) # this will be (a[0], a[1]), (a[1], a[2]), ...

# The next will produce the result abs(a[1]-a[0]), abs(a[2]-a[1]), ...
differences = map(abs, starmap(sub, pairs))

# This will be abs(a[2]-a[1])>abs(a[1]-a[0]), abs(a[3]-a[2])>abs(a[2]-a[1]), ...
cmp = starmap(lt, pairwise(differences))

# Differences strictly increases if all items in cmp are evaluated to True...
result = all(cmp)
print(result)

The output for such input is False

Answer 3

Numpy is your friend:

import numpy as np

x=np.array([1,3,7,2,-3])
(np.diff(abs(x[1:] - x[:-1])) > 0).all()  # returns False

If you're fancy a function, I would do like this:

def expanding(l):
    # convert list to  np.array if a list was passed
    if isinstance(l, list):
        l = np.array(l)

    return (np.diff(abs(l[1:] - l[:-1])) > 0).all()

Answer 4

I would recommend writing the condition in an iterator that you then pass to any so to make sure that on the first occurrence of a non-expanding difference the iteration stops and False is returned.

Here is how this would look:

def expanding(l):
    return not any((abs(l[i-1]-l[i])>=abs(l[i]-l[i+1]) for i in range(1,len(l)-1)))

Answer 5

def expanding(L):
    
    x=list()
    for i in range(len(L)-2):
        if abs(L[i+1]-L[i+2]) > abs(L[i]-L[i+1]):
            x.append(True)
        else:
            x.append(False)
    return all(x)
print(expanding([1,3,7,2,9]))

Output:

True

Explanation: when we calculate difference list for the given list -> [2,4,5,7] The difference list is strictly increasing.

Print(expanding([1,3,7,2,-3]))

Output:

False

Explanation: when we calculate difference list for the given list -> [2,4,5,5] The difference list is not increasing (i.e., 5>5 is False)

Answer 6

Your logic is a little bit wrong. Once you know that one item is out of order you should answer False for the whole list.

def expanding(l):
 for i in range(0,len(l)-3):
  if (abs(l[i+2]-l[i+1])<=abs(l[i+1]-l[i])):
   return False 
 return True

Answer 7

Code Written By Debkanta Mondal

Python3

def expanding(l):
dif=[]
for x,y in zip(l,l[1:]):
    diff=abs(y-x)
    dif.append(diff)
return all(i<j for i,j in zip(dif,dif[1:]))

print(expanding([1,3,7,2,-3]) )