TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
a,b,c,d = map(int, input().split())

def afunc(a,b,c,d):
  alist = [a,b,c,d]
  pre = a
  for char in alist[1:3]:
    if pre == char:
      print("Bad")
      return
    else:
      pre = char
  print("Good")

afunc(a,b,c,d)

a,b,c,d = map(int, input().split())

alist = [a,b,c,d]
pre = a
for char in alist[1:3]:
  if pre == char:
    print("Bad")
    return
  else:
    pre = char
print("Good")

S = str(input())
a = int(S[0])
b = int(S[1])
c = int(S[2])
d = int(S[3])

def afunc(a,b,c,d):
  alist = [a,b,c,d]
  pre = a
  for char in alist[1:4]:
    if pre == char:
      print("Bad")
      return
    else:
      pre = char
  print("Good")

afunc(a,b,c,d)


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
n,l = map(int,input().split())
li = []
for i in range(1,n+1):
  li.append(abs(l+i-1))
m = min(li)
if l+i-1 >= 0:
  print(int((n*(l-1)+(n*(n+1)/2)-l-i+1)))
else:
  print(int((n*(l-1)+(n*(n+1)/2)+l+i-1)))

s = input()
for i in range(3):
  if s[i] == s[i+1]:
    print('Bad')
    exit()
    
print('Good')

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S = list(input)
if S[0]!=S[1] and S[1]!=S[2] and S[2]!=S[3]:
    print("Bad")
else:
    print("Good")

S = list(input())
if S[0]!=S[1] and S[1]!=S[2] and S[2]!=S[3]:
    print("Good")
else:
    print("Bad")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
N, L = map(int,input().split(' '))
l=list(range(L,N+L,1))
minabs = min([abs(x) for x in l])
if N+L+1<=0:
    print(sum(l)+minabs)
else:
    print(sum(l)-minabs) 

inp = str(input())
def a(inp):
    for x in range(3):
    
        if inp[x]==inp[x+1]:
            return 'Bad'
    return 'Good'
print(a(inp))

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
# ABC131 A - Security
S = input()
rt = 'Good'
for x in range(len(S)-1):
    if S[x:x+1] == S[x+1:x+2]:
        rt = 'Bad'
    break
print(rt)

# ABC131 A - Security
tmp = ''
rt = 'Good'
for x in input():
    if x != tmp:
        tmp = x
    else:
        rt = 'Bad'
        break
print(rt)

Verdicts: Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
s = input()
for i in range(len(s)):
  if s[i] == s[i+1]:
    print("Bad")
  else:
    print("Good")

s = input()
res = "Good"
for i in range(3):
  if s[i] == s[i+1]:
    res = "Bad"
print(res)

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
s = input()
print('Bad' if true in [s[i] is s[i + 1] for i in range(3)] else 'Good')

s = input()
print('Bad' if true in [s[i] is s[i + 1] for i in 3] 'Good')

s = input()
print('Bad' if true in [s[i] is s[i + 1] for i in 3] else 'Good')

s = input()
print('Bad' if True in [s[i] is s[i + 1] for i in range(3)] else 'Good')


Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
N , L = map(int, input().split())

list = [L + (i+1)-1 for i in range(N)]

list.sort(key=lambda x:abs(x))

del list[0]
print(list)

str = input()
p = ""
resut = "Good"
for s in str:
  if p == s:
    result = "Bat"
print(result)

str = input()
p = ""
resut = "Good"
for s in str:
  if p == s:
    result = "Bat"
  p = s
print(result)

str = input()
p = ""
result = "Good"
for s in str:
    if p == s :
        result = "Bad"
    p = s
print(result)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
N,L = map(int, input().split())
list = []
sum = 0
min = 10000
sign = 1
for i in range(1,N+1):
    sum += L+i-1
    list.append(L+i-1)
for num in list:
    if min > abs(num):
        min = abs(num)
        if num > 0:
            sign = 1
        else:
            sign = -1
print(sum-min*sign)


M = input()
S = list(M)

result = "Good"
for str in S:
    if M.count(str+str) > 0:
        result = "Bad"
        break
print(result)


Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
a,b,c,d = map(int,input().split())

e = int(b // c)
f = int(a // c)
if f == int(a / c):
    g = e - f + 1
else:
    g = e - f

h = int(b // d)
i = int(a // d)
if i == int(a / d):
    j = h - i + 1
else:
    j = h - i

import fractions

cd = c*d / fractions.gcd(c,d)

k = int(b // cd)
l = int(a // cd)
if l == int(a / cd):
    m = k - l + 1
else:
    m = k - l

ans = (b-a) + 1 - (g + j - m)
print(int(ans))


s = str(input())

l = []
for x in s:
    l += [x]

truf = True
for x in range(3):
    if l[x] == l[x+1]:
        truf = False

if truf:
    print('Good')
else:
    print('Bad')

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
inputs = input()

if inputs[0]==inputs[1] or inputs[1]==inputs[2] or inputs[2]==inputs[3]:
  print("bad")
else:
  print("good")

inputs = input()

pre_num = "x"
for num in inputs:
    if pre_num == num:
        print("bad")
        exit()
    pre_num = num

print("good")

inputs = input()

pre_num = "x"
for num in inputs:
    if pre_num == num:
        print("bad")
        exit()
    pre_num = num

print("good")

inputs = input()

pre_num = "x"
for num in inputs:
    if pre_num == num:
        print("Bad")
        exit()
    pre_num = num

print("Good")

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
import math

def lcm(x, y):
    return (x * y) // math.gcd(x, y)


A,B,C,D = map(int,input().split())
c = B//C - (A-1)//C
d = B//D - (A-1)//D
E = lcm(C,D)
e = B//E - (A-1)//E
answer = B-A+1-(c+d-e)
print(answer)
            


import fractions
import sys

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)


A,B,C,D = map(int,input().split())
if C == 1 or D == 1:
    print(0)
    sys.exit(0)

E = lcm(C,D)
c = (A-1)//C + 1 if C!=1 else A
d = (A-1)//D + 1 if D!=1 else A
e = (A-1)//E + 1 if E!=1 else A
cde = [[c,C], [d,D], [e,E]]
cnt_cde = []
for x,y in cde:
    if x*y < B:
        cnt_cde.append((B-x*y)//y+1)
    elif x*y == B:
        cnt_cde.append(1)
    else :
        cnt_cde.append(0)
answer = B-A+1-(cnt_cde[0]+cnt_cde[1]-cnt_cde[2])
print(answer)
            


S = input()
for i,s in enumerate(S):
    if i == 3:
        print('Good')
        break
    if S[i] == S[i+1]:
        print('Bad')
        break

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
li = list(input())
flag = False
for i in range(li):
  if i == 0:
    continue
  flag = li[i-1] == li[i]
  if flag:
    break
print("Bad" if flag else "Good")

li = list(input())
flag = False
for i in range(len(li)):
  if i == 0:
    continue
  flag = li[i-1] == li[i]
  if flag:
    break
print("Bad" if flag else "Good")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
N, L = map(int, input().split())
flavors = [x + L - 1 for x in range(1, N + 1)]
flavors.remove(min(flavors, key=abs))
print(sum(flavors))

n = input()
print(["Yes" if n[0] != n[1] != n[2] != n[3] else "No"][0])

n = input()
print(["Good" if n[0] != n[1] != n[2] != n[3] else "Bad"][0])


Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S = input()
cnt = 1

for i in range(len(S)-1):
    if S[i] == S[i+1]:
        cnt = 0
        exit()
        
if cnt:
    print("good")
else:
    print("Bad")

S = input()
cnt = 1

for i in range(len(S)-1):
    if S[i] == S[i+1]:
        cnt = 0
        exit()

if int(cnt):
    print("Good")
else:
    print("Bad")


S = input()
cnt = 1

for i in range(len(S)-1):
    if S[i] == S[i+1]:
        cnt = 0
        exit()
        
if cnt:
    print("Good")
else:
    print("Bad")

S = input()
cnt = 1

for i in range(len(S)-1):
    if S[i] == S[i+1]:
        cnt = 0
        exit()
        
if cnt:
    print("Good")
else:
    print("Bad")


S = input()
cnt = 1

for i in range(len(S)-1):
    if S[i] == S[i+1]:
        cnt = 0
        

if int(cnt):
    print("Good")
else:
    print("Bad")

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
#131a
S = int(input())
if (S[0]==S[1]) or (S[1]==S[2]) or (S[2]==S[3]:
    print("Bad")
else:
    print("Good")

#131a
S = str(input())
if (S[0]==S[1]) or (S[1]==S[2]) or (S[2]==S[3]):
    print("Bad")
else:
    print("Good")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S = int(input())
flag = True
for i in range(3):
  if S[i] == S[i+1]:
    flag = False
if flag == True:
  print("Good")
else:
  print("Bad")

S = input()
flag = True
for i in range(3):
  if S[i] == S[i+1]:
    flag = False
if flag == True:
  print("Good")
else:
  print("Bad")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
str = int(input())

if (str / 1000 == str % 1000 / 100) or (str % 1000 / 100 == str % 100 / 10) or (str % 100 / 10 == str % 10) :
  print("Bad")
else:
  print("Good")

str = int(input())

if (str / 1000 == str % 1000 / 100) or (str % 1000 / 100 == str % 100 / 10) or (str % 100 / 10 == str % 10) :
  print("Bad")
else:
  print("Good")
    
print(str / 1000 == str % 1000 / 100) 

str = int(input())

if ((int) (str / 1000) == (int) (str % 1000 / 100)) or ((int) (str % 1000 / 100) == (int) (str % 100 / 10)) or ((int) (str % 100 / 10) == (int) (str % 10)):
  print("Bad")
else:
  print("Good")
  

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S = input()
S = list(S)
S.append("a")
hoge = "Good"
for i in range(4):
    if hoge[i] == hoge[i + 1]:
        hoge = "Bad"

print(hoge)

S = input()
S = list(S)
S.append("a")
hoge = "Good"
for i in range(4):
    if S[i] == S[i + 1]:
        hoge = "Bad"

print(hoge)

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
import re
s = input()
if re.search(r'(11|22|33|44|55|66|77|88|99|00)', s):
    print("Yes")
else:
    print("No")

import re
s = input()
if re.search(r'(11|22|33|44|55|66|77|88|99|00)', s):
    print("Bad")
else:
    print("Good")

Verdicts: Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S = input()
if S[0] == S[1]:
    print("Bad")
elif S[1] == S[2]:
    print("Bad")
elif S[2] == S[3]:
    print("Bad")
print("Good")

S = input()
if S[0] == S[1]:
    print("Bad")
elif S[1] == S[2]:
    print("Bad")
elif S[2] == S[3]:
    print("Bad")
else:
	print("Good")

Verdicts: Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S = int(input())
flag = 0

for i in range(3):
  if S[i] == S[i+1]:
    flag = 1
    
if flag:
  print("Bad")
  
else:
  print("Good")

S = list(input())
flag = 0

for i in range(3):
  if S[i] == S[i+1]:
    flag = 1
    
if flag:
  print("Bad")
  
else:
  print("Good")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
N,L=map(int,input().split())
LL=[L+i for i in range(N)]
LLL=[abs(L+i) for i in range(N)]

if N+L<0:
  print(sum(LL)+min(LLL))
else:
  print(sum(LL)-min(LLL))

N,L=map(int,input().split())
LL=[L+i for i in range(N)]
LLL=[abs(L+i) for i in range(N)]

if N+L<0:
  print(sum(LL)+min(LLL))
elif N+L=0:
  print(sum(LL))
else:
  print(sum(LL)-min(LLL))

S=input()
if S[0]==S[1] or S[1]==S[2] or S[2]==S[3]:
  print("Bad")
else:
  print("Good")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
pass=input()

x1=pass[0]
x2=pass[1]
x3=pass[2]
x4=pass[3]

res='Good'
if x1=x2: res='Bad'
if x2=x3: res='Bad'
if x3=x4: res='Bad'

print(res)

pas=input()

x1=pas[0]
x2=pas[1]
x3=pas[2]
x4=pas[3]

res='Good'
if x1==x2: res='Bad'
if x2==x3: res='Bad'
if x3==x4: res='Bad'

print(res)

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S = list(input())
if S[0]==s[1] or S[1]==S[2] or S[2]==S[3]:
  print('Bad')
else:
  print('Good')

S = list(input())
if S[0]==S[1] or S[1]==S[2] or S[2]==S[3]:
  print('Bad')
else:
  print('Good')

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S=[input()]

if S[0]==S[1]:
  print('Bad')
elif S[1]==S[2]:
  print('Bad')
elif S[2]==S[3]:
  print('Bad')
else:
  print('Good')
  



S=list(input())

if S[0]==S[1]:
  print('Bad')
elif S[1]==S[2]:
  print('Bad')
elif S[2]==S[3]:
  print('Bad')
else:
  print('Good')

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
import math
input = list(map(int,input().split()))
A = input[0]
B = input[1]
C = input[2]
D = input[3]

betweenAandB = B-A+1

cA = math.ceil(A/C)
cB = int(B/C)
cDiv = cB - cA + 1

dA = math.ceil(A/D)
dB = int(B/D)
dDiv = dB - dA + 1

GCD = math.gcd(C,D)
LCM = C*D/GCD

lcmA = math.ceil(A/LCM)
lcmB = int(B/LCM)
lcmDiv = max(lcmA, lcmB) - min(lcmA, lcmB) + 1

ans = betweenAandB - cDiv - dDiv + lcmDiv
print(ans)


N = input()
pre = 10
count = 0
for x in N:
    if x == pre:
        print("Bad")
        count = 1
        break
    pre = x
if count == 0:
    print("Good")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
n, l = map(int, input().split())

s = n*(l-1) + n*(n+1)/2
c = s
j = 1

for i in range(n):
  t = s - ((l-1)-1)
  T = abs(s-t)
  if T < c:
    c = T
    j = i
    
e = l+j
print(int(s-e))
  




n = list(input())

if n[0] == n[1]:
  print("Bad")
  exit()
elif n[1] == n[2]:
  print("Bad")
  exit()
elif n[2] == n[3]:
  print("Bad")
  exit()
print('Good')

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
n=list(input())
f=0
for i in range(len(n)):
    if(n[i]==n[i+1]):
    	f=1
if(f==1):
	print("Bad")
else:
	print("Good")

n=list(input())
f=0
for i in range(len(n)-1):
    if(n[i]==n[i+1]):
        f=1
if(f==1):
    print("Bad")
else:
    print("Good")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
security_num = input()
pre_num = ""
    
for num in security_num:
	if pre_num == num: return "Bad"
	pre_num = num

return "Good"

import fractions

A,B,C,D = input().strip().split(" ")
A = int(A)
B = int(B)
C = int(C)
D = int(D)

div1 = A // C
div2 = A // D
div3 = (B-1) // C
div4 = (B-1) // D

X = C*D // int(fractions.gcd(C,D))
div5 = B // X

del_nums = (div3 + div4) - (div1 + div2) + div5
result = B - A - del_nums
print(result)

nums = input().strip()
pre_num = ""
result = ""
flag = True

for num in nums:
	if pre_num == num: flag = False
	pre_num = num

if flag: result = "Good"
else: result = "Bad"

print(result)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S=input()
a=(str(S)[0])
b=(str(S)[1])
c=(str(S)[2])
d=(str(S)[3])
if(int(a)==int(b)):
  print("Bad")
else:
    print("Good")
    if(int(b)==int(c)):
  print("Bad")
else:
    print("Good")
if(int(c)==int(d)):
  print("Bad")
else:
    print("Good")

S=input()
a=(str(S)[0])
b=(str(S)[1])
c=(str(S)[2])
d=(str(S)[3])
if(int(a)==int(b)):
  print("Bad")
elif(int(b)==int(c)):
  print("Bad")
elif(int(c)==int(d)):
  print("Bad")
else:
    print("Good")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
a = input()

print('Good' if a[i+1] == a[i] else 'Bad' for i in range(len(a)))

a,b,c,d = map(int, input().split())
if a =b or a=c or a=d or b =c or c = d or b= d:
  print("Good")
else:
  print("Bad")

a,b,c,d = map(int, input().split())

if a = b or a = c or a = d or b = c or b = d or c =d:
  print('Good')
else:
  print('Bad

a = input()

print('Good' if a[0] != a[1] !=a[2] !=a[3]  else 'Bad')

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
s = input()
flag = 1
for i in range(1, n):
    if s[i - 1] == s[i]:
        flag = 0
if flag:
    print('Yes')
else:
    print('No')

s = input()
flag = 1
n = len(s)
for i in range(1, n):
    if s[i - 1] == s[i]:
        flag = 0
if flag:
    print('Yes')
else:
    print('No')

s = input()
print('Bad' if sum(s[i] == s[i + 1] for i in range(3)) else 'Good')

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S = list(input())
print(S)

if (S[0] == S[1] or S[1] == S[2] or S[2] == S[3]):
    print("Bad")
else:
    print("Good")

S = list(input())

if (S[0] == S[1] or S[1] == S[2] or S[2] == S[3]):
    print("Bad")
else:
    print("Good")

Verdicts: Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S=list(map(int,input()))
for i in (0,2):
  if S[i] == S[i+1] :
    print('Bad')
    break
else:
  print('Good')

S=list(map(int,input()))
for i in (0,len(S)-2):
  if S[i] == S[i+1] :
    print('Bad')
    break
else:
  print('Good')

S=input()
if S[0]==S[1] or S[1]==S[2] or S[2]==S[3]:
  print("Bad")
else:
  print("Good")

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
s=int(input())
if s[0]!=s[1] and s[1]!=s[2] and s[2]!=s[3]:
  print('Good')
  
else:
  print('Bad')
  

s=input()
if s[0]!=s[1] and s[1]!=s[2] and s[2]!=s[3]:
  print('Good')
  
else:
  print('Bad')
  


Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
s = input()
a = []
a = list(s)

if a[0]==a[1] or a[1]==a[2] or a[2]==a[3]:
	print('bad')
else:
	print('good')

s = input()
a = []
a = list(s)

if a[0]==a[1] or a[1]==a[2] or a[2]==a[3]:
	print('Bad')
else:
	print('Good')

Verdicts: Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
a,b,c,d = map(int, input().split())
print("Bad" if a==b or b==c or c==d else "Good")

s = input()
if s[0]==s[1] or s[1]==s[2] or s[2]==s[3]:
    print("Bad")
else:
    print("Good")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
s=int(input())
if s[0]!=s[1] and s[1]!=s[2] and s[2]!=s[3]:
    print('Good')
else:
    print('Bad')

s=input()
n=0
while s[n]!=s[n+1]:
    n+=1
    print('Good')
else:
    print('Bad')


s=int(input())
n=0
while s[n]!=s[n+1]:
    n+=1
    n=5:
        print('Good') 
else:
    print('Bad')

s=input()
if s[0]!=s[1] and s[1]!=s[2] and s[2]!=s[3]:
    print('Good')
else:
    print('Bad')


Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
a=list(input())
if a[0]==a[1]:
  print("Bad")
  elif a[1]==a[2]:
    print("Bad")
    elif a[2]==a[3]:
      print("Bad")
      else:
        print("Good")

a=map(int,input().split())
if a[0]==a[1]:
  print("Bad")
  elif a[1]==a[2]:
    print("Bad")
    elif a[2]==a[3]:
      print("Bad")
      else:
        print("Good")

a,b,c,d=map(int,input().split())
if a==b:
  print("Bad")
  elif b==c:
    print("Bad")
    elif c==d:
      print("Bad")
      else:
        print("Good")

a,b,c,d=map(int,input().split())
if a==b:
  print("bad")
  elif b==c:
    print("bad")
    elif c==d:
      print("bad")
      else:
        print("good")

a=input()
if a[0]==a[1]:
  print("Bad")
  elif a[1]==a[2]:
    print("Bad")
    elif a[2]==a[3]:
      print("Bad")
      else:
        print("Good")

a,b,c,d=map(int,input().split())
if a=b:
  print("bad")
  else if b=c:
    print("bad")
    else if c=d:
      print("bad")
      else:
        print("good")

a,b,c,d=map(int,input().split())
if a==b:
  print("bad")
  else if b==c:
    print("bad")
    else if c==d:
      print("bad")
      else:
        print("good")

s=input()
if s[0]==s[1] or s[1]==s[2] or s[2]==s[3]:
  print("Bad")
else:
  print("Good")

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
s = int(input())
if s[0] == s[1] or s[1] == s[2] or s[2] == s[3]:
    print('Bad')
else:
    print('Good')

s = input()
if s[0] == s[1] or s[1] == s[2] or s[2] == s[3]:
    print('Bad')
else:
    print('Good')

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
s=input()

for i in range(3):
        if s[i] == s[j+1]:
                print("Bad")
                exit()
print("Good")

s=input()

for i in range(3):
        if s[i] == s[i+1]:
                print("Bad")
                exit()
print("Good")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S = map(int, input().split())

flag = 0;

for i in range(1, 3):
    if S[i-1] = S[i] :
        flag = 1

res = "Good" if flag==0 else "Bad"

print(res)

S = input()

flag = 0;

for i in range(1, 4):
    if S[i-1] == S[i] :
        flag = 1

res = "Good" if flag==0 else "Bad"

print(res)

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S = input()

for i in range(3):
    if S[i] == S[i + 1]:
        print('Bad')
    else:
        print('Good')


S = str(input())
A = S.split()

for i in range(A):
    if A[i]=A[i+1]:
        print('Bad')
    else:
        print('Good')


S = str(input())
A = S.split()

for i in A:
    if A[i]=A[i+1]:
        print('Bad')
    else:
        print('Good')


S = input()
A = S.split()

for i in A:
    if A[i] == A[i + 1]:
        print('Bad')
    else:
        print('Good')


S = str(input())
A = S.split()

for i in A:
    if A[i] == A[i + 1]:
        print('Bad')
    else:
        print('Good')


S = input()
A = S.split()

for i in A:
    if A[i]=A[i+1]:
        print('Bad')
    else:
        print('Good')


S = input()

if S[0] == S[1] or S[1] == S[2] or S[2] == S[3]:
    print('Bad')
else:
    print('Good')


Verdicts: Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
s = list(int(input()))
if s[0]==s[1] or s[1]==s[2] or s[2]==s[3]:
  print('Bad')
else:
  print('Good')

s = list((input())
if s[0]==s[1] or s[1]==s[2] or s[2]==s[3]:
  print('Bad')
else:
  print('Good')

s = list(input())
if s[0]==s[1] or s[1]==s[2] or s[2]==s[3]:
  print('Bad')
else:
  print('Good')

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
# -*- coding: utf-8 -*-

N,L=map(int, input().split())

ans = 0
for i in range(N):
    ans = ans + L + i

if L > 0:
    ans = ans - L
if (L + N - 1) < 0:
    ans = ans - (L + N - 1)

print(ans)

# -*- coding: utf-8 -*-

S=input()

ans = 'Good'

if S[0] == S[1] or S[1] == S[2] or S[2] == S[3] :
    ans = 'Bad'

print(ans)

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
N = int(input())
l = [list(map(int, input().split())) for i in range(n)]
l.sort(key= x:x[1])
t=0
for i in l:
    a,b=i
    t+=a
    if(t>b):
        print("No")
        break
    else:
        print("Yes")


S = input()
n=0
b=0
while n<3 :
    if S[n]==S[n+1]:
        b=1
    n+=1
if b==1:
    print("Bad")
else:
    print("Good")


Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
import sys
from fractions import gcd
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]

a, b, c, d = LI()
a = a-1

cd = int(c * d / gcd(c, d))
cs = b // c - a // c
ds = b // d - a // d
cds = b // (cd) - a // (cd)
print(b - a - cs - ds + cds)


import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
from collections import defaultdict

num  = S()
for i in range(3):
    if num[i] == num[i+1]:
        print("Bad")
        break
else:
    print("Good")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
i=list(input())
o=0
for j in range(3):
  if int(i[j])==int(i[j+1]):
    print('Bad')
    o+=1
    break
  else:
    None
if o==1:
  print('Good')
else:
  None
 

i=list(input())
o=0
for j in range(3):
    if int(i[j])==int(i[j+1]):
        print('Bad')
        o+=1
        break
    else:
         None
if o==1:
    print('Good')



i=list(input())
o=0
for j in range(3):
  if int(i[j])==int(i[j+1]):
    print('Bad')
    o+=1
    break
  else:
    None
if o==0:
  print('Good')
else:
  None
 

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
import math

a = list(map(int, input().split()))
a = a[0]

x=a%10
y=a//10%10
z=a//100%10
w=a//1000

if(x!=y and y!= z and z!= w):
    print("Good")
else:
    print("Bad")
    
print(x,y,z,w)

import math

a = list(map(int, input().split()))
a = a[0]

x=a%10
y=a//10%10
z=a//100%10
w=a//1000

if(x!=y and y!= z and z!= w):
    print("Good")
else:
    print("Bad")

Verdicts: Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S = list(input())

for i in range(3):
    if S[i] == S[i+1]:
        print('bad')
        break
    if i == 2:
        print('good')


S = list(input())

for i in range(3):
    if S[i] == S[i+1]:
        print('Bad')
        break
    if i == 2:
        print('Good')


Verdicts: Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
N, L = (int(i) for i in input().split())
C = 0
S = 0

if L > 0:
	for i in range(N):
		if i > 0:
			S += L + i
elif L+N-1 < 0:
	for i in range(N):
		if i < N-1:
			S += L + i
else:
	for i in range(N):
		S += L + i

print(S)



S = input()
C = 0
for i in range(3):
	if S[i] == S[i+1]:
		C = 1

if C == 1:
	print('Bad')
else:
	print('Good')

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
import fractions

a,b,c,d = map(int,input().split())
lcm = c * d // fractions.gcd(c , d) 

if a % c == 0:
    c_start = int(a/c)
else:
    c_start = int(a/c)+1

if a % d == 0:
    d_start = int(a/d)
else:
    d_start = int(a/d)+1

if a % lcm == 0:
        lcm_start = int(a/lcm)
else:
        lcm_start = int(a/lcm)+1

c_end = int(b/c)
d_end = int(b/d)
lcm_end = int(b/lcm)

c_num = c_end - c_start + 1
d_num = d_end - d_start + 1
lcm_num=lcm_end - lcm_start + 1

print(b - a + 1 - c_num - d_num + lcm_num)


s = list(str(input()))
ans = 0

for ii in range(len(s)-1):
    if s[ii] == s[ii+1]:
        ans = 1

if ans == 1:
    print("Bad")
else:
    print("Good")


Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
S = input()
judge = 0

for i in range(4):
  if S[i] == S[i+1]:
    judge += 1
    
if judge == 0:
  print('Good')
else:
  print('Bad')


S = input()
judge = 0

for i in range(3):
  if S[i] == S[i+1]:
    judge += 1
    
if judge == 0:
  print('Good')
else:
  print('Bad')


Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
a = input()

if a[0]==a[1] or a[1]==a[2] or a[2]==a[3]:
  print('Good') 
else:
  print('Bad')


a = input()
 
if a[0]==a[1] or a[1]==a[2] or a[2]==a[3]:
  print('Bad') 
else:
  print('Good')

Verdicts: Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
a,b,c,d = map(int,input().split())

if a == b:
    print("Bad")
elif b == c:
    print("Bad")
elif c == d:
    print("Bad")
else:
    print("Good")

S = input()
list1 = list(map(int,S))

a = list1[0]
b = list1[1]
c = list1[2]
d = list1[3]

if a == b:
    print("Bad")
elif b == c:
    print("Bad")
elif c == d:
    print("Bad")
else:
   print("Good")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
A=list(map(int,input()))
if (str(A[0])+str(A[1]))==(str(A[2])+str(A[3])):
    print("Yes")
else:
    print("No")

A=list(map(int,input()))
if A[0]!=A[1] and A[1]!=A[2] and A[2]!=A[3]:
    print("Good")
else:
    print("Bad")

Verdicts: Wrong Answer

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
a,b,c,d = list(map(int,input().split()))
cou = 0
if a is b:
  cou = cou + 1
elif b is c:
   cou = cou + 1
elif c is d:
   cou = cou + 1
else:
  print("Good")
if cou > 0:
  print("Bad")


a,b,c,d = list(map(int,input().split()))
cou = 0
if a is b:
  cou +=1
elif b is c:
  cou +=1
elif c is d:
  cou +=1
else:
  print("Good")
if cou > 0:
  print("Bad")


a = int(input())
b = a//1000
c = (a//100)%10
d = (a//10)%10
e = a%10
cou = 0
if b is c:
  cou = cou + 1
elif c is d:
   cou = cou + 1
elif d is e:
   cou = cou + 1
else:
  print("Good")
if cou > 0:
  print("Bad")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
a=int(input())
if a[0]==a[1] or a[1]==a[2] or a[2]==a[3]:
    print('Bad')
else:
    print('Good')

a=input()
if a[0]==a[1] or a[1]==a[2] or a[2]==a[3]:
    print('Bad')
else:
    print('Good')

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
a,b,c,d = map(int,input().split())
count = 0
e = b - a
for i in range(a,d):
    if(i % c != 0 and i % d != 0):
        count += 1
for i in range(d,b + 1):
    if(i % c != 0 and i % d != 0):
        count += 1 
print(count)

s = int(input())
n = []
f = 0

while s > 0:
    n.append(s % 10)
    s = s // 10

n.reverse()
if(len(n) < 3):
    f = 1

for i in range(1,len(n)):
    if(n[i] == n[i -1]):
        f = 1
        break

if(f == 1):
    print('Bad')
else:
    print('Good')

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
var input=GET(require("fs").readFileSync("/dev/stdin","utf8"));
var str = input();
if(str[0] == str[1] || str[1]==str[2] || str[2]==str[3])console.log("Bad");
else console.log("Good")

s = input()
if s[0] != s[1] and s[1] != s[2] and s[2]!=s[3]:
    print("Good")
else:
    print("Bad")

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the same.  You are given the current security code S. If S is hard to enter, print `Bad`; otherwise, print `Good`.

Submission attempts (in order):
n=list(map(int,input()))
for i in (range(3)):
    if n[i]==n[i+1]:
        count+=1
if count>=1:
    print("Bad")
else:
    print("Good")

s=input()
if s[0]==s[1] or s[1]==s[2] or s[2]==s[3]:
    print("Bad")
else:
    print("Good")

Verdicts: Runtime Error

Accepted