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

cnt=0
for i in w:
  if w[cnt] == w[cnt+1]:
    print("Bad")
  else:
    print("Good")
  cnt += 1



w=input()

cnt=0
for i in w:
    if cnt+1 < len(w):
        if w[cnt] == w[cnt+1]:
            print("Bad")
            exit()
    cnt += 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):
flag = True
S = input()
for i in range(1,len(S)):
  if S[i] == S[i-1]:
    flag = False

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

flag = True
S = input()
for i in range(1,len(S)):
  if S[i] == S[i-1]:
    flag = False

if flag:
  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):
from fractions import gcd
A,B,C,D = map(int, input().split())

A =A-1
CD = int(C * D / gcd(C, D))
num_A_C = int(A / C)
num_A_D = int(A / D)
num_A_CD = int(A / CD)
num_B_C = int(B / C)
num_B_D = int(B / D)
num_B_CD = int(B / CD)

num_C =num_B_C - num_A_C
num_D =num_B_D - num_A_D
num_CD =num_B_CD - num_A_CD

ans = B - A -num_C - num_D + num_CD
print(ans)

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

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

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

if flag:
    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 = str(input())
count = 0
for i in range(1,4):
	if A[-i]==A[-i-1]:
		count += 1
if count == 0:
	print("good")
else:
	print("bad")

A = str(input())
count = 0
for i in range(1,4):
	if A[-i]==A[-i-1]:
		count += 1
if count == 0:
	print("Good")
else:
	print("Bad")

Verdicts: Wrong Answer

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

Submission attempts (in order):
#import collections
Sin = input()
#print(Sin)
S = [int(x) for x in list(str(Sin))]
#print(S)
test = 0
for i in range(0,3):
    print(i)
    if S[i+1] == S[i]:
        print("Bad")
        test = 1
        
if test !=1:
    print("Good")


	
import sys
Sin = input()
#print(Sin)
S = [int(x) for x in list(str(Sin))]
#print(S)
test = 0
for i in range(0,3):
#    print(i)
    if S[i+1] == S[i]:
        print("Bad")
        test = 1
        sys.exit()
        
if test !=1:
    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()
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)

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


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

ans = 0

for i in [0, 1, 2]:
  if s[i] == s[i + 1]:
    ans += 1
  else:
  
if ans >= 1:
  print('Bad')
else:
  print('Good')


s = input()

ans = 0

for i in [0, 1, 2]:
  if s[i] == s[i + 1]:
    ans += 1
    
if ans >= 1:
  print('Bad')
else:
  print('Good')


Verdicts: Runtime Error

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

Submission attempts (in order):
a,b,c,d = sorted(input())
print (Bad)


a,b,c,d = 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):
a = input()
for i in range(1, len(a)):
    if a[i] == a[i-1]:
        print("Bad")
print("Good")

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

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

A,B,C,D = map(int,input().split())
E = lcm(C, D)
sample = B-A
ans = sample - ((B//C-A//C) + (B//D-A//D)-(B//E-A//E))
print(ans)

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


Verdicts: Runtime Error

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

Submission attempts (in order):
# -*- coding: utf-8 -*-
S = map(int, input().split())

s = str(S)

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

# -*- coding: utf-8 -*-
S = input().split()
 
s = list(S[0])

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

Verdicts: Wrong Answer

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

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

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

Verdicts: Wrong Answer

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

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

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

    else:
print('Good')

S=input()

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

else:
  print ('Good')

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

S = list(input(""))
count = 0

for i in range(len(S)):
    if S[i] == S[i - 1]:
        count += 1
        continue
    if len(S) == 4:
        if count == 1:
            print("Bad")
            break
        elif count == 0:
            print("Good")
            break

S = list(input(""))
count = 0

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

import sys

S = list(input(""))
count = 0
for i in range(len(S)):
    if len(S) >= 4:
        if S[i] == S[i - 1]:
            count += 1
            continue
        if count >= 1:
            print("Bad")
        else:
            print("Good")

S = list(input(""))
count = 0
for i in range(1,4):
    if S[i] == S[i - 1]:
        count += 1
    if len(S) == 4:
        if count == 1:
            print("Bad")
            break
        elif count == 0:
            print("Good")
            break

S = list(input(""))
count = 0

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


if count >= 1:
    print("Bad")
elif count == 0:
    print("Good")

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

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

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

pat = r"(\d)\1"

res = re.search(pat, S)

print(res)

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

import re
S = input()

pat = r"(\d)\1"

res = re.search(pat, S)


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

Verdicts: Wrong Answer

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

Submission attempts (in order):
s = list(map(int, str(input()).split()))

pre = None
check = False

for i in s:
  if pre != None:
    if pre == i:
      print("Bad")
      check = True
      break
  pre = i
  
if check:
  print("Good")
    

n, l = input().split()

def apple_aji(i):
  return int(l) + int(i) - 1

def apple_pie(n):
  ajis = [apple_aji(x) for x in n]
  mini = min(list(map(abs, ajis)))
  mini = mini * -1
  if mini in ajis:
    pass
  else:
    mini = mini * -1
  print(ajis)
  ajis.remove(mini)
  print(ajis)
  return sum(ajis)

print(apple_pie(range(1, int(n))))

s = list(str(input()))

flag = True
pre = None
for i, value in enumerate(s):
  if i != 0:
    if pre == value:
      flag = False
      break

  pre = value
    
if flag:
  print("Good")
else:
  print("Bad")

Verdicts: 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):
n=int(input())
l=[]
r=[]
for i in range(n):
    a,b=map(int,input().split())
    r.append(a)
    l.append(b)
m=max(l)
s=sum(r)
if s<m:
    print("Yes")
else:
    print("No")

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

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

lst = list(str(input()))
flag = 0
for i in range(3):
    if lst[i] == lst[i+1]:
        flag += 1
if flag == 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=input()
if s[0]==s[1] or s[1]==s[2] or s[2]==s[3] or s[3]==s[4]:
    print("good")
else:
    print("bad")

s = list(input())
if s//1000==s//100-s//1000*10:
    print("good")
    if s//100-s//1000*10==s//10-s//100*10+s//1000*100:
        print("good")
        if s//10-s//100*10+s//1000*100==s-s//10*10+s//100*100-s//1000*1000:
print("bad")        

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

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

n = len(s)
i = 1
while i != n:
    if s[i] == s[i - 1]:
        print('bad')
        exit()
    i += 1
print('Good')

s = input()

n = len(s) - 1
i = 1
while i != n:
    if s[i] == s[i - 1]:
        print('bad')
        exit()
    i += 1
print('Good')

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

Verdicts: Wrong Answer

Wrong Answer

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

Submission attempts (in order):
s=input()
print("Good" if len(s)=len(set(s)) else "Bad")

s=input()

flag=True
for i in range(len(s)-1):
    if s[i+1]==s[i]:
        flag=False
print("Good" if flag 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):
S=list(int(i) for i in input().split())
for x in range(len(S)+1):
  if S[x]==S[x+1]:
    print('Bad')
  else:
    print('Good')


S=list(int(i) for i in input().split())
for x in range(len(S)-1):
  if S[x]==S[x+1]:
    print('Bad')
  break
  else:
    print('Good')


S=list(int(i) for i in input().split())
for x in range(len(S)-1):
  if S[x]==S[x+1]:
    print('Bad')
  break 
else:
  print('Good')


S=list(int(i) for i in input().split())
for x in range(len(S)-1):
  if S[x]==S[x+1]:
    print('Bad')
    break 
else:
  print('Good')


S=list(int(i) for i in input().split())
for x in range(len(S)+1):
  if S[x]==S[x+1]:
    print('Bad')
  break 
else:
  print('Good')


S=list(int(i) for i in input().split())
if S[i]==S[i+1]:
  print('Bad')
else:
  print('Good')


S=list(int(i) for i in input().split())
for x in range(len(S)+1):
  if S[x]==S[x+1]:
    print('Bad')
    break 
else:
  print('Good')


S=list(int(i) for i in 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

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):
w=input();print("GBoaodd"[w[0]!=w[1]!=w[2]!=w[3]::2])

S=input();print("GBoaodd"[1^(S[0]!=S[1]!=S[2]!=S[3])::2])

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 bisect

n = int(input())

a, b = map(int, input().split())
task_lis = [[b, a]]
sum_a = 0
ch_over = 1


for i in range(n-1):
    a, b = map(int, input().split())
    if a > b:
        ch_over = 0
        break
    else:
        pass
    ok2 = bisect.insort_right(task_lis,[b, a])


for i in range(n):
    if chover == 0:
        break
    else:
        pass
    sum_a += task_lis[i][1]
    if task_lis[i][0] < sum_a:
        ch_over = 0
        break

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


str = input()
L = [int(s) for s in str]

if L[0] == L[1]:
    ans = "Bad"
elif L[1] == L[2]:
    ans = "Bad"
elif L[2] == L[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 = sorted(str,input())
Scnt = len(S)
Sset = set(S)

if Scnt == Sset:
    print("Good")
else:
    print("Bad")

S = [str(x) for x in input()]
cnt = 0
 
for i in range(0,3):
    if S[i] == S[i+1]:
        cnt += 1
 
if cnt >= 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=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(map(int,input().split()))

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

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

ans = "Good"

s_temp = 99

for num in s:
    if int(num) == s_temp:
        ans = "Bad"
        break
    else:
        s_temp = int(num)

print(ans)


s = input()

ans = "Good"

s_temp = 99

for num in s:
    if int(num) == s_temp:
        ans = "Bad"
        break
    else:
        s_temp = int(num)

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

prev = a[0]

flag = False

for i in range(1, 4):
  if (prev == a[i]):
    flag = True
    break

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


a = input()

prev = a[0]

flag = False

for i in range(1, 4):
  if (prev == a[i]):
    flag = True
    break
  prev = a[i]

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


Verdicts: Wrong Answer

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

Submission attempts (in order):
n = int(input())
li = [tuple(map(int,input().split())) for _ in range(n)]
li.sort(key=lambda x: x[1])
t = 0
for i in range(n):
    if t + li[i][0] > li[i][1]:
        print("No")
        exit()
    else:
        t += li[i][0]
print("Yes")

S = input()
for i in range(len(S)-1):
  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):
e = list(map(int,input().split()))
a = e[0]
b = e[1]
c = e[2]
d = e[3]

cnt = 0
for i in range(a,b+1):
    if (int(i/c)-i/c != 0) and (int(i/d)-i/d != 0):
        cnt += 1

print(cnt)

e = list(map(int,input().split()))
a = e[0]
b = e[1]
c = e[2]
d = e[3]
cnt = 0
t = [j for j in range(a,b+1) if j%c != 0 and j%d != 0]

for i in t:
    if (i//c-i/c != 0) and (i//d-i/d != 0):
        cnt += 1
    else:
        pass
print(cnt)

e = list(map(int,input().split()))
a = e[0]
b = e[1]
c = e[2]
d = e[3]
cnt = 0
for j in range(a,b+1):
    if j%c != 0 and j%d != 0:
        cnt += 1
print(cnt)

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

def gcd(x,y):
    while y !=0:
        x,y = y,x%y
    return x

def sums(x):
    S1 = x//c
    S2 = x//d
    S3 = x// (c*d//gcd(c,d))
    return x - S1 - S2 + S3


print(sums(b)-sums(a-1))

e = list(map(int,input().split()))
a = e[0]
b = e[1]
c = e[2]
d = e[3]
cnt = 0
for j in range(a,b+1):
    if j%c != 0 and j%d != 0:
        cnt += 1
    else:
        pass
print(cnt)

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

Runtime Error

Runtime Error

Runtime Error

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

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

flag = 0
for i in range(3):
  if(n[i] == n[i+1]):
    flag = 1
  if(flag == 1):
    print("Bad")
    break
if(flag == 0):
  print("Good")


n = input()

flag = 0
for i in range(3):
  if(n[i] == n[i+1]):
    flag = 1
  if(flag == 1):
    print("Bad")
    break
if(flag == 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()
for i in range(1,4):
  if S[i-1]==S[i]:
    print("Bad")
    continue
  elif i==3:
    print("Good")

S = input()
for i in range(1,4):
  if S[i-1]==S[i]:
    print("Bad")
    break
  elif i==3:
    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())
flag = 0

for i in range(0,3,1):
  if int(s[i:i+2]) % 11 == 0:
    flag = 1

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


s = str(input())
flag = 0

for i in range(0,2,1):
  if int(s[i:i+2]) % 11 == 0:
    flag = 1

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

s = str(input())
flag = 0

for i in range(0,3,1):
  if int(s[i:i+2]) % 11 == 0:
    flag = 1

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


Verdicts: Wrong Answer

Wrong Answer

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

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

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

S=input()

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

Verdicts: Wrong Answer

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

Submission attempts (in order):
#!/usr/bin/env python3
import sys
from collections import namedtuple
import functools

YES = "Yes"  # type: str
NO = "No"  # type: str

def solve(N: int, t: "List[int]", x: "List[int]", y: "List[int]"):
    for i in range(N):
        min_length = abs(x[i+1] - x[i]) + abs(y[i+1] - y[i])
        travel_time = t[i+1] - t[i]

        if min_length > travel_time:
            return NO
        elif min_length == travel_time:
            next
        elif (travel_time - min_length) % 2 == 0:
            next
        else:
            return NO

    return YES


# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    t = [int()] * (N)  # type: "List[int]" 
    x = [int()] * (N)  # type: "List[int]" 
    y = [int()] * (N)  # type: "List[int]" 
    for i in range(N):
        t[i] = int(next(tokens))
        x[i] = int(next(tokens))
        y[i] = int(next(tokens))
    t.insert(0, 0)
    x.insert(0, 0)
    y.insert(0, 0)
    print(solve(N, t, x, y))

if __name__ == '__main__':
    main()


#!/usr/bin/env python3
import sys


def solve(S: str):
    for i in range(len(S) - 1):
        if S[i] == S[i+1]:
            return 'Bad'
    return 'Good'


# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = str(next(tokens))  # type: str
    print(solve(S))

if __name__ == '__main__':
    main()


Verdicts: Runtime Error

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

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

list = [int(x)for x in input()]
count =0
for i in range(3):
  if list[i] == list[i+1]:
    count +=1
if count ==0:
  print('Good')
else:
  print('Bad')

Verdicts: Wrong Answer

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

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


an1 = math.floor(b/c)
an2 = math.floor((a-1)/c)
an3 = math.floor(b/d)
an4 = math.floor((a-1)/d)

gcd = round(c * d / gcd(c, d))

an5 = math.floor(b/gcd)
an6 = math.floor((a-1)/gcd)
an = an1-an2 + an3-an4 -(an5-an6)
print((b-a+1)-an)

    

from fractions import gcd
import math
a,b,c,d = map(int,input().split())
 
an1 = math.floor(b/c)
an2 = math.floor((a-1)/c)
an3 = math.floor(b/d)
an4 = math.floor((a-1)/d)
 
gcd = round(c * d / gcd(c, d))
 
an5 = math.floor(b/gcd)
an6 = math.floor((a-1)/gcd)
an = an1-an2 + an3-an4 -(an5-an6)
print((b-a+1)-an)

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

if count > 0:
    print("Bad")
else:
    print("Good")


Verdicts: Runtime Error

Runtime Error

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

Submission attempts (in order):
s=list(int(input()))
f=True
for i in range(1,4):
	if s[i-1]==s[i]:
		f=False
		break
	else:
		continue
if f:
	print("Good")
else:
	print("Bad")

s=list(str(input()))
f=True
for i in range(1,4):
	if s[i-1]==s[i]:
		f=False
		break
	else:
		continue
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 = input()
if n[0]==n[1] or n[1]==n[2] or n[2]==n[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 = str(input())
if S[0] == S[1] or S[1] == S[2] or S[2] == S[3]:
    print('Bud')
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: 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
import sys

L = list(input())
print(L)
for i in range(len(L)):
    for j in range(len(L)):
        if (i != j) and (abs(i-j) == 1) and (L[i] == L[j]):
            print("Bad")
            sys.exit()
print("Good")


#coding:utf-8
import sys

L = list(input())
for i in range(len(L)):
    for j in range(len(L)):
        if (i != j) and (abs(i-j) == 1) and (L[i] == L[j]):
            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 = 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: 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())
def gcd(x, y):
    if x == 0:
        return y
    else:
        return gcd(y % x, x)
def lcm(x,y):
    return x * y // gcd(x,y)
L = lcm(C,D)
b = B - (B // C) - (B // D) + (B // L)
a = (A-1) - ((A-1) // C) - ((A-1) // D) + ((A-1) // L)
print(b - a)

A,B,C,D = 10, 40, 6, 8

def gcd(x, y):
    if x == 0:
        return y
    else:
        return gcd(y % x, x)

def lcm(x,y):
    return x * y // gcd(x,y)
L = lcm(C,D)
b = B - (B // C) - (B // D) + (B // L)
a = (A-1) - ((A-1) // C) - ((A-1) // D) + ((A-1) // L)
print(b - a)

A,B,C,D = map(int, input().split())
cnt = 0
for i in range(A, B+1):
    if not i % C == 0:
        if not i % D == 0:
            cnt = cnt + 1
print(cnt)

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

def gcd(x, y):
    if x == 0:
        return y
    else:
        return gcd(y % x, x)

def lcm(x,y):
    return x * y // gcd(x,y)
L = lcm(C,D)
b = B - (B // C) - (B // D) + (B // L)
a = (A-1) - ((A-1) // C) - ((A-1) // D) + ((A-1) // L)
print(b - a)

S = input()

S1 = S[0]
S2 = S[1]
S3 = S[2]
S4 = S[3]

flg = "Good"

if S1 == S2:
  flg = "Bad"
elif S2 == S3:
  flg = "Bad"
elif S3 == S4:
  flg = "Bad"

print(flg)

Verdicts: Runtime Error

Wrong Answer

Runtime Error

Runtime Error

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

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

for i in range(a, b):
    if i%c != 0:
        if i%d !=0:
            print(i)

count=0

security=input()
sec_list=list(security)

for s in range(0,len(security)-1):
    if sec_list[s]==sec_list[s+1]:
        count+=1

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

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

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

N = str(input())
if N[0]==N[1] or N[1]==N[2] or N[2]==N[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())
count = 0
for i in range(3):
  if S[i] == S[i+1]:
    count += 1
print("Yes" if count > 0 else "No")

S = list(input())
count = 0
for i in range(3):
  if S[i] == S[i+1]:
    count += 1
print("Bad" if count > 0 else "Good")

Verdicts: Wrong Answer

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

Submission attempts (in order):
#n = int(input())
#n,k = map(int,input().split())
#x = list(map(int,input().split()))


s = list(input())

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

#n = int(input())
#n,k = map(int,input().split())
#x = list(map(int,input().split()))


a = list(input())

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

Verdicts: Runtime Error

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

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


n=str(input())
n=list(n)
if n[0]==n[1] or n[1]==n[2] or n[2]==n[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):
lock_num = input()
#lock_num = [int(x) for x in lock_num]
tag = 0
for i in range(len(lock_num)-1):
  if int(lock_num[i]) == int(lock_num[i+1]):
    tag = 1
if tag == 0:
  print("Good")
else tag ==1:
  print("Bad")

lock_num = input().split()
lock_num = [int(x) for x in lock_num]
tag = 0
for i in range(len(lock_num)-1):
  if lock_num[i] == lock_num[i+1]:
    tag = 1
if tag == 0:
  print("Good")
else tag ==1:
  print("Bad")

lock_num = list(input())
#lock_num = [int(x) for x in lock_num]
tag = 0
for i in range(3):
  if int(lock_num[i]) == int(lock_num[i+1]):
    tag = 1
if tag == 0:
  print("Good")
else tag ==1:
  print("Bad")

lock_num = input()
#lock_num = [int(x) for x in lock_num]
tag = 0
for i in range(3):
  if int(lock_num[i]) == int(lock_num[i+1]):
    tag = 1
    break
if tag == 0:
  print("Good")
else:
  print("Bad")

Verdicts: Runtime Error

Runtime Error

Runtime Error

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

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

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

if flag:
    print('good')
else:
    print('bad')

S = input()
flag = True

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

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):
a = int(input())
print(a)
b = a%10
print(b)
c = int(((a-b)/10)%10)
print(c)
d = int(((a-b-c*10)/100)%10)
print(d)
e = int(((a-b-c*10-d*100)/1000)%10)
print(e)
mylst = [e, d, c, b]
if e == d:
    print("Bad")
elif d == c:
    print("Bad")
elif c == b:
    print("Bad")
else:
    print("Good")

a = int(input())
b = a%10
c = int(((a-b)/10)%10)
d = int(((a-b-c*10)/100)%10)
e = int(((a-b-c*10-d*100)/1000)%10)
mylst = [e, d, c, b]
if e == d:
    print("Bad")
elif d == c:
    print("Bad")
elif c == b:
    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()
i = str(s)
for i in range(3):
  if s[i] == s[i+1]:
    print('Bad')
    break
  else:
    print('Good')

s = input()
i = str(s)
t = 0
for i in range(3):
  if s[i] == s[i+1]:
    print('Bad')
    break
  else:
    t += 1
if t == 3:
  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):
p = input().split()

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

p = input()

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


Verdicts: Runtime Error

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

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

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


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


Verdicts: Runtime Error

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

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


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


Verdicts: Wrong Answer

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

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

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


ss = input()

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

ss = input()

for i in range(3):
  if ss[i] == ss[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):
a=input()
b=False
for i in range(3):
 if a[i+1]==a[i]:
  b=True

if b:
 print(“Bad”)
else:
 print(“Good”)

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

if b:
print(“Bad”)
else:
print(“Good”)

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

if b:
 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=list(int(input))
i=0
for j in range(1,4):
  if a[i]== a[j]:
    print('Bad')
    break
  elif a[i]!= a[j] and j == 4:
    print('Good')
  i += 1
  

a=list(int(input))
i=0
for j in range(1,4):
  if a[i]== a[j]:
    print('Bad')
    break
  elif a[i]!= a[j] and j == 4:
    print('Good')
  else:
    continue
  
  

a=list(int(input))
i=0
for j in range(1,4):
  if a[i]== a[j]:
    print('Bad')
    break
  elif a[i]!= a[j] and j == 3:
    print('Good')
  i += 1
  

a=list(input())
i=0
for j in range(1,4):
  if a[i]== a[j]:
    print('Bad')
    break
  elif a[i]!= a[j] and j == 3:
    print('Good')
  i += 1
  

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted