Odtnhj

I am trying to make a function that for a sequence of integers as an array can determine whether it is possible to obtain a strictly increasing sequence by removing no more than one element from the array. If an element can be remove than the output is True otherwise return False. I tried,

def almostIncreasingSequence(sequence):

 if sequence[:-1] == sequence[1::]:
 return True
 else:
 return False

It works for list,

 sequence = [1, 3, 2, 1]
 >>> False

Since you cannot remove any number that would lead to an increasing sequence. However, if the list was

sequence: [1, 3, 2]
>>> True

It is true since you can remove 2 or 3 to have an increasing sequence. My function incorrectly outputs False though.

I really don't see what was your first idea...
How about a more simple solution ?

def fn(seq):
 last_i = None
 lives = 1
 for i in seq :
 if last_i is None :
 last_i = i
 else :
 if (i <= last_i):
 lives = lives - 1
 if (lives < 0) :
 return False
 last_i = i
 return True

>>> fn([1, 3, 2, 1])
False
>>> fn([1, 3, 2])
True
>>> fn([1, 3, 2, 3])
True
>>> fn([1, 3, 2, 4, 6, 8])
True
>>> fn([1, 3, 2, 4, 6, 8, 2])
False

The code below uses the monotonicity check as wrote in this answer and iterates over the elements of the list to check if poping a single element results in increasing monotonicity.

def strictly_increasing(L):
 return all(x<y for x, y in zip(L, L[1:]))
def non_decreasing(L):
 return all(x<=y for x, y in zip(L, L[1:]))

L = [1, 3, 2]
L_mod = L.copy()
my_bool = False
if not strictly_increasing(L):
 for i, x in enumerate(L):
 L_mod.pop(i)
 if strictly_increasing(L_mod):
 my_bool = True
 exit
 else: L_mod = L.copy()
else:
 my_bool = True

Use strictly_increasing or non_decreasing as you wish.