## Task

**_Given_** *an array of integers* , **_Find_** **_the maximum product_** *obtained from multiplying 2 adjacent numbers in the array*.
____

# Notes

* **_Array/list_** size is *at least 2*.

* **_Array/list_** numbers could be a *mixture of positives, negatives also zeroes* .
___

# Input >> Output Examples
```
adjacentElementsProduct([1, 2, 3]); ==> return 6
```

## **_Explanation_**:

* **_The maximum product_** *obtained from multiplying* ` 2 * 3 = 6 `, and **_they're adjacent numbers in the array_**.
___
```
adjacentElementsProduct([9, 5, 10, 2, 24, -1, -48]); ==> return 50
```
## **_Explanation_**:
**_Max product_** obtained *from multiplying*   ``` 5 * 10  =  50  ```.
___
```
adjacentElementsProduct([-23, 4, -5, 99, -27, 329, -2, 7, -921])  ==>  return -14
```

## **_Explanation_**:

* **_The maximum product_** *obtained from multiplying* ` -2 * 7 = -14 `, and **_they're adjacent numbers in the array_**.
___
___
___

# [Playing with Numbers Series](https://www.codewars.com/collections/playing-with-numbers)

# [Playing With Lists/Arrays Series](https://www.codewars.com/collections/playing-with-lists-slash-arrays)

# [For More Enjoyable Katas](http://www.codewars.com/users/MrZizoScream/authored)
___

## ALL translations are welcomed

## Enjoy Learning !!
# Zizou

Difficulty: introductory

Starter code:

def adjacent_element_product(array):
	

Solutions:
def adjacent_element_product(array):
    return max( a*b for a, b in zip(array, array[1:]) )

def adjacent_element_product(array):
    return max(array[i]*array[i+1] for i in range(len(array)-1))

def adjacent_element_product(array):
    return max(x * y for x, y in zip(array, array[1:]))


from operator import mul
def adjacent_element_product(array):
    return max(map(mul, array, array[1:]))

from itertools import islice

def adjacent_element_product(xs):
    return max(x * y for x, y in zip(xs, islice(xs, 1, None)))

def adjacent_element_product(array):
    new_list = []
    sum = 1
    for e in range(len(array)):
        if e == 0:
            sum *= array[e] * array[e+1]
            new_list.append(sum)
            sum = 1
            
        elif e in range(1, len(array) - 1):
            sum *= array[e-1] * array[e]
            new_list.append(sum)
            sum = 1
            sum *= array[e+1] * array[e]
            new_list.append(sum)
            sum = 1
            
        else:
            sum *= array[e] * array[e-1]
            
    return max(new_list)

def adjacent_element_product(x):
    L=[]
    for i in range(len(x)-1):
        L.append(x[i]*x[i+1])
    return max(L)
    
    


def adjacent_element_product(array):
    products = []
    for i in range(0, len(array) - 1):
        products.append(array[i] * array[i + 1])
    return max(products)

def adjacent_element_product(arr):
    product = [arr[i]*arr[i+1] for i in range(len(arr)-1)]
    return max(product)

def adjacent_element_product(array):
    max = array[0]*array[1];
    for i in range(1,len(array)-1):
        temp = array[i]*array[i+1]
        if max < temp:
            max = temp 
    return max

def adjacent_element_product(lst):
    return max(lst[i]*lst[i+1] for i in range(len(lst)-1))

def adjacent_element_product(array):
    max_product = array[0] * array[1]
    i = 2
    while i < len(array):
        max_product = max(max_product, array[i-1]*array[i])
        i += 1
    return max_product

def adjacent_element_product(arr):
    return max(arr[i] * n for i, n in enumerate(arr[1:]))

def adjacent_element_product(array):
    return max([array[i]*array[i+1] for i in range(len(array)-1)])

def adjacent_element_product(a):
    return max(x * y for x, y in zip(a, a[1:]))

def adjacent_element_product(xs):
    return max(xs[i - 1] * xs[i] for i in range(1, len(xs)))

def adjacent_element_product(n):
    return max([n[i]*n[i+1] for i in range(len(n) - 1)])


adjacent_element_product=lambda array:max([a*b for a,b in zip(array[:-1],array[1:])])

def adjacent_element_product(array):
    return(max([j*array[i+1] for i,j in enumerate(array[:-1])]))

adjacent_element_product = lambda arr: len(arr) and max(x*y for x,y in zip(arr, arr[1:]))

def adjacent_element_product(arr):
    a = arr[0] * arr[1]
    for i in range(1,len(arr)):
        if arr[i] * arr[i-1] > a:
            a = arr[i] * arr[i-1]
    return a

def adjacent_element_product(array):
    arr = []
    for i in range(0,len(array)-1):
        arr.append(array[i]*array[i+1])
    return max(arr)

def adjacent_element_product(arr):
    s = []
    for i in range(len(arr)- 1):
        s.append(arr[i] * arr[i + 1])
    n = max(s)
    return n

def adjacent_element_product(arr):
    return sorted([arr[x] * arr[x + 1] for x in range(len(arr) -1 )] , reverse=True)[0]


def adjacent_element_product(array):
    john=[]
    for i,v in enumerate(array):
        if i==len(array)-1:
            pass
        else:
            john.append(array[i]*array[i+1])
    return max(john)
            


def adjacent_element_product(array):
    m = -10000000
    for n,i in enumerate(array[:-1]):
        m = max(m,i*array[n+1])
        
    return m        

def adjacent_element_product(array):
    list_pro=list()
    for index in range(len(array[:-1])):
        product=array[index]*array[index+1]
        list_pro.append(product)
    return max(list_pro)

def adjacent_element_product(array):
    return max([i * l for i, l in zip(array, array[1:])])

def adjacent_element_product(A):
    return max([a*b for a, b in zip(A[:-1], A[1:])])

def adjacent_element_product(array):
    a=[]
    print(array)
    for i in range(len(array)):
        a.append(array[i]*array[i-1])
    return max(a[1:])# max product


def adjacent_element_product(array):
    max = array[0] * array[1]
    for i in range(len(array) - 1):
        temp = array[i] * array[i + 1]
        if(max < temp):
            max = temp
    return max

def adjacent_element_product(array):
    M = array[0]*array[1]
    for i, element in enumerate(array[1:]):
        x = element * array[i]
        if x > M:
            M = x
    return M

def adjacent_element_product(array):
    arr_max=[]
    for i in range(len(array)-1):
        arr_max.append(array[i]*array[i+1])
    return max(arr_max)

def adjacent_element_product(array):
    new=[]
    for i in range(len(array)-1):
        numero=array[i]*array[i+1]
        new.append(numero)
    
    return max(new)

def adjacent_element_product(array):
    result = array[0] * array[1]
    for i in range(1,len(array)-1):
        temp = array[i] * array[i+1]
        if result < temp:
            result = temp
    return result


def adjacent_element_product(array):
    m=None
    for i in range(1,len(array)):
        if m==None or array[i]*array[i-1]>m:
            m=array[i]*array[i-1]
    return m


def adjacent_element_product(a):
    b=[]
    for i in range(len(a)-1):
        c=a[i]*a[i+1]
        b.append(c)
    return max(b)

def adjacent_element_product(array):
    maxProduct = array[0] * array[1];
    for i in range(1, len(array) - 1):
        product = array[i] * array[i + 1]
        if product > maxProduct:
            maxProduct = product
        
    return maxProduct;

def adjacent_element_product(a):
    return max(a[x]* a[x+1] for x in range(len(a)-1))

def adjacent_element_product(p):
    return max(p[i]*p[-~i] for i in range(~-len(p)))

def adjacent_element_product(array):
    lst = [array[i] * array[i+1] for i in range(len(array)-1)]
    return max(lst)

def adjacent_element_product(array):
    k=[]
    for i in range(len(array)-1):
        k.append(array[i]*(array[i+1]))
    return max(k)

def adjacent_element_product(array):
    length = len(array)
    res = []
    for i in range(length):
        if i < length-1:
            res.append(array[i] * array[i+1])
            
    res.sort()
    return res[-1]

def adjacent_element_product(array):
    l=array[-2]*array[-1]
    for i in range(len(array)-2):
        l=max(l,array[i]*array[i+1])
    return l

def adjacent_element_product(array):
    arr = []
    left_index = 0
    right_index = -len(array) + 1
    middle_index = 1
    if len(array) == 2:
        return array[0] * array[1]
    while middle_index < len(array):
        arr.append(array[left_index] * array[right_index])
        left_index += 1
        right_index += 1
        middle_index += 1
    return max(arr)

def adjacent_element_product(array):
    return max(m*n for m, n in zip(array, array[1:]))
   


def adjacent_element_product(array):
    max_product = array[0] * array[1]
    for i in range(len(array)-1):
        subset = array[i] * array[i+1]
        if subset > max_product:
            max_product = subset 
    return max_product

def adjacent_element_product(array):
    return max(i * array[idx - 1] for idx, i in enumerate(array[1:], 1))

def adjacent_element_product(array):
    return max([array[x] * array[x-1] for x in range(1,len(array))])


def adjacent_element_product(array):
    max = array[0]*array[1]
    for i in range(2,len(array)):
        if(array[i]*array[i-1] > max): max = array[i]*array[i-1]
    return max

def adjacent_element_product(array):
    return max(list(map(lambda x, y: x*y, array[:-1],array[1:])))


def adjacent_element_product(array):
    maximum = array[0] * array[1]
    for n1, n2 in zip(array[1:], array[2:]):
        maximum = max(maximum, n1*n2)
    return maximum

adjacent_element_product = lambda a: max( x*y for x,y in zip(a,a[1:]) )

def adjacent_element_product(array):
    m = 0
    max = array[0]*array[1]
    for i in range(1, len(array)-1) :
        m = array[i]*array[i+1]
        if m > max : max = m
    return max # max product

def adjacent_element_product(array):
    results_list = []
    prev = array[0]

    for element in array[1:]:
        maximum = prev * element
        prev = element
        results_list.append(maximum)

    return max(results_list)

def adjacent_element_product(array):
    new_list = []
    for x in range(len(array)):
        if x+1 >= len(array):
            break
        else:
            new_list.append(array[x] * array[x+1])
    return max(new_list)

def adjacent_element_product(array):
    res = array[0] * array[1]
    for i in range(2, len(array)):
        prod = array[i] * array[i-1]
        if prod > res: res = prod
    return res

from itertools import starmap
from operator import mul
from typing import List


def adjacent_element_product(array: List[int]) -> int:
    return max(starmap(mul, list(zip(array, array[1:]))))


def adjacent_element_product(array):
    max = - float('inf')
    for i in range(1,len(array)):
            if array[i] * array[i-1] > max:
                max = array[i] * array[i-1]
    return max

adjacent_element_product = lambda lst: max(x * y for x, y in zip(lst, lst[1:]))

def adjacent_element_product(array):
    m = -1000000
    for i in range(len(array)-1):
        m = max(m, array[i] * array[i+1])
        
    return m

def adjacent_element_product(array):
    maxp=None
    i=1
    while i<len(array):
        product=array[i]*array[i-1]
        if maxp==None or product>maxp:
            maxp=product
        i=i+1
    return maxp

def adjacent_element_product(array):
    biggest = -1000000
    i = 0
    
    while i < len(array)-1:
        prod = array[i] * array[i+1]
        if prod > biggest: biggest = prod
        i += 1
    return biggest


def adjacent_element_product(lst):
    return max(a * b for a, b in zip(lst[:-1], lst[1:]))

def adjacent_element_product(array):
     return max(array[i] * array[i + 1] for i in range(len(array) - 1))
         # max product


def adjacent_element_product(a):
#     return max([x*y for x in a[:-1] for y in a[1:] ])
    return max([a[i]*a[i+1] for i in range(0,len(a)-1)])

def adjacent_element_product(arr):
    return max([ e1*e2 for e1,e2 in zip(arr[1:] , arr[:-1])])

def adjacent_element_product(array):
    max_prod = array[0] * array[1]
    for i in range(1,len(array)):
        if array[i] * array[i-1] > max_prod:
            max_prod = array[i] * array[i-1]
    return max_prod

def adjacent_element_product(array):
    
    a = []
    
    for i in range(0,len(array)):
    
        for j in range(0,len(array)):
        
            if abs(j-i)==1:
        
                p = array[i]*array[j]
                
                a.append(p)
    

    return max(a)
    
    


def adjacent_element_product(a):
    m = a[0] * a[1]
    for i in range(len(a)):
        try:
            if a[i] * a[i+1] > m:
                m = a[i] * a[i+1]
        except:
            return m

def adjacent_element_product(array):
    res = []
    start = array[0]

    for num in array[1:]:
        res.append(start * num)
        start = num
    
    return max(res)

def adjacent_element_product(array):
    return max([array[e]*array[e+1] for e in range(len(array)-1)])

def adjacent_element_product(array):
    prods = []
    for i in range(len(array)-1):
        prods.append(array[i]*array[i+1])
    return max(prods)

def adjacent_element_product(arr):
    list = []
    for number in range(len(arr)-1):
        list.append(arr[number] * arr[number+1])
    return max(list)

def adjacent_element_product(array):
    max_prod=array[0]*array[1]
    
    if len(array)>2:
        for i in range(1,len(array)-1):
            if array[i]*array[i+1]>max_prod:
                max_prod= array[i]*array[i+1]
    
    return max_prod

def adjacent_element_product(array):
    max_prod = array[0] * array[1]
    for i in range(2, len(array)):
        temp = array[i] * array[i-1]
        if temp > max_prod:
            max_prod = temp
    return max_prod

def adjacent_element_product(array):
    max_sum = array[0] * array[1]
    for i in range(0,len(array)-1):
        if array[i] * array[i+1] > max_sum:
            max_sum = array[i] * array[i+1]
    return max_sum

def adjacent_element_product(array):
    max = -99999999999
    for i, n in enumerate(array):
        if i < len(array) - 1 and n * array[i + 1] > max:
            max = n * array[i + 1]

    return max

def adjacent_element_product(array):
    index1 = 0
    index2 = 0
    max1 = -9999999
    for i in range(len(array)-1):
        if((array[i] * array[i+1]) > max1):
            max1 = array[i] * array[i+1]
            index1 = i
            index2 = i+1
    return array[index1] * array[index2]

def adjacent_element_product(array):
    res = []
    for i in range(len(array) - 1):
        ans = array[i] * array[i + 1]
        res.append(ans)
    return max(res)

def adjacent_element_product(array):
    return max(map(lambda i: array[i] * array[i + 1], range(len(array) - 1)))

def adjacent_element_product(array):
    max_product = array[0] * array[1]
    
    for index, item in enumerate(array[1:-1]):
        next_item = array[index+2]
        product = item * next_item
        
        if product > max_product:
            max_product = product
    
    return max_product

def adjacent_element_product(array):
    return max(k*i for i,k in zip(array, array[1:]))

def adjacent_element_product(array):
    return max(array[i]*array[i+1] for i,x in enumerate(array[:-1]))

from operator import mul

def adjacent_element_product(a):
    return max(map(mul,a,a[1:]))


def adjacent_element_product(array):
    m = array[0] * array[1]
    for i in range(1,len(array)-1):
        m = max(m,array[i] * array[i+1])
    return m# max product

def adjacent_element_product(array):
    new_list =[]
    for i in range (len(array)):
        if array[i] != array[-1]:
            new_list.append(array[i] * array[i+1])
    new_list.sort()
    return new_list[-1]

def adjacent_element_product(array):
    i = 1
    maximum = (array[0]*array[i])
    for c in array[:-1]:
        if (c*array[i])> maximum:
            maximum = (c*array[i])
        i += 1
    return maximum

def adjacent_element_product(array):
    mults = []
    i = 0
    while i+1 < len(array):
        mults.append(array[i]*array[i+1])
        i += 1
    return max(mults)
    
        
        


def adjacent_element_product(array):
    len_array = len(array)
    products = []
    for value in range(0, (len_array-1)):
        products.append(array[value]*array[value+1])
    products.sort()
    return products[-1]

def adjacent_element_product(a):
    list=[]
    for i in range(0,len(a)-1):
        list.append(a[i]*a[i+1])
    return max(list)



def adjacent_element_product(array):
    i = 0
    listy = []
    while i < (len(array)-1):
        num = int(array[i])*int(array[i+1])
        listy.append(num)
        i+=1
    
    
    
    return max(listy)

def adjacent_element_product(array):
    
    if len(array) == 2:
        
        product_1 = 1
        for element in array:
            product_1 *= element
        
        return product_1
    
    elif len(array) >= 2:
        
        products = []
        for number in range(1, len(array)):
            product_2 = 1
            product_2 *= array[number - 1] * array[number]
            products.append(product_2)
            
        return max(products)    
            
        
        
        


def adjacent_element_product(arr):
    product = [arr[i]*arr[i+1] for i in range(len(arr)-1)]
    print (product)
    return max(product)

def adjacent_element_product(array):
    biggest = array[0] * array[1]
    index = 1
    while index < len(array):
        if array[index] * array[index-1] > biggest:
            biggest = array[index] * array[index-1]
        index += 1
    return biggest

def adjacent_element_product(array):
    num = array[0] * array[1]
    i = 1
    while i+1 < len(array):
        if array[i]*array[i+1] > num:
            num = array[i]*array[i+1]
        i += 1
    return num

def adjacent_element_product(array):
    print(array)
    i = 1
    rtot = array[0]*array[1]
    while i+1 <= len(array):
        if array[i]*array[i-1] >= rtot:
            rtot = array[i]*array[i-1]
            print(rtot)
        i += 1
    return rtot

def adjacent_element_product(array):
    
    max_prod = max([ i * array[_index+1] for _index, i in enumerate(array[:-1]) ])
        
    return max_prod

def adjacent_element_product(array):
    maximum = array[0]*array[1]
    for number in range(1, len(array)-1):
        if array[number]*array[number+1] > maximum:
            maximum = int(array[number])*int(array[number+1])
    return maximum

from functools import reduce


def adjacent_element_product(array):
    return max([reduce(lambda n, m: n * m, array[x:x+2]) for x in range(len(array) - 1)])

def adjacent_element_product(array):
    maxp = float('-inf')
    for i in range(1, len(array)):
        x = array[i]
        y = array[i-1]
        maxp = max(maxp, x*y)
    return maxp

def adjacent_element_product(a):
    return max(a[i+1]*a[i] for i in range(len(a) - 1))

def adjacent_element_product(array):
    res = min(array) * max(array)
    for i, item in enumerate(array):
        if (i + 1) < len(array):
            if (item * array[i + 1]) >= res:
                res = item * array[i + 1]
    return res

def adjacent_element_product(array):
  products = []
  for i in range(len(array)-1):
    
    product = array[i] * array[i +1]
    products.append(product)
  return max(products)

def adjacent_element_product(array):
    a = []
    for i in range(0,len(array)-1):
        a.append(array[i] * array[i+1])
    a = sorted(a)
    return a[len(a)-1]

def adjacent_element_product(array):
    maxpro = -111111111111
    p = 0
    while p < len(array)-1:
        maxar = array[p] * array[p+1]
        if maxar > maxpro:
            maxpro = maxar
        p = p + 1
    return(maxpro)

def adjacent_element_product(array):
    i=0
    c=array[0]*array[1]
    while i<len(array)-1:
        if array[i]*array[i+1]>c:
            c=array[i]*array[i+1]
        i+=1
    return c


def adjacent_element_product(array):
    i=0
    b=0
    c=array[0]*array[1]
    while i < len(array)-1:
        b = array[i]*array[i+1]
        if b>c:
            c=b
            i+=1
        else:
            i+=1
    
    return c

def adjacent_element_product(array):
    i=0
    j=1
    x=array[i]*array[i+1]
    while i<=len(array)-2:
        j=array[i]*array[i+1]
        print (j)
        i+=1
        if j>=x:
            x=j
        else:
            x=x
    return x