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

s = input()

print("Bad" if any(s[i]==s[i+1] for i in range(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):
s = str(input())
number_list = []
count = 0
for number in s:
    number_list.append(number)
for i in range(3):
    if number_list[i] == number_list[i+1]:
        count += 1
    else:
        pass
if count == 0:
    print('Bad')
else:
    print('Good')


s = str(input())
number_list = []
count = 0
for number in s:
    number_list.append(number)
for i in range(3):
    if number_list[i] == number_list[i+1]:
        count += 1
    else:
        pass
if count == 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):

def gcdm(g,l):
    while(l):
        g,l=l,g%l
    return g
def mota(l,r,a):
    if r<a:
        total=0
    else:
        
        if l<a:
            first=a
        elif l>=a:
            if l%a==0:
                first=l
            else:
                first=(l//a + 1)*a
        #print(a,first)
        last=r-r%a
    
        total=((last-first)//a)+1
    return total
a,b,c,d=list(map(int,input().split()))
p=[c,d]
p.sort()
c,d=p[0],p[1]
total1=mota(a,b,c)

#print(total1)
total2=mota(a,b,d)
#print(total2)
h=(c*d)//gcdm(c,d)
total3=mota(a,b,h)
#print(h)
#print(total3)
print(b-a+1-(total1+total2-total3))
    


    


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

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

a = int(s[0])
for i in range(1,len(s)) :
    if (a == int(s[i])):
        print("Bad")
        exit()
    a = s[i]
print("Good")

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

def is_s_safe(n):
    for i in range (0,2):
        if s[i]==s[i+1]:
            return ("Bad")

        else:
            return ("Good")
is_s_safe(s)

x=input()
def goodorbad(n):
    for i in range (0,3):
        if n[i]==n[i+1]:
            return "Good"
    return "Bad"
goodorbad(x)

s=str(input())

def is_s_safe(n):
    for i in range (0,2):
        if s[i]==s[i+1]:
            return "Bad"
    return "Good"
is_s_safe(s)


x=input()
def goodorbad(n):
    for i in range (0,3):
        if n[i]==n[i+1]:
            return "Good\n"
    return "Bad\n"
goodorbad(x)


x=input()
def goodorbad(n):
    for i in range (0,3):
        if n[i]==n[i+1]:
            return "Good"
    return "Bad"
goodorbad(x)


import numpy as np
N=int(input())
a=[]
b=[]
xa=[]
xb=[]
y=[]
for i in range (0,N):
    c,d=(int(x) for x in input().split(" "))
    xa.append(c)
    xb.append(d)
     
z=np.argsort(xb)

for i in range (0,N):
    a.append(xa[z[i]])
    b.append(xb[z[i]])
for i in range (0,N):
    if i==0:
      	y.append(a[0])
    else:
      	y.append(a[i]+y[i-1])
def check(i,a,b):
    if b[i]>=y[i]:
        return True
    else:
        return False
def final_check(a,b,N):
    for i in range (0,N):
        if check(i,a,b)==False:
            return "No"
    return "Yes"
print (final_check(a,b,N))


s=str(input())

def is_s_safe(n):
    for i in range (0,3):
        if s[i]==s[i+1]:
            return "Bad"
    return "Good"
print (is_s_safe(s))


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

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

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

t=input()
print("Bad") if (t[0]==t[1])or(t[1]==t[2])or(t[2]==t[3]) 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):
A, B, C, D = map(int, input().split())
p = 0
cntC = int(B / C) - int(A / C)
cntD = int(B / D) - int(A / D)


def gcd(C, D):
    while D:
        C, D = D, C % D
    return C


def lcm(C, D):
    return C * D // gcd (C, D)


CD = lcm(C, D)

cntCD = int(B / CD) - int(A / CD)

# print(cntC, cntD, cntCD, CD)
calc = (B-A+1) - (cntC + cntD - cntCD)

if (A % C) == 0 and (B % D) == 0:
        calc -= 1

print(calc)

S = list((input()))
fl = True

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

if fl == 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):
a = input()
ok = 1
for i in range(1, 4):
	if a[i] == a[i - 1]:
      ok = 0
if ok:
  print("Good")
else:
	print("Bad")

a = input()
ok = 1
for i in range(1, 4):
    if a[i] == a[i - 1]:
        ok = 0
if ok:
    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()
if N[0]==N[1] or N[1]==N[2] or N[2]==N[3] :
    print("Good")
else:
    print("Bad")

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

print("Bad" if [sum([x[i]==x[i+1] for i in range(len(x)-1)]) for x in [str(input())]]!=[0] 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):
s=input()
length=len(s)
flag=True
for i in range(length-1):
  if s[i]==s[i+1]:
    flag=False
    break
if flag:
  print("Yes")
else:
  print("No")

s=input()
length=len(s)
flag=True
for i in range(length-1):
  if s[i]==s[i+1]:
    flag=False
    break
if flag:
  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=input()

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

s=input()

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

a=int(input())
b=int(input())
c=int(input())
d=int(input())

S=[a,b,c,d]
if num=(a=b,b=c,c=d):
    print('Bad')
else:
    print('Good')

s=input()

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


s=input()

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


ｓ=input()

if s[0] == s[1]:
    print('Bad')
if s[1] == s[2]:
    print('Bad')    
if 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

Wrong Answer

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 = int(input())
A = [None for _ in range(N)]
B = [None for _ in range(N)]
endflg = [0 for _ in range(N)]
for i in range(N):
  A[i],B[i] = map(int,input().split())
time = 0

limit = max(B) + 1

for i in range(N):
  Pb = B.index(min(B))
  if time + A[Pb] <= B[Pb]:
    endflg[Pb] = 1
    B[Pb] = limit
    time = time + A[Pb]
  else:
    break
    
if endflg == [1 for _ in range(N)]:
  print("Yes")
else:
  print("No")
  

def GCD(a,b):
  if a<b:
    tmp = a
    a = b
    b = tmp
 
  r = a % b
  while (r!=0): 
    a = b
    b = r
    r = a % b
  return b


A,B,C,D = map(int,input().split())
A = A - 1
upperC = int(B // C)
upperD = int(B // D)
lowerC = int(A // C)
lowerD = int(A // D)

numC = upperC - lowerC
numD = upperD - lowerD

gcd = GCD(C,D)

lcm = C * D / gcd
upperL = int(B / lcm)
lowerL = int(A / lcm)
numL = upperL - lowerL

print(str(B - A - (numC + numD - numL)))

S = input()
A = [int(S[0]),int(S[1]),int(S[2]),int(S[3])]

flg = 0
for i in range(len(A) - 1):
  if A[i] == A[i + 1]:
    flg = 1
    break

if flg:
  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 fractions
a, b, c, d = list(map(int, input().split()))
e = c * d // fractions.gcd(c, d)

cko = b//c - (a-1)//c
dko = b//d - (a-1)//d
eko = b//e - (a-1)//e
print(b-a+1-cko-dko+eko)

S = input()
if "11" in S or "22" in S or "33" in S or \
   "44" in S or "55" in S or "66" in S or \
   "77" in S or "88" in S or "99" in S or "00" in S :
    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

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

num_C_baisu = (B//C - math.ceil(A/C)) + 1

num_D_baisu = (B//D - math.ceil(A/D)) + 1

CD = int(C*D/math.gcd(C,D))

num_CD_baisu = (B//CD - math.ceil(A/CD)) + 1

baisu_num = num_C_baisu + num_D_baisu - num_CD_baisu

print(B-A+1-baisu_num)

import math

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

num_C_baisu = B//C - (A-1)//C 

num_D_baisu = B//D - (A-1)//D 

CD = int(C*D/math.gcd(C,D))

num_CD_baisu = B//CD - (A-1)//CD 

baisu_num = num_C_baisu + num_D_baisu - num_CD_baisu

print(B-A+1-baisu_num)

a,b,c,d= list(input())

if a==b:
    print('Bad')
elif b==c:
    print('Bad')
elif c==d:
    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):
s = input()

pre = 'a'

for i in s:
    if pre == i:
        print('Bad')
    pre = i

print('Good')



s = input()

pre = 'a'
dame = 0

for i in s:
    if pre == i:
        dame = 1
    pre = i

if dame == 1:
    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):
import numpy as np

l, n = [i for i in input().split(' ')]

nl = np.array([i for i in range(n)]) + 1
ll = nl + l - 1

mini = ll.index(min(abs(ll)))
lll = ll.pop(mini)

print(sum(lll))

inp = input()
if inp[0] == inp[1]:
   print('Bad')
elif inp[1] == inp[2]:
   print('Bad')
elif inp[2] == inp[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()

t= "Bad";
for i in range(0,len(s)):
    if s.find(s[i],i+1,len(s)-1) == i+1:
        t="Good"
        
print(t)




s = input()
t= "Good"

for i in range(0,len(s)):
    if s.find(s[i],i+1) == i+1:
        t="Bad"
print(t)
   


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:
		a, b = b, a % b
	return a
def baisu(x,a):
    if x%a ==0:
        return int(x//a)
    else:
        x -=1
        return baisu(x,a)

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

to_a = a - baisu(a,c) - baisu(a,d) + baisu(a,c*d/gcd(c,d))
to_b = b - baisu(b,c) - baisu(b,d) + baisu(b,c*d/gcd(c,d))


print(int(to_b-to_a+1))


def gcd(a, b):
	while b:
		a, b = b, a % b
	return a
def baisu(x,a):
    return int(x//a)
a,b,c,d = map(int,input().split())

to_a = a - baisu(a,c) - baisu(a,d) + baisu(a,c*d/gcd(c,d))
to_b = b - baisu(b,c) - baisu(b,d) + baisu(b,c*d/gcd(c,d))


if a%c == 0 or a%d == 0:
    print(int(to_b - to_a))
else:
    print(int(to_b-to_a+1))

def gcd(a, b):
	while b:
		a, b = b, a % b
	return a
def baisu(x,a):
    return int(x//a)
a,b,c,d = map(int,input().split())

to_a = a - baisu(a,c) - baisu(a,d) + baisu(a,c*d/gcd(c,d))
to_b = b - baisu(b,c) - baisu(b,d) + baisu(b,c*d/gcd(c,d))



if a%c == 0 or a%d == 0:
    print(int(to_b - to_a))
else:
    print(int(to_b-to_a+1))


s = input()
count= 0

for i in range(3):
    if s[i] == s[i+1]:
        count += 1
    else:
        pass
if count>0:
    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):
S = list(input())

out = "Good"

for i in range(0,4):
  if S[i] == S[i+1]:
    out = "Bad"
    
print(out)


  


S = list(input())

out = Good

for i in range(0,4):
  if S[i] == S[i+1]:
    out = "Bad"
    
print(out)


  

S = list(input())

out = "Good"

for i in range(0,3):
  if S[i] == S[i+1]:
    out = "Bad"
    
print(out)


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

for i in range(1,4):
  if s[i-1]==s[i]:
    print("Bad")
    exit()
print("Good")
  

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

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

s = B - A + 1

if A % C == 0 or A % D == 0:
    A -= 1

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

E = lcm(C, D)

val1 = A // C
val2 = B // C
val3 = A // D
val4 = B // D
val5 = A // E
val6 = B // E

print(s - (val2 - val1 + val4 - val3 - (val6 - val5)))


import math

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

s = B - A + 1

if A % C == 0 or A % D == 0:
    A -= 1

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

E = lcm(C, D)

val1 = A // C
val2 = B // C
val3 = A // D
val4 = B // D
val5 = A // E
val6 = B // E

print(s - (val2 - val1 + val4 - val3 - (val6 - val5)))


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

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


s = input()

ans = 'Bad' if s[0] == s[1] or s[1] == s[2] or s[2] == s[3] else '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):
num = input()

n='X'
ans='Good'
for i in range(1,4,1):
  if n==num[i]:
    print('Bad')
    break
  else:
    n=num[i]
print(ans)

num = input()
 
n='X'
ans='Good'
for i in range(4):
  if n==num[i]:
    ans='Bad'
    break
  else:
    n=num[i]
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):
x = (input())
flag = 0

for i in (0,4):
    if x[i] == x[i+1]:
        flag += 1
    else :
        flag += 0

if flag == 0:
    print("Good")
else :
    print("Bad")

x = input()
flag = 0

for i in (0,4):
    if x[i] == x[i+1]:
        flag += 1
    else :
        flag += 0

if flag == 0:
    print("Good")
else :
    print("Bad")

x = (input())
int flag = 0

for i in (0,4)
    if x[i] == x[i+1]
        flag += 1
    else 
        flag += 0

if flag == 0
    print('Good')
else print('Bad')

x = input()
flag = 0

for i in range(0,3):
    if x[i] == x[i+1]:
        flag += 1
    else :
        flag += 0

if flag == 0:
    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):
# import math
import fractions


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


def lcm(x, y):
    # DeprecationWarning: fractions.gcd() is deprecated. Use math.gcd() instead.
    return x * y // fractions.gcd(x, y)


a1 = a - 1
div_a = (a1 // c) + (a1 // d) - (a1 // lcm(c, d))
div_b = (b // c) + (b // d) - (b // lcm(c, d))

print((b - a + 1) - (div_b - div_a))


s = input()
msg = "Good"

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

print(msg)


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(map(int, input().split()))

try:
    for i in range(4):
        if S[i] == S[i + 1]:
            print('Bad')
            break
except:
    print('Good')

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

try:
    for i in range(4):
        if S[i] == S[i + 1]:
            print(S[i],S[i + 1])
            print('Bad')
            break
except:
    print('Good')

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

try:
    for i in range(4):
        if S[i] == S[i + 1]:
            print('Bad')
            break
except:
    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()
l = len(s)
ans = 0

for i in range(l):
    for k in range(i,k) :
        if s[i] == s[k]:
            ans += 1

if ans == 0:
    print('Good')
if ans !=0:
    print('Bad')

s = input()
l = len(s)
ans = 0

for i in range(l-1):
    if s[i] == s[i+1]:
        ans +=1

if ans == 0:
    print('Good')
if ans !=0:
    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())
if L >= 0:
  print(int((N-1)/2*(L + L + N)))
else:
  if L + N - 1 >= 0: 
    print(int(N / 2 * (L + L + N - 1)))
  else:
    print(int((N - 1)/ 2 * (L + L + N - 2)))


S=input()
for i in range(3):
  if S[i]==S[i+1]:
    print("Bad")
    exit(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):
#!/usr/bin/python
# -*- Coding: utf-8 -*-
import re

def nchars(s, n):
    assert n > 0
    reg = re.compile("(.)\\1{%d,}" % (n - 1))  
    while True:
        m = reg.search(s)
        if not m:
            break
        yield m.group(0)
        s = s[m.end():]


if __name__ == '__main__':

    a=input()	
    
    if len(list(nchars(a,2))) == 0 :
        print("Good")
    else:
        print("bad")

#!/usr/bin/python
# -*- Coding: utf-8 -*-
import re


a=input()


if len(a) == len(re.sub("([0-9])\\1(?!\\1)", "", a)) and len(a) == 4:

    print("Good")

else:

    print("bad")

#!/usr/bin/python
# -*- Coding: utf-8 -*-
import re
 
if __name__ == '__main__':
 
    a=input()	

    if len(a) == len(re.sub("([0-9])\\1(?!\\1)", "", a)):
        print("Good")
    else:
        print("bad")

#!/usr/bin/python
# -*- Coding: utf-8 -*-
import re


a=input()


if len(a) == len(re.sub("([0-9])\\1(?!\\1)", "", a)) and len(a) == 4:

    print("Good")

else:

    print("Bad")

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 fractions
  
A,B,C,D= map(int,input().split())
 
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
 
CD=lcm(C, D)
 
dc =  B//C -  (A-1)//C
dd = B//D - (A-1)//D
dcd = B//CD - (A-1)//CD
 
print(B-A+1-dc-dd+dcd)

S = input()
dif = False
for i in range(len(S)-1):
    if S[i]==S[i+1]:
        dif=True
if dif:
    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):
from itertools import groupby
import sys
rr = lambda: sys.stdin.readline().rstrip()
s = rr()
print('Good' if len(groupby(s)) == 4 else 'Bad')
















from itertools import groupby
import sys
rr = lambda: sys.stdin.readline().rstrip()

print('Good' if len(list(groupby(rr()))) == 4 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,l = list(map(int,input().split()))

flavor = int(n*(l+(l+n-1))/2)

if (l<0):
  if l>=(-n+1):
  	print(flavor)
  elif l<(-n+1):
    print(flavor-(l+n-1))
    

else:
  print(flavor-l)

import sys
s = str(input())

k = None
for i in s:
  if i==k:
    print("Bad")
    sys.exit()
  k = i

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):
from fractions import gcd
a,b,c,d = map(int,input().split())
l = (c*d) // fractions.gcd(c,d)
 
x = b//c - (a-1)//c
y = b//d - (a-1)//d
z = b//l - (a-1)//l
s = int(x+y-z)
 
print(b-a+1-s)

from fractions import gcd
a,b,c,d = map(int,input().split())
l = (c*d) // gcd(c,d)
 
x = b//c - (a-1)//c
y = b//d - (a-1)//d
z = b//l - (a-1)//l
s = int(x+y-z)
 
print(b-a+1-s)

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

x = b//c - (a-1)//c
y = b//d - (a-1)//d
z = b//l - (a-1)//l

s = (x+y-z)
print(b-a+1-s)

import math
a,b,c,d = map(int,input().split())
l = (c*d) // math.gcd(c,d)

x = b//c - (a-1)//c
y = b//d - (a-1)//d
z = b//l - (a-1)//l

s = (x+y-z)
print(b-a+1-s)

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

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

S=input()
for i in range(len(S)-1):
    if S[i]==S[i+1]:
        print('Bad')
        exit()
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):
a= list(map(int,input().split()))
flg=0
for i in range(len(a)-1):
    if(a[i]==a[i+1]):
        flg =1
        break
if(flg==1):
    print("Bad")
elif(flg==0):
    print("Good")



a= list(input())
flg=0
for i in range(len(a)-1):
    if(a[i]==a[i+1]):
        flg =1
        break
if(flg==1):
    print("Bad")
elif(flg==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):
s = input()
print(s)

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

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

n = int(input())
flag = 0
for i in range(len(n)-1):
  if n[i] == n[i+1]:
    flag = 1

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

n = input()
flag = 0
for i in range(len(n)-1):
    if n[i] == n[i+1]:
        flag = 1

if flag == 1:
    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):
s = list(input())

for i in range(len(s)):
    if s.count(s[i]) == 1:
        print("Good")
        quit()
print("Bad")

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

s = list(input())
 
if s[0] == s[1] or s[1] == s[2] or s[2] == s[3]:
        print("Bad")
        quit()
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 = str(input())
l = list(S)
s = int(len(S))

num = 0
for i in range(s):
    for j in range(i+1, s):
        if l[i] == l[j]:
            num += 1
        else:
            num += 0

if num == 0:
    print("Yes")
else:
    print("No")

import sys
S = int(input())
l = list(S)
s = int(len(S))

num = 0
for i in range(s):
    if l[i] == l[i+1]:
        print("Bad")
        sys.exit()
    else:
        num += 1
        if num == 3:
            print("Yes")

S = str(input())
l = list(S)
s = int(len(S))

num = 0
for i in range(s):
    if l[i] == l[i+1]:
        num += 1
    else:
        num += 0

if num == 0:
    print("Good")
else:
    print("Bad")

S = str(input())
l = list(S)
s = int(len(S))

num = 0
for i in range(s):
    if l[i] == l[i+1]:
        num += 1
    else:
        num += 0

if num == 0:
    print("Yes")
else:
    print("No")

S = str(input())
l = list(S)

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


S = str(input())
l = list(S)

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

Verdicts: Wrong Answer

Runtime Error

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

print(res)

s = input()
res = "Good"
for i in range(1,len(s),1):
    if s[i-1] == s[i]:
        res = "BAD"
print(res)

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

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):
def gcd(a, b):
  while b:
    a, b = b, a % b
  return a

a, b, c, d = map(int, input().split())
num = 0
cd = c*d/(gcd(c,d))
s = b - a + 1
s_c = int(s/c)
s_d = int(s/d)
s_cd = int(s/cd)
if(a%c >= b%c):
  num = num + 1
if(a%d >= b%d):
  num = num + 1
if(a%cd >= b%cd):
  num = num - 1
print(s -(s_c + s_d - s_cd) - num)

abcd = int(input())
d = abcd % 10
c = int(((abcd - d) % 100)/10)
b = (abcd - c*10 - d)%1000
a = int(abcd / 1000)

s = "Good"
if(a == b){
  s = "Bad"
}
if(b = c){
  s = "Bad"
}
if(c == d){
  s = "Bad"
}

print(s)

abcd = int(input())
d = int(abcd % 10)
c = int(((abcd - d) % 100)/10)
b = int((abcd - c*10 - d)%1000/100)
a = int(abcd / 1000)

if(a == b):
  print("Bad")
elif(b == c):
  print("Bad")
elif(c == d):
  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):
inp = map(int, input().split())
inp = inp.list()
hard = 0
for number in range(0, 3) :
  if inp[number] == inp[number + 1] :
    print ("Bad")
    hard = 1
    
if hard == 0 :
  print ("Good")

inp = map(int, input().split())
inp = list(inp)
hard = 0
for number in range(0, 3) :
  if inp[number] == inp[number + 1] :
    hard = 1
    
if hard == 0 :
  print ("Good")
else :
  print ("Bad)


inp = list(input())
hard = 0
for number in range(0, 3) :
  if inp[number] == inp[number + 1] :
    hard = 1
    
if hard == 0 :
  print ("Good")
else :
  print ("Bad)

inp = input()
inp = list(inp)
hard = 0
for number in range(0, 3) :
  if inp[number] == inp[number + 1] :
    hard = 1
    
if hard == 0 :
  print ("Good")
else :
  print ("Bad)

inp = map(int, input().split())
inp = list(inp)
hard = 0
for number in range(0, 2) :
  if inp[number] == inp[number + 1] :
    hard = 1
    
if hard == 0 :
  print ("Good")
else :
  print ("Bad)

inp = list(input())
hard = 0
for number in range(0, 3) :
  if inp[number] == inp[number + 1] :
    hard = 1
    
if hard == 0 :
  print("Good")
else :
  print("Bad")

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, L= map(int, input().split())
if L<0 and L+N-1>0:
    print(int((2*L+N-1)*N/2))
elif L>0:
    print(int((2*L+N)*(N-1)/2))
else:
    print(int((2*L+N-2)*(N-1)/2))

N, L= map(int, input().split())
if L<0 and L+N-1>0:
    print(int((2*L+N-1)*N/2))
elif L>0:
    print(int((2*L+N)*(N-1)/2))
else:
    print(int((2*L+N-2)*(N-1)/2))

a = map(int,input())
b=a%10
c=(a-b)/10
judg="Good"
for i in range(4):
    if b==c%10:
        judg="Bad"
    else:
        b=c%10
        c=(c-b)/10
print(judg)

a = map(int,input().split())
b=a%10
c=(a-b)/10
judg="Good"
for i in range(4):
    if b==c%10:
        judg="Bad"
    else:
        b=c%10
        c=(c-b)/10
print(judg)

a=int(input())
b=a%10
c=(a-b)/10
judg="Good"
for i in range(3):
    if b==c%10:
        judg="Bad"
    else:
        b=c%10
        c=(c-b)/10
print(judg)

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 = [int(e) for e in input().split()]

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

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=list(map(int, input()))
ans="Good"
for i in range(len(s)):
  if i == 0:
    continue
  if s[i] == s[i-1]:
    ans = "Bad"

s=list(map(int, input()))
ans="Good"
for i in range(len(s)):
  if i == 0:
    continue
  if s[i] == s[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):
s=input()
if s[0]==s[1] or s[1]==s[2] or s[2]==s[3]:
  print('Yes')
else:
  print('No')

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(int(input()))
if s[0] != s[1] and s[1] != s[2] and s[2] != s[3]:
     print('Good')
else:
     print('Bad')

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())
S = 0
b = abs(L)
for i in range(1,N+1):
  a = L + i - 1
  S += a
  b = min(abs(a),b)
if -N < L:
  ans = S - b
else:
  ans = S + b
print(ans)

A,B,C,D = map(int,input().split())
X = max(C,D)
Y = min(C,D)
def gcd(a,b):
  while b!= 0:
    a,b = b,a%b
  return a
l = C*D/ gcd(X,Y)
def f(x):
  return x - (x//C + x//D - x//l)
ans = f(B) - f(A-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

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[0]!=a[1]&a[1]!=a[2]&a[2]!=a[3] else print("Bad")

s=input()
for i in range(1,4):
  if s[i]==s[i-1]:
    print("Bad")
    return
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

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')
        break
    else:
        print('Good')
        break

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

s=input()
n=0
for i in range(4):
    if s[i-1]==s[i]:
        n+=1
    break
if n>0:
    print('Bad')
else:
    print('Good')

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

s=list(input())+['']
n=0
for i in range(4):
    if s[i]==s[i+1]:
        n+=1
    else:
        n+=0
if n>0
    print('Bad')
else:
    print('Good')

s=input()+['']
n=0
for i in range(4):
    if s[i]==s[i+1]:
        n+=1
    else:
        n+=0
if n>0
    print('Bad')
else:
    print('Good')

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

s=input()
n=0
for i in range(4):
    if s[i]==s[i+1]:
        n+=1
    else:
        n+=0
if n>0
    print('Bad')
else:
    print('Good')

s = list(input())
temp = s[0]
flag = 0
for i in range(1,4):
    if s[i] == temp:
        flag = 1
        break
    else:
        temp = s[i]
print('Bad' if flag == 1 else 'Good')

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Runtime Error

Runtime Error

Runtime Error

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

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

S = int(input())

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

if result == 0:
    print("Good")
else:
    print("Bad")
 

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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted