Buggy python submission (verdict: Runtime Error):
'''input
4
10 30 40 20
'''

n=int(input())
arr=list(map(int,input().split()))
dp=[0]*len(arr)
dp[0]=0
for i in range(len(arr)):
    if(i==1):
        dp[i]=dp[i-1]+abs(arr[i]-arr[i+1])
    else:
        dp[i]=min(dp[i-1]+abs(arr[i]-arr[i-1]),dp[i-2]+abs(arr[i]-arr[i-2]))
print(dp[n-1])

Fixed submission:
'''input
4
10 30 40 20
'''

n=int(input())
arr=list(map(int,input().split()))
dp=[0]*len(arr)
for i in range(1,n):
	dp[i]=dp[i-1]+abs(arr[i]-arr[i-1])
	if(i>1):
		a=dp[i-2]+abs(arr[i]-arr[i-2])
		dp[i]=min(dp[i],a)
print(dp[n-1])

Buggy python submission (verdict: Runtime Error):
import sys
sys.setrecursionlimit(100000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Fixed submission:
import sys
sys.setrecursionlimit(200000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Buggy python submission (verdict: Runtime Error):
import sys
sys.setrecursionlimit(1000000000000000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Fixed submission:
import sys
sys.setrecursionlimit(200000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Buggy python submission (verdict: Runtime Error):
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Fixed submission:
import sys
sys.setrecursionlimit(200000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Buggy python submission (verdict: Runtime Error):
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    memo[vrijednost] = min(abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1),abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2))
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Fixed submission:
import sys
sys.setrecursionlimit(200000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Buggy python submission (verdict: Runtime Error):
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    else:
        memo[vrijednost] = min(abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1),abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2))
        return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Fixed submission:
import sys
sys.setrecursionlimit(200000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Buggy python submission (verdict: Runtime Error):
import sys
sys.setrecursionlimit(1000000000000000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    else:
        memo[vrijednost] = min(abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1),abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2))
        return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Fixed submission:
import sys
sys.setrecursionlimit(200000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Buggy python submission (verdict: Runtime Error):
import sys
sys.setrecursionlimit(1000000000000000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    else:
        memo[vrijednost] = min(abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1),abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2))
        return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Fixed submission:
import sys
sys.setrecursionlimit(200000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Buggy python submission (verdict: Runtime Error):
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    else:
        memo[vrijednost] = min(abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1),abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2))
        return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Fixed submission:
import sys
sys.setrecursionlimit(200000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Buggy python submission (verdict: Runtime Error):
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    else:
        memo[vrijednost] = min(abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1),abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2))
        return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Fixed submission:
import sys
sys.setrecursionlimit(200000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Buggy python submission (verdict: Runtime Error):
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    else:
        memo[vrijednost] = min(abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1),abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2))
        return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Fixed submission:
import sys
sys.setrecursionlimit(200000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Buggy python submission (verdict: Time Limit Exceeded):
def doritto(vrijednost):
    global kameni
    global memo
    if vrijednost == len(kameni) -2:
        if memo[vrijednost][vrijednost+1] == -1:
            memo[vrijednost][vrijednost+1] = abs(kameni[vrijednost] - kameni[vrijednost+1])
        return memo[vrijednost][vrijednost+1]
    elif vrijednost == len(kameni) -1:
        return 0
    else:
        if memo[vrijednost][vrijednost+1] == -1:
            if memo[vrijednost][vrijednost+2] == -1:
                memo[vrijednost][vrijednost+2] = doritto(vrijednost+2)
            memo[vrijednost][vrijednost+1] = doritto(vrijednost+1)
        elif memo[vrijednost][vrijednost+2] == -1:
            memo[vrijednost][vrijednost + 2] = doritto(vrijednost + 2)
        return min(abs(kameni[vrijednost] - kameni[vrijednost+1]) + memo[vrijednost][vrijednost+1],abs(kameni[vrijednost] - kameni[vrijednost+2]) + memo[vrijednost][vrijednost + 2])
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append([])
    for j in range(N):
        memo[i].append(-1)
print(doritto(0))

Fixed submission:
import sys
sys.setrecursionlimit(200000)
def doritto(vrijednost):
    global kameni
    global memo
    if memo[vrijednost] != -1:
        return memo[vrijednost]
    if vrijednost == len(kameni) -2:
        return abs(kameni[vrijednost] - kameni[vrijednost+1])
    elif vrijednost == len(kameni) -1:
        return 0
    a = abs(kameni[vrijednost] - kameni[vrijednost+1]) + doritto(vrijednost+1)
    b = abs(kameni[vrijednost] - kameni[vrijednost+2]) + doritto(vrijednost+2)
    memo[vrijednost] = min(a,b)
    return memo[vrijednost]
N = int(input())
kameni = list(map(int,input().split()))
memo = []
for i in range(N):
    memo.append(-1)
print(doritto(0))

Buggy python submission (verdict: Runtime Error):
#!/usr/bin/env python
# coding: utf-8

dp = {}
NOT_FOUND = pow(10, 4) + 1

def sget(i):
    if i in dp:
        return dp[i]
    return NOT_FOUND

def chmin(a, b):
    if (a > b):
        return b
    return a

def main(N, hs):
    dp[0] = 0
    #for i in range(1, N):
    #    dp[i] = chmin(sget(i), sget(i - 1) + abs(hs[i] - hs[i - 1]))
    #    if i > 1:
    #        dp[i] = chmin(sget(i), sget(i - 2) + abs(hs[i] - hs[i - 2]))
    def rec(i):
        if sget(i) < NOT_FOUND:
            return sget(i)
        if i == 0:
            return 0
        res = NOT_FOUND
        res = chmin(res, rec(i-1) + abs(hs[i] - hs[i-1]))
        if (i > 1):
            res = chmin(res, rec(i-2) + abs(hs[i] - hs[i-2]))
        dp[i] = res
        return dp[i]
    return rec(N-1)


if __name__ == '__main__':
    #N = 4
    #hs = [10, 30, 40, 20]
    #N = 2
    #hs = [10, 10]
    #N = 6
    #hs = [30, 10, 60, 10, 60, 50]
    #N = 2
    #hs = [1, 3, 2, 1]
    N = int(input())
    hs = list(map(int, input().split(" ")))
    print(main(N, hs))
    #print(dp)


Fixed submission:
#!/usr/bin/env python
# coding: utf-8

N = int(input())
h = list(map(int, input().split()))

DP = [0, abs(h[0]-h[1])]
for i in range(N-2):
    DP += [min(DP[-2] + abs(h[i]-h[i+2]), DP[-1] + abs(h[i+1]-h[i+2]))]

print(DP[-1])

#dp = {}
#NOT_FOUND = pow(10, 4) + 1
#
#def sget(i):
#    if i in dp:
#        return dp[i]
#    return NOT_FOUND
#
#def chmin(a, b):
#    if (a > b):
#        return b
#    return a
#
#def main(N, hs):
#    dp[0] = 0
#    #for i in range(1, N):
#    #    dp[i] = chmin(sget(i), sget(i - 1) + abs(hs[i] - hs[i - 1]))
#    #    if i > 1:
#    #        dp[i] = chmin(sget(i), sget(i - 2) + abs(hs[i] - hs[i - 2]))
#    #def rec(i):
#    #    if sget(i) < NOT_FOUND:
#    #        return sget(i)
#    #    if i == 0:
#    #        return 0
#    #    res = NOT_FOUND
#    #    res = chmin(res, rec(i-1) + abs(hs[i] - hs[i-1]))
#    #    if (i > 1):
#    #        res = chmin(res, rec(i-2) + abs(hs[i] - hs[i-2]))
#    #    dp[i] = res
#    #    return dp[i]
#    #return rec(N-1)
#    return dp[N-1]
#
#
#if __name__ == '__main__':
#    #N = 4
#    #hs = [10, 30, 40, 20]
#    #N = 2
#    #hs = [10, 10]
#    #N = 6
#    #hs = [30, 10, 60, 10, 60, 50]
#    #N = 2
#    #hs = [1, 3, 2, 1]
#    N = int(input())
#    hs = list(map(int, input().split()))
#    print(main(N, hs))

Buggy python submission (verdict: Runtime Error):
def Stepenica(i,p1,p2):
    if i<len(L):
        p3=min( p1+abs(L[i]-L[i-2]), p2+abs(L[i]-L[i-1]) )
        Stepenica(i+1,p2,p3)
    else:
        print(p2)
        return
    
n=int(input())
L=list(map(int,input().split()))
Stepenica(2,0,abs(L[0]-L[1]))
               


Fixed submission:
n=int(input())
L=list(map(int,input().split()))
dp=[]
dp.append(0)
dp.append(abs(L[0]-L[1]))
for i in range(2, n):
    dp.append( min( dp[i-2]+abs(L[i]-L[i-2]), dp[i-1]+abs(L[i]-L[i-1]) ) )
print(dp[n-1])

Buggy python submission (verdict: Runtime Error):
def Stepenica(L,i,p1,p2):
    if i<len(L):
        p3=min( p1+abs(L[i]-L[i-2]), p2+abs(L[i]-L[i-1]) )
        Stepenica(L,i+1,p2,p3)
    else:
        print(p2)
        return
    
n=int(input())
L=list(map(int,input().split()))
Stepenica(L,2,0,abs(L[0]-L[1]))
               


Fixed submission:
n=int(input())
L=list(map(int,input().split()))
dp=[]
dp.append(0)
dp.append(abs(L[0]-L[1]))
for i in range(2, n):
    dp.append( min( dp[i-2]+abs(L[i]-L[i-2]), dp[i-1]+abs(L[i]-L[i-1]) ) )
print(dp[n-1])