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):
output = []
 
for (i, x) in enumerate(S):
    if i == 0:
        pre = x
    else:
        if pre == x:
            output = "Bad"
        pre = x
            
if len(output) > 0:
    print(output)
else:
    output = "Good"
    print(output)

output = []

for (i, x) in enumerate(S):
    if i == 0:
        pre = x
    else:
        if pre == x:
            output = "Bad"
        pre = x
            
if output == "Bad":
    print(output)
else:
    output == "Good"
    print(output)

output = []
 
for (i, x) in enumerate(S):
    if i == 0:
        pre = x
    else:
        if pre == x:
            output = "Bad"
        pre = x
            
if len(output) > 0:
    print(output)
else:
    output = "Good"
    print(output)

output = []
 
for (i, x) in enumerate(S):
    if i == 0:
        pre = x
    else:
        if pre == x:
            output = "Bad"
            print(output)
        pre = x
            
if len(output) > 0:
    print(output)
else:
    output = "Good"
    print(output)

message = []

for (i, x) in enumerate(S):
    if i == 0:
        pre = 0
        pre = x
    else:
        if pre == x:
            message = "Bad"
        pre = x
            
if message == "Bad":
    print(message)
else:
    print("Good")

output = []
 
for (i, x) in enumerate(input()):
    if i == 0:
        pre = x
    else:
        if pre == x:
            output = "Bad"
        pre = x
            
if len(output) > 0:
    print(output)
else:
    output = "Good"
    print(output)

Verdicts: 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):
n=str(input())
print("Good" if all([n[j]!=n[j+1] for i in range(3)]) else "Bad")

n=str(input())
print("Good" if all([n[i]!=n[i+1] for i in range(3)]) else "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 = input()

form=""
for s in N:
    if form == s:
        print("Bad")
        break
    else:
        pass
    form = s
print("Good")


import sys
N = input()

form=""
for s in N:
    if form == s:
        print("Bad")
        sys.exit()
    else:
        pass
    form = s
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=str(input () )
B=0
while B ==!2:
if A[B] == A[B+1]:
    print ('Bad')
    B += 1 
    break  
    print('Good')

n, L = map(int, input().split())
N = 0
G = 999
for i in range(1, n+1):
    N += (i + L - 1)
NN = N
for i in range(1, n+1):
    DD = NN - (L + i - 1)
    if abs(NN-DD)< G :
        G = abs(NN-DD)
        ZZ = DD
print(ZZ)

A=str(input () )
B=0
while B =!2:
if A[B] == A[B+1]:
    print ('Bad')
    B += 1 
    break  
    print('Good')


A=input ()
B=0
while B =!2:
if A[B] == A[B+1]:
    print ('Bad')
    break
else:
    B +=1
else:
    print('Good')


n,L = map(int,input().split())
N=0
G=0
for i in range(1,n):
    N +=(i+L-1)
NN = N
for i in range(1,n):
        DD = NN - (L+i-1)
        if DD>G :
            G = DD
print(G)
    

A=str(input () )
B=0
while B!=3:
    if A[B]==A[B+1]:
        print('Bad')
        break
    else:    
        B=B+1
else:
    print('Good')    

Verdicts: 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):
#ABCA - Security
a = int(input())
s = list(a)
count = 0
for i in range(3):
    if s[i] != s[i+1]:
        count += 1
if count == 3:
    print("Good")
else:
    print("Bad")

#ABCA - Security
a = str(input())
s = list(a)
count = 0
for i in range(3):
    if s[i] != s[i+1]:
        count += 1
if count == 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 = str(int(input("４桁の数字を入力してください。＞＞＞")))
cnt = 0
for i in range(1, 4):
    cnt+=1
    if S[i] == S[i-1]:
        print('Bad')
        break
    elif cnt == 3:
        print('Good')

S = str(int(input("４桁の数字を入力してください。＞＞＞")))
cnt = 0
for i in range(1, 4):
    cnt+=1
    if S[i] == S[i-1]:
        print('Bad')
        break
    elif cnt == 3:
        print('Good')

S = str(input())
cnt = 0
for i in range(1, 4):
    cnt+=1
    if S[i] == S[i-1]:
        print('Bad')
        break
    elif cnt == 3:
        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):
s = input()
if s[0] == s[1] or s[1]==s[2] or s[2]==s[3]:
  print('Good')
else:
  print('Bad')

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

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 = str(input())
ans=0
for i in range(0,2):
  if S[i]==S[i+1]:
    ans = 1
    exit()
  else:
    pass
if ans == 1:
  print('Bad')
else:
  print('Good')


S = str(input())
for i in range(0,2):
  if S[i]==S[i+1]:
    print('Good')
    break
  else:
    print('Bad')


S = str(input())
ans=0
for i in range(0,2):
  if S[i]==S[i+1]:
    ans = 1
    exit()
  else:
    pass
if ans==1:
  print('Bad')
else:
  print('Good')

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


S = str(input())
for i in range(len(S)):
  if S[i]==S[i+1]:
    print('Good')
    break
  else:
    print('Bad')


S = str(input())
for i in len(S):
  if S[i]==S[i+1]:
    print('Good')
    break
  else:
    print('Bad')

S = str(input())
for i in range(0,2):
  if S[i]==S[i+1]:
    print('Good')
    exit()
  else:
    pass
print('Bad')


S = str(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

Wrong Answer

Wrong Answer

Runtime Error

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):
import fractions
a, b, c, d = map(int, input().split())
ans = 0
nc = 1
nc2 = 0
nd = 1
nd2 = 0 
ndc = 1
ndc2 = 0
while b >= c*nc:
  nc2 += 1
  nc += 1
while b >= d*nd:
  nd += 1
  nd2 += 1
cd = c*d//fractions.gcd(c,d)
while b >= cd*ndc:
  ndc += 1
  ndc2 += 1
nc2 -= a//c
nd2 -= a//d
ndc2 -= a//(cd)
ans = b-a+1-nc2-nd2+ndc2
print(ans)

s = list(str(input()))
for i in range(3):
  if s[i] == s[i+1]:
    print("Bad")
    quit()
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] 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):
import fractions as frac
a,b,c,d = map(int,input().split())


lcm = (c * d) // frac.gcd(c,d)
if a % lcm != 0:
    s = lcm - a % lcm
else:
    s = 0
e = b % lcm
m = ((b - e) - (a + s)) // lcm
modgcd = (b - a + 1) - (s + (lcm - 1) * m + e)

if a % c != 0:
    s = c - a % c
else:
    s = 0
e = b % c
m = ((b - e) - (a + s)) // c
modc = (b - a + 1)- (s + (c - 1) * m + e)

if a % d != 0:
    s = d - a % d
else:
    s = 0
e = b % d
m = ((b - e) - (a + s)) // d
modd = (b - a + 1) - (s + (d - 1) * m + e)

print((b - a + 1)-(modc + modd - modgcd))


s=input()

for i in range(3):
    if s[i] in s[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):
S = input()
ans = 0
for i in range(3):
  if S[i] != S[i+1]:
    ans = 1
print('Good' if ans == 1 else 'Bad')

S = input()
ans = 0
for i in range(3):
  if S[i] == S[i+1]:
    ans = 1
if ans == 0:
  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=int(input())

a=s//1000
b=s//100 - a*10
c=s//10-a*100-b*10
d=s%10

print(a,b,c,d)

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


s=int(input())

a=s//1000
b=s//100 - a*10
c=s//10-a*100-b*10
d=s%10



if a==b or b==c or c==d :
    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)
  break
elif S[1] == S[2]:
  print(Bad)
  break
elif S[2] == S[3]:
  print(Bad)
  break
else:
  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)
  
  

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 = 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 =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

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):
pc = list(map(int, input().split("")))

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

pc = input()

if pc[0] != pc[1] and pc[1] != pc[2] and pc[2] != pc[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):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
##############################
from fractions import gcd


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


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

A -= 1


nb = B - B//C - B//D + B//lcm(C, D)
na = A - A//C - A//D + A//lcm(C, D)

print(nb - na)



n, l = map(int, input().split())


tastes = []
for i in range(n):
    tastes += [l+i]


if 0 in tastes:
    print(sum(tastes))
else:
    
    tastes.sort(key=abs)
    print(sum(tastes[1:]))

S = input()

for i in range(len(S)-1):
    if S[i] == S[i+1]:
        print('Bad')
        exit()

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):
a,b,c,d=map(int,input().split())
ans=0
for a in range(b):
  if a%c!=0 or a%d!=0:
    ans+=1
print(ans)
  

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):
import numpy as np


def taste(N, L):
    all_abs = np.array([np.abs(L + i - 1) for i in range(1, N + 1)])
    all_base = np.array([L + i - 1 for i in range(1, N + 1)])

    return all_abs, all_base

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

all_abs, all_base = taste(N, L)

N_1_all = all_base[np.min(all_abs) != all_abs]

re = np.sum(N_1_all)
print(re)


s = input()

state = "Good"
for i in range(3):
    if s[i] == s[i + 1]:
        state = "Bad"
        print(state)
        break
if  state == "Good":
    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(0,len(s)-1):
  if s[i]==s[i+1]:print('Bad')
else:print('Good')

s=input()
for i in range(0,len(s)-1):
  if s[i]==s[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

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()
print("Good" if any([s[i]!=s[i+1] for i in range(len(s)-1)]) else "Bad")

s=input()
print("Bad" if any([s[i]==s[i+1] for i in range(len(s)-1)]) else "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):
try:
s = input()
if s[0] == s[1] or s[1] == s[2] or s[2] == s[3]:
    print('Bad')
else:
    print('Good')
except EOFError:
    pass


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

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):
y = input()
a =  [int(a) for a in list(str(y))]
if a[0] == a[1] or a[1] == a[2] or a[2] == a[3]:
    print ('bad')
else:
    print('good')


y = input()
a =  [int(a) for a in list(str(y))]
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):
s=list(str(input()))
count=0
for i in range(3):
  if s[i]==s[i+1]:
    count+=1

if count==0:
  print('Good')
  else:
    print('Bad')    

s=list(str(input()))
count=0
for i in range(3):
  if s[i]==s[i+1]:
    count+=1

if count==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):
password = input().split()
pw = set(password)
if len(password) != len(pw):
  print("Bad")
  break
print("Good")


password = list(input())
pw = set(password)
if len(pw) != 4:
  print("Bad")
  break
print("Good")


password = set(input().split())
if len(password) != 4:
  print("Bad")
  break
print("Good")


password = list(input())
for i in range(len(password)):
  for j in range(i+1, len(password)):
    if password[i] == password[j]:
      print("Bad")
      break
print("Good")

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

n = int(input())
new = set(n)
if len(new) != 4:
  print("Bad")
else:
  print("Good")

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


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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Wrong Answer

Runtime Error

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):
l = ['%d%d'%(i, i) for i in range(10)]
S = input()
if S.count(l) > 0:
    print('Bad')
else:
    print('Good')

l = ['%d%d'%(i, i) for i in range(10)]
S = input()
if sum([S.count(i) for i in l]) > 0:
    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] or s[1] == s[2] or s[2] == s[3]:
  print(Bad)
else:
  print(Good)
  
  

s = input()
for i in range(len(s))[1:]:
  if s[i] == s[i-1]:
    print(Bad)
    break:
print(Good)
  

s = input()
bad = False
for i in range(len(s))[1:]:
  if s[i] == s[i-1]:
    bad = True
    break:

if bad:
  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

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 = range(1, 8 + 1)
    b = range(1, 8 + 1)
    c = range(1, 8 + 1)
    d = range(1, 8 + 1)

    if a == b or b == c or c == d:
        return ('Bad')
    else:
        return ('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):
a,b,c,d = input()

aa = int(a)
bb = int(b)
cc = int(c)
dd = int(d)
 
if aa==bb:
    print("bad")
elif bb==cc:
    print("bad")
elif cc==dd:
    print("bad")
else:
    print("good")
  

a,b,c,d = input()

aa = int(a)
bb = int(b)
cc = int(c)
dd = int(d)
 
if aa==bb:
  print("bad")
elif bb==cc:
  print("bad")
elif cc==dd:
  print("bad")
else:
  print("good")
  


a,b,c,d = input()
pass = [int(a),int(b),int(c),int(d)]

if pass[0]==pass[1] or pass[1]==pass[2] or pass[2]==pass[3]:
    print("bad")

else:
    print("good")

a,b,c,d = input()

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

Verdicts: Wrong Answer

Wrong Answer

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] or s[1] == s[2] or s[2] == s[3]):
  print('Good')
else:
  print('Bad')

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 = input()
for i in range(len(s) -1):
  if s[i] == s[i + 1]:
    print('Bad')
print('Good')


s = input()
for i in range(len(s) -1):
  if s[i] == s[i + 1]:
    print('Bad')
    exit(0);
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):
pas=list(input())
if pas[0]==pas[1] or pas[1]==pas[2] or pas[2]==pas[3]:
    print('bad')
else:
    print('good')

pas=list(input())
if pas[0]==pas[1] or pas[1]==pas[2] or pas[2]==pas[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 = int(input())
print("Bad" if a[0] == a[1] or a[1] == a[2] or a[2] == a[3] else "Good")

a = input()
print("Bad" if a[0] == a[1] or a[1] == a[2] or a[2] == a[3] 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):
import fractions
a,b,c,d=map(int,input().split())

cc=b//c-(a-1)//c
dd=b//d-(a-1)//d
s=b//(c*d//fractions.gcd(c,d))-(a-1)//(c*d//fractions.gcd(c,d))


print((b-(a-1)-(cc+dd-s)))

a=list(input())

ans=0
for i in range(int(len(a))-1):
    if a[i]==a[i+1]:
        ans+=1
    else:
        ans+=0

if ans==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,b,c,d = map(int,input().split())
total_num = b-a+1
# # of x%c==0
c_num = b//c - (a-1)//c
d_num = b//d - (a-1)//d
from fractions import gcd
lcm = c*d/gcd(c,d)
cd_num = b//lcm - (a-1)//lcm
print(total_num-c_num-d_num+cd_num)


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

n = b-a-1
n_c = n//c
n_d = n//d
n_gap = n//(c*d)

print(n-n_c-n_d+n_gap+1)

s = list(map(int, input().split()))
for i in range(1,4):
  if s[i]==s[i-1]:
    print('Bad')
    exit()
print('Yes')

s = list(input())
if s[0]==s[1] or s[1]==s[2] or s[2]==s[3]:
  print('Bad')
  exit()
print('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):
x=input()
ans="Good"
for i in range(0,3):
        if x[i]==x[i+1]:
                ans="Bad"
        print(x[i],x[i+1])
print(ans)

x=input()
ans="Good"
for i in range(0,3):
        if x[i]==x[i+1]:
                ans="Bad"
    
print(ans)

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):
# coding: utf-8
# Your code here!

s = input()

t = ""
f = True

for i in s:
    if t == i:
        f = False
        break
    t = i

print("Good" if t else "Bad")

# coding: utf-8
# Your code here!

s = input()

t = ""
f = True

for i in s:
    if t == i:
        f = False
        break
    t = i

print("Good" if f else "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):
x = input().rstrip().split("")
count = 0
temp = ""
how = True
for i in x:
  if temp == i:
    how=False
  temp = i

if how:
  print("Good")
else:
  print("Bad")
  

x = input().rstrip()
count = 0
temp = ""
how = True
for i in x:
  if temp == i:
    how=False
  temp = i

if how:
  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 = input()
p = N[0]
for n in range(1,4):
  if p==N[n]:
    print('Bad')
    break
  p = N[n]
  print(n,p)
else:
  print('Good')


N = list(input())
p = N[0]
for n in N[1:]:
  if p==n:
    print('Bad')
    break
  p = n
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):
c = input()
num = list(c)

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

c = input()
num = list(c)

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

c = input()
num = list(c)

if num[0] == num[1]:
    print('Bad')
elif num[1] == num[2]:
    print('Bad')
elif num[2] == num[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=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: 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())
s_o = 10
flag = "ok"
for i in range(s):
    if s_o == i:
        flag = "ng"
    s_o = i
if flag == "ng":
    print("Bad")
else:
    print("Good")


s = input()
s_o = 10
flag = "ok"
for i in s:
    if s_o == i:
        flag = "ng"
    s_o = i
if flag == "ng":
    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):
def gcd(a,b):
    while b!=0:
        a,b=b,a%b
    return a

 
def lcm(a,b):
    return a*b/gcd(a,b)
  
A,B,C,D=map(int,input().split())

if A%C == 0:
    AC = int(A/C) - 1
else:
    AC = int(A/C)
if A%D == 0:
    AD = int(A/D) - 1
else:
    AD = int(A/D)
    
lcmCD = lcm(C,D)
if A%(lcmCD) == 0:
    ACD = int(A/(lcmCD)) - 1
else:
    ACD = int(A/(lcmCD))
    
print((B - A + 1) - (int(B/C) - AC + int(B/D) - AD - int(B/(lcmCD) + ACD)))

a = input()
lena = len(a)
bad = False
aft = 0

for i in a:
    bef = i
    if bef==aft:
        bad = True
        break
    else:
        aft=bef
if bad==True:
    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):
password = list(input())
for i in range(3):
    if password[i] == password[i+1]:
        print("Bad")
        break
    else:
        print("Good")
        break

password = list(input())
for i in range(4):
    if password[i] == password[i+1]:
        print("Bad")
        break
    else:
        print("Good")
        break

password = list(input())
for i in range(3):
    if password[i] == password[i+1]:
        print("Bad")
        break
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):
code = input()
previous = 'a'
for c in code:
    if previous == c:
        print('bad')
        break
    previous = c


code = input()
previous = 'a'
for c in code:
  if perivioud == c:
    print('bad')
    break

code = input()
previous = 'a'
for c in code:
    if previous == c:
        print('Bad')
        break
    previous = c
print('Good')


code = input()
previous = 'a'
ch = True
for c in code:
    if previous == c:
        print('Bad')
        ch = False
        break
    previous = c
if ch:
    print('Good')


Verdicts: Wrong Answer

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):
for i in range(len(l)):
    if l[i]==l[i+1]:
        print('Bad')
        break
else:
    print('Good')

l=input()
for i in range(len(l)-1):
    if l[i]==l[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):
def solve():
    s = input()
    for i in range(3):
        print(s[i],s[i+1])
        if s[i]==s[i+1]:
            return 'Bad'
    else:
        return 'Good'

if __name__ == '__main__':
    print(solve())

s = input()
for i in range(3):
    if s[i]==s[i+1]:
        print('Bad')
        break
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):
# ABC 131
S=str(input())
if ("11"or"22"or"33"or"44"or"55"or"66"or"77"or"88"or"99"or"00") in S:
    print("Bad")
else:
    print("Good")

# ABC 131
S=str(input())
for i in range(1,len(S)):
    if S[i]==S[i-1]:
        ans ="Bad"
        break
    else:
        ans ="Good"
print(ans)

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):
def security(s):

    return "Good" if s[0] != s[1] and s[1] != s[2] and s[2] != s[3] else "Bad"
def main():
    s = list(int(input()))
    print(security(s))

if __name__ == '__main__':
    main()


def security(s):

    return "Good" if s[0] != s[1] and s[1] != s[2] and s[2] != s[3] else "Bad"
def main():
    s = list(str(input()))
    print(security(s))

if __name__ == '__main__':
    main()


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):
input_line = input()
last_c = ''
bad = False
for i in range(len(input_line)):
  c = input_line[i]
  if last_c == c:
    print('Bad')
    bad = true
    break
if not bad:
  print('Good')
  

input_line = input()
last_c = ''
bad = False
for i in range(len(input_line)):
  c = input_line[i]
  if last_c == c:
    print('Bad')
    bad = True
    break
  last_c = c
if not bad:
  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()

S = list(map(S.split()))

flg = 0
temp = 0

for i in range(len(S)-1):
    if S[i] == S[i+1]:
        print(Bad)
        flg = 1
        break

if flg == 0:
    print(Good)


S = input()

flg = 0
temp = 0

for i in range(len(S)-1):
    if S[i] == S[i+1]:
        print("Bad")
        flg = 1
        break

if flg == 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):
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i=0;i<(int)(n);i++)
#define all(x)    (x).begin(),(x).end()
typedef long long ll;
const int MOD = (int)1e9 + 7;

int main(){
  string p;
  cin >> p;
  flag = !((p[0] == p[1])||(p[1]==p[2])||p[2]==p[3]);
  if(flag){
  cout << "No" << endl;
  }
  else{
  cout << "Yes" <<endl;
  } 
}



s = input()

flag = True
for i in range(N-1):
  if s[i] == s[i+1]:
    print("Bad")
	flag = False

if flag:
  	print("Good")

s = input()

flag = True
for i in range(len(s)-1):
  if s[i] == s[i+1]:
    print("Bad")
	flag = False

if flag:
  	print("Good")


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

apple = list(range(L,L+N))

s = sum(apple)

m = 1000000000000000000
for x in apple:
  if abs(m) > abs(x):
    m = x

print(s-m)

s = input()

flag = True
for i in range(len(s)-1):
  if s[i] == s[i+1]:
    print("Bad")
    flag = False
    break
if flag:
  print("Good")

Verdicts: 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 = input()

ans = 'Nad'
for i in range(len(s)-1):
    if s[i] == s[i+1]:
        ans = 'Good'
        break
print(ans)


s = input()

ans = 'Bad'
for i in range(len(s)-1):
    if s[i] == s[i+1]:
        ans = 'Good'
        break
print(ans)


s = input()

ans = 'Good'
for i in range(len(s)-1):
    if s[i] == s[i+1]:
        ans = 'Bad'
        break
print(ans)


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()
for i in range(3):
  if s[i] == s[i+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: 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 = map(int,input())

for i in range(4) :
	if S[i-1] == S[i] :
		print('Bad')
	break :
	else: 
		print('Good')

S = map(int,input())

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

S = map(int,input())

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

S = map(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

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):
input=list(input())
if int(input[0])==int(input[1]) or int(input[1])==int(input[2]) or int(input[2])==int(input[3]):
　print("Bad")
else:
 print("Good")

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

input=list(input())


if int(input[0])==int(input[1]) or int(input[1])==int(input[2]) or int(input[2])==int(input[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):
import asyncio
a, b, c, d = map(int, input().split())
loop = asyncio.get_event_loop()
i = c if c < d else d
num = 0
global num
loop_was_not_running = not loop.is_running()
async def y(q):
  if q % c and q % d:
    num += 1
    
def print_hello_world(future):
  if loop_was_not_running:
    loop.stop()

li = [y(o) for o in range(a, b)]
future = asyncio.gather(*li)
asyncio.ensure_future(future)
future.add_done_callback(print_hello_world)
    if loop_was_not_running:
        loop.run_forever()
print(num)


s = input()
for k in ["11", "22", "33", "44", "55", "66", "77", "88", "99", "00"]:
  if k in s:
    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):
n=imput()
if n[i]==n[i+1] for i in range(0,3):
    print("Bad")
else:
    print("Good")


n=input()
if any(n[i]==n[i+1] for i in range(0,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()
n=''
result='Good'
for i in s:
    if s==i:
        result='Bad'
        break
    n=i
print(result)

s=input()
n=''
result='Good'
for i in s:
    if s==n:
        result='Bad'
        break
    n=i
print(result)

s=input()
for i in range(3):
    if s[i]==s[i+1]:
        print('Bad')
        break
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):
N, L=map(int, input().split())
if L>0:
    A=(N-1)*L+N*(N-1)/2
elif N+L<=0:
    A=(N-1)*L+(N-1)*(N-2)/2
else:
    A=(L*2+N-1)*N/2
print(int(A))

S=int(input())
a=int(S/1000)
b=int((S-a*1000)/100)
c=int((S-a*1000-b*100)/10)
d=int(S-a*1000-b*100-c*10)
if a==b or b==c or 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):
S = input()
if S[0] == S[1] or S[1] == S[2] or S[2] == S[3]:
    print("Good")
else:
    print('Bad')

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

Accepted