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

b=int(s%1000)
a=int((s-b)/1000)
d=int(b%100)
c=int((b-d)/100)
f=int(d%10)
e=int((d-f)/10)

if a=d or d=e or e=f :
    print("Bad")
else:
    print("Good")

s=int(input())

b=int(s%1000)
a=int((s-b)/1000)
d=int(b%100)
c=int((b-d)/100)
f=int(d%10)
e=int((d-f)/10)

if a==d or d==e or e==f :
    print("Bad")
else:
    print("Good")


s=int(input())

b=int(s%1000)
a=int((s-b)/1000)
d=int(b%100)
c=int((b-d)/100)
f=int(d%10)
e=int((d-f)/10)

if a==c or c==e or e==f :
    print("Bad")
else:
    print("Good")


Verdicts: Runtime Error

Wrong Answer

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

Submission attempts (in order):
s = input()
if s[0] == s[1] or s[0] == s[1] or s[0] == s[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: 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())
cou = 0
for i in range(len(S)-1):
  if(S[i]==S[i-1]):
    cou += 1
  break
if(cou>0):
  print("Bad")
else:
  print("Good")

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


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

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

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

s = int(input())
ans = "Good"
for i in range(10):
  k = str(i)+str(i)
  if(k in s):
    ans = "Bad"
    break
print(ans)

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

s = str(input())
ans = "Good"
for i in range(10):
  k = str(i)+str(i)
  if(k in s):
    ans = "Bad"
    break
print(ans)


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

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

s = input()
switch = False
for i in range(0, 3):
  if s[i] == s[i + 1]:
    switch = True
if switch:
  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):
def f(X,Y):
    return X//Y

A,B,C,D = map(int, input().split())
X = B-A+1
if (C>D):
    x = C
    y = D
else:
    y = C
    x = D

r = x % y
while(r!=0):
    x = y
    y = r
    r = x % y

print("%d" % (X - f(X, C) - f(X, D) + f(X, C*D//y)))

S = input()
prev = S[0]
for s in S[1:]:
  if s == prev:
    print("Bad")
    exit()
    
print("Good")

S = input()
prev = S[0]
for s in S[1:]:
  if s == prev:
    print("Bad")
    exit()
  prev = s
    
print("Good")


Verdicts: Runtime Error

Wrong Answer

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

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

for i in range(3):
  if S[i] == S[i+1]:
    check = 1

if check == 0:
  print('Yes')
else:
  print('No')

S = input()
check = 0

for i in range(3):
  if S[i] == S[i+1]:
    check = 1

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

Verdicts: Wrong Answer

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

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

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


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

from collections import Counter 
from collections import defaultdict
from collections import deque
import math
import itertools
import heapq
import numpy as np
import sys
sys.setrecursionlimit(10**6)

#n=int(input())
#n,m=list(map(int,input().split()))
#a=list(map(int,input().split()))
input_list = lambda : list(map(int,input().split()))


s=input()

for i in range(1,len(s)):
    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):
num=str(input())
for i in range(1,len(num)):
  if num[i]==num[i-1]:
    print('bad')
    exit()
print('Good')

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

Verdicts: Wrong Answer

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

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

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

Verdicts: Runtime Error

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

Submission attempts (in order):
S=input()
for i in range(len(S)-1):
  if S[i]==S[i+1]:
    print('bad')
    exit()
print('good')

S=input()
for i in range(len(S)-1):
  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):
n = int(input())
ab = [list(map(int,input().split())) for i in range(n)]

ab.sort(key= lambda x:x[1])
time = 0

for i in range(n):
    time += ab[i][0]
    if time > ab[i][1]:
        ans = "No"
        break
else:
    ans = "Yes"

print(ans)

s = input()

for i in range(3):
    if s[i] == s[i+1]:
        ans = "Bad"
        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):

#include<algorithm>
#include<string>


#include<map>
#include<math.h>

#define rep(i,a,n) for(int (i)=(a);(i)<(n);(i)++)
#define rrep(i,a,n) for(int (i)=(a);(i)>=(n);(i)--)

#define INF 1000000000
#define MOD 1000000007

typedef  long long ll;

using namespace std;

template<class T> inline bool chmin(T& a, T b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}

template<class T> inline bool chmax(T& a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

double euclid_distance(double a,double b){
    return sqrt(a*a+b*b);
}

ll gcd(ll  a,ll b){
    ll r;
    if(a < b){
        int tmp;
        tmp = a;
        a = b;
        b = tmp;
    }
    while(r = a % b){
        a = b;
        b = r;
    }
    return b;
}

void Integer_factorization(long long int b,long long int n){
    long long int a = 2;
    long long int count = 0;
    long long int ans = 1;
    long long int ndash = n;
    if(b == 1) cout << n << endl;
    else{
    while(ndash >= a*a){
        if(n % a  == 0){
            count++;
            n/=a;

        if(count % b == 0){
            ans *= a;
        }
        }else{a++;count = 0;}
    }

    cout<<  ans << endl;
    }
}

void solve() {
   string s;

   cin >> s;

   rep(i,0,s.size()-1){
       rep(j,i+1,s.size()){
           if(s[i] == s[j]){

           cout << "Bad";
           return;
           }
       }
   }

   cout << "Good" << endl;
}
int main() {

	cin.tie(0);
	ios::sync_with_stdio(false);

	solve();

	return 0;
}


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

Verdicts: Runtime Error

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

Submission attempts (in order):
s = input()
num = 0
for i in range(len(s)-1):
        print(i)
        if s[i] == s[i+1]:
                num = 1
print("Good") if num == 0 else print("Bad")

s = input()
num = 0
for i in range(len(s)-1):
        if s[i] == s[i+1]:
                num = 1
print("Good") if num == 0 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 check_pass(ps):
    for i in range(len(ps) - 1):
        dif = ps[i] - ps[i + 1]
        if dif == 0:
            print("bad")
            return ""
    print("good")
    return ""


# input process
inputData = input()
ps = [int(x) for x in inputData]

check_pass(ps)


from math import floor


# calculation process
def check_pass(ps):
    for i in range(len(ps) - 1):
        dif = ps[i] - ps[i + 1]
        if dif == 0:
            print("Bad")
            return ""
    print("Good")
    return ""


# input process
inputData = input()
ps = [int(x) for x in inputData]

check_pass(ps)


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


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


Verdicts: Runtime Error

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

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

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


S = int(input())

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


S = int(input())

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

S = int(input())

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


s = int(input())

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


s = int(input())

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


s = input()

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

Verdicts: 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):
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=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()
if s[0] == s[1]:
  print(Bad)
elif s[2] == s[1]:
  print(Bad)
elif s[3] == s[2]:
  print(Bab)
else:
  print(Good)

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

S = input()
s=len(S)
print(s)

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

Verdicts: Runtime Error

Runtime Error

Wrong Answer

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

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


ans=(b//c+b//d-b//(c*d//math.gcd(c,d)))-((a-1)//c+(a-1)//d-(a-1)//(c*d//math.gcd(c,d)))

print(b-a+1-ans)


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

Verdicts: Runtime Error

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

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

flg=False
for i in range(len(matchNums)-1):
    if matchNums[i] == matchNums[i+1]:
        flg = True
if flg:
    print("Bad")
else
    print("Good")

matchNums=input()

flg=False
for i in range(len(matchNums)-1):
    if matchNums[i] == matchNums[i+1]:
        flg = True
if flg:
    print("Bad")
else:
    print("Good")

Verdicts: Runtime Error

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

Submission attempts (in order):
N, L = map(int, input().split())
p_list = []
for i in range(1, N+1):
    p_list += [L + i - 1]
print(sum(p_list) - sorted(p_list, key=abs)[0])

S = input()
tmp = S[0]
for num in S[1:]:
    if num == tmp:
        print('Bad')
        exit()
    tmp = num
print('Good')

Verdicts: Runtime Error

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

Submission attempts (in order):
n = input()
for i in range(0,len(n)-1,1):
  if (n[i] == n[i+1]):
    print("Bad")
    else:
    print("Good")

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

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

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

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

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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Wrong Answer

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

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

if s[0] == s[1] or s[1] == s[2] and 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):
S = str(input())
cnt = 0
for i in range(len(S)-1):
    if S[i] == S[i+1]:
        print("Bad")
        print(S[i],S[i+1])
        exit()
print("Good")

S = str(input())
cnt = 0
for i in range(len(S)-1):
    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):
OK_f = 0
S=list(input())
for i in range(len(S)):
    if S[i] == S[i-1]:
        OK_f = 1;
        break
if OK_f == 0:
    print("good")
else:
    print("bad")

OK_f = 0
S=list(input())
for i in range(len(S)):
    if i>0 and S[i] == S[i-1]:
        OK_f = 1;
        break
if OK_f == 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 math
from functools import reduce
from fractions import gcd
#import math
#import itertools
#import statistics
#import numpy as np
#import collections
#n = int(input())
a, b, c, d = list(map(int, input().split()))
#b = list(map(int, input().split()))

#10 11  13 14 15  17  19 20 21 22 23  25 26 27 28 29 
# 31  33 34 35  37 38 39  
lcm = a*b/gcd(a, b)
diff = b-a+1
d1 = (b//c - a//c)
d2 = (b//d - a//d)
a1 =  int((b//lcm-a//lcm))

print(diff-d1-d2+a1)



S = list(input())
count = 0
bad = False

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


#print(bad)

if 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):
arr = list(map(int, input().split()))
for k in range(len(arr)):
  if arr[k] == arr[k+1]:
    print("Bad")
    exit()
print("Good")

arr = list(input())
for k in range(len(arr) - 1):
  if arr[k] == arr[k+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):
ss=input().strip()
flg=False
for i in range(1,len(ss)):
  if ss[i]==ss[i-1]:
    True
    
if flg==True:
  print("Bad")
else:
  print("Good")

ss=input().strip()
flg=False
for i in range(1,len(ss)):
  if ss[i]==ss[i-1]:
    flg=True
    
if flg==True:
  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().sprit()

Flag = True

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

S = input().split()

Flag = True

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

S = int(input())

Flag = True

if (S//1000) == ((S%1000)//100) or ((S%1000)//100) == ((S%100)//10) or ((S%100)//10) == ((S%10)//1):
  Flag = False
  
if Flag == False:
  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())

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

s=input()

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

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


import sys

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


Verdicts: Wrong Answer

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

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

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


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

Verdicts: Runtime Error

Runtime Error

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

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

def main():
    s = str(input())
    if s[0] == s[1] or s[1] == s[2] or s[2] == s[3]:
        print('Bad')
    else:
        print('Good')
            
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):
n = input()
print('Yes' if n[0] != n[1] and n[1] != n[2] and n[2] != n[3] else 'No')

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

Verdicts: Wrong Answer

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

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

if a != b:
  if: b != c:
      if: c != d:
          print("Good")
          return 0
        
print("Bad")


a = input()

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

a = input()

def check():
  for i in range(3):
    if a[i] == a[i+1]:
      print("Bad")
      return 
  print("Good")

check()

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

s[0]s = input()

flg = 0

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

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


s = input()

flg = 0

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

if flg == 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):
ls = list(map(int,input()))
for i in range(len(ls)-1):
  if(ls[i] == ls[i+1]):
    print("bad")
    exit()
print("good")

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

Verdicts: Wrong Answer

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

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

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

Verdicts: Runtime Error

Accepted
Problem: The door of Snuke's laboratory is locked with a security code.  The security code is a 4-digit number. We say the security code is _hard to enter_ when it contains two consecutive digits that are the 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(i) for i in input().split()]

lcm = (C*D)//fractions.gcd(C,D)
A = A-1
t1 = A - (A//C + A//D - A//lcm)
t2 = B - (B//C + B//D - B//lcm)
print(int(t2 - t1))


N = input()

ans = 'Good'
for i in range(len(N)-1):
	if N[i] == N[i+1]:
		ans='Bad'
print(ans)


Verdicts: Runtime Error

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

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

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


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

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

Verdicts: Runtime Error

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):
s = list(map(int, input().solit()))
flg = 1
for i in range(4) :
  if i != 0 & s[i -1] == s[i] :
    flg = 0
if flg == 1 :
  print("Good")
else :
  print("Bad")
    

s = list(map(int, input()))
flg = 1
for i in range(4) :
  if i != 0 :
    if s[i -1] == s[i] :
      flg = 0
if flg == 1 :
  print("Good")
else :
  print("Bad")

Verdicts: Runtime Error

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

Submission attempts (in order):
S = list(map(int,input()))
flag = False
for i in range(len(S)-1):
    if (S[i] == S[i+1]):
        flag = True
    if (flag == True):
        break
if (flag == True):
    print("bad")

else:
    print("good")

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

if (flag == True):
    print("bad")

else:
    print("good")

S = list(map(int,input()))
flag = False
for i in range(len(S)-1):
    if (S[i] == S[i+1]):
        flag = True
if (flag == True):
    print("bad")

else:
    print("good")

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

if (flag == True):
    print("Bad")

else:
    print("Good")

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

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

Submission attempts (in order):
S = str(input())
k = 1
for i in range(3):
    if S[i] == S[i+1]:
        print("bad")
        k = 0
        break
    else:
        continue
if k !=0:
    print("Good")

S = str(input())
k = 1
for i in range(3):
    if S[i] == S[i+1]:
        print("bad")
        k = 0
        break
    else:
        continue
if k == 1:
    print("Good")

S = str(input())
k = 1
for i in range(3):
    if S[i] == S[i+1]:
        print("Bad")
        k = 0
        break
    else:
        continue
if k == 1:
    print("Good")

Verdicts: Wrong Answer

Wrong Answer

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

Submission attempts (in order):
A=list(input())
n=0
for i in range(len(A)-1):
  if A[i]==A[i+1]:
    n=1
    break
print("good"if n==0 else "bad")

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

Verdicts: Wrong Answer

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

Submission attempts (in order):
s = input()
checker = True
for i in range(3):
    a , b = int(s[i]), int(s[i+1])
    if a == b:
        checker=False

if checker:
    print("Good")
else:
    print("bad")

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

if checker:
    print("Good")
else:
    print("bad")

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

if checker:
    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):
a=str(nput())
b=''
r='Good'
for c in a:
    if b == c:
        r='Bad'
        break
    else:
        b = c
print(r)

a=str(input())
b=''
r='Good'
for c in a:
    if b == c:
        r='Bad'
        break
    else:
        b = c
print(r)

Verdicts: Runtime Error

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

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

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

Verdicts: Runtime Error

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

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

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

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

str = input()

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

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

Verdicts: Runtime Error

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

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

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

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

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

Verdicts: Wrong Answer

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

ans = 'Good'

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

passward = input()
last = None
for i in passward:
    if last == i:
        print("Bad")
        break
    else:
        last = i
else:
    print("Good")

Verdicts: Runtime Error

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

Submission attempts (in order):
import math
    def Euclidean(x,y):
        if y == 0:
            return x
        else:
            return Euclidean(y,x%y)
     
A,B,C,D = [int(x) for x in input().split()]
count = B - A + 1
E = Euclidean(C,D)
F = C*D/E
     
C_ = math.floor(B/C) - math.floor((A-1)/C)
D_ = math.floor(B/D) - math.floor((A-1)/D)
C_and_D = math.floor(B/F) - math.floor((A-1)/F)
print(count - int(C_ + D_ - C_and_D))

import math
def Euclidean(x,y):
    if y == 0:
        return x
    else:
        return Euclidean(y,x%y)
         
A,B,C,D = [int(x) for x in input().split()]
count = B - A + 1
E = Euclidean(C,D)
F = C*D/E
         
C_ = math.floor(B/C) - math.floor((A-1)/C)
D_ = math.floor(B/D) - math.floor((A-1)/D)
C_and_D = math.floor(B/F) - math.floor((A-1)/F)
print(count - int(C_ + D_ - C_and_D))

import sys
S = input()
tmp = ""
for i in S:
    if tmp == i:
        print("Bad")
        sys.exit()
    tmp = i
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(int, input().split()))

is_good = True
for i in range(len(s)-1):
    if s[i] == s[i+1]:
        #print('Bad')
        is_good = False
        break

print('Good' if is_good else 'Bad')
    
    

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

x,y = c,d


while y != 0:
	x,y = y,x%y

x = (c*d)//x

count1 = b - (b//c + b//d -b//x)
count2 = (a - 1) - ((a-1)//c + (a-1)//d -(a-1)//x) 
print(count1 - count2)

s = str(input())
is_good = True
for i in range(len(s)-1):
    if s[i] == s[i+1]:
        #print('Bad')
        is_good = False
        break

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


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


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

in_ = input()
is_ok = "Bad"
for i in range(0,len(in_)-1):
  if in_[i] == in_[i+1]:
    pass
  else:
    is_ok = 'Good'
print(is_ok)


in_ = input()
is_ok = "Good"
for i in range(0,len(in_)-1):
  if in_[i] == in_[i+1]:
    is_ok = "Bad"
print(is_ok)


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

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

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

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

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

Verdicts: Runtime Error

Wrong Answer

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

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

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

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

       
for i in range(4):
  if i==3:
    break
  if a[i]==a[i+1] and i==2:
    count+=1
if count>=2:
  print('Bad')
else:
  print('Good')

a=list(input())
count=0

       
for i in range(4):
  if i==3:
    break
  if a[i]==a[i+1] and i==2:
    count+=2
if count>=2:
  print('Bad')
else:
  print('Good')

a=list(input())
count=0
for i in range(4):
  if a[i]==a[i+1] and i==2:
    count+=1
print(count)

a=list(input())
count=0

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

Verdicts: Wrong Answer

Wrong Answer

Runtime Error

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

Submission attempts (in order):
from fractions import gcd
from math import ceil

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

def num(l, r, n):
    return r//n-(l-1)//n

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

l = lcm(c, d)
print((b-a+1)-num(a, b, c)-num(a, b, d)+num(a, b, l))

s = list(input())

count = 0
for i in (0, 2):
    if s[i] == s[i+1]:
        count += 1

if count == 0:
    print('Good')
else:
    print('Bad')

s = list(int(s) for s in input())

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

else:
    print('Good')

Verdicts: Runtime Error

Wrong Answer

Accepted