Given a sequence of items and a specific item in that sequence, return the item immediately following the item specified. If the item occurs more than once in a sequence, return the item after the first occurence. This should work for a sequence of any type.

When the item isn't present or nothing follows it, the function should return nil in Clojure and Elixir, Nothing in Haskell, undefined in JavaScript, None in Python.

```python
next_item([1, 2, 3, 4, 5, 6, 7], 3) # => 4
next_item(['Joe', 'Bob', 'Sally'], 'Bob') # => "Sally"
```

Difficulty: introductory

Starter code:

def next_item(xs, item):
	

Solutions:
def next_item(xs, item):
    it = iter(xs)
    for x in it:
        if x == item:
            break
    return next(it, None)

def next_item(xs, item):
  it = iter(xs)
  next(iter(x for x in it if x == item), None)
  return next(it, None)

import itertools
def next_item(xs, item):
    try:
        xs = iter(xs)
        for x in xs:
            if x==item: return next(xs)
    except:
        return None

def next_item(xs, item):
    ret = False
    for x in xs:
        if ret:
            return x
        if item == x:
            ret = True        

def next_item(xs, item):
  it = iter(xs)
  return next(iter(next(it, None) for x in it if x == item), None)

def next_item(xs, item):
    found = None
    for x in xs:
        if found:
            return x
        if x == item:
            found = True
    return None

def next_item(xs, item): 
    it = iter(xs)
    try:
        while True:
            x = next(it)
            if x==item:
                x = next(it)
                return x
    except StopIteration:
        return None

def next_item(xs, item):
    if xs.__class__.__name__ == 'listiterator': 
        while xs:
            try:
                 if next(xs) == item: return next(xs)
            except:
                 return
    elif xs.__class__.__name__ == 'count':
         return item+1
    try:
        return xs[xs.index(item)+1]
    except:
        return

def next_item(xs, item):
    cursor = iter(xs)
    while True:
        try:
            element = next(cursor)
            if element == item:
                return next(cursor)
        except StopIteration:
            return

def next_item(xs, item, trap = None):
    for i in xs:
        if trap:
            return i
        if i == item:
            trap = True

def next_item(xs, item):
    items = iter(xs)
    for thing in items:
        try:
            if thing == item:
                return next(items)
        except StopIteration:
            return None
    return None
    
    
        
        
    


def next_item(xs, item):
    ans, trap = None, False
    for i in xs:
        if trap:
            return i
        if i == item:
            trap = True
    return None
        


def next_item(xs, item):
    xs = iter(xs)
    for x in xs:
        if x == item:
            break
    return next(xs, None)

def next_item(xs, item):
    iterXS = iter(xs)
    for i in iterXS:
        if i == item:
            try:
                return next(iterXS)
            except: 
                return None

def next_item(xs, item):
    return (lambda x: next(x, None) if item in x else None)(iter(xs))

def next_item(xs, item):
    # TODO: Implement me
    ret = False
    for j in xs:
        if ret:
            return j
        if j == item:
            ret = True

def next_item(xs, item):
    itemFound = False
    for i in xs:
        if itemFound:
            return i
        if i == item:
            itemFound = True

from itertools import dropwhile, islice


def next_item(xs, item):
    return next(islice(dropwhile(lambda x: x != item, xs), 1, 2), None)



def next_item(xs, item):
    
    xs = iter(xs)
    if item in xs:
        return next(xs, None)
 # TODO: Implement me


from itertools import dropwhile, islice

def next_item(xs, item, nth_successor=1):
    return next(islice(dropwhile(lambda x: x != item, xs),
                       nth_successor,
                       nth_successor + 1),
                None)


def next_item(xs, item):
    l=[]
    # so that the list is not very large, cut it to item+1 elem
    for i in xs:
        l.append(i)
        if item in l and len(l) == l.index(item)+2:
            break
    # return answer
    return None if (item not in l or l[-1]==item) else l[l.index(item)+1]


def next_item(xs, item):
    f = int(1)
    for x in xs:
        if f == 0:
            f = 1
            return x
        if x == item:
            f = 0
    # TODO: Implement me


def next_item(xs, item):
    flag = False
    for el in xs:
        if flag: return el
        if el == item: flag = True


def next_item(xs, item):
    flag = False
    for element in xs:
        if flag:
            return element
        if element == item:
            flag = True
    return None
        


def next_item(xs, item):
    found = False
    for i in xs:
        if found:
            return i
            break
        elif i == item:
            found = True
            



def next_item(xs, item):
    it = iter(xs)
    next((x for x in it if x == item), None)
    return next(it, None)


def next_item(xs, item):
    xl = (i for i in xs)
    try:
        while next(xl) != item:
            continue
        return next(xl)
    except StopIteration:
        pass

def next_item(xs, item):
    it = iter(xs)
    next(iter(el for el in it if el == item), None)
    return next(it, None)

def next_item(xs, item):
    object = iter(xs)
    for el in object:
        if el == item:
            break
    return next(object, None)

def next_item(xs, item):
    stop = False
    for el in xs:
        if stop:
            return el
        elif el == item:
            stop = True


def next_item(xs, item):
    count = 0
    result = 0
    try:
        if (item in xs) and xs.index(item) != len(xs) - 1:
            return xs[(xs.index(item) + 1)]
        else:
            return None
    except:
        try:
            while count != item:
                result = next(xs)
                count += 1
            return result // 2 + 1
        except:
            return 663

def next_item(xs, item):
    done = False
    for i in xs:
        if done == True:
            return i
        if i == item:
            done = True
    return None


def next_item(xs, item):
    end = False
    for i in xs:
        if end:
            return i
        if i == item:
            end = True

def next_item(xs, item):
    found = False
    for x in xs:
        if x == item:
            found = True
        elif found:
            return x
    return

def next_item(xs, item):
    after = False
    for i in xs:
        if after:
            return i
        if i == item:
            after = True

def next_item(xs, item):
    iter_obj = iter(xs)

    while True:
        try:
            element = next(iter_obj)
            if element == item:
                element = next(iter_obj)
                return element
        except StopIteration:
            break
            return None

def next_item(xs, item):
    f = False
    for i in xs:
        if f:
            return i
        if i == item:
            f = True

def next_item(xs, item):
    it=iter(xs)
    for i in it:
        if i==item:
            return next(it,None)
    return None

def next_item(xs, item):
    xs = xs.__iter__()
    while True:
        try:
            if next(xs) == item: return next(xs)
        except: break

def next_item(xs, item):
    found = False
    for e in xs:
        if found:
            return e
        if e==item:
            found = True
    return None


def next_item(my_list, item):
    found = None
    for x in my_list:
        if found:
            return x
        if x == item:
            found = True
    return None
    
# Given a sequence of items and a specific item in that sequence, 
# return the item immediately following the item specified. If the item occurs more than once in a sequence, return the item after the first occurence. 
# This should work for a sequence of any type.  
    
#       Test.assert_equals(next_item([1, 2, 3, 4, 5, 6, 7, 8], 5), 6)
#         Test.assert_equals(next_item(['a', 'b', 'c'], 'd'), None)
#         Test.assert_equals(next_item(['a', 'b', 'c'], 'c'), None)


def next_item(xs, item):
    idx = None
    cnt = 0
    for i,e in enumerate(xs):
        if cnt == 1:
            break
        if e == item:
            idx = i
            cnt += 1
    if idx == i:
        return None
    try:
        print(xs[idx])
        return xs[i]
    except:
        if idx is None:
            return idx
        return e

def next_item(xs, item):
    idx = None
    cnt = 0
    for i,e in enumerate(xs):
        if cnt == 1:
            break
        if e == item:
            idx = i
            cnt += 1
    print(xs)
    print(e, i, idx)
    if idx == i:
        return None
    try:
        print('first')
        print(xs[idx])
        return xs[i]
    except:
        if idx is None:
            print('second')
            return idx
        print('third')
        return e

def next_item(xs, item):
    xs = iter(xs)
    for element in xs:
        if element == item:
            try:
                return next(xs)
            except:
                pass
        



import itertools
def next_item(xs, item):
        if type(xs)==list or type(xs)==tuple or type(xs)==str:
            try:
                return xs[xs.index(item)+1]
            except:
                return None
        for i in xs:
            if item==i:
                return next(xs)

 


def next_item(xs, item):
    it = iter(xs)
    try:
        while next(it) != item: pass
        return next(it)
    except:
        return None


def next_item(seq, item):

    if type(seq) in [list, str]: return seq[seq.index(item)+1] if ((item != seq[-1])+(item in seq))==2 else None

    else:
        bar = next(seq); foo = next(seq)
        foobar = item + (foo - bar)

        last_item = 0
        for i in range(700):
            try:
                c = seq.__next__()
                if c is not None: last_item = c
            except StopIteration: break

        return foobar if foobar<last_item else None

def next_item(xs, item):
    iterator = iter(xs)
    for i in iterator:
        if i == item:
            return next(iterator, None)
    
    return None

import itertools
def nth(iterable, n, default=None):
    return next(itertools.islice(iterable, n, None), default)

def next_item (xs,item):
     a=itertools.dropwhile(lambda x: x!=item,xs)
     return nth(a,1,None)
       


def next_item(xs, item):
    found = False
    for i in xs:
        if found:
            return i
        if i == item:
            found = True
    else:
        return None


def next_item(xs, item):
    i = None
    for count, element in enumerate(xs):
        if element == item:
            i = count + 1
            continue
        if i is not None:
            return element
    return None

def next_item(xs, item):
    found = False
    for i in xs:
        if i == item:
            found = True
        elif found == True:
            return i

def next_item(xs, item):
    i = iter(xs)
    try:
        while next(i) != item:
            pass
        return next(i)
    except StopIteration:
        return None

def next_item(a, item):
    found = 0
    for e in a:
        if found: return e
        if e == item: found = 1

def next_item(xs, item):
    c=0
    s=0
    try:
        return xs[xs.index(item)+1]
    except (ValueError,IndexError):
        return None
    except AttributeError:
        while True: 
            try:
                t = next(xs)
                print(t)
                if c==1:
                    s=t
                    break
                if t==item:
                    c=1
            except StopIteration: 
                return None
        return s

def next_item(xs, item):
    return_next = False
    for elem in xs:
        if return_next:
            return elem
        elif elem == item:
            return_next = True
    return None

def next_item(l, item):
    try:
        return l[l.index(item)+1] if item in l and l.index(item)+1 < len(l) else None
    except:
        return next(l)


def next_item(xs, item):
    flag = False
    
    for x in xs:
        if flag == True:
            return x
        if item == x:
            flag = True


def next_item(xs, item):
    find=False
    findValue=None
    for i in xs:
        if find:
            findValue=i
            break
        if i==item:
            find=True
    return findValue

def next_item(xs, item):
    c = 0
    l = []
    for x in iter(xs):
        if x == item:
            l.append(x)
            c += 1
        elif c == 1:
            l.append(x)
            break
    try:
        return l[-1] if len(l) >= 2 else None
    except:
        return None

def next_item(r,v):
    ix = iter(r)
    try:
        while next(ix) != v: continue
        return next(ix)
    except StopIteration: return None

def next_item(xs, item):
    # TODO: Implement me
    a=iter(xs)
    while(True):
        try:
            if next(a)==item:
                return next(a)
        except:
            return None


def next_item(xs, item):
    if hasattr(xs, '__iter__') and hasattr(xs, '__next__'):
        for x in xs:
            if x == item:
                return next(xs)

    if xs==[] or item not in xs:
        return None
        
    if xs.index(item)==(len(xs)-1):
        return None 
    
    return xs[(xs.index(item)+1)]

def next_item(xs, item=None):
    try:
        a = xs.index(item)
        return xs[a + 1]
    except ValueError:
        return None
    except IndexError:
        pass
    except AttributeError:
        if item in xs:
            return next(xs)
                


def next_item(xs, item):
    xs = iter(xs)
    
    try:
        while True:
            elem = next(xs)
            if elem == item:
                break
    except StopIteration:
        return None
    

    try:
        return next(xs)
    except StopIteration:
        return None

import sys

def next_item(xs, item):
    f = 0
    try :
        for i in xs:
            if f == 1 : return i
            if i == item: f = 1
    except : pass


import collections

def next_item(xs, item):
    try:
        return xs[xs.index(item) + 1]
    except AttributeError:
        try:
            while next(xs) != item:
                continue
            return next(xs)
        except StopIteration:
            return None
    except (ValueError, IndexError):
        return None

def next_item(xs, item):
    n = False
    for x in xs:
        if n: return x
        if x == item: n = True

import itertools

def next_item(xs, item):
    it = iter(xs)
    for x in it:
        if x == item:
            break
    return next(it, None)

import itertools
def next_item(xs, item):
    next_item = None
    if type(xs) is itertools.count:
        for i in xs:
            if i == item:
                next_item = next(xs)
                break
    else:
        list_xs = list(xs)
        for n, x in enumerate(list_xs):
            if item == list_xs[n] and n < len(list_xs)-1:
                next_item = list_xs[n+1]
                break
    return next_item

def next_item(xs, item):
    r = False
    for i in xs:
        if r:
            return i
        else:
            if i == item:
                r = True
    return None

def next_item(xs, item):
    xs = iter(xs)
    try:
        while (next(xs) != item) : pass
        return next(xs)
    except:
        return None

def next_item(xs, item):
    print ('xs =', xs)
    xs = iter(xs)
    try:
        while (next(xs) != item) : pass
        return next(xs)
    except:
        return None

def next_item(xs, item):
    """return first item in xs after item"""
    found = False
    for c in xs:
        if found: return c
        if c == item:
            found = True
    return None 

def next_item(xs, item):
    y = False
    for x in xs:
        if y:
            return x
        if item == x:
            y = True   

def next_item(xs, item):
    itr = iter(xs)
    for elem in itr:
        if elem == item:
            break
    return next(itr, None)


def next_item(xs, item): 
    p=0
    for k in xs:
        if p==1:
            return k
        if k==item:
            p=1
    return None

def next_item(xs, item):
    found=False
    for i in xs:
        if found:
            return i
        else:
            found=(i==item)

def next_item(xs, item):
    token=0
    for i in xs:
        if token==1: return i
        if i==item: token=1
    return None

def next_item(xs, item):
    print((xs,item))
    print((type(xs)))
    if type(xs)==str:
        print((xs[-2:-1]))
        return xs[xs.index(item)+1:xs.index(item)+2] if xs[-1:]!=item and item in xs else None
    if type(xs)==list:
        if item in xs and not item==xs[-1]:
            return xs[xs.index(item)+1] 
        else:
            return None
    else :
        p=0
        for k in xs:
            if p==1:
                return k
            if k==item :
                p=1           
        return None    


def next_item(xs, item):
    iterator = iter(xs)
    for x in iterator:
        if x == item:
            return next(iterator, None)
    return None

def next_item(xs, item):
    iterable = iter(xs)
    for x in iterable:
        if x == item:
            break
    return next(iterable, None)

def next_item(xs, item):
    for i, x in enumerate(xs):
        try:
            if (x == item and i != len(xs)-1):
                return xs[i + 1]
        except:
            return next(xs)

def next_item(xs, item):
    it = iter(xs)
    return None if item not in it else next(it, None)

def next_item(xs, item):
    if item not in xs: return None
    if type(xs) in [str,list]:
        return None if item not in xs[:-1] else xs[xs.index(item)+1]
    return next(xs)

def next_item(xs, item):
    mark = False
    for i in xs: 
        if mark:
            return i
        if i == item:
            mark = True

def next_item(xs, item):
    found = False
    result = None
    for x in xs:
        if found:
            result = x
            break
        if x == item:
            found = True
    return result



def next_item(xs, item):
    lst = iter(xs)
    for x in lst:
        if x == item:
            break
    return next(lst, None)

def next_item(xs, item):
    if type(xs) == list:
        if xs.count(item) == 0:
            return None
        q = xs.index(item)
        if (q + 1) >= len(xs):
           return None
        return xs[q + 1]
    else:
        qq = 0
        for i in xs:
            if i == item and qq == 0:
                qq = 1
                continue
            if qq == 1:
                return i
        return None

def next_item(xs, item):
    it = iter(xs)
    for value in it:
        if value == item:
            return next(it, None)
    return None

def next_item(xs, item):
    if type(xs) == str or type(xs) == list:
        if item not in xs or item == xs[-1]:
            return None
        elif type(xs) == str:
            return xs[xs.find(item)+1]
        else:
            return xs[xs.index(item)+1]
            
    primer_paso = next(xs)
    segundo_paso = next(xs)
    steps = segundo_paso - primer_paso
    
    if (item in xs) and ((item + steps) in xs) :
        return item + steps
    else:
        return None

def next_item(xs, item, flag=0):
    for i in xs:
        if flag == 1: return i
        if i == item: flag = 1

def next_item(xs, item):
    print((repr(xs), item))
    try:
        return xs[xs.index(item)+1]
    except ValueError:
        return None
    except IndexError:
        return None
    except AttributeError:
        if repr(xs)[:5] == 'count':
            return item + 1
        else:
            try:
                i = 0
                while i != item:
                    i = xs.__next__()
                    if i == item:
                        return xs.__next__()
            except StopIteration:
                return None
                


def next_item(xs, item):
    it = iter(xs)
    if item in it:
        try:
            return next(it)
        except:
            pass

def next_item(xs, item):
    # TODO: Implement me
    print(isinstance(xs, range))
    i=0

    for num in xs:
        if i==1:
            return num
        if num==item:
            i+=1
    return None

def next_item(xs, item):
    it = iter(xs)
    for e in it: 
        if e == item: break
    else: return
    for e in it: return e

def next_item(xs, item):
    f = 0
    for x in xs:
        if f: return x
        if x == item: f = 1

def next_item(xs, item):
    if type(xs) is str:
        xs = [x for x in xs]
    if type(xs) is list: # Convert list to generator, so that everything is generator
        xs = (x for x in xs)
    for x in xs: # Go over generator
        if x == item:
            try:
                return next(xs) # print(x)
            except StopIteration:
                return None
    return None

def next_item(xs, item):
    if type(xs) is str or type(xs) is list:
        for i in range(len(xs)):
                if xs[i] == item and xs.index(xs[i]) < xs.index(xs[-1]):
                    return xs[i+1]
        return None
    else:
        j = 0
        for j in xs:
            if j == item:
                return next(xs)