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


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


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

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


S=[str(x) for x in input()]
ans=0
for i in range(4):
  if S[i]==S[i+1]:
  	ans+=1
    
    if ans >= 1 :
      print('Bad')
      else print('Good')

S=[str(x) for in input()]
ans=0
for i in range(4):
  if S[i]==S[i+1]:
  	ans+=1
    
    if ans>=1:
      print('Bad')
      else print('Good')

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


S = input()

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


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

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())
hoge = []

for i in range(n):
    hoge.append(list(map(int, input().split())))
hoge.sort(key = lambda x: x[1])

total = 0
able = True
for i in hoge:
    total += i[0]
    if i[1]<total:
        able = False

if able:
    print("Yes")
else:
    print("No")

pa = input()
x = ""
out = False
for i in pa:
    if x == i:
        out = True
    x = i
if out:
    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()))

result = True
for i in range(len(s)-1):
    if a[i] == a[i+1]:
        result = bad
        break
if result == "bad":
    print("Bad")
else:
    print("Good")

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

result = "True"
for i in range(len(s)-1):
    if s[i] == s[i+1]:
        result = "bad"
        break
if result == "bad":
    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 sys
i = int(input())
i = list(i)
for k in range(3):
  if i[k] == i[k+1]:
    print("Bad")
    sys.exit()
print("Good")

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

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

print("Good")

a = input()
flag = False

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

if not flag:
    print("Good")


Verdicts: Runtime Error

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

Submission attempts (in order):
N,L = list(map(int,input().split()))


i = 1
taste = []

while i == N:
        taste.append(L + i - 1)
        i += 1

if L > 0 :
        print(sum(taste[1:N]))
elif L < N and N + L < 0:
        print(sum(taste[0:N-1]))
elif L <= 0 and N - L >= 0:
        print(sum(taste))


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


i = 1
taste = []

while i <= N:
        taste.append(L + i - 1)
        i += 1


if L > 0 :
        print(sum(taste[1:N]))
elif L <= 0 and N + L < 0:
        print(sum(taste[0:N-1]))
elif L <= 0 and N + L >= 0:
        print(sum(taste[0:N-1]))

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


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



Verdicts: Runtime Error

Runtime Error

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

Submission attempts (in order):
s=input()
if s[0]!=s[1] and s[1]!=s[2] and s[2]!=s[3]:
  print("Yes")
else:
  print("No")

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

x = input()
ans = 'Good'
for i in range(len(x)-1):
  if x[i]==x[i+1]:
    ans = 'Bad'
    break
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):
char_list = list(str)
for i in range(4):
    
    if i == 3:
        print('Good')
        break
    
    if char_list[i] == char_list[i+1] and i < 3:
        print('Bad')
        break

char_list = list(input())
for i in range(4):
    
    if i == 3:
        print('Good')
        break
    
    if char_list[i] == char_list[i+1] and i < 3:
        print('Bad')
        break

Verdicts: Runtime Error

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

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

x = int(b/c) -int((a-1)/c)

y = int(b/d) -int((a-1)/d)

lcm_xy = int(c*d/math.gcd(c,d))
で割り切れる個数
xy = int(b/lcm_xy) -int((a-1)/lcm_xy)
#print(x,y,xy,al)
print(al-(x+y-xy))

a,b,c,d=map(int,input().split())
r_ab=range(a,b+1)
count=0
for i in r_ab:
  if i%c!=0 and i%d!=0:
    count+=1
print(count)

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


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


Verdicts: Wrong Answer

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

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


if __name__ == "__main__":
    main()

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


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

lst_A = list(input())

ans = "Bad"

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


lst_A = list(input())
 
ans = "Bad"
 
for i in range(3):
	if lst_A[i] == lst_A[i + 1]:
  		break
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 = list(map(int, list(input())))
for i in range(s - 1):
    if s[i] == s[i + 1]:
        print('Bad')
    print('Good')


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


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


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

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


Verdicts: Runtime Error

Wrong Answer

Wrong Answer

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

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


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

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


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


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


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


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


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


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


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


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


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


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


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

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):
import re;print('GBoaodd'[re.search('r(.)\1',input())::2])


import re;print("GBoaodd"[len(re.sub(r"(.)\1","",input()))!=4::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 sys
readline=sys.stdin.buffer.readline
n=int(input())
a=[list(map(int, readline().split())) for _ in range(n)]
a.sort(key=lambda x: x[1])
t=0
for i in range(n):
  t+=a[i][0]
  if t>a[i][1]:
    print("No")
    break
  elif i==n-1:
    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

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the 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 = True
for i in s:
    if(abs(s.find(i)-s.rfind(i)) == 1):
        ans = False
if ans == True:
    print("Yes")
else:
    print("No")


s = input()
ans = True
for i in s:
    if(s.count(i+i)):
        ans = False
if ans == True:
    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 math import gcd
a,b,c,d = map(int, input().split())
c_n = b//c - (a-1)//c
d_n = b//d - (a-1)//d
l = (c*d)//gcd(c,d)
l_n = b//l - (a-1)//l
print(b - a - c_n - d_n + l_n + 1)

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()
r="g↨ood"
for i in range(len(s)-1):
  if s[i]==s[i+1]:
    r="b↨ad"
    break
print(r)

s=input()
r="good"
for i in range(len(s)-1):
  if s[i]==s[i+1]:
    r="bad"
    break
print(r)

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

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):
import re

security_code = input()
regex = r'(.)\1'
result = re.match(regex, security_code)

if result is None:
  print('Good')
else:
  print('Bad')

import re

security_code = input()
regex = r'.*(.)\1.*'
result = re.match(regex, security_code)

if result is None:
  print('Good')
else:
  print('Bad')

Verdicts: Wrong Answer

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

Submission attempts (in order):
def main():
  inp = input()
  before =None
  for a in inp:
    if before is None:
      before = a
      continue
    if before == a:
      print("Bad")
      return
    before = a
  print("Good")

def main():
  inp = input()
  before =None
  for a in inp:
    if before is None:
      before = a
      continue
    if before == a:
      print("Bad")
      return
    before = a
  print("Good")

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):
import fractions
a, b, c, d = map(int, input().split())
 
def wareruzu(x):
    start_a = a if a % x == 0 else a - (a % x) + x
    end_b = b - (b % x)
    m = end_b - start_a
    return int(m / x) + 1
 
all_n = b - a + 1
print(all_n - wareruzu(c) - wareruzu(d) + wareruzu((c*d) / fractions.gcd(c,d)))

S = input()

flg = False
for i in range(3):
    if S[i] == S[i+1]:
        flg =True

print('Bad' if flg 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()
n = ""
for i in range(4):
    if S[i:i+1]==n:
        print("Bad")
        break
    n = S[i:i+1]
print("Good")

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

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

import sys
input = sys.stdin.readline


def main():
    S = input()[:-1]
    for i in range(3):
        if S[i:i+1]==S[i+1:i+2]:
            print('Bad')
            return
    print('Good')


if __name__ == '__main__':
    main()

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

for i range(3):
  if pass[i] == pass [i+1]:
  	print('Bad')
  	break
  elif i == 2:
    print('Good')
    
  

password = input()

for i in range(3):
    if password[i] == password[i+1]:
        print('Bad')
        break
    elif i == 2:
        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 collections


S = list(input())

c = collections.Counter(S)

if max(c.values) >= 2:
  print("Bad")
else:
  print("Good")


import collections


S = list(input())

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

print(answer)

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')
        break
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):
import sys

def def1(s):
    
    if s[0] == s[1]:
        return True
    
    if len(s) == 2:
        return False
    
    return def1(s[1:])

def main():
    input = sys.stdin.readline
    S = input()
    
    print('bad' if def1(S) else 'good')

if __name__ == '__main__':
    main()

import sys

def def1(s):
    
    if s[0] == s[1]:
        return True
    
    if len(s) == 2:
        return False
    
    return def1(s[1:])

def main():
    input = sys.stdin.readline
    S = input()
    
    print('Bad' if def1(S) else '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):
a = list(input())
print(a)
flag = 0
for i in range(3):
    if a[i] == a[i+1]:
        flag = 1
if flag == 1:
    print('Bad')
else:
    print('Good')


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

pas = input("password: ")
pas = list(pas)

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



pas = input("password: ")
pas = list(pas)

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



pas = input()
pas = list(pas)

for i in range(3):
    if pas[i] == pas[i+1]:
        print('Bad')
        exit()
    a = i
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):
import fractions
def lcm(a,b):
  return a*b //fractions.gcd(a, b)

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

b_num = B//C + B//D - B//lcm(C, D)
a_num = (A-1)//C + (A-1)//D - (A-1)//lcm(C, D)
print((B-(A-1))-(b_num-a_num))

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


def lcm(a, b):
    return a * b // gcd(a, b)

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

b_num = B//C + B//D - B//lcm(C, D)
a_num = (A-1)//C + (A-1)//D - (A-1)//lcm(C, D)

print((B-A+1) -(b_num - a_num))

num = input()
l = [i for i in num]
count = 0
for k in range(0,len(l)-1):
    if l[k] == l[k+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):
def main():

    s = map( int, input().split())
    s = str(s)

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

if __name__ == '__main__':
    main()



def main():

    s = input()
    s = str(s)
    flag = 0

    if(s[0] == s[1]):
        print('Bad')
        flag = 1
    
    if(flag == 0 and s[1] == s[2]):
        print('Bad')
        flag = 1
    
    if(flag == 0 and s[2] == s[3]):
        print('Bad')
        flag = 1
    
    if(flag == 0):
        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):
a=list(input())
flag=True
for i in range(len(a)-1):
  if a[i]==a[i+1]:
    print("Bad")
    return
print("Good")

a=list(input())
flag=True
for i in range(len(a)-1):
  if a[i]==a[i+1]:
    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 = input()
if s[0] == s[1] or s[1] == s[2] 0r 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 len(set(sort(s))) == 4:
    print("Good")
else:
    print("No")

s = input()
if len(set(s)) == 4:
    print("Good")
else:
    print("No")

s = input()
if len(set(s.sort())) == 4:
    print("Good")
else:
    print("No")

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

Verdicts: Runtime Error

Wrong Answer

Runtime Error

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

Submission attempts (in order):
import fractions
A, B, C, D = (int(x) for x in input().split())

C_ = int(B/C) - int(A/C)
if A%C == 0:                                                                                                                                                                                                
    C_ += 1                                                                                                                                                                                                 
D_ = int(B/D) - int(A/D)
if A % D == 0:                                                                                                                                                                                              
    D_ += 1                                                                                                                                                                                                 

E = C * D / fractions.gcd(C, D)
E_ = int(B/E) - int(A/E)

ans = B - A + 1 - C_ - D_ + E_
print(ans)


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):
作成したプログラムには欠陥がある。今回の課題ではない1度ずつ探索を行いその中でも最もスコアが高かった時の角度を最後の出力しているが、自分が想定した角度とは違う角度が最大となっている例として画像2-2では自分は最適な角度が0度であると考えているのに対して、出力では最適な角度は----と自分が想定している角度ではなかった。このようになった理由として考えられるのはキティの特徴の考え方の一つであると思われる黄色の目と鼻の位置が元からある場所よりも近いのがあったからと考えられる。また画像2-2や2-3であった複数のキティを検出だが検出することはできたものの最終出力では複数の赤枠の出力ができなかった。2ー3のファイルでは画像を回転させるごとにキティを探索することができたが(60、180、300)このプログラムでは最もテンプレートに近い時のキティである

import math
import fractions
import copy
import numpy as np
def j(q):
    if q==1: print("Bad")
    elif q == 0:print("Good")
    exit(0)
rem = pow(10,9)+7
"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def iprow():
    return [int(i) for i in input().split()]
def printrow(a):
    for i in a:
        print(i)
def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)




a = input()                                  






if a[0] == a[1] or a[1] == a[2] or a[2] == a[3]:
    j(1)
j(0)

Verdicts: Runtime Error

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

Submission attempts (in order):
n, l = map(int, input().split())
if l>=0:
	print(n**2/2+l*n-n/2-l)
if l<0 and n-1<l:
  	print(n**2/2+l*n-n/2)
else:
  	print((n**2/2)+l*n-n/2-l-n+1)

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

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):
def judge(S):
  S = [int(i) for i in str(S)]
  delta1 = S[1]-S[0]
  delta2 = S[2]-S[1]
  delta3 = S[3]-S[2]
  
  if delta1 * delta2 * delta3 == 0:
    print('Bad')
  else:
    print('Good')

def judge(S):
  S = [int(i) for i in S]
  delta1 = S[1]-S[0]
  delta2 = S[2]-S[1]
  delta3 = S[3]-S[2]
  
  if delta1 * delta2 * delta3 == 0:
    print('Bad')
  else:
    print('Good')
    

S = input()
S = [int(i) for i in S]

delta1 = S[1]-S[0]
delta2 = S[2]-S[1]
delta3 = S[3]-S[2]
  
if delta1 * delta2 * delta3 == 0:
	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):
from sys import stdin




def gcd(n,m):
    if n<m:
        return gcd(m,n)
    if n%m==0:
        return m
    else:
        return gcd(m,n%m)



a,b,c,d = [int(x) for x in stdin.readline().rstrip().split()]

c_num = b//c-(a-1)//c
d_num = b//d-(a-1)//d

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

LCM_num = int(b//(LCM)-(a-1)//(LCM))

ans = b-a+1
ans -= c_num
ans -= d_num
ans += LCM_num
print(ans)




from sys import stdin

n = stdin.readline().rstrip()
ex_str = n[0]
for i,a_str in enumerate(str(n)):

    
    if(i>0 and ex_str==a_str):
        print("Bad")
        break
    elif(ex_str!=a_str and i == len(n)-1):
        print("Good")
    ex_str = a_str

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

cnt=0

for i in range(1,len(s):
    if s[i]==s[i-1]:
        cnt += 1

if cnt > 1:
    print("Bad")
else:
    print("Good")

s=input()

cnt=0

for i in range(1,len(s)):
    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):
import fractions

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

b_c = b//c - (a-1)//c
d_c = b//d - (a-1)//d
cd = (c * d) // fractions.gcd(c, d)
cd_c = b//cd - (a-1)//cd

print((b - a + 1) - (b_c + d_c - cd_c))


import fractions

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

b_c = b//c - (a-1)//c
d_c = b//d - (a-1)//d
cd = (c * d) // math.gcd(c, d)
cd_c = b//cd - (a-1)//cd

print((b - a + 1) - (b_c + d_c - cd_c))


s = list(input())

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

s = input()
ans = True
for i in range(3):
    ans = ans and (s[i] != s[i+1])
if ans: 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 i in range(len(s)):
    if s[i]==s[i+1]:
        result='Bud'
        break
    else:
        result='Good'
print(result)


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

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

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


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


Verdicts: Runtime Error

Runtime Error

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

Submission attempts (in order):
S = str(input())
if S[0] == S[1] or S[1] == S[2] or S[2] == S[3]:
    print('Yes')
else:
    print('No')

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):
x = input()
def samenum(string):
  for i in range(3):
  	if string[i] == string[i+1]:
    	return "Bad"
  		quit()
  return "Good"

print(samenum(x))

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

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

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):
pre = None
for i in list(input()):
	if i == pre:
      	print("Bad")
        exit()
    pre = i
print("Good")

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


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

i=list(input())
if(i[0]==i[1] or i[1]==i[2] or i[2]==i[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())
if (a + b) // 2 == a;
  print('Bad')
elif (b + c) // 2 == b;
  print('Bad')
elif (c + d) // 2 == c;
  print('Bad')
else;
  print('Good')


a, b, c, d = map(int, input().split())
if (a + b) / 2 == a:
  print('Bad')
elif (b + c) / 2 == b:
  print('Bad')
elif (c + d) / 2 == c:
  print('Bad')
else:
  print('Good')


a, b, c, d = map(int, input().split())
if (a + b) // 2 == a:
  print('Bad')
elif (b + c) // 2 == b:
  print('Bad')
elif (c + d) // 2 == c:
  print('Bad')
else:
  print('Good')


s = input();print('GBoaodd'[any(s[i] == s[i+1] for i in range(3))::2])

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()
a=s//1000
b=(s-a*1000)//100
c=(s-a*1000-b*100)//10
d=s-a*1000-b*100-c*10
if a==b :
    print"Bad"
    elif b==c:
        print"Bad"
    elif c==d:
        print"Bad"
else:
    print"Good"

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

s=int(input())
a=s//1000
b=(s-a*1000)//100
c=(s-a*1000-b*100)//10
d=s-a*1000-b*100-c*10
if a==b :
    print("Bad")
elif b==c:
    print("Bad")
elif c==d:
    print("Bad")
else:
    print("Good")

Verdicts: Runtime Error

Runtime Error

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

Submission attempts (in order):
list = input()
chk = 10
for code in list :
    if chk == code :
        print("bad")
        break
    chk = code
else :
    print("good")

A,B,C,D = (int(x) for x in input().split())
n = A
count = 0
while n <= B:
    if n%C != 0 
        if n%D != 0:
            count += 1
    n += 1
print(count)


list = input()
chk = 10
for code in list :
    if chk == code :
        print("Bad")
        break
    chk = code
else :
    print("Good")


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):
import numpy as np
import math
A, B, C, D = list(map(int, input().split()))

def lcm(x, y):
    return (x * y) / math.gcd(x, y)
E = lcm(C, D)

u = np.arange(A,B+1)
count_U = len(u)
u_c = [i for i in u if i % C == 0]
count_C = len(u_c)
u_d = [i for i in u if i % D == 0]
count_D = len(u_d)
u_e = [i for i in u if i % E == 0]
count_E = len(u_e)

answer = count_U - (count_C + count_D -count_E)
print(answer)


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

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





spline = input().split()
N = int(spline[0])
L = int(spline[1])


taste = []
for i in range(1,N+1): 
    taste.append(L+i-1)  
#print(taste)


taste_max = sum(taste)
#print("max"+str(taste_max))



taste_any = []
for k in range(0,N):
    taste_any.append(sum(taste) - taste[k])
#print(taste_any)



taste_any = np.asarray(taste_any)
diff = abs(sum(taste) - taste_any)

diff_list = diff.tolist()
#print("diff_list"+str(diff_list))

coef = diff_list.index(min(diff_list))
#print(coef)

print(taste_any[coef])




# -*- coding: utf-8 -*-



S = input()
jud = False


if len(S) != 4:
    print("4桁でありません")

for i in range(0,3):
    if S[i] == S[i+1]:
        jud = True
    else:
        pass

if jud == 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())

c = 0
for i in range(3):
  if S[i] != S[i+1]:
    c += 1
if c == 3:
  print('GOOD')
else:
  print('BAD')


S = list(int(input()))

c = 0
for i in range(3):
  if S[i] != S[i+1]:
    c += 1
if c == 3:
  print('GOOD')
else:
  print('BAD')


S = list(int(input()))

c = 0
for i in range(3):
  if S[i] != S[i+1]:
    c += 1
if c == 3:
  print('Good')
else:
  print('Bad')


S = list(input())

c = 0
for i in range(3):
  if S[i] != S[i+1]:
    c += 1
if c == 3:
  print('Good')
else:
  print('Bad')


Verdicts: Wrong Answer

Runtime Error

Runtime Error

Accepted