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):
n=int(input())
a=int(n/1000)
an=n-a*1000
b=int(an/100)
bn=an-b*100
c=int(bn/10)
d=bn-c*10

if(a==b or b==c or c==d):
    print("bad")
else:
    print("good")

n=int(input())
a=int(n/1000)
an=n-a*1000
b=int(an/100)
bn=an-b*100
c=int(bn/10)
d=bn-c*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 = list(input())

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

s = list(input())

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

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

apples = [l+i for i in range(n)] 
ans = sum(apples) - apples[apples.index(min(apples, key=abs))] の合計ーりんごの味の絶対値の最小
print(ans)


s = input()
ans = 0
for i in range(3):
    if s[i] == s[i + 1]:
        ans = 1
        break

print('Good' if ans == 0 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):
def check_key(S, key_length):
    for i,k in enumerate(S):
        if k == S[i+1]:
            return 'bad'
        if i == key_length - 1:
            return 'Good'
        else:
            continue
S = "3776"
key_length = len(S)
print(check_key(S, key_length))


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

def check_key(S, key_length):
    for i,k in enumerate(S):
        if k == S[i+1]:
            return 'bad'
        if i == key_length - 1:
            return 'Good'
        else:
            continue
S = input()
key_length = len(S)
print(check_key(S, key_length))


a,b,c,d = [int(s) for s in input()]
print('Bad') if a == b or b == c or c == d 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):
i = input()

for j in range(i-1):
  if(j==j+1):
    print("Bad")
    break
  else(j==(len(i)-2)):
    print("Good")

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

S=input()
p = 'a'
for s in S:
  if p == s:
    p = 'a'
    break
  else:
    p = s
print("Bad" if p == 'a' 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()
for i in range(2):
  if a[i]==a[i+1]:
    print("Bad")
    return
print("Good")

import math
def lcm(x,y):
  return x*y/math.gcd(x,y)
def numantidiv(a,b,c):
    r=a-math.floor(a/b)-math.floor(a/c)+math.floor(a/lcm(b,c))
    return r

a,b,c,d=(int(x) for x in input().split())
ans=numantidiv(b,c,d)-numantidiv(a-1,c,d)
print(ans)

import math
def lcm(x,y):
  return x*y/math.gcd(x,y)
def numantidiv(a,b,c):
    r=a-math.floor(a/b)-math.floor(a/c)+math.floor(a/lcm(b,c))
    return r
a,b,c,d=(int(x) for x in input().split())
ans=numantidiv(b,c,d)-numantidiv(a-1,c,d)
print(ans)

S=input()
for i in range(3):
  if S[i]==S[i+1]:
    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):
S1,S2,S3,S4=list(map(int,input().split()))

if S1 == S2 or S2 == S3 or S3 == S4:
    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=str(input())
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):
N = int(input())
if (N % 100) % 11 == 0:
    print("Bad")
elif (N - (N % 10)) / 10 % 11 == 0:
    print("Bad")
elif (N - (N % 100)) / 100 % 11 == 0:
    print("Bad")
else:
    print("Good")


N = int(input())
N += 10000
if (N % 100) % 11 == 0:
    print("Bad")
elif (N - (N % 10)) / 10 % 11 == 0:
    print("Bad")
elif (N - (N % 100)) / 100 % 11 == 0:
    print("Bad")
else:
    print("Good")


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

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):
#!/usr/bin/env python3
#import math
import fractions

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

if __name__ == '__main__':
    a, b, c, d = list(map(int, input().split()))
    bc = b // c
    bd = b // d
    ac = (a - 1) // c
    ad = (a - 1) // d
    l = lcm(c, d)

    ans = (b - (bc + bd)) - ((a - 1) - (ac + ad)) + b // l
    print(ans)
    

#!/usr/bin/env python3

if __name__ == '__main__':
    s = input()
    f = True
    for c in range(1, len(s)):
        if s[c-1] == s[c]:
            f = False

    if f:
        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):
# _*_ coding: utf-8 _*_ 
S = input()
if S[0] == S[1] or S[1] == S[2] or S[2] == S[3] :
    print('Bat')

else:
    print('Good')

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

print(out)

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(i) for i in input().split()]
if s[1]==s[2] or s[2]==s[3] or s[3]==s[4]:
    print("Bad")
else:
    print("Good")

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

Verdicts: Runtime Error

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

Submission attempts (in order):
S=int(input())
n=1
while n>0.01:
    if int(S/1000*n)==int(S/100*n)-10*int(S/1000*n):
        print("Bad")
        break
    else:
        n=n/10
else:
    print("Good")

S=int(input())
n=1
while n>0.001:
    if int(S/1000*n)==int(S-1000*n)/(100*n):
        print("Bad")
        break
    else:
        n=n/10
else:
    print("Good")

S=int(input())
n=1
while n>0.001:
    if int(S/1000*n)==int(S-1000*n)/(100*n):
        print("Bad")
        break
    else:
        n=n/10
else:
    print("Good")

S=int(input())
n=1
while n>0.001:
    if S//(1000*n)==(S-(1000*n)*(S//(1000*n)))//(100*n):
        print("Bad")
        break
    else:
        S=S-(1000*n)*(S//(1000*n))
        n=n/10
else:
    print("Good")

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

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

Submission attempts (in order):
def hasSequenceElement(password):
  password = str(password)
  length = len(password)
  for i in range(length - 1):
    if password[i] == password[i + 1]:
      return True
  return False
    
password = 5456

if hasSequenceElement(password):
  print('Bad')
else:
  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):
def gcd(x,y):
  if y == 0:
    return x
  else:
    return gcd(y,x%y)
a,b,c,d = map(int, input().split())
p = b//c + (-a//c) +1
q = b//d + (-a//d) +1
r = b*gcd(c,d)//(c*d) + (-a*gcd(c,d)//(c*d)) +1
print(b-a+1-p-q+r)

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

Verdicts: Runtime Error

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

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

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

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

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 = [x for x in input()]
ans = 'Good'
for i in range(3):
  if s[i] == s[i+1]:
    ans = 'Bat'
    break
print(ans)



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



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



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



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):
s=input()
f=-1
print(s)
b=' '
l=len(s)
if l==4:
	f=0
	for i in range(l):
		if(s[i]<'0' or s[i]>'9'):
			f=-1
			break;
		elif(s[i]==b):
			f=1
			break;
		else:
			b=s[i]
if(f==-1):
	print('Illegal')
elif(f==1):
	print('Bad')
else:
	print('Good')

s=input()
f=-1
b=' '
l=len(s)
if l==4:
	f=0
	for i in range(l):
		if(s[i]<'0' or s[i]>'9'):
			f=-1
			break;
		elif(s[i]==b):
			f=1
			break;
		else:
			b=s[i]
if(f==-1):
	print('Illegal')
elif(f==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):
S=input()
a = [int(c) for c in s]

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

S=input()
a = [int(c) for c in S]

if (a[0]-a[1]) * (a[1]-a[2]) * (a[2] - a[3]) ==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):
N,L=map(int, input().split())  

aji=0
eat=99999

for i in range(1,N+1):
    aji=aji+i+L-1
    if abs(aji) < abs(eat):
        eat = aji
        
print(aji)

S=input()

hantei="Good"

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

Verdicts: Runtime Error

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

Submission attempts (in order):
S = int(input())
for i in range(1, 4):
  if A[i] == A[i-1]:
    print("Bad")
    exit()
print("Good")

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

Verdicts: Runtime Error

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

Submission attempts (in order):
import sys
s = input()
pre = ''
for i in s:
  if pre == i:
    print('Bad')
    sys.exit()
print('Good')

import sys
s = input()
pre = ''
for i in s:
  if pre == i:
    print('Bad')
    sys.exit()
  pre = i
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]||S[1]==S[2]||S[2]==S[3]||S[3]==S[4]:
  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")


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

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())
 
sum = 0
lower = 100
for i in range(1, N+1):
    sum = sum + L + i -1
for i in range(1, N+1):
    s = abs(L + i -1)
    if s < lower:
        lower = s
        ij = i
 
print(sum - (L + ij -1))

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

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

Verdicts: Runtime Error

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

Submission attempts (in order):
S=input()
f=False
for i in range(len(S)-1):
    if S[i]==S[i+1]:
        f=True
        break
if f:
    print("Good")
else:
    print("Bad")

S=input()

f=False
for i in range(len(S)-1):
    if S[i]==S[i+1]:
        f=True
        break
if f:
    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 math
a,b,c,d = map(int, input().split())


first = [c,d%c]
first.sort()
if d%c==0:
  cd = c
elif first[0]==1:
  cd = 1
else:
  while first[0]>=2:
    first[1] = first[1]%first[0]
    first.sort()
    if first[0]==0:
      cd = first[1]
    elif first[0]==1:
      cd = 1
lcm = c*d/cd
      
zen = b-a+1
c_num = (b//c) -math.ceil(a/c)+1
d_num = (b//d) -math.ceil(a/d)+1
lcm_num = (b//lcm) - math.ceil(a/lcm)+1
ans = zen - c_num - d_num + lcm_num
print(ans)

s = input()
s_list = [i for i in s]
flag = True
for i in range(1,4):
  if s_list[i]==s_list[i-1]:
    print('Bad')
    flag = False
    break

if flag:
  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")

s = input()
flag = True
for i in range(3):
    if s[i] == s[i + 1]:
        flag = False

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

ans = 'Good'

while i-1 < range(s):
  if s[i] == s[i+1]:
    ans = 'Bad'
    print(ans)
    break
  elif :
    i += 1
    
print(ans)
  	

s=list(input())

ans = 'Good'
i = 0

while i+1 < len(s):
  if s[i] == s[i+1]:
    ans = 'Bad'
    break
  else:
    i += 1

print(ans)

Verdicts: Runtime Error

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

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

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

Verdicts: Runtime Error

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

Submission attempts (in order):
S = input()
num = S[0]
flag = 0
for i in range(1,len(S)):
  if num==S[i]:
    print("Bad")
    flag=1
    break
if flag==0:
  print("Good")

S = input()
num = S[0]
flag = 0
for i in range(1,len(S)):
  if num==S[i]:
      print("Bad")
      flag=1
      break
  else:
      num=S[i]
if flag==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):
A =input()
print('Bad' if A[0] == A[1] | A[1] == A[2] | A[2] == A[3] | A[3] == A[4]  else 'Good')


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

S=list(input())
c=0
for i in range(3):
    if S[i]==S[i+1]:
        c+=1
print('Bad' if c>0 else '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()
flag = 'Yes'
for i in range(len(s)-1):
  if s[i] == s[i+1]:
    flag = 'No'
print(flag)


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

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())
prev = S[0]
ans = True
for s in range(1, 4):
    if s == prev:
        ans = False
    prev = s
print("Good" if ans else "Bad")


S = list(input())
prev = S[0]
ans = True
for i in range(1, 4):
    if S[i] == prev:
        ans = False
    prev = S[i]
print("Good" if ans 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):
s = list(str(input()))

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


s = list(str(input()))

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


s = list(str(input()))

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


s = list(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

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

p=list(input())
f=0
for i in range(len(p)-1):
  if p[i]==p[i+1]:
    f+=1
    break
if f>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()
flag = False
for i in range(3):
  if List[i] == List[i+1]:
    flag = True
if flag:
  print("Bad")
else:
  print("Good")
  

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

Verdicts: Runtime Error

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

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

i = b//c- (a-1)//c
j = b//d- (a-1)//d

f=fractions.gcd(c,d)
f2= c * d / f
k = b//f2 - (a-1)//f2

pot = i + j - k

print(b-(a-1)-pot)

s=input()
result = True

for i in range(3):
    if s[i]==s[i+1]:
        result = False
if result:
    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):
def judge(S):
	S_list  = list(str(S))  
	
	i_pure = None
	for i in S_list:
		if i == i_pure:
			return 'Bad'
		i_pure = i

	return 'Good'


# S = ['3776','8080','1333','0024']

S = stdin.readline()
# for s in S:
# 	print(judge(s))

print(judge(S))

import re


def judge(S):
	S_list  = list(str(S))  
	
	i_pure = None
	for i in S_list:
		if i == i_pure:
			return 'Bad'
		i_pure = i

	return 'Good'


S = ['3776','8080','1333','0024']
for s in S:
	print(judge(s))

import re


def judge(S):
	S_list  = list(str(S))  
	
	i_pure = None
	for i in S_list:
		if i == i_pure:
			return 'Bad'
		i_pure = i

	return 'Good'


# S = ['3776','8080','1333','0024']

S = input('input:')
# for s in S:
# 	print(judge(s))

print(judge(S))

from sys import stdin

def judge(S):
	S_list  = list(str(S))  
	
	i_pure = None
	for i in S_list:
		if i == i_pure:
			return 'Bad'
		i_pure = i

	return 'Good'


# S = ['3776','8080','1333','0024']

S = stdin.readline()
# for s in S:
# 	print(judge(s))

print(judge(S))

Verdicts: Runtime Error

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

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


a=list(input())
b=[]
for i in range(3):
  if a[i]==a[i+1]:
      b.append(0)
  else:
      b.append(1)
if b in 0:
    print('Bad')
else:
    print('Good')




a=list(input())
if a[0]==a[1] or a[1]==a[2] or a[2]==a[3]:
  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()
ans=0
for i in range(0,3):
  if s[i]=s[i+1]:
    ans+=1
  else:
    ans+=0

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

s=input()
ans=0
for i in range(0,len(s)-1):
  if s[i]=s[i+1]:
    ans+=1
  else:
    ans+=0

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

s=input()
ans=0
for i in range(0,3):
  if s[i]==s[i+1]:
    ans+=1
  else:
    ans+=0

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


Verdicts: Runtime Error

Runtime Error

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

Submission attempts (in order):
s = list(map(int,input().split()))
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):
a=list(input())
for i in range(len(a)-1):
	if a[i]==a[i+1]:
		print("Good")
	else:print("Bad")

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


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

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

S = input()

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

import sys
import fractions as fl

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


all = b - a + 1

e = c * d // fl.gcd(c, d)

r1 = (a-1) // c + (a-1) // d - (a-1) // e

r2 = b // c + b // d - b // e
ans = all - (r2 - r1)
print(ans)

def security(input):
    input = list(input)
    for i in range(len(input)-1):
        if input[i] == input[i+1]:
            result = "Bad"
            break
        else:
            result = "Good"
    return result

import sys

S = input()

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

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):
n=int(input())
a=[]
b=[]
gap=0
e=0
f=0
m=0
for i in range(n):
    c,d=map(int,input().split())
    a.append(c)
    b.append(d)
while (gap<=n/9):
    gap=gap*3+1
while (gap>0):
    for i in range(gap,n):
        key=b[i]
        l=a[i]
        if(key<b[i-gap]):
            j=i
            while True:
                b[j]=b[j-gap]
                a[j]=a[j-gap]
                j-=gap
                if(j<gap or key>=b[j-gap]):
                    break
            b[j]=key
            a[j]=l
        gap=int((gap-1)/3)
for i in range(n):
    e+=a[i]
    if(e>b[i]):
        m=1
if(m==1):
    print('No')
else:
    print('Yes')


s=str(input())
c=0
for i in range(3):
  if(s[i]==s[i+1]):
    c=1
    break
if(c==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):
import sys
n = int(input())
ab = [list(map(int, input().split())) for i in range(n)]

ab.sort(key=lambda x: x[1])
now = 0 
for i in range(n):
    now = now + ab[i][0]
    if now > ab[i][1]:
        print('No')
        sys.exit()

print('Yes')


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):
def saidaikouyaku(a, b):
    if b > a:
        a, b = b, a

    while b != 0:
        a, b=b,(a%b)
    return a

A, B, C, D = map(int, input().split())
hani = B - A + 1
Cnum = int(B / C) - int((A - 1) / C)
Dnum = int(B / D) - int((A - 1) / D)
saisyoukoubai = int(C * D / saidaikouyaku(C, D))
koubainum = int(B / saisyoukoubai) - int((A - 1) / saisyoukoubai)
#print(hani)

print(hani - Cnum - Dnum + koubainum)


S = int(input())

a = S % 10
b = int((S % 100) / 10)
c = int(S % 1000 / 100)
d = int(S / 1000)

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

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

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

Verdicts: Runtime Error

Wrong Answer

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

Submission attempts (in order):
S=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")


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, b, c,d = map(int, input().split())
import math
min = c*d/math.gcd(c,d)
def num(x):
    return x-x//c - x//d + x//min
print(int(num(b)-num(a-1)))

s = str(input())

if s[0]==s[1] or s[1]==s[2] or s[3]==s[2]:
    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 fractions import gcd

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


def cnt_div(a, b, x):
    q, r = divmod(a, x)

    if r == 0:
        m = q - 1
    else:
        m = q

    n = b // x

    return n - m


num_c = cnt_div(a, b, c)
num_d = cnt_div(a, b, d)
lcm = int((c * d) / gcd(c, d))
num_c_d_gcd = cnt_div(a, b, lcm)

print((b - a + 1) - (num_c + num_d - num_c_d_gcd))


S = input()

l = len(S)

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

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 math import ceil,floor
from fractions import gcd

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

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

ans = B-A+1
ans -= (B//C - ceil(A/C) + 1)
ans -= (B//D - ceil(A/D) + 1)
ans += (B//lcm(C,D) - ceil(A/lcm(C,D)) + 1)

print(ans)

S = input()

def main():
    for i in range(1,len(S)):
        if S[i] == S[i-1]:
            return "Bad"
    return "Good"

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

S = list(input())
for i in range(len(S)-1):
  if int(S[i])-int(S[i+1]) == 0:
    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):
a,b,c,d=map(int,input().split())
import fractions
import math
nc=math.floor(b/c)-math.ceil(a/c)+1
nd=math.floor(b/d)-math.ceil(a/d)+1
min=c*d/fractions.gcd(c,d)
ncd=math.floor(b/min)-math.ceil(a/min)+1
print(b-a+1-(nc+nd-ncd))

a,b,c,d=map(int,input().split())
import math
import fractions
nc=math.floor((b-a)/c)
nd=math.floor((b-a)/d)
lcd=c*d//fractions.gcd(c,d)
ncd=math.floor((b-a)/lcd)
sum=nc+nd-ncd
print(b-a-sum)

a=input()
cnt=0
for i in range(3):
    if a[i]==a[i+1]:
        cnt+=1
print("Good" if cnt==0 else "Bad")


Verdicts: Runtime Error

Runtime Error

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

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

if S[0] != S[1] and S[1] != S[2] and S[2] != S[3]:
  print("good")
else:
  print("sad")

s = input()

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

S = input()

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

S = input()

if S[0] != S[1] and S[1] != S[2] and S[2] != S[3]:
  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):
S = list(input())
if S[0]==S[1]orS[1]==S[2]orS[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()


for i in range(len(S)):
    A=S[i:i+1]
    print(A)

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



S=input("input 4 num")

for i in range(len(S)):
    A=S[i:i+1]
    print(A)

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

S=int(input())


for i in range(len(S)):
    A=S[i:i+1]
    print(A)

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

for i in range(len(S)):
    A=S[i:i+1]
    print(A)

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

S=int(input())


for i in range(len(S)):
    A=S[i:i+1]
    print(A)

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


S=input()

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

Verdicts: Wrong Answer

Wrong Answer

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

for i, s in enumerate(code):
  if i != 0:
  	if s == pre:
      print("Bad")
      exit()
  pre = s
  
print("Good")


code = str(input())

for i, s in enumerate(code):
    if i != 0:
        if s == pre:
            print("Bad")
            exit()
    pre = s

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 = input()
s = set()
for c in n:
  s.add(c)
if s.len() == 4:
  print("Good")
else:
  print("Bad")

n = input()
s = set()
for c in n:
  s.push(c)
if s.len() == 4:
  print("Good")
else:
  print("Bad")

n = input()
for i in range(0, 3):
  if n[i] == n[i+1]:
    print("Bad")
    exit(0)
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 = str(input()).split()
ans = 'Good'
for i in range(3):
  if S[i] == S[i+1]:
    ans = 'Bad'
Print(ans)
  


S = str(input())
ans = 'Good'
for i in range(2):
  if S[i] == S[i+1]:
    ans = 'Bad'
Print(ans)

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

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

Verdicts: Runtime Error

Runtime Error

Wrong Answer

Accepted