In this kata, you will write a function that returns the positions and the values of the "peaks" (or local maxima) of a numeric array.

For example, the array `arr = [0, 1, 2, 5, 1, 0]` has a peak at position `3` with a value of `5` (since `arr[3]` equals `5`).

~~~if-not:php,cpp,java,csharp
The output will be returned as an object with two properties: pos and peaks. Both of these properties should be arrays. If there is no peak in the given array, then the output should be `{pos: [], peaks: []}`.
~~~
~~~if:php
The output will be returned as an associative array with two key-value pairs: `'pos'` and `'peaks'`.  Both of them should be (non-associative) arrays.  If there is no peak in the given array, simply return `['pos' => [], 'peaks' => []]`.
~~~
~~~if:cpp
The output will be returned as an object of type `PeakData` which has two members: `pos` and `peaks`.  Both of these members should be `vector`s.  If there is no peak in the given array then the output should be a `PeakData` with an empty vector for both the `pos` and `peaks` members.

`PeakData` is defined in Preloaded as follows:

~~~
~~~if:java
The output will be returned as a ``Map>` with two key-value pairs: `"pos"` and `"peaks"`. If there is no peak in the given array, simply return `{"pos" => [], "peaks" => []}`.
~~~
~~~if:csharp
The output will be returned as a `Dictionary>` with two key-value pairs: `"pos"` and `"peaks"`. 
If there is no peak in the given array, simply return `{"pos" => new List(), "peaks" => new List()}`.
~~~

Example: `pickPeaks([3, 2, 3, 6, 4, 1, 2, 3, 2, 1, 2, 3])` should return `{pos: [3, 7], peaks: [6, 3]}` (or equivalent in other languages)

All input arrays will be valid integer arrays (although it could still be empty), so you won't need to validate the input.

The first and last elements of the array will not be considered as peaks (in the context of a mathematical function, we don't know what is after and before and therefore, we don't know if it is a peak or not).

Also, beware of plateaus !!! `[1, 2, 2, 2, 1]` has a peak while `[1, 2, 2, 2, 3]` does not. In case of a plateau-peak, please only return the position and value of the beginning of the plateau. For example: 
`pickPeaks([1, 2, 2, 2, 1])` returns `{pos: [1], peaks: [2]}` (or equivalent in other languages)

Have fun!

Difficulty: introductory

Starter code:

def pick_peaks(arr):
	

Solutions:
def pick_peaks(arr):
    pos = []
    prob_peak = False
    for i in range(1, len(arr)):
        if arr[i] > arr[i-1]:
            prob_peak = i
        elif arr[i] < arr[i-1] and prob_peak:
            pos.append(prob_peak)
            prob_peak = False
    return {'pos':pos, 'peaks':[arr[i] for i in pos]}

def pick_peaks(arr):
    peak, pos = [], []
    res = { "peaks":[], "pos":[] }
    
    for i in range(1, len(arr)) :
        if arr[i]>arr[i-1] :
            peak, pos = [arr[i]], [i]
        
        elif arr[i]<arr[i-1] :
            res["peaks"] += peak
            res["pos"] += pos
            peak, pos = [], []
    
    return res

def pick_peaks(arr):
    
    def add_peak(p):
        peaks["pos"].append(p)
        peaks["peaks"].append(arr[p])
        
    def is_peak(p):
        return arr[p-1] < arr[p] > arr[p+1]
        
    def is_plateau_start(p):
        return arr[p-1] < arr[p] == arr[p+1]
        
    def does_plateau_end_lower(p):
        return next((val for val in arr[p+1:] if val != arr[p]), arr[p]) < arr[p]

    peaks = {"pos":[], "peaks":[]}
    for p in range(1, len(arr)-1):
        if is_peak(p):
            add_peak(p)
        elif is_plateau_start(p) and does_plateau_end_lower(p):
            add_peak(p)
    
    return peaks

def pick_peaks(arr):
  peaks = []
  pos = []
  current_pos = None
  
  for i in range(len(arr)-1):
    if arr[i] < arr[i+1]:
      current_pos = i+1
    elif arr[i] > arr[i+1] and i != 0 and current_pos is not None:
      pos += [current_pos]
      peaks += [arr[current_pos]]
      current_pos = None
      
  return {"pos":pos, "peaks":peaks}




def pick_peaks(a):
    deltas = [(i, x2 - x1) for i, (x1, x2) in enumerate(zip(a, a[1:]), 1) if x1 != x2]
    indexes = [i for (i, dx1), (_, dx2) in zip(deltas, deltas[1:]) if dx1 > 0 > dx2]
    return dict(pos=indexes, peaks=[a[i] for i in indexes])


def pick_peaks(arr):
    peaks = {"pos":[], "peaks":[]}
    for i in range(1, len(arr)):
        next_num = next((num for num in arr[i:] if num != arr[i]), float("inf"))
        if arr[i-1] < arr[i] and next_num < arr[i]:
            peaks["pos"].append(i)
            peaks["peaks"].append(arr[i])
    return peaks


def pick_peaks(arr):

    PairList = []

    for i,e in enumerate(arr):
    
        if arr[i-1] >= e or i == 0:
        
            continue
        
        for k in arr[i:]:
        
            if k == e:
            
                continue
                
            elif k > e:
            
                break
                
            else:
            
                PairList.append([i,e])
                break 
    
    return {'pos':[k[0] for k in PairList], 'peaks':[k[1] for k in PairList]}

def pick_peaks(arr):
    prev_dex = prev_val = None
    result = {'pos': [], 'peaks': []}
    upwards = False
    for i, a in enumerate(arr):
        if prev_val == a:
            continue
        elif prev_val is None or prev_val < a:
            upwards = True
        else:
            if prev_dex and upwards:
                result['pos'].append(prev_dex)
                result['peaks'].append(prev_val)
            upwards = False
        prev_dex = i
        prev_val = a
    return result


import re

def pick_peaks(arr):
    slope = "".join("u" if b > a else "d" if a > b else "p" for a, b in zip(arr, arr[1:]))
    positions = [m.start() + 1 for m in re.finditer(r"up*d", slope)]
    peaks = [arr[pos] for pos in positions]
    return {"pos": positions, "peaks": peaks}

def pick_peaks(arr):
    cast = []
    
    for i,e in enumerate(arr):
        if cast and e == cast[-1][0]:#
            continue
        cast.append((e,i))
        
    doc = {"pos":[], "peaks":[]}#
    
    for i in range(1,len(cast)-1):
        if cast[i-1][0] < cast[i][0] > cast[i+1][0]:
            doc['peaks'].append(cast[i][0])
            doc['pos'].append(cast[i][1])
            
    return doc

# In this kata, you will write a function that returns the positions
# and the values of the "peaks" (or local maxima) of a numeric array.
# For example, the array arr = [0, 1, 2, 5, 1, 0] has a peak
# at position 3 with a value of 5 (since arr[3] equals 5).
# The output will be returned as an object with two properties: pos and peaks.
# Both of these properties should be arrays. If there is no peak
# in the given array, then the output should be {pos: [], peaks: []}.
# Example: pickPeaks([3, 2, 3, 6, 4, 1, 2, 3, 2, 1, 2, 3])
# should return {pos: [3, 7], peaks: [6, 3]} (or equivalent in other languages)
# All input arrays will be valid integer arrays (although it could still
# be empty), so you won't need to validate the input.
# The first and last elements of the array will not be considered as peaks
# (in the context of a mathematical function, we don't know what is after
# and before and therefore, we don't know if it is a peak or not).
# Also, beware of plateaus !!! [1, 2, 2, 2, 1] has a peak while
# [1, 2, 2, 2, 3] does not. In case of a plateau-peak, please only
# return the position and value of the beginning of the plateau.
# For example: pickPeaks([1, 2, 2, 2, 1]) returns {pos: [1], peaks: [2]}
# (or equivalent in other languages)

def sign(x):
    if x>0:
       return 1
    elif x<0:
       return -1
    elif x==0:
       return 0

def pick_peaks(arr):
    pos = []
    peaks = []
    l = len(arr)
# Calculate differential array    
    diff_arr = []
    for i in range (0, l-1):
        diff_arr.append(sign(arr[i+1] - arr[i]))
# Pick_Peaks
    i = 0
    while i < l-2:
        k = 1
        while sign(diff_arr[i+k]) == 0 and i+k < l-2:
            k += 1
        if (sign(diff_arr[i+k]) < sign(diff_arr[i]) and
            sign(diff_arr[i]) != 0 and sign(diff_arr[i+k]) != 0):
                pos.append(i+1)
                peaks.append(arr[i+1])
        i += k
# Create Dictionary!        
    d_pos_peaks = dict(pos=pos, peaks=peaks)    
    return d_pos_peaks

def pick_peaks(arr):
    redic = { "pos":[], "peaks":[] }
    for i in range(1,len(arr)-1):
        if all(( arr[i] > arr[i-1], arr[i] >= arr[i+1])):
            j = i
            while arr[j] == arr[i] and j < len(arr)-1:
                j += 1
                if arr[j] < arr[i]:
                    redic['pos'].append(i)
                    redic['peaks'].append(arr[i])
    return redic

def pick_peaks(arr):
    result = {'pos': [], 'peaks':[]}
    increasing = False
    for i in range(1, len(arr)):
        if arr[i] > arr[i-1]:
            increasing = True
            tmpk = arr[i]
            tmpindx = i
        elif arr[i] < arr[i-1]:
            if increasing:
                result['pos'].append(tmpindx)
                result['peaks'].append(tmpk)
                increasing = False
    return result

def pick_peaks(a):
    a=[int(i) for i in a]
    pred = 0
    prov = False
    peaks = []
    pos = []
    count = 0
    spusk = True

    for i in range(len(a)):
        if pred == a[i] and spusk==False:
            count+=1
            prov = True
            continue
        if pred > a[i]:
            if prov==True:
                peaks.append(a[i-1])
                pos.append(i-1-count)
            prov=False
            spusk=True
        elif i!=0 and pred < a[i]:
            prov = True
            spusk=False
        pred = a[i]
        count = 0
    d = {"pos": pos, "peaks" : peaks}

    return d

def pick_peaks(arr):
    i, pos = len(arr) - 2, []
    while i > 0:
        while i > 0 and arr[i + 1] >= arr[i]:
            i -= 1
        while i > 0 and arr[i + 1] <= arr[i]:
            i -= 1
            if arr[i + 1] > arr[i]:
                pos.append(i + 1)
    return {'peaks': [arr[i] for i in pos[::-1]], 'pos': pos[::-1]}

def pick_peaks(arr):
    result = {'pos': [], 'peaks': []}
    pos = 0
    for i in range(1, len(arr) - 1):
        if arr[i] != arr[pos]:
            pos = i
        if pos and arr[pos - 1] < arr[pos] > arr[i + 1]:
            result['pos'].append(pos)
            result['peaks'].append(arr[pos])
    return result

def pick_peaks(arr):
    print(arr)
    peaks = {'pos':[], 'peaks': []}
    enum_arr = list(enumerate(arr))
    possible_peaks = enum_arr[1:-1]
    for point in possible_peaks:
        current_p, current_v = point[0], point[1]
        prior_p, prior_v = enum_arr[current_p - 1]
        next_p, next_v = enum_arr[current_p + 1]
        is_peak = prior_v < current_v > next_v
        if is_peak:
            peaks['pos'].append(current_p)
            peaks['peaks'].append(current_v)
        is_plateau = prior_v == current_v or current_v == next_v
        if is_plateau:
            is_peak = prior_v < current_v
            i = current_p
            while is_peak:
                try:
                    next = enum_arr[i + 1][1]
                    curr = enum_arr[i][1]
                except IndexError:
                    break
                next_plateau = next == curr
                if not next_plateau:
                    peak_end = next < curr
                    if peak_end:
                        peaks['pos'].append(current_p)
                        peaks['peaks'].append(current_v)
                        is_peak = False
                    else:
                        break
                i += 1
    return peaks

def pick_peaks(arr):
    pos_delta = [pd for pd in enumerate((b - a for a, b in zip(arr, arr[1:])), 1) if pd[1]]
    positions = [a[0] for a, b in zip(pos_delta, pos_delta[1:]) if a[1] > 0 and b[1] < 0]
    return {'pos': positions, 'peaks': [arr[p] for p in positions]}


def pick_me(arr):
    plateau = None

    for i, p in enumerate(arr[1:-1]):
        # peak as is
        if arr[i] < p > arr[i+2]:
            yield(i+1, p)
            plateau = None

        # start of potential plateau
        if arr[i] < p == arr[i+2]:
            plateau = (i+1, p)

        # found end of plateau
        if plateau and arr[i] == p > arr[i+2]:
            yield plateau
            plateau = None


def pick_peaks(arr):
    picked = list(zip(*pick_me(arr)))
    pos, peaks = picked if picked else ([], [])

    return {
        "pos": list(pos), 
        "peaks": list(peaks)
    }


def pick_peaks(arr):
    res = {'pos': [], 'peaks': []}
    for i in range(1, len(arr) - 1):
        if arr[i - 1] < arr[i] > arr[[n for n in range(i, len(arr)) if arr[n] != arr[i] or n == len(arr) - 1][0]]:
            res.update({'pos': res.get('pos') + [i]})
            res.update({'peaks': res.get('peaks') + [arr[i]]})
    return res

def pick_peaks(arr):
    lastind = -1
    pos = list()
    peaks = list()
    status = 'init'
    for i in range(1, len(arr)):
        if arr[i] > arr[i-1]:
            status = 'rising'
            lastind = i
        elif arr[i] < arr[i-1]:
            if status=='rising':
                pos.append(lastind)
                peaks.append(arr[i-1])
                status = 'lol'
    return {"pos": pos, "peaks": peaks}

def pick_peaks(arr):
    if not arr:
        return {"pos": [], "peaks": []}
    
    pos = []
    peaks = []
    arr_iter = enumerate(arr)
    curr_pos, curr_peak = next(arr_iter)
    climbing = False
    
    for index, value in arr_iter:
        if value > curr_peak:
            curr_pos, curr_peak = index, value
            climbing = True
        elif value < curr_peak:
            if climbing:
                pos.append(curr_pos)
                peaks.append(curr_peak)
                climbing = False
            curr_pos, curr_peak = index, value
    
    return {"pos": pos, "peaks": peaks}


def pick_peaks (nums):
    pp_dict = {'pos': [], 'peaks': []}
    size = len(nums)
    i = 1
    
    for i in range (1, size - 1):
        if nums[i] > nums[i - 1]:
            plateau_start = i
            try:
                while nums[i] == nums[i + 1]:
                    i += 1
                if nums[i] > nums[i + 1]:
                    pp_dict['pos'].append (plateau_start)
                    pp_dict['peaks'].append (nums[plateau_start])
            except LookupError:
                break
    
    return pp_dict
                


def pick_peaks(arr):
    coords = {'pos': [i for i in range(1, len(arr) - 1) if arr[i - 1] < arr[i] >
                    arr[[x for x in range(i, len(arr)) if arr[x] != arr[i] or x == len(arr) - 1][0]]]}
    coords.update({'peaks':[arr[elem] for elem in coords.get('pos') ]})
    return coords

def pick_peaks(arr):
    # compress arr, keeping track of position of the first occurance of a value
    ppos = [i for i, x in enumerate(arr) if i == 0 or arr[i-1] != arr[i]]
    pos   = [ppos[i] for i in range(1,len(ppos)-1) \
        if arr[ppos[i]] > arr[ppos[i-1]] and arr[ppos[i]] > arr[ppos[i+1]] ]
    return {'pos': pos, 'peaks': [arr[i] for i in pos]}


def pick_peaks(arr):
    maximas, positions = [], []
    for i, num in enumerate(arr):
        same_as_num = [x == num for x in arr[i:]]
        end = not all(same_as_num) and i + same_as_num.index(False) - 1
        local_max = end and num > arr[i - 1] and num > arr[end + 1]
        
        if not (i == 0 or i == len(arr) - 1) and local_max:
            maximas.append(arr[i])
            positions.append(i)

    return {"pos": positions, "peaks": maximas}


def pick_peaks(arr):
    pos = []
    for i in range(1, len(arr)-1):
        # next index with a value != current_value
        next_i = next((n for n, v in enumerate(arr[i:]) if v != arr[i]), None)
        if arr[i-1] < arr[i] and next_i and arr[i] > arr[i:][next_i]:
            pos.append(i)
    return {
        'pos': pos,
        'peaks': [arr[po] for po in pos], 
    }

def next_different_value(arr, index):
    next_index = index + 1
    while arr[index] == arr[next_index] and next_index != len(arr) - 1:
        next_index += 1
    return arr[index] > arr[next_index]

def pick_peaks(arr):
    res = {'pos': [], 'peaks': []}
    if len(arr) < 3:
        return res
    def fill_res(pos, peaks):
        res['pos'].append(pos)
        res['peaks'].append(peaks)
    for index, value in enumerate(arr):
        if index not in [0, len(arr) - 1]:
            if arr[index] > arr[index - 1] and next_different_value(arr, index):
                fill_res(index, value)
    return res

def pick_peaks(arr):
    p = []
    z = []
    res = {"pos": [], "peaks": []}
    for i, k in enumerate(arr[1:-1]):
        if k > arr[i] and k > arr[i+2]:
            p.append(i+1)
            z.append(k)
        elif k == arr[i+2] and k > arr[i]:
            n = 1
            while True:
                n += 1
                if k != arr[i+n] or i+n == len(arr)-1:
                    break
            if k > arr[i+n]:
                p.append(i+1)
                z.append(k)
    res["pos"] = p
    res["peaks"] = z
    return res

def pick_peaks(arr):
    out = {}
    i, wait_pick, temp_pick = 1, 0, 0
    while i < len(arr) - 1:
        if arr[i] == arr[i+1] and arr[i] > arr[i-1]:
            temp_pick = i
            wait_pick = 1
            i += 1   
            continue
        if wait_pick == 1:
            if arr[i] > arr[i+1]:
                out[temp_pick] = arr[temp_pick]
                wait_pick = 0
            elif arr[i] < arr[i+1]:
                wait_pick = 0
            i += 1
        else:
            if arr[i] > arr[i-1] and arr[i] > arr[i+1]:
                out[i] = arr[i]
            i += 1
    return {"pos": list(out.keys()), "peaks": list(out.values())}

def pick_peaks(arr):
    pos = []
    peaks = []
    i = 1
    while i < len(arr)-1:
        if arr[i-1] < arr[i] and arr[i] > arr[i+1]: #case when there is a simple peak
            pos.append(i); peaks.append(arr[i])
        elif arr[i-1] < arr[i] < arr[i+1]: #case when the value of each number is incrementing
            pass
        elif arr[i-1] < arr[i]: #the case when we have a plato
            if i < len(arr): #to avoid the situation of i value greater then arr len
                for j in range(i,len(arr)-1): #we check all number to len(arr)-1 
                    if arr[j] == arr[j+1]:    #to understand when and where the plato ends
                        continue              #plato continues
                    elif arr[j] < arr[j+1]:   #case when we meet the number which is greater
                        i = j - 1             #then each plato's number
                        break
                    elif arr[j] > arr[j+1]:   #case when the plato has ended we simply add 
                        pos.append(i)         #the i and its value to lists
                        peaks.append(arr[i])
                        i = j - 1
                        break
        i+=1

    return {'pos': pos, 'peaks': peaks}

def pick_peaks(a):
    po, pe = 'pos', 'peaks'
    d = { po: [], pe: [] }
    for n in range(2, len(a)):
        b, P, e = n-2, n-1, n                              
        if a[ b ] < a[ P ] >= a[ e ]:                           
            if len(a[ P :  ]) != a[ P :  ].count(a[ P ]):    
                if max( a[ P : ] ) >= a[ P ]  :
                    if d[po]:
                        if min( a[ d[po][-1] : P ] ) >= d[pe][-1]:
                            d[po] = d[po][ : -1]
                            d[pe] = d[pe][ : -1]
                    d[po].append( P )
                    d[pe].append( a[ P ] )
    return d

def pick_peaks(array):
    peaks, pos = [], []
    platpos = platpeaks = ""

    for i in range(1, len(array) - 1):
        if array[i - 1] < array[i] > array[i + 1]:
            peaks.append(array[i]), pos.append(i)
        elif array[i - 1] < array[i] == array[i + 1]:
            platpos, platpeaks = i, array[i]
        elif array[i - 1] == array[i] > array[i + 1] and platpos != "":
            pos.append(platpos), peaks.append(platpeaks)

    return{"pos": pos, "peaks": peaks}

def pick_peaks(arr):
    peaks = []
    pos = []
    i = 0
    clean = list(arr)
    
    while i < len(clean)-1:
        if i == 0 or i == len(clean)-1:
            i = i + 1
            pass
        else:
            c = 1
            while clean[i] == clean[i+c] and i+c<len(clean)-1:
                c = c+1
                
            if clean[i] > clean[i-1] and clean[i] > clean[i+c]:
                peaks.append (clean[i])
                pos.append(i)
            
            i = i+c

    return {"pos":pos, "peaks":peaks}


def pick_peaks(arr):
    peak = []
    pos = []
    prev = 0
    growing = False
    for i in range(1,len(arr)):
        if arr[prev] > arr[i] and growing:
            peak.append(arr[prev])
            pos.append(prev)
            growing = False
        elif arr[prev] < arr[i]:
            growing = True
        if arr[prev] == arr[i]:
            prev = prev
        else:
            prev = i
    return { 'pos' : pos, 'peaks' : peak}


def pick_peaks(arr):
    pos = []
    peaks = []
    for x, num in enumerate(arr):
        if x == 0 or x == len(arr)-1:
            continue
        if arr[x-1] < num and arr[x+1] < num:
            pos.append(x)
            peaks.append(num)
        elif arr[x-1] < num and arr[x+1] == num:
            # checks for plateau peaks
            i = x
            plateau = True
            while plateau:
                i+= 1
                try:
                    if arr[i] < num:
                        pos.append(x)
                        peaks.append(num)
                        plateau = False
                    elif arr[i] > num:
                        plateau = False
                except IndexError:
                    plateau = False
                    
    return {'pos':pos, 'peaks': peaks}
            
            
        


def pick_peaks(arr):
    pos = []
    peaks = []
    i = 1
    while i < len(arr) - 1:
        if arr[i - 1] < arr[i]:
            j = i + 1
            while j < len(arr):
                print(arr[i], arr[j])
                if arr[i] > arr[j]:
                    pos.append(i)
                    peaks.append(arr[i])
                    break
                elif arr[i] == arr[j]:
                    j += 1
                else:
                    break
        i += 1
    return {"pos": pos, "peaks": peaks}

from itertools import groupby
def pick_peaks(arr):
# remove plateaus using groupby and just remember the first occurrence position
# build a new list called "sequence"
    start = 0
    sequence = []
    for key, group in groupby(arr):
        sequence.append((key, start))  # adds tuples for key and first occurrence
        start += sum(1 for element in group) # start plus number of consequtive occurrences
        
    peaks = []
    pos = [] 
# b like before tuple(value, original index), m like middle, a like after 
    for (b, bi), (m, mi), (a, ai) in zip(sequence, sequence[1:], sequence[2:]):
        if b < m and a < m:
            pos.append(mi)
            peaks.append(m)
# Build result            
    result = {}
    result['pos'] = pos
    result['peaks'] = peaks
    return result


def pick_peaks(arr):
    real = [arr[x] for x in range(len(arr) -1) if arr[x] != arr[x+1]]
    track = [x for x in range(len(arr)-1) if arr[x] == arr[x+1]]
    if real:
        real.append(arr[-1])
    pos = [x for x in range(1, len(real)-1) if (real[x] > real[x-1]) and (real[x] > real[x+1])]
    posn = [x+1 for x in range(1,)]
    peak = [real[x] for x in range(1, len(real)-1) if (real[x] > real[x-1]) and (real[x] > real[x+1])]
    new = []
    count = 0
    a = 0
    for i in range(len(real)):
        if arr[i+count] != real[i]:
            skip = 0
            while arr[i+count] != real[i]:
                count += 1
                skip += 1
            if new:
                new.append([i + new[-1][1], skip])
            else:
                new.append([i, skip])
    for j in range(len(new)):
        for k in range(len(pos)):
            if pos[k] >= new[j][0]:
                pos[k] = pos[k] + new[j][1]

    total = {"pos": pos, "peaks": peak}
    return total

def pick_peaks(arr):
    #your code here
    pos = []
    peaks = []
    plateau = []

    numbers = len(arr)
    print("length of array: "+str(numbers))
    print("list:")
    print(arr)

    for number in range(numbers):
        if number == 0 or number == (numbers - 1):
            pass
        else:
            candidate = arr[number]
            pre = arr[(number - 1)]
            post = arr[(number + 1)]
            if candidate > pre and candidate > post:
                pos.append(number)
                peaks.append(candidate)
            elif number == 1 or number == (numbers - 2):
                pass
#             elif candidate == post and candidate == arr[(number + 2)] and number != (number - 1):
            elif candidate > pre and candidate == post:  
                if candidate >= arr[(number + 2)] and number != (number - 1) and candidate != arr[(numbers - 1)]:
                    pos.append(number)
                    peaks.append(candidate)
                else:
                    pass
    print("plateau:")
    print(plateau)
    answer = {}
    answer["pos"] = pos
    answer["peaks"] = peaks
    print(answer)
    return answer

def pick_peaks(arr):
    start = 0
    sequence = []
    ind,val=[],[]
    posPeaks = {
        "pos": [],
        "peaks": [], }

    from itertools import groupby

    for key, group in groupby(arr):
        sequence.append((key, start))
        start += sum(1 for _ in group)

    for (b, bi), (m, mi), (a, ai) in zip(sequence, sequence[1:], sequence[2:]):
        if b < m and a < m:
            ind.append(mi)
            val.append(m)
        
    posPeaks["pos"]=ind
    posPeaks["peaks"]=val
    return (posPeaks)

def pick_peaks(arr):
    result = {"pos":[],"peaks":[]}
    for i in range(1,len(arr)-1):
        if arr[i]>arr[i-1] and arr[i]>arr[i+1]:
            result["pos"].append(i)
            result["peaks"].append(arr[i])
            
        elif arr[i]>arr[i-1] and arr[i]==arr[i+1]:
            for k in range(i+2,len(arr)):
                if arr[i]>arr[k]:
                    result["pos"].append(i)
                    result["peaks"].append(arr[i])
                    break
                elif arr[k]>arr[i]:
                    break
    return result


def pick_peaks(arr):
    #your code here
    result=[]
    resultIndex=[]
    for element in range(len(arr)):
        if element>0 and element!=(len(arr)-1):
            if arr[element]>arr[element-1] and arr[element]>arr[element+1]:
                peak=arr[element]
                result.append(peak)
                resultIndex.append(element)
            elif(arr[element]>arr[element-1] and arr[element]==arr[element+1] ):
                curr=arr[element]
                currIndex=element
                for next in range(element+1,len(arr)-1):
                    if(arr[next]>arr[next+1]):
                        result.append(curr)
                        resultIndex.append(currIndex)
                        break
                    elif(arr[next]==arr[next+1]):
                        continue
                    else:
                        break
    return {"pos":resultIndex,"peaks":result}

def pick_peaks(arr):
    #your code here
    result = {'pos':[], 'peaks':[]}
    flagIndex = -1
    for i in range(1, len(arr)-1):
        if arr[i-1] < arr[i] > arr[i+1]:
            result['pos'].append(i)
            result['peaks'].append(arr[i])
        elif arr[i-1] < arr[i] == arr[i+1]:
            flagIndex = i
        elif flagIndex != -1:
            if arr[i] > arr[i+1]:
                result['pos'].append(flagIndex)
                result['peaks'].append(arr[flagIndex])
                flagIndex = -1
            elif arr[i] < arr[i+1]:
                flagIndex = -1
            
    return result

def pick_peaks(arr):
    output = {"pos": [], "peaks": []}
    topPos = 0
    if len(arr) > 0:
        topPeak = arr[0]
        for i in range(1, len(arr)):
            if arr[i] > arr[i-1]:
                topPos = i
                topPeak = arr[i]
            elif arr[i] < arr[i-1]:
                """ It's help to know if there was a climbing previously """
                if topPos > 0:
                    output["pos"].append(topPos)
                    output["peaks"].append(topPeak)
                    topPos = 0
    return output



def pick_peaks(arr):
    out = {
        'pos': [],
        'peaks': []
    }
    if len(arr) == 0:
        return out
    last_i = arr[0]
    latest_maxima = None
    latest_maxima_pos = None
    for pos in range(len(arr)):
        i = arr[pos]
        if i > last_i:
            latest_maxima = i
            latest_maxima_pos = pos
        if i < last_i and latest_maxima is not None:
            out['pos'].append(latest_maxima_pos)
            out['peaks'].append(latest_maxima)
            latest_maxima = None
            latest_maxima_pos = None
        last_i = i
    return out

def pick_peaks(arr):
    dict = {"pos": [], "peaks": []}
    
    for i in range(1, len(arr)-1):
        if(arr[i-1] < arr[i] and arr[i] > arr[i+1]):
            dict["pos"].append(i)
            dict["peaks"].append(arr[i])
        
        elif(arr[i-1] < arr[i] and (arr[i] == arr[i+1])):
            cur = i+1
            while cur+1 < len(arr):
                if(arr[cur] > arr[cur+1]):
                    dict["pos"].append(i)
                    dict["peaks"].append(arr[i])
                    break
                if(arr[cur] < arr[cur+1]):
                    break
                cur+=1
            
        
    return dict

def pick_peaks(a):
    ind = []
    val = []
    for i in range(1, len(a)-1):
            if  a[i-1] < a[i] and a[i] > a[i+1]:
                ind.append(i)
                val.append(a[i])
            elif a[i] > a[i-1] and a[i] == a[i+1]:
                for j in range(i+1, len(a)-1):
                        if a[j] == a[i] and a[j]<a[j+1]:
                            break
                        elif a[j] == a[i] and a[j+1]<a[j]:
                            ind.append(i)
                            val.append(a[i])
                            break
    return {'pos': ind, 'peaks': val}

def pick_peaks(arr):
    local_peaks = {
        'pos': [],
        'peaks': []
    }
    count = 1
    length = len(arr)
    while count < length - 1:

        value = arr[count]
        add_node = False
        if value >= arr[count + 1] and value > arr[count - 1]:
            if value == arr[count + 1]:
                #checking if value eventually goes down
                for i in range(2, length - count):
                    if arr[count + i] > value:
                        break
                    elif arr[count + i] < value:
                        add_node = True
 
            else:
                add_node = True
     
        if add_node:
            local_peaks['pos'].append(count)
            local_peaks['peaks'].append(value)           
        count += 1

    return local_peaks

def pick_peaks(arr):     
    l=[]
    t=[]
    for i in range(len(arr)-2):
        if arr[i+1]>arr[i]:
            k=0
            while k+i+1<len(arr):
                if arr[k+i+1]>arr[i+1]:
                    break
                if arr[k+i+1]<arr[i+1]:
                    l.append(arr[i+1])
                    t.append(i+1)
                    break
                k=k+1
    return {'pos':t,'peaks':l}

def pick_peaks(a):
    pos = []
    try:
        for k in range(1, len(a) - 1):
            if a[k] > a[k - 1] and a[k] > a[k + 1]:
                pos.append(k)
            elif a[k] > a[k - 1] and a[k] == a[k + 1]:
                i = k + 2
                while i < len(a) - 1 and a[i] == a[k]:
                    i += 1
                
                if a[i] < a[k]:
                    pos.append(k)
                else:
                    k = i
                    
        peaks = [a[i] for i in pos]
        return {'pos': pos, 'peaks': peaks}
    except IndexError:
        print(a)
        print('i=', i)

def pick_peaks(arr):
    d = {"pos" : [], "peaks" : []}
    i = 0
    print(arr)
    if len(arr) > 2 and arr[0] >= arr[1]:
        while arr[i] >= arr[i+1] and i < len(arr)-2:
                i += 1 
    while i < len(arr)-1:
        if arr[i] < arr[i+1]:
            pass   
        elif arr[i] == arr[i+1]:
            temp = i
            while arr[i] == arr[i+1] and i < len(arr)-2:
                i+=1
            if arr[i] > arr[i+1]:
                d["pos"].append(temp)
                d["peaks"].append(arr[temp])
                while arr[i] >= arr[i+1] and i < len(arr)-2:
                    i += 1
        else:
            d["pos"].append(i)
            d["peaks"].append(arr[i])
            while arr[i] >= arr[i+1] and i < len(arr)-2:
                i += 1
        i+=1
    return d

def pick_peaks(arr):
    #your code here
    a_1 = []
    a_2 = []

    result_ab = {'pos': a_1, 'peaks': a_2}

    for i in range(0, (len(arr)-1)):
        if (i != 0) and (i != len(arr)-1):
            if (arr[i] > arr[i-1]) and (arr[i] > arr[i+1]):
                a_1.append(i)
                a_2.append(arr[i]) 
            elif (arr[i] > arr[i-1]) and (arr[i] == arr[i+1]):
                # elem = i
                copy_arr = arr[:]
                while (copy_arr[i] == copy_arr[i+1]):
                    del copy_arr[i+1]
                    if i != len(copy_arr)-1:
                        if (copy_arr[i] > copy_arr[i+1]): # !!!
                            a_1.append(i)
                            a_2.append(arr[i]) 
                            break
                        elif (copy_arr[i] == copy_arr[i+1]):
                            continue
                        else:
                            break
                    else:
                        break
            else:
                pass
        else:
            pass

    return result_ab


def isPeak(arr, pos):
    if pos == 0 or pos == len(arr) - 1:
        return False
    if arr[pos - 1] >= arr[pos]:
        return False
    for nextElem in arr[pos + 1:]:
        if nextElem > arr[pos]:
            return False
        if nextElem < arr[pos]:
            return True

def pick_peaks(arr):
    result = {"pos": [], "peaks": []}
    for pos, val in enumerate(arr):
        if isPeak(arr, pos):
            result["pos"].append(pos)
            result["peaks"].append(val)
    return result


def pick_peaks(arr):
    out = {}
    pos = []
    peaks = []
    temp = []
    for i, x in enumerate(arr[1:-1], start=1):
        prev = arr[i-1]
        nxt = arr[i+1]
        if x > prev:
            temp = [i, x]
        if x < prev and temp or x > nxt and temp:
            pos.append(temp[0])
            peaks.append(temp[1])
            temp.clear()

    out['pos'] = pos
    out['peaks'] = peaks
    return out

from itertools import groupby

def pick_peaks(arr):

    result = {'pos':[], 'peaks':[]}
    if not arr: return result
    
    arr = dict(enum(list(j) for i,j in groupby(arr)))         
    keys = sorted(arr.keys())
    
    for i in arr:        
        if i != keys[0] and i != keys[-1]:        
            curr  = arr[i][0]
            prev = arr[keys[keys.index(i) + 1]][0]
            post     = arr[keys[keys.index(i) - 1]][0]
            
            if curr > post and curr > prev:
                result['pos']   = result['pos'] + [i]
                result['peaks'] = result['peaks'] + [arr[i][0]]
    return result
    
def enum(listA):
    value = 0
    for j in listA:
        if len(j) == 1:
            yield(value,j)
            value += 1
        else:
            yield(value, j)
            value += len(j) 

def pick_peaks(arr):
    obj = {"pos": [], "peaks": []}
    
    if len(arr) == 0:
        return obj
    
    upward = True if arr[0] < arr[1] else False
    pos = 1
    plateau = 0
    
    while pos < len(arr) - 1:
        if upward:
            if arr[pos] == arr[pos+1]:
                plateau += 1
            elif arr[pos] > arr[pos+1] and arr[pos] >= arr[pos-1]:
                obj["pos"].append(pos-plateau)
                obj["peaks"].append(arr[pos])
                upward = False
                plateau = 0
            else:
                plateau = 0
            pos += 1
        else:
            if arr[pos] < arr[pos+1]:
                upward = True
            pos += 1
    
    return obj

def pick_peaks(arr):
    a = []
    b = []
    for i in range(1, len(arr)-1):
        for l in range(i, len(arr)-1):
            if arr[l+1] > arr[i]:
                break
            if arr[l+1] < arr[i]:
                if arr[i-1] < arr[i] and arr[i+1] <= arr[i]:
                    a.append(i)
                    b.append(arr[i])
                    break
    return {"pos":a,"peaks":b}

def pick_peaks(arr):
    print(arr)
    obj = {"pos": [], "peaks": []}
    if len(arr) == 0:
        return obj
    upward = True if arr[0] < arr[1] else False
    pos = 1
    plateau = 0
    
    while pos < len(arr) - 1:
        if upward:
            if arr[pos] == arr[pos+1]:
                plateau += 1
            elif arr[pos] > arr[pos+1] and arr[pos] >= arr[pos-1]:
                obj["pos"].append(pos-plateau)
                obj["peaks"].append(arr[pos])
                upward = False
                plateau = 0
            else:
                plateau = 0
            pos += 1
        else:
            if arr[pos] < arr[pos+1]:
                upward = True
            pos += 1
    
    return obj
    
    


def pick_peaks(arr):
    #your code here
    pos = []
    prob_peak = False
    for i in range(1, len(arr)):
        if arr[i] > arr[i-1]:
            prob_peak = i
        elif prob_peak and arr[prob_peak] > arr[i]:
            pos.append(prob_peak)
            prob_peak = False
    return {"pos":pos, "peaks":[arr[i] for i in pos]}

def pick_peaks(arr):
    #your code here
    pos, peaks = [], []
    for i in range(len(arr)-2):
        a, b, c = list(range(i, i+3))
        if pos and peaks[-1] == arr[b]:
            condition = True
            for i in range(pos[-1], b):
                condition = condition and arr[i] == arr[b]
            if condition is True:
                continue
        while arr[a] == arr[b] and a > 0:
            a -= 1
        while arr[b] == arr[c] and c < len(arr)-1:
            c += 1
        if arr[a] < arr[b] and arr[b] > arr[c]:
            pos += [b]
            peaks += [arr[b]]
    return {"pos":pos, "peaks":peaks}


def pick_peaks(arr):
    peaks = {'peaks': [], 'pos': []}
    if len(arr) == 0:
        return peaks
    p = min(arr)
    pos = 0
    for i in range(2, len(arr)):
        if arr[i-1] > arr[i-2] and arr[i-1] >= arr[i]:
            p = arr[i-1]
            pos = i-1
        if arr[i] < p:
            peaks['peaks'].append(p)
            peaks['pos'].append(pos)
            p = min(arr)
            pos = 0
    return peaks

def pick_peaks(arr):
    pos = []
    peaks = []
    if len(arr) > 0:
        n = 0
        peak_start = 0
        curr_height = arr[0]
        is_descending = True
        for p in arr:
            if p > curr_height:
                is_descending = False
                curr_height = p
                peak_start = n
            elif p == curr_height:
                pass
            elif p < curr_height:
                if not is_descending:
                    pos.append(peak_start)
                    peaks.append(curr_height)
                is_descending = True
                curr_height = p
            else:
                raise Error
            n += 1
    return {"pos": pos, "peaks": peaks}

def pick_peaks(arr):
    posPeaks = {'pos': [] , 'peaks': []}
    for i in range(1, len(arr)-1):
        if arr[i] > arr[i-1]:
            if arr[i] > arr[i+1]:
                posPeaks['pos'].append(i)
                posPeaks['peaks'].append(arr[i])
            if arr[i] == arr[i+1]:
                for x in range(i+2, len(arr)):
                    if arr[x] < arr[i]:
                        posPeaks['pos'].append(i)
                        posPeaks['peaks'].append(arr[i])
                        break
                    if arr[x] > arr[i]:
                        break
    return posPeaks

def pick_peaks(arr):
    ans = {"pos":[],"peaks":[]}
    for i in range(1,len(arr)-1):
        start = None
        end = None
        if arr[i-1] == arr[i]:
            for x in range(i,0,-1):
                while arr[i-x] != arr[i]:
                    start = i-x+1
                    break
        if arr[i+1] == arr[i]:
            for y in range(i,len(arr)-1):
                if arr[y] != arr[i]:
                    end = y -1
                    break
                else:
                    end = y
        if start == None: start = i
        if end == None: end = i
        if arr[start-1]< arr[start] and arr[end+1] < arr[end]:
            if start not in ans["pos"]:
                ans["pos"].append(start)
                ans["peaks"].append(arr[start])
    return ans

def pick_peaks(arr):
    ans = {"peaks" :[] ,"pos": []}
    point = False
    for i in range(len(arr)):
        if arr[i]> arr[i-1]:
            point = i
        elif arr[i] < arr[i-1] and point:
            ans["pos"].append(point)
            ans["peaks"].append(arr[point])
            point = False
    return ans
    #your code here


def pick_peaks(arr):
    print(arr)
    ans = {"pos":[],"peaks":[]}
    for i in range(1,len(arr)-1):
        start = None
        end = None
        if arr[i-1] == arr[i]:
            for x in range(i,0,-1):
                while arr[i-x] != arr[i]:
                    start = i-x+1
                    break
        if arr[i+1] == arr[i]:
            for y in range(i,len(arr)-1):
                if arr[y] != arr[i]:
                    end = y -1
                    break
                else:
                    end = y
        if start == None: start = i
        if end == None: end = i
        if arr[start-1]< arr[start] and arr[end+1] < arr[end]:
            if start not in ans["pos"]:
                ans["pos"].append(start)
                ans["peaks"].append(arr[start])
        print("i:",i,"val:",arr[i],start,end)
    return ans

import operator

def pick_peaks(arr):
  pos = []
  peaks = []
  if len(arr) < 3:
    return { "pos" : [], "peaks" : []}

  # substract
  diff = list(map(operator.sub, arr[1:], arr[:-1]))

  # deal with plateue
  for i in range(len(diff) - 1, 0, -1):
    if diff[i-1] == 0:
      diff[i-1] = diff[i]
  
  # find peaks
  is_peak = lambda a,b: 1 if a*b<0 and a>b else 0
  muld = list(map(is_peak, diff[:-1], diff[1:]))

  # get positions
  pos = [i+1 for i,v in enumerate(muld) if v == 1]
  
  # get peaks
  for i in pos:
    peaks.append(arr[i])

  return { "pos" : pos, "peaks" : peaks}


def pick_peaks(arr):
    pospeaks = {"pos":[], "peaks":[]}
    
    for i in range(1, len(arr) - 1):
        lowerbefore = arr[i - 1] < arr[i]
        lowerafter = False
        for j in arr[i:]:
            if j == arr[i]:
                continue
            elif j < arr[i]:
                lowerafter = True
                break
            elif j > arr[i]:
                break
        if lowerbefore and lowerafter:
            pospeaks["pos"].append(i)
            pospeaks["peaks"].append(arr[i])
    
    return pospeaks

def pick_peaks(lst):
    res = {'pos': [], 'peaks': []}
    idx = 0
    for i in range(1, len(lst) - 1):
        if lst[i] != lst[idx]:
            idx = i
        if idx and lst[idx - 1] < lst[idx] > lst[i + 1]:
            res['pos'].append(idx)
            res['peaks'].append(lst[idx])
    return res

def pick_peaks(arr):
    dict = {'pos':[],'peaks':[]}
    for i in range(1,len(arr)-1):
        if arr[i] > arr[i-1] and arr[i] >= arr[i+1]:
            add = True
            if arr[i] == arr[i+1]:
                j = i
                done = False
                while j < len(arr) and add and not done:
                    if arr[j] > arr[i]:
                        add = False
                    elif arr[j] < arr[i]:
                        done = True
                    j += 1
                if not done:
                    add = False
            if add:
                dict['pos'].append(i)
                dict['peaks'].append(arr[i])
    return dict

def pick_peaks(arr):
    pos = []
    peaks = []
    n = 0

    for i in range(1, len(arr) - 1):
        if arr[i] > arr[i - 1] and arr[i] > arr[i + 1]:
            pos.append(i)
            peaks.append(arr[i])

        # checking plateau cases
        elif arr[i] > arr[i - 1] and arr[i] == arr[i + 1]:
            n = 0
            for j in range(i + 1, len(arr)):
                # for the values that come after the possible plateau value
                # check to see that it decreases after staying constant

                if arr[j] == arr[i]:
                    n += 1

                else:
                    break

            if i + n + 1 < len(arr) and arr[i + n + 1] < arr[i]:

                pos.append(i)
                peaks.append(arr[i])

    return {"pos": pos, "peaks": peaks}

def pick_peaks(arr):
    set = {'pos' : [], 'peaks' : []}
    for i in range(1, len(arr)-1):
        if arr[i] > arr[i-1] and arr[i] > arr[i+1]:
            set['pos'].append(i)
            set['peaks'].append(arr[i])
        if arr[i] == arr[i+1] and arr[i] > arr[i-1]:
            for x in range(i+2, len(arr)):
                if arr[i]<arr[x]:
                    break
                if arr[i]>arr[x]:
                    set['pos'].append(i)
                    set['peaks'].append(arr[i])
                    break
    return set

def pick_peaks(arr):
    
    print('input:{}'.format(arr))
    if len(arr) < 1:
        return {"pos":[],"peaks":[]}
        
    #your code here
    UP     = 0
    DOWN   = 1
    FLAT   = 2
    trends = ["UP","DOWN","FLAT"]
    
    if arr[0] == arr[1]:
        trend = FLAT
    elif arr[0] > arr[1]:
        trend = DOWN
    else:
        trend = UP

    prev = arr[0]  
    pos = []
    peaks=[]
    
    local_max = None    
    for i in range(1,len(arr)):
        if trend == UP:
            if arr[i] == prev:
                trend = FLAT
                local_max =  i-1 #
            elif arr[i] < prev:
                trend = DOWN
                pos.append(i-1)
                peaks.append(prev)
        elif trend ==DOWN:
            if arr[i] == prev:
                trend = FLAT
                local_max =  None
            elif arr[i] > prev:
                trend = UP
        elif trend == FLAT:
            if arr[i] > prev:
                trend = UP
            elif arr[i] < prev:
                if local_max != None:
                    pos.append(local_max)
                    peaks.append(prev)
                trend = DOWN
  
        prev = arr[i]
    
    #terminated with flat
    if trend == FLAT:
        pos=pos[0:]
        peaks=peaks[0:]
    return {"pos":pos,"peaks":peaks}

def pick_peaks(arr):
    res = { "pos" : [], "peaks" : [] }
    flag = False
    
    for i in range( 1, len(arr) - 1 ):
        if flag:
            if arr[i] == arr[i+1]:
                continue
            elif arr[i] > arr[i+1]:
                res["pos"].append(temp)
                res["peaks"].append(arr[i])
                flag = False
            else:
                flag = False
        
        elif arr[i] > arr[i-1]:
            if arr[i] > arr[i+1]:
                res["pos"].append(i)
                res["peaks"].append(arr[i])
            elif arr[i] == arr[i+1]:
                temp = i
                flag = True
                
    return res


def pick_peaks(arr):
    r = {'pos' : [], 'peaks' : []}
    state = 'none'
    c = 1
    for i in range(1, len(arr)):
        if arr[i] > arr[i-1]:
            state = 'up'
        elif arr[i] == arr[i-1]:
            if state == 'still':
                c+=1
            if state == 'up':
                state = 'still'
        elif arr[i] < arr[i-1]:
            if state == 'up':
                r['pos'].append(i-1)
                r['peaks'].append(arr[i-1])
            elif state == 'still':
                r['pos'].append(i-c-1)
                r['peaks'].append(arr[i-c-1])
            state = 'down'
    return r

def pick_peaks(arr):
    pos = []
    peaks = []
    if arr:
        cur = arr[0]
        cur_pos = 0
        for i in range(1, len(arr)):
            if arr[i] > arr[i-1]:
                cur = arr[i]
                cur_pos = i
            elif arr[i] < cur and cur_pos != 0:
                pos.append(cur_pos)
                peaks.append(cur)
                cur_pos = 0
    return {
        'pos': pos,
        'peaks': peaks
    }

def pick_peaks(arr):
    pos, peaks = [], []

    for i in range(1, len(arr) - 1):
        if arr[i] >= arr[i + 1]:
            k = i
            while k < len(arr) - 2 and arr[k] == arr[k + 1]:
                k += 1
            if arr[i - 1] < arr[i] and arr[i] > arr[k + 1]:
                pos.append(i)
                peaks.append(arr[i])
    
    return {"pos": pos, "peaks": peaks}


def pick_peaks(arr):
    out = {'pos': [], 'peaks': []}
    
    for i in range(1, len(arr) - 1):
        plateau_idx = i+1
        if arr[i-1] < arr[i] == arr[i+1]: # might be at a plateau peak
            while plateau_idx < len(arr):
                if arr[plateau_idx] == arr[i]:
                    plateau_idx += 1
                else:
                    break
        if plateau_idx < len(arr) and arr[i-1] < arr[i] > arr[plateau_idx]: # unique peak
            out['pos'].append(i)
            out['peaks'].append(arr[i])
    return out

def pick_peaks(a):
    #your code here
    
    previous = 0 
    current = 0
    
    pos = []
    peaks = []
    
    for next in range(1,len(a)):
        if a[next] > a[current]:
            previous = current
            current = next
        else:
            if a[next] < a[current]:
                if a[previous] < a[current]:
                    pos.append(current)
                    peaks.append(a[current])
                previous = current
                current = next
            
    
    
            
    return {"pos": pos, "peaks": peaks}
    
    



def pick_peaks(arr):
    pos = []
    peaks = []
    for x in range(len(arr)):
        if x != 0 and x!= len(arr)-1:
            if arr[x] > arr[x-1] and arr[x] > arr[x+1]:
                pos.append(x)
                peaks.append(arr[x])
            elif arr[x] > arr[x-1] and arr[x] >= arr[x+1]:
                
                
                for y in arr[x:]:
                    print((y, x, arr[x], arr[x:]))
                    if arr[x] > y:
                        pos.append(x)
                        peaks.append(arr[x])
                        break
                    elif arr[x]< y:
                        break
                

    return {"pos": pos, "peaks":peaks}
                


def pick_peaks(arr):
    pos = []
    peaker = None
    for i in range(1 ,len(arr)):
        if arr[i-1] < arr[i]:
            peaker = i
        elif arr[i-1] > arr[i] and peaker:
            pos.append(peaker)
            peaker = None
    return {'pos':pos, 'peaks':[arr[i] for i in pos]}

def pick_peaks(arr):
    return_dict = {"pos": [], "peaks": []}
    fall = False
    peak = False
    plateaus_after_peak = False
    plateaus = False
    plateaus_pos = 0

    for position, current in enumerate(arr):

        if position == 0:
            print(f"[{position}] {current} - START")
        elif position == len(arr) - 1:
            print(f"[{position}] {current} - END")

        else:

            next = arr[position + 1]
            previous = arr[position - 1]

            if previous > current < next:
                fall = True
                peak = False
                plateaus_after_peak = False
                plateaus = False
                print(f"[{position}] {current} - Fell!")

            elif previous > current > next:
                fall = True
                peak = False
                plateaus_after_peak = False
                plateaus = False
                print(f"[{position}] {current} - Falling...")

            elif previous < current < next:
                fall = False
                peak = False
                plateaus_after_peak = False
                plateaus = False
                print(f"[{position}] {current} - Rising...")

            elif previous < current == next:
                fall = False
                peak = True
                plateaus_after_peak = False
                plateaus = True
                plateaus_pos = position
                print(f"[{position}] {current} - Plateaus start!")

            elif previous == current > next:

                if position == 1:
                    print(f"[{position}] {current} - End of starting plateaus!")

                # jeśli nie drugi i nie przedostatni
                elif position != 1 and position != len(arr) - 2:

                    if plateaus_after_peak:
                        fall = True
                        peak = False
                        plateaus_after_peak = False
                        plateaus = False
                        print(f"[{position}] {current} - Plateus End after peak - Falling...")

                    else:
                        fall = True
                        peak = False
                        plateaus_after_peak = False
                        plateaus = False
                        print(f"[{position}] {current} - End of plateaus! Falling, saving the start of plateaus!")
                        return_dict["pos"].append(plateaus_pos)
                        return_dict["peaks"].append(current)
                elif position == len(arr) - 2 and current > next and not plateaus_after_peak:
                    fall = True
                    peak = False
                    plateaus_after_peak = False
                    plateaus = False
                    print(f"[{position}] {current} - End of plateaus! Falling, saving the start of plateaus!")
                    return_dict["pos"].append(plateaus_pos)
                    return_dict["peaks"].append(current)

            elif previous > current == next:
                fall = False
                peak = False
                plateaus_after_peak = True
                plateaus = True
                print(f"[{position}] {current} - Plateus start after a peak!")

            elif previous < current > next:
                fall = False
                peak = True
                plateaus_after_peak = False
                plateaus = False
                print(f"[{position}] {current} - Its a peak! Saving")
                return_dict["pos"].append(position)
                return_dict["peaks"].append(current)

            elif previous == current == next:
                fall = False
                plateaus = True
                print(f"[{position}] {current} - Plateus Flat!")
            elif previous == current < next:
                if plateaus_after_peak:
                    fall = True
                    peak = False
                    plateaus_after_peak = False
                    plateaus = False
                    print(f"[{position}] {current} - Plateus End after peak - Rising...")
            elif plateaus:
                if position + 1 == len(arr) - 1: #jesli nie jest przedostatni
                    if not plateaus_after_peak:
                        fall = False
                        peak = True
                        plateaus_after_peak = False
                        plateaus = False
                        print(f"[{position}] {current} - Plateus Before End")
                        return_dict["pos"].append(plateaus_pos)
                        return_dict["peaks"].append(current)
                    else:
                        print(f"[{position}] {current} - X1!")
                else:
                    print(f"[{position}] {current} - X2!")

            else:
                print(f"[{position}] {current} - OUTSIDE!")

    return return_dict

def pick_peaks(arr):
    pos = []
    peak = []
    peaking = False
    platu = None
    for (count, item) in enumerate(arr):
        try:
            if arr[count] < arr[count + 1]:
                peaking = True
                platu = None
            elif arr[count] == arr[count + 1] and peaking:
                platu = count
                peaking = False
            elif peaking:
                pos.append(count)
                peak.append(item)
                peaking = False
            elif platu and arr[count+1] > arr[count]:
                platu = None
                peaking = True
            elif platu and arr[count+1] < arr[count]:
                pos.append(platu)
                peak.append(arr[platu])
                platu = None
                peaking = False
            else:
                pass
        except IndexError:
            break
    return {'pos': pos, 'peaks': peak}


def pick_peaks(arr):
    dct = {"pos": [], "peaks": []}
    for i in range(1, len(arr) - 1):
        if arr[i-1] < arr[i] and arr[i] > arr[i+1]:
            dct["pos"].append(i)
    plateau_peak(arr, dct)
    dct["pos"].sort()
    dct["peaks"] = [arr[x] for x in dct["pos"]]
    return dct

def plateau_peak(arr, dct):
    last = 0
    for i in range(1, len(arr) - 1):
        if arr[i] == arr[i+1]:
            continue
        elif arr[i] > arr[i+1] and arr[i] == arr[i-1] and arr[i] > arr[last]:
            dct["pos"].append(last+1)
            last = i
        else:
            last = i

def pick_peaks(arr):
    if not arr: 
        return {"pos":[],"peaks":[]}
    else: 
        peak_pos = []
        peak_value = []
        value = 0
        for i in range(1,len(arr)-1):
            if (arr[i-1] < arr[i]) and (arr[i+1] < arr[i]):
                peak_pos.append(i)
                peak_value.append(arr[i])
            if (arr[i-1] < arr[i]) and (arr[i+1] == arr[i]):
                for j in range(i+1,len(arr)):
                    if (arr[j] < arr[i]):
                        peak_pos.append(i)
                        peak_value.append(arr[i])      
                        print(('value added',i,j))
                        break
                    if (arr[j] > arr[i]):
                        break
                    
                        
        return {"pos":peak_pos,"peaks":peak_value}
            


def check(arr, n):
    for num in arr:
        if num < n: return True
        elif num > n: return False
    return False
    
def pick_peaks(arr):
    data = {"pos": [], "peaks": []}
    for i, n in enumerate(arr[1:-1], 1):
        if arr[i-1] < n >= arr[i+1] and check(arr[i:], n):
            data["pos"] += [i]
            data["peaks"] += [n]

    return data

def pick_peaks(arr):
    pos = []
    peaks = []
    
    local_max = 0
    for i in range(1, len(arr) - 1):
        if arr[i - 1] < arr[i]:
            local_max = i
        
        if arr[i - 1] <= arr[i] > arr[i + 1] and local_max not in pos and local_max != 0:
            pos.append(local_max)
            peaks.append(arr[local_max])
    
    return {'pos': pos, 'peaks': peaks}

def pick_peaks(arr):

    pos=list()
    peaks=list()
    j=0
    
    for i in range(1, len(arr)-1):
        
        if (arr[i-1]<arr[i]) and (arr[i+1]<arr[i]):
            pos.append(i)
            peaks.append(arr[i])

        elif arr[i-1]<arr[i] and arr[i]==arr[i+1] and i+1<len(arr)-1:
            pos.append(i)
            peaks.append(arr[i])
            j=1

        elif j==1 and ((arr[i-1]==arr[i] and arr[i]<arr[i+1]) or \
                       (arr[i]==arr[i+1] and i+1==len(arr)-1)):
            pos.pop()
            peaks.pop()
            j=0

    return {'pos': pos, 'peaks': peaks}


def pick_peaks(arr):
    results = {'pos': [], 'peaks': []}
    
    for i in range(1, len(arr)-1):
        if is_peak(arr, i):
            results['pos'].append(i)
            results['peaks'].append(arr[i])
    
    return results


def get_direction(last, i):
    if i > last:
        return 1
    elif i == last:
        return 0
    else:
        return -1
    
    
def is_peak(arr, index):
    result = False
    cur_val = arr[index]
    
    if get_direction(cur_val, arr[index -1]) < 0:
        for i in range(index, len(arr)):
            dir = get_direction(cur_val, arr[i])
            if dir < 0:
                result = True
                break
            elif dir > 0:
                result = False
                break
    
    return result


def pick_peaks(arr):
    result = {
        "pos": [],
        "peaks": []
    }

    for pos, val in enumerate(arr):
        if pos == 0 or pos == len(arr) - 1:
            continue
        if arr[pos+1] > val:
            continue
        if arr[pos-1] == val:
            continue
        if arr[pos+1] == val and arr[pos-1] < val:
            for i in range(pos+1, len(arr)):
                if arr[i] == val:
                    continue
                elif arr[i] > val:
                    break
                else:
                    result['pos'].append(pos)
                    result['peaks'].append(val)
                    break
            continue
        if arr[pos-1] < val:
            result['pos'].append(pos)
            result['peaks'].append(val)
            
    return result
    


def pick_peaks(arr):
    setThis = False
    pos = []
    peaks = []
    print([x for x in range(len(arr))])
    print(arr)
    for i in range(1,len(arr)-1):
        if arr[i] > arr[i-1] and arr[i] > arr[i+1]:
            pos.append(i)
            peaks.append(arr[i])
        elif arr[i] > arr[i-1] and arr[i] == arr[i+1]:
            j = i+1
            while arr[j] == arr[i] and j < len(arr)-1:
                j += 1
            if j == len(arr) or arr[j] < arr[i] :
                pos.append(i)
                peaks.append(arr[i])
                i = j
    print(pos)
    print(peaks)
    res = { "pos": pos, "peaks": peaks}
    return res