How to see if the list contains consecutive numbers

Question

I want to test if a list contains consecutive integers and no repetition of numbers. For example, if I have

l = [1, 3, 5, 2, 4, 6]

It should re

Answer 1

import numpy as np
import pandas as pd    

(sum(np.diff(sorted(l)) == 1) >= n) & (all(pd.Series(l).value_counts() == 1))

We test both conditions, first by finding the iterative difference of the sorted list np.diff(sorted(l)) we can test if there are n consecutive integers. Lastly, we test if the value_counts() are all 1, indicating no repeats.

Answer 2

1.

l.sort()

2.

for i in range(0,len(l)-1)))
   print(all((l[i+1]-l[i]==1)

Answer 3

With sorting

In Python 3, I use this simple solution:

def check(lst):
    lst = sorted(lst)
    if lst:
        return lst == list(range(lst[0], lst[-1] + 1))
    else:
        return True

Note that, after sorting the list, its minimum and maximum come for free as the first (lst[0]) and the last (lst[-1]) elements. I'm returning True in case the argument is empty, but this decision is arbitrary. Choose whatever fits best your use case.

In this solution, we first sort the argument and then compare it with another list that we know that is consecutive and has no repetitions.

Without sorting

In one of the answers, the OP commented asking if it would be possible to do the same without sorting the list. This is interesting, and this is my solution:

def check(lst):
    if lst:
        r = range(min(lst), max(lst) + 1) # *r* is our reference
        return (
            len(lst) == len(r)
            and all(map(lst.__contains__, r))
            # alternative: all(x in lst for x in r)
            # test if every element of the reference *r* is in *lst*
        )
    else:
        return True

In this solution, we build a reference range r that is a consecutive (and thus non-repeating) sequence of ints. With this, our test is simple: first we check that lst has the correct number of elements (not more, which would indicate repetitions, nor less, which indicates gaps) by comparing it with the reference. Then we check that every element in our reference is also in lst (this is what all(map(lst.__contains__, r)) is doing: it iterates over r and tests if all of its elements are in lts).

Answer 4

Once you verify that the list has no duplicates, just compute the sum of the integers between min(l) and max(l):

def check(l):
    total = 0
    minimum = float('+inf')
    maximum = float('-inf')

    seen = set()

    for n in l:
        if n in seen:
            return False

        seen.add(n)

        if n < minimum:
            minimum = n

        if n > maximum:
            maximum = n

        total += n

    if 2 * total != maximum * (maximum + 1) - minimum * (minimum - 1):
        return False

    return True

Answer 5

def solution(A):
    counter = [0]*len(A)
    limit = len(A)
    for element in A:
        if not 1 <= element <= limit:
            return False
        else:
            if counter[element-1] != 0:
                return False
            else:
                counter[element-1] = 1

    return True

Answer 6

Here is a really short easy solution without having to use any imports:

range = range(10)
L = [1,3,5,2,4,6]
L = sorted(L, key = lambda L:L)
range[(L[0]):(len(L)+L[0])] == L

>>True

This works for numerical lists of any length and detects duplicates. Basically, you are creating a range your list could potentially be in, editing that range to match your list's criteria (length, starting value) and making a snapshot comparison. I came up with this for a card game I am coding where I need to detect straights/runs in a hand and it seems to work pretty well.