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

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

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

s = input()
l = list(s)
flag = 0
for i in range(0,len(l)-1):
	if l[i+1]==l[i]:
		flag=1
		break
if flag==1:
	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())
S1 = sorted(S)

if S1[0] == S1[1] and S1[2] == S1[3] and S1[1] != S[2]:
  print("Yes")
else:
  print("No")


S = list(input())

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

Verdicts: Wrong Answer

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

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

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

import fractions
a,b,c,d=map(int,input().split())
print(b-a+1-(b//c-(a-1)//c+b//d-(a-1)//d-b//(c*d/fractions.gcd(c,d))+(a-1)//(c*d/fractions.gcd(c,d))))


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


Verdicts: Runtime Error

Runtime Error

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

Submission attempts (in order):
a, b, c, d = map(int, input().split())
m=0
for i in range(a,b+1):
    if (i%c == 0 or i%d == 0):
        continue
    m += 1
print(m)

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

S = input()

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

import sys

S = input()

for i in range(3):
  if S[i] == S[i+1]:
    print("Bad")
    sys.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 math


def solve():
    a, b, c, d = map(int, input().split())
    lcm = c * d // math.gcd(c, d)
    num_b = b - b // c - b // d + b // lcm
    num_a = a - 1 - (a - 1) // c - (a - 1) // d + (a - 1) // lcm
    return num_b - num_a


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


def solve():
    s = input()
    return "Bad" if any([s[i] == s[i + 1] for i in range(len(s) - 1)]) else "Good"


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


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(3):
  f=f and S[i]==S[i+1]
if f:
  print("Bad")
else:
  print("Good")

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

Verdicts: Wrong Answer

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

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

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

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

Verdicts: Runtime Error

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

Submission attempts (in order):
s = int(input())
if s[0] == s[1] 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):
# -*- coding:utf8 -*-

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

# -*- coding:utf8 -*-

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

Verdicts: Runtime Error

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

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

S = list( input() )
dif = [ int( S[1]-S[0] ), int( S[2]-S[1] ), int( S[3]-S[2] ) ]
if 0 in dif: 
   print( "Good" )
else : 
   print( "Bad" )

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

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

S = list( input() )
new = [ S[1]-S[0], S[2]-S[1], S[3]-S[2] ]
if 0 in new : 
   print( "Good" )
else : 
   print( "Bad" )

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

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

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

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

n=100
check=0

for i in S:
    if i==n:
        check=0
    
    n=i

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

S = input()

n=100
check=0

for i in S:
    if i==n:
        check=1
    
    n=i

if check==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=str(input())
a=int(0)
for i in range(0,2):
    if S[i]==S[i+1]:
        break
        print('bad')
    else:
        continue
else:
    print('good')

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

l = list(S)

print(l)

f = False

for i, s in enumerate(l):
    if s == l[i-1]:
        f = True
        break

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

S = input()

l = list(S)

f = False

for i in range(1, len(l)):
    if l[i] == l[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):
pi=""
j="Good"
for i in input():
  if pi == i:
    j="Bad"
print(j)

pi=""
j="Good"
for i in input():
  if pi == i:
    j="Bad"
  pi=i
print(j)

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

#14:18
S = input()
for i in range(3):
    if S[i] == S[i+1]:
        print("Bad")
        exit()
print("Good")


Verdicts: Wrong Answer

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

Submission attempts (in order):
s = int(input())
if a[0] == s[1] or s[1] == s[2] or s[2] == s[3] or s[3] == s[4]:
    print('Bad')
else:
    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):
import io
import math
# libraries

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

if m<=0<=m+n-1:
  print(sum(range(m,m+n)))

  elif m<0:
  print(sum(range(m,m+n-1)))

  else:
  print(sum(range(m+1,m+n)))

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):
n = list(input());

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

n = list(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):
s=input()

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

s=input()

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

Verdicts: Wrong Answer

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

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

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):
s = input('Security Code: ')

flg = False
for i in range(3):
  flg = flg or (int(s[i:i+2]) % 11) == 0

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

num = input()

if num[0] == num[1] or num[1] == num[2] or num[2] == num[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())
one_aji = 0
aji = []
answer = []
for i in range(N):
    one_aji = L+i
    if one_aji < 0:
        answer.append(one_aji)
        one_aji *= -1
        aji.append(one_aji)
    else:
        aji.append(one_aji)
        answer.append(one_aji)
zettai = 500
ind = 0
for i, a in enumerate(aji):
    a = int(a)
    if a < zettai:
        zettai = a
        ind = i
         
answer.pop(ind)
print(sum(answer))


S = input()
# = map(int,input().split())
ans = ''
for s in S:
    if s == ans:
        print('Bad')
        exit()
    else:
        ans = 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):
import fractions

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

A -= 1

lcm = (C * D) // fractions.gcd(C, D)

excluded = A - (A // C + A // D - A // lcm)
num = B - (B // C + B // D - B // lcm)

print(num - excluded)

S = input()

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


Verdicts: Runtime Error

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

Submission attempts (in order):
S = input()
for c in S:
    if 1 < S.count(c):
        print('Bad')
        exit
print('Good')

import sys
S = input()
for i in range(len(S)-1):
    if S[i] == S[i+1]:
        print('Bad')
        sys.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 = list(map(int, input().split()))
if s[0] != s[1] and s[1] != s[2] and s[2] != s[3]:
    print('Good')
else:
    print('Bad')


s = list(map(int, input().split()))
if s[0] != s[1] != 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

Runtime Error

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

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

for i in range(3):
    if str(a)[i] == str(a)[i+1]:
        print(i)
        print("Good")
        break
    elif i == 2:
        print("Bad")

a = input()

isGood = False

if a[0] == a[1]: isGood = True
elif a[1] == a[2]: isGood = True
elif a[2] == a[3]: isGood = True

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

x = input()
def samenum(string):
  for i in range(3):
    if string[i] == string[i+1]:
        return "Bad"
        quit()
  return "Good"
 
print(samenum(x))

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 = int(input())
xy = [0] * n
for i in range(n):
    xy[i] = tuple([int(j) for j in input().split()])
loop = True
cnt = 0
while loop:
    xy_num = len(xy)
    for i in xy:
        a, b = i
        for j in xy:
            if j[0] == a and j[1] != b:
                d = j[1]
                for k in xy:
                    if k[1] == b and k[0] != a:
                        c = k[0]
                        if (c, d) not in xy:
                            xy.append((c, d))
                            cnt += 1
                    if k[1] == d and k[0] != a:
                        c = k[0]
                        if (c, b) not in xy:
                            xy.append((c, b))
                            cnt += 1
            if j[1] == b:
                c = j[0]
                for k in xy:
                    if k[0] == c and k[1] != b:
                        d = k[1]
                        if (a, d) not in xy:
                            xy.append((a, d))
                            cnt += 1
    if len(xy) == xy_num:
        loop = False
print(cnt)


s = input()
b = ''
for i in s:
  if i == b:
    print('Bad')
    exit()
  b = 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):
n=int(input())
a=n//1000
b=(n//100)%10
c=(n//10)%10
d=n%10

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

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

n=int(input())
a=n//1000
b=(n//100)%10
c=(n//10)%10
d=n%10
 
if a==b:
  print(Bad)
elif b==c:
  print(Bad)
elif c==d:
  print(Bad)
else:
  print(Good)

n=int(input())
a=n//1000
b=(n//100)%10
c=(n//10)%10
d=n%10
 
if a==b:
  print('Bad')
elif b==c:
  print('Bad')
elif c==d:
  print('Bad')
else:
  print('Good')

Verdicts: Runtime Error

Runtime Error

Runtime Error

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

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

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

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


import sys
a=list(input())
b=''
c=0
for i in range(4):
  if b=a[i]:
    c+=1
    if c>=2:
      print('Bad')
    else:
      print('Good')
    
  else:
    pass
  c=0
print('Bad')


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


Verdicts: Runtime Error

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()
for c, d in zip(s, s[1:]):
  if c == d:
    print('Bad')
 	break
else:
  print('Good')
 

s = input()
for c, d in zip(s, s[1:]):
  if c == d:
    print('Bad')
    break
else:
  print('Good')


Verdicts: Runtime Error

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

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

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




s = input()

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




Verdicts: Runtime Error

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

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

S=input()
ans='Good'
for i in range(3):
    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()

result='Good'
for i in range(1, len(S)):
    if S[i-1]==S[i]:
        S = 'Bad'
        break
print(result)

S = input()

result='Good'
for i in range(1, len(S)):
    if S[i-1]==S[i]:
        result = 'Bad'
        break
print(result)

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()
answer='GOOD'
for i in range(len(s)-1):
  if s[i]==s[i+1]:
    answer='BAD'
    break
print(answer)

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

Verdicts: Wrong Answer

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

Submission attempts (in order):

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

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


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

if flag==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):
print(['Good', 'Bad'][len(set(input()))==4])

print(["Good", "Bad"][[True] in [[i==j] for i,j in zip(*[[list(s[1:]) if i==0 else list(s[:-1]) for i in range(2)] for s in [input()]][0])]])

Verdicts: Wrong Answer

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

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

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


# -*- coding: utf-8 -*-
S = input()

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


Verdicts: Wrong Answer

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

Submission attempts (in order):
number = input()
s = number[0]

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

number = input()
s = number[0]

for i in range(1,4):
  if s == number[i]:
    print("Bad")
    exit()
  
  s = number[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):
num=input()
c=False
for i in range(1,len(num)+1):
  if num[i]==num[i-1]:
    c=True
    
if c==True:
  print("Bad")
else:
  print("Good")

num=input()
c=False
for i in range(1,len(num)):
  if num[i]==num[i-1]:
    c=True
    
if c==True:
  print("Bad")
else:
  print("Good")

Verdicts: Runtime Error

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

Submission attempts (in order):
s=list(input())
for i in range(0,len(s)-1):
    if s[i]==s[i+1]:
        print('Bad')
        break
print('Good')


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


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


Verdicts: Wrong Answer

Wrong Answer

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

Submission attempts (in order):
S = int(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, l = map(int, input().split())
tastes = range(l, n + l)
ijo = [taste for taste in tastes if taste >= 0]
under = [taste for taste in tastes if taste < 0]
if len(ijo) == 0:
    print(sum(under[:-1]))
elif len(under) == 0:
    print(sum(ijo[1:]))
else:
    print(sum(tastes))


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

if difficult:
    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())
print(S)
c=0
if S[0]==S[1]:
    c=1
if S[1]==S[2]:
    c=1
if S[2]==S[3]:
    c=1
if c==0:
    print('Good')
else:
    print('Bad')


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


Verdicts: Wrong Answer

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

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

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

Verdicts: Runtime Error

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

Submission attempts (in order):
import fractions

A, B, C, D = tuple([int(a) for a in input().split(' ')])


def func1(n):
    return n - n//C - n//D + n//(C*D//fractions.gcd(C, D))


print(func1(B) - func1(A-1))


_input = input()
S = _input

tmp = None
ans = 'Good'
for s in S:
    if s == tmp:
        ans = 'Bad'
        break
    tmp = s

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):
x = input()
x = str(x)
f = True

for i in range(1,3)
	if(x[i-1] == x[i])
  		f = False
    	break
   
if f:
  print("Good")
else:
  print("Bad")

x = input()
x = str(x)
f = True

for i in range(1,4):
  if(x[i-1] == x[i]):
    f = False
    break
   
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):
s = int(input())
for i in range(1, s):
    if s[i] == s[i-1]:
        print ('Bad')
        exit()

print ('Good')


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

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


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

if flg == 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):
S = list(input())

prev = S[0]
ans = 'Good'

print(S)
for i in range(1, len(S)):
  print(i)
  if S[i] == prev:
    ans = 'Bad'
  
  prev = S[i]
  
print(ans)

S = list(input())

prev = S[0]
ans = 'Good'

print(S)
for i in range(1, len(S)):
  if S[i] == prev:
    ans = 'Bad'
  
  prev = S[i]
  
print(ans)

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

prev = S[0]
ans = 'Good'

for i in range(1, len(S)):
  if S[i] == prev:
    ans = 'Bad'
  
  prev = S[i]
  
print(ans)

S = list(input())

prev = S[0]
ans = 'Good'

for i in range(1, len(S)):
  if S[i] == prev:
    ans = 'Bad'
  
  prev = S[i]
  
print(ans)

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):
N = int(input())
arr = [[int(i) for i in input().split()] for j in range(N)]
arr = sorted(arr,key=lambda x:(x[1], x[0]))
i = 0


while i < N-1:
  if (sum(arr[:i+1][0])) > arr[i+1][1]:
    break
  i += 1
    
if i == N-1:
  print("Yes")
else:
  print("No")

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

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

Verdicts: Runtime Error

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

Submission attempts (in order):
s=input()
if s[0]==s[1] or s[1]==s[2] or s[2]=-s[3]:
  print("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 = int(input())

s = list(S)

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


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

s = list(S)

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):
import sys
row = sys.stdin.readline
 
ls = list(row())
s = sum([1 for i in range(1, len(ls) + 1) if ls[i-1] == ls[i]])
print("Good" if s == len(ls) else "Bad")


import sys
row = sys.stdin.readline
 
ls = list(row())
s = sum([1 for i in range(1, len(ls) + 1) if ls[i-1] == ls[i]])
print("Good" if s+1 == len(ls) else "Bad")


import sys
row = sys.stdin.readline
 
ls = list(row())
s = sum([1 for i in range(1, len(ls)) if ls[i-1] != ls[i]])
print("Good" if s+1 == len(ls) 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):

def main():
    s = input()
    cnt = 0
    for i in range(1, len(s)):
        if s[i-1] == s[i]:
            cnt += 1
    if cnt >= 2:
        print('Bad')
    else:
        print('Good')


if __name__ == "__main__":
    main()



def main():
    s = input()
    cnt = 0
    for i in range(1, len(s)):
        if s[i-1] == s[i]:
            cnt += 1
    if cnt >= 1:
        print('Bad')
    else:
        print('Good')


if __name__ == "__main__":
    main()


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

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


Verdicts: Runtime Error

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

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

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

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

ABCD = list(map(int, input().split()))

A = ABCD[0]
B = ABCD[1]
C = ABCD[2]
D = ABCD[3]


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


firstC = int((A-1)/C)
firstD = int((A-1)/D)
firstCD = int((A-1)/lcm(C,D))

# if A%lcm(C,D) ==0 and firstCD > 0:
#     firstCD -= 1

endC = int(B/C)
endD = int(B/D)
endCD = int(B/lcm(C,D))

End = B-endC-firstD + endCD
First = (A-1) - firstC - firstD + firstCD



thereC = endC - firstC
thereD = endD - firstD
thereCD = endCD - firstCD

NoP = thereC+thereD - thereCD

# print(thereC)
# print(thereD)
# print(thereCD)
# print(NoP)
print((B-A+1)-NoP)
# print(End-First)










S = input()

word = "p"
Judge = True

for i in range(len(S)):
    if word == S[i]:
        Judge = False
        break

    word = S[i]

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

Verdicts: Runtime Error

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

Submission attempts (in order):
S = input()
flag = False
for s in S:
  if flag:
    if temp = s:
      print("Bad")
      quit()
  temp = s
  flag = True
print("Good")

S = input()
flag = False
for s in S:
  if flag:
    if temp == s:
      print("Bad")
      quit()
  temp = s
  flag = True
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):
# input
S = input()

fl = True
for i, s in range(0, 4):
    if S[i] == S[i + 1]:
        print("Bad")
        fl = False
        break

if fl is True:
    print("Good")

# input
S = input()

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

if fl is True:
    print("Good")

Verdicts: Runtime Error

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

Submission attempts (in order):
s = input()
if(s[0] == s[1] or s[1] == s[2] || 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()
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("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):
import fractions

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

count = B - A + 1
lcd_of_CD = C * D // math.gcd(C, D)

count -= B // C
count += (A - 1) // C
count -= B // D
count += (A - 1) // D
count += B // lcd_of_CD
count -= (A - 1) // lcd_of_CD

print(count)

import fractions

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

count = B - A + 1
lcd_of_CD = C * D // fractions.gcd(C, D)

count -= B // C
count += (A - 1) // C
count -= B // D
count += (A - 1) // D
count += B // lcd_of_CD
count -= (A - 1) // lcd_of_CD

print(count)

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

def main():
    string = input()
    for i in range(len(string) - 1):
        if string[i] == string[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 = input()

tmp = ""
for val in s:
  if tmp == val:
    print("Bad")
    import sys.exit(0)
  tmp = val

print("Good")

s = input()
 
tmp = ""
for val in s:
  if tmp == val:
    print("Bad")
    import sys
    sys.exit(0)
  tmp = val
 
print("Good")

Verdicts: Runtime Error

Accepted