ZhenlongDai/ACPR huggingface dataset:
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10000000)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate
    
    from bisect import bisect_left,bisect_right
    import heapq
    from math import floor, ceil
    

    
    

    N = int(input())
    if N<=999:
        print('ABC{:03d}'.format(N))
    else:
        print('ABD{:03d}'.format(N-999))

if __name__ == '__main__':
    main()

Failing test case input:
-37

Expected output:
ABC


Actual output:
ABC-37


Fixed submission (verdict: Accepted):


def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10000000)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate
    
    from bisect import bisect_left,bisect_right
    import heapq
    from math import floor, ceil
    

    
    

    N = int(input())
    if N<=999:
        print('ABC')
    else:
        print('ABD')

if __name__ == '__main__':
    main()

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
if N >= 999:
    print("ABC")
else:
    print("ABD")

Failing test case input:
2343

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
N = int(input())
if N <= 999:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print('abd') if int(input()) >= 1000 else print('abc')

Failing test case input:
1711

Expected output:
ABD


Actual output:
abd


Fixed submission (verdict: Accepted):
print('ABD') if int(input()) >= 1000 else print('ABC')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys


def input():
    return sys.stdin.readline()[:-1]






n = int(input())
if n>999:
    print("ABC")
else:
    print("ABD")

Failing test case input:
1100

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
import sys


def input():
    return sys.stdin.readline()[:-1]






n = int(input())
if n<1000:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N = input()

if N >= str(999):
    print('ABC')

else:
    print('ABD')

Failing test case input:
0000

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
N = int(input())

if N < 1000:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())

if n < 1000:
    print('ACB')
else:
    print('ADB')


Failing test case input:
2152

Expected output:
ABD


Actual output:
ADB


Fixed submission (verdict: Accepted):
n = int(input())

if n < 1000:
    print('ABC')
else:
    print('ABD')
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
mod = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

n = ni()

if n < 999:
    print('ABC')
else:
    print('ABD')

Failing test case input:
999

Expected output:
ABC

Actual output:
ABD


Fixed submission (verdict: Accepted):
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
mod = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

n = ni()

if n < 1000:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
if n<=999:
  print("ABD")
else:
  print("ABD")



Failing test case input:
0000

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
n=int(input())
if n<=999:
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
if n<1000:
    print('ABC'+str(n))
else:
    print('ABD'+str(n))

Failing test case input:
1011

Expected output:
ABD


Actual output:
ABD1011


Fixed submission (verdict: Accepted):
n=int(input())
if n<1000:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
if N < 1000:
  print("ABC"+ str(N))
else:
  print("ABD" + str(N))

Failing test case input:
-24

Expected output:
ABC


Actual output:
ABC-24


Fixed submission (verdict: Accepted):
N = int(input())
if N < 1000:
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
a='ABD'
b='ABC'
c=str(N+1)
d=str(N)
if N<=999:
  print(b+d)
else:
  print(a+c)

Failing test case input:
793

Expected output:
ABC


Actual output:
ABC793


Fixed submission (verdict: Accepted):
N=int(input())
a='ABD'
b='ABC'

if N<=999:
  print(b)
else:
  print(a)

Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n = int(input())
if n<1000:
    print('ABD')
else:
    print('ABC')

Failing test case input:
202

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
n = int(input())
if n<1000:
    print('ABC')
else:
    print('ABD')
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if n <= 999:
  answer = "ABC"+str(n).zfill(3)
else:
  answer = "ABD"+str(n-999).zfill(3)
print(answer)
  

Failing test case input:
506

Expected output:
ABC


Actual output:
ABC506


Fixed submission (verdict: Accepted):

n = int(input())
if n <= 999:
  answer = "ABC"
else:
  answer = "ABD"
print(answer)

Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N = input()

if N <= str(999):
    print('ABC')

elif N <= str(1998):
    print('ABD')

Failing test case input:
1010

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
N = int(input())

if N < 1000:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if n <= 999:
  print('ABC'+str(n))
else:
  print('ABD'+str(n-999))

Failing test case input:
-27

Expected output:
ABC


Actual output:
ABC-27


Fixed submission (verdict: Accepted):
n = int(input())
if n <= 999:
  print('ABC')
else:
  print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if n <= 999:
  print("ABC")
else:
  print("ADC")

Failing test case input:
1506

Expected output:
ABD


Actual output:
ADC


Fixed submission (verdict: Accepted):
n = int(input())
if n <= 999:
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
print("ABC"+str(N) if N < 1000 else "ABD"+str(N-1000))

Failing test case input:
1481

Expected output:
ABD

Actual output:
ABD481


Fixed submission (verdict: Accepted):
N = int(input())
print("ABC" if N < 1000 else "ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):




n1 = input()
n = int(n1)+1

if n<=1000:
    print("ABC"+n1)
else:
    print("ABD"+str(n))

Failing test case input:
-37

Expected output:
ABC


Actual output:
ABC-37


Fixed submission (verdict: Accepted):




n1 = input()
n = int(n1)+1

if n<=1000:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print("AB" + "C" if int(input()) <= 999 else "D")

Failing test case input:
1111

Expected output:
ABD


Actual output:
D


Fixed submission (verdict: Accepted):
print("AB" + ("C" if int(input()) <= 999 else "D"))

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
print('ABC' if 1<n<1000 else 'ABD')

Failing test case input:
-22

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
n = int(input())
print('ABC' if n<1000 else 'ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n  = int(input())

if n >= 999:
    print("ABC")
else:
    print("ABD")

Failing test case input:
0001

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
n  = int(input())

if n <= 999:
    print("ABC")
else:
    print("ABD")
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if n < 1000:
  print('ABC' + str(n))
else:
  print('ABD' + str(n-999))


Failing test case input:
0100

Expected output:
ABC


Actual output:
ABC100


Fixed submission (verdict: Accepted):
n = int(input())
if n < 1000:
  print('ABC')
else:
  print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


n = int(input())

pref = ""
if n <= 999:
    pref = "ABC"
else:
    pref = "ABD"
    n = n - 999

print(pref + str(n).zfill(3))


Failing test case input:
7410

Expected output:
ABD


Actual output:
ABD6411


Fixed submission (verdict: Accepted):


n = int(input())

pref = ""
if n <= 999:
    pref = "ABC"
else:
    pref = "ABD"

print(pref)

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


n = input()

print('ABD' + n if int(n) >= 1000 else 'ABC' + n)

Failing test case input:
0111

Expected output:
ABC


Actual output:
ABC0111


Fixed submission (verdict: Accepted):


n = input()

print('ABD' if int(n) >= 1000 else 'ABC')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
offset = 'ABC' if N < 999 else 'ABD'
print(offset)

Failing test case input:
999

Expected output:
ABC

Actual output:
ABD


Fixed submission (verdict: Accepted):
N = int(input())
offset = 'ABC' if N <= 999 else 'ABD'
print(offset)

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A=int(input())
if A > 999:
  print("ABD" + str(A-1000+1))
else :
  print("ABC" + str(A))




Failing test case input:
1711

Expected output:
ABD


Actual output:
ABD712


Fixed submission (verdict: Accepted):
A=int(input())
if A > 999:
  print("ABD" )
else :
  print("ABC")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
under = "ABC"
over = "ABD"

if N > 1000:
  tmp = str(N-1000)
  print(over + tmp)
else:
  tmp = str(N)
  print(under + tmp)

Failing test case input:
0111

Expected output:
ABC


Actual output:
ABC111


Fixed submission (verdict: Accepted):
N = int(input())
under = "ABC"
over = "ABD"

if N > 1000:

  print(over)
elif N == 1000:
  print("ABD")
else:

  print(under)

Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
print('ABC' if int(input()) < 999 else 'ABD')

Failing test case input:
999

Expected output:
ABC

Actual output:
ABD


Fixed submission (verdict: Accepted):
print('ABC' if int(input()) <= 999 else 'ABD')

Problem: p03327
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
N = int(input())

if N <= 999:
  print("ABC"+str(N))
else:
  print("ABD"+str(N-999))

Failing test case input:
-37

Expected output:
ABC


Actual output:
ABC-37


Fixed submission (verdict: Accepted):
N = int(input())

if N <= 999:
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = str(input())
print('ABC'+n) if int(n) < 1000 else print('ABD'+str(int(n)+1)[1:])

Failing test case input:
-34

Expected output:
ABC


Actual output:
ABC-34


Fixed submission (verdict: Accepted):
n = str(input())
print('ABC') if int(n) < 1000 else print('ABD')
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
if a >= 1000:
  print(a-999)
else:
  print(a)

Failing test case input:
1111

Expected output:
ABD


Actual output:
112


Fixed submission (verdict: Accepted):
a = int(input())
if a >= 1000:
  print("ABD")
else:
  print("ABC")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
res = ""

if(n < 1000):
    res = "ABC"
else:
    res = "ABD"

Failing test case input:
-27

Expected output:
ABC


Actual output:

Fixed submission (verdict: Accepted):
n = int(input())
res = ""

if(n < 1000):
    res = "ABC"
else:
    res = "ABD"

print(res)

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k=int(input())
if k<999:
    print("ABC")
else:
    print("ABD")

Failing test case input:
999

Expected output:
ABC

Actual output:
ABD


Fixed submission (verdict: Accepted):
k=int(input())
if k<1000:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())

if N >= 1000:
    print("ABC")
else:
    print("ABD")

Failing test case input:
600

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
N = int(input())

if N < 1000:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print("ABC" if int(input())<=999 else "ADC")

Failing test case input:
3296

Expected output:
ABD


Actual output:
ADC


Fixed submission (verdict: Accepted):
print("ABC" if int(input())<=999 else "ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if n < 1999:
	print('ABD')
else:
	print('ABC')

Failing test case input:
7410

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
n = int(input())
if n >= 1000:
	print('ABD')
else:
	print('ABC')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())

if n < 1000:
    print('ABC')
else:
    print('ADB')


Failing test case input:
2152

Expected output:
ABD


Actual output:
ADB


Fixed submission (verdict: Accepted):
n = int(input())

if n < 1000:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if n < 1000:
	print('ABD')
else:
	print('ABC')

Failing test case input:
-76

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
n = int(input())
if n >= 1000:
	print('ABD')
else:
	print('ABC')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
if N >= 1000:
    print('ABC'+str(N-1000))
else:
    print('ABC'+str(N))

Failing test case input:
127

Expected output:
ABC


Actual output:
ABC127


Fixed submission (verdict: Accepted):
N = int(input())
if N >= 1000:
    print('ABD')
else:
    print('ABC')
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = int(input())

if s > 999:
    print("ABD" + str(s - 999))
else:
    print("ABC" + str(s))

Failing test case input:
0010

Expected output:
ABC


Actual output:
ABC10


Fixed submission (verdict: Accepted):
s = int(input())

if s > 999:
    print("ABD")
else:
    print("ABC")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if n < 999:
    print('ABC')
else:
    print('ABD')

Failing test case input:
999

Expected output:
ABC

Actual output:
ABD


Fixed submission (verdict: Accepted):
n = int(input())
if n <= 999:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if n < 999:
    print('ABC')
else:
    print('ABD')

Failing test case input:
999

Expected output:
ABC

Actual output:
ABD


Fixed submission (verdict: Accepted):
n = int(input())
if n <= 999:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
if(int(input()) > 1000):
  print("‪ABD")
else:
  print("ABC")

Failing test case input:
1011

Expected output:
ABD


Actual output:
‪ABD


Fixed submission (verdict: Accepted):
if(int(input()) < 1000):
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
offset = 'ABC' if N < 1000 else 'ABC'
print(offset + str(N%1000))

Failing test case input:
-54

Expected output:
ABC


Actual output:
ABC946


Fixed submission (verdict: Accepted):
N = int(input())
offset = 'ABC' if N <= 999 else 'ABD'
print(offset)

Problem: p03327
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
import sys
import heapq

def input():
    return sys.stdin.readline().rstrip()


def main():
    N =int(input())

    if N>999:
        print(f"ABD{N-1000:03}")
    else:
        print(f"ABC{N:03}")









if __name__ == "__main__":
    main()


Failing test case input:
1101

Expected output:
ABD


Actual output:
ABD101


Fixed submission (verdict: Accepted):
import sys
import heapq

def input():
    return sys.stdin.readline().rstrip()


def main():
    N =int(input())

    if N>999:
        print("ABD")
    else:
        print("ABC")









if __name__ == "__main__":
    main()

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())

if N < 1000:
  print("ABC"+str(N))
else:
  print("ABD"+str(N))

Failing test case input:
1101

Expected output:
ABD


Actual output:
ABD1101


Fixed submission (verdict: Accepted):
N=int(input())

if N < 1000:
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
if N<1000:
    print('ABC',N)
else:
    print('ABD',N-999)

Failing test case input:
1011

Expected output:
ABD


Actual output:
ABD 12


Fixed submission (verdict: Accepted):
N=int(input())
if N<1000:
    print('ABC')
else:
    print('ABD')
Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n=int(input())
print('ABC' if 1<=999 else 'ABD')

Failing test case input:
1011

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
n=int(input())
print('ABC' if n<=999 else 'ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


a = int(input())

if a <= 99:
    print("ABC")
else:
    print("ABD")

Failing test case input:
912

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):


a = int(input())

if a <= 999:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())

if n / 1000 == 0:
	print("ABC")
else: 
	print("ABD")

Failing test case input:
-22

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
n = int(input())

if n / 1000 < 1:
	print("ABC")
else: 
	print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
if n<=999:
  print("ABC"+str(n))
else:
  print("ABD"+str(n-999))

Failing test case input:
3296

Expected output:
ABD


Actual output:
ABD2297


Fixed submission (verdict: Accepted):
n=int(input())
if n<=999:
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def con_n(N):
    if N <= 1000:
        return 'ABC'
    elif N > 1000:
        return 'ABD'

Failing test case input:
-23

Expected output:
ABC


Actual output:

Fixed submission (verdict: Accepted):
n = int(input())
def con_n(n):
    if n < 1000:
        return 'ABC'
    elif n >= 1000:
        return 'ABD'
    
print(con_n(n))

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
N=1000
if N>=1000:
  print("ABD")
else:
  print("ABC")

Failing test case input:
793

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
N=int(input())
if N>=1000:
  print("ABD")
else:
  print("ABC")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
if N % 999 != 0:
    print("ABD")
else:
    print("ABC")

Failing test case input:
411

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
N = int(input())
if N > 999:
    print("ABD")
else:
    print("ABC")

Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N=int(input())

if N < 1000:
    print('ABC')


elif 1000 <= N < 1998:
    print('ABD')

Failing test case input:
2152

Expected output:
ABD


Actual output:

Fixed submission (verdict: Accepted):
N=input()

if int(N) >= 1000:
    print('ABD')


else:
    print('ABC')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=input()
if int(n)<1000:
  ans="ABC"+n
else:
  ans="ABD"+n[1:]
print(ans)

Failing test case input:
972

Expected output:
ABC


Actual output:
ABC972


Fixed submission (verdict: Accepted):
n=input()
if int(n)<1000:
  print("ABC")
else:
  print("ABD")
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
if n<1000:
  print("ABC"+str(n))
else:
  print("ABD"+str(n))

Failing test case input:
761

Expected output:
ABC


Actual output:
ABC761


Fixed submission (verdict: Accepted):
n=int(input())
if n<1000:
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
N = int(input())
if N <= 999:
    print("ABC")
else:
    print("ADC")

Failing test case input:
1539

Expected output:
ABD


Actual output:
ADC


Fixed submission (verdict: Accepted):
N = int(input())
if N <= 999:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
if N > 999 == 0:
    print("ABD")
else:
    print("ABC")


Failing test case input:
1481

Expected output:
ABD

Actual output:
ABC


Fixed submission (verdict: Accepted):
N = int(input())
if N > 999:
    print("ABD")
else:
    print("ABC")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda x: [na() for _ in range(x)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda x: [ns() for _ in range(x)]
nas = lambda: stdin.readline().split()

n = ni()

if n < 1000:
    print("ABC{:0>3}".format(n))
else:
    print("ABD{:0>3}".format(n - 999))

Failing test case input:
0111

Expected output:
ABC


Actual output:
ABC111


Fixed submission (verdict: Accepted):
import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda x: [na() for _ in range(x)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda x: [ns() for _ in range(x)]
nas = lambda: stdin.readline().split()

n = ni()

if n < 1000:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left 

sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print('\n'.join(map(str, x)))

N = int(input())

if N>999:
    print('ABC')
else:
    print('ABD')




Failing test case input:
600

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left 

sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print('\n'.join(map(str, x)))

N = int(input())

if N>999:
    print('ABD')
else:
    print('ABC')
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
if N >= 999:
    print("ABC")
else:
    print("ABD")

Failing test case input:
0100

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
N = int(input())
if N <= 999:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n = int(input())
if n < 1000:
	print("ABC"+str(n))
else:
	print("ABD"+str(n-999))


Failing test case input:
0010

Expected output:
ABC


Actual output:
ABC10


Fixed submission (verdict: Accepted):
n = int(input())
if n < 1000:
	print("ABC")
else:
	print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys

input = sys.stdin.readline


def main():
    n = int(input())
    if n < 1000:
        print("ABC{:03}".format(n))
    else:
        print("ABD{:03}".format(n - 999))


if __name__ == "__main__":
    main()


Failing test case input:
2152

Expected output:
ABD


Actual output:
ABD1153


Fixed submission (verdict: Accepted):
import sys

input = sys.stdin.readline


def main():
    n = int(input())
    if n < 1000:
        print("ABC")
    else:
        print("ABD")


if __name__ == "__main__":
    main()

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
print("ABC" if 1000<n else "ABD")

Failing test case input:
0101

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
n = int(input())
print("ABC" if n<1000 else "ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
if N > 999:
    print('ABC')
else:
    print('ABD')

Failing test case input:
0111

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
N=int(input())
if N > 999:
    print('ABD')
else:
    print('ABC')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):



n = int(input())

if n >= 999:
    print("ABD")

else:
    print("ABC")


Failing test case input:
999

Expected output:
ABC

Actual output:
ABD


Fixed submission (verdict: Accepted):



n = int(input())

if n > 999:
    print("ABD")

else:
    print("ABC")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if n<999:
  print("ABC"+str(n))
else:
  print("ABD"+str(n-999))

Failing test case input:
127

Expected output:
ABC


Actual output:
ABC127


Fixed submission (verdict: Accepted):
n = int(input())
if n<=999:
  print("ABC")
else:
  print("ABD")
Problem: p03327
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):









import sys



ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)

def main():
    n = int(input())
    if n < 1000:
        print("ABC"+str(n).zfill(3))
    else:
        n -= 999
        print("ABD"+str(n).zfill(3))

if __name__ == '__main__':
    main()

Failing test case input:
1111

Expected output:
ABD


Actual output:
ABD112


Fixed submission (verdict: Accepted):









import sys



ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)

def main():
    n = int(input())
    if n < 1000:
        print("ABC")
    else:
        print("ABD")

if __name__ == '__main__':
    main()

Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n = int(input())

if n >= 1000:
    print("ABD" + str(n - 999).zfill(3))
else:
    print("ABC" + str(n))

Failing test case input:
1110

Expected output:
ABD


Actual output:
ABD111


Fixed submission (verdict: Accepted):
n = int(input())

if n >= 1000:
    print("ABD")
    
if n <= 999:
    print("ABC")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
def con_n(n):
    if n <= 1000:
        return 'ABC'
    elif n > 1000:
        return 'ABD'
    
con_n(n)

Failing test case input:
999

Expected output:
ABC

Actual output:

Fixed submission (verdict: Accepted):
n = int(input())
def con_n(n):
    if n < 1000:
        return 'ABC'
    elif n >= 1000:
        return 'ABD'
    
print(con_n(n))

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())

if N <= 999:
  print("ABC"+str(N))
else:
  print("ABD"+str(N))

Failing test case input:
-22

Expected output:
ABC


Actual output:
ABC-22


Fixed submission (verdict: Accepted):
N=int(input())

if N < 1000:
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
print("ABC" if N-999<0 else "ABD")

Failing test case input:
999

Expected output:
ABC

Actual output:
ABD


Fixed submission (verdict: Accepted):
N=int(input())
print("ABC" if N-1000<0 else "ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
a='ABD'
b='ABC'
c=str(N-999)
d=str(N)
if N<=999:
  print(b+d)
else:
  print(a+c)

Failing test case input:
-27

Expected output:
ABC


Actual output:
ABC-27


Fixed submission (verdict: Accepted):
N=int(input())
a='ABD'
b='ABC'

if N<=999:
  print(b)
else:
  print(a)

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
print("ABC" if N < 1000 else "ABC")

Failing test case input:
1481

Expected output:
ABD

Actual output:
ABC


Fixed submission (verdict: Accepted):
N=int(input())
print("ABC" if N < 1000 else "ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if n<1000:
    print("ABD")
else:
    print("ABC")

Failing test case input:
260

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
n = int(input())

if n<1000:
    print("ABC")
else:
    print("ABD")
Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N=int(input())

if N<=999:
  print("ABC"+str(N))
else:
  print("ABR"+str(N-1000+1))




Failing test case input:
912

Expected output:
ABC


Actual output:
ABC912


Fixed submission (verdict: Accepted):
N=int(input())

if N<=999:
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())

if N < 1000:
    print("ABD0")
else:
    print("ABD1")

Failing test case input:
1539

Expected output:
ABD


Actual output:
ABD1


Fixed submission (verdict: Accepted):
N=int(input())

if N < 1000:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n = int(input())

if n >= 1000:
    print("ABD" + str(n - 999).zfill(3))
if n <= 999:
    print("ABC" + str(n))

Failing test case input:
0111

Expected output:
ABC


Actual output:
ABC111


Fixed submission (verdict: Accepted):
n = int(input())

if n >= 1000:
    print("ABD")
    
if n <= 999:
    print("ABC")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
if N >= 1000:
    print('ABC')
else:
    print('ABC')

Failing test case input:
1010

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
N = int(input())
if N >= 1000:
    print('ABD')
else:
    print('ABC')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
offset = 'ABC' if N < 999 else 'ABC'
print(offset + str(N%999))

Failing test case input:
0001

Expected output:
ABC


Actual output:
ABC1


Fixed submission (verdict: Accepted):
N = int(input())
offset = 'ABC' if N <= 999 else 'ABD'
print(offset)

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input(' '))

def calc1(N):
  if N <= 999:
    return 'ABC' + str(N).zfill(3)
  else:
    return 'ABD' + str(-999 + N).zfill(3)

print(calc1(N))

Failing test case input:
972

Expected output:
ABC


Actual output:
 ABC972


Fixed submission (verdict: Accepted):
N = int(input(' '))

def calc1(N):
  if N <= 999:
    return 'ABC' 
  else:
    return 'ABD' 

print(calc1(N))

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())

if n % 999 == 0:
    print(999)
else:
    print(n%999)

Failing test case input:
2152

Expected output:
ABD


Actual output:
154


Fixed submission (verdict: Accepted):
n = int(input())

if n <= 999:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
if(N<=999):
    print("ABC")
if(N>=1000&N<=1998):
    print("ABD")

Failing test case input:
0111

Expected output:
ABC


Actual output:
ABC
ABD


Fixed submission (verdict: Accepted):
N=int(input())
if(N<=999):
    print("ABC")
if(N>=1000):
    print("ABD")
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
if N<1000:
    print('ABC%03d'%(N))
else:
    N=N-999
    print('ABD%03d'%(N))

Failing test case input:
1011

Expected output:
ABD


Actual output:
ABD012


Fixed submission (verdict: Accepted):
N=int(input())
if N<1000:
    print('ABC')
else:
    N=N-999
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
from sys import stdin
N = int(stdin.readline().rstrip())
if N <= 999:
    print("ABC")
    
else:
    print("ARC")

Failing test case input:
1539

Expected output:
ABD


Actual output:
ARC


Fixed submission (verdict: Accepted):
from sys import stdin
N = int(stdin.readline().rstrip())
if N <= 999:
    print("ABC")
    
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())

if N <= 999:
    print("ABC" + str(N))
else:
    print("ABD"+str(N))

Failing test case input:
972

Expected output:
ABC


Actual output:
ABC972


Fixed submission (verdict: Accepted):
N = int(input())

if N <= 999:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if n > 999:
	print('ABD')
else:
	print('ABD')

Failing test case input:
0100

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
n = int(input())
if n > 999:
	print('ABD')
else:
	print('ABC')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())

contest = "ABC"
if n >= 1000:
    contest = "ABD"

print("{}{:0>3}".format(contest,n%1000))

Failing test case input:
506

Expected output:
ABC


Actual output:
ABC506


Fixed submission (verdict: Accepted):
n = int(input())

contest = "ABC"
if n >= 1000:
    contest = "ABD"

print(contest)

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=int(input())
if a<1000:
  print(a)
else:
  print(a-999)

Failing test case input:
0111

Expected output:
ABC


Actual output:
111


Fixed submission (verdict: Accepted):
a=int(input())
if a<1000:
  print('ABC')
else:
  print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
line = input()

num = int(line)

if num < 1000:
    print("ABC" + str(num))
else:
    print("ABD" + str(num - 1000))

Failing test case input:
1010

Expected output:
ABD


Actual output:
ABD10


Fixed submission (verdict: Accepted):
line = input()

num = int(line)

if num < 1000:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
if n<=99:
    print("ABC")
else:
    print("ABD")


Failing test case input:
972

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
n=int(input())
if n<=999:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())

if n < 1000:
    print('abc')
else:
    print('abd')

Failing test case input:
411

Expected output:
ABC


Actual output:
abc


Fixed submission (verdict: Accepted):
n = int(input())

if n < 1000:
    print('ABC')
else:
    print('ABD')
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
if int(input())<999:
    print('ABC')
else:
    print('ABD')

Failing test case input:
999

Expected output:
ABC

Actual output:
ABD


Fixed submission (verdict: Accepted):
if int(input())<1000:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


def main():
    
    N = int(input())

    if N < 1000:
        print('ABC{0:03d}'.format(N))
    else:
        print('ABD{0:03d}'.format(N-999))


if __name__ == '__main__':
    main()

Failing test case input:
4600

Expected output:
ABD


Actual output:
ABD3601


Fixed submission (verdict: Accepted):


def main():
    
    N = int(input())

    if N < 1000:
        print('ABC')
    else:
        print('ABD')


if __name__ == '__main__':
    main()

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):



n = int(input())
if n < 1000:
    print("ABC" + str(n))
else:
    print("ABD" + str(n - 999))

Failing test case input:
1011

Expected output:
ABD


Actual output:
ABD12


Fixed submission (verdict: Accepted):



n = int(input())
if n < 1000:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())

if n < 999:
	print('ABC')
else:
	print('ABD')

Failing test case input:
999

Expected output:
ABC

Actual output:
ABD


Fixed submission (verdict: Accepted):
n = int(input())

if n <= 999:
	print('ABC')
else:
	print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
if(int(input()) >= 1000):
  print("‪ABD")
else:
  print("ABC")

Failing test case input:
2152

Expected output:
ABD


Actual output:
‪ABD


Fixed submission (verdict: Accepted):
if(int(input()) < 1000):
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())

if N <= 999:
  print('ABC' + str(N))
else:
  print('ABD' + str(N-999))

Failing test case input:
2343

Expected output:
ABD


Actual output:
ABD1344


Fixed submission (verdict: Accepted):
N = int(input())
 
if N <= 999:
  print('ABC')
else:
  print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
if a < 1000:
    print('abc')
else:
    print('abd')

Failing test case input:
0010

Expected output:
ABC


Actual output:
abc


Fixed submission (verdict: Accepted):
a = int(input())
if a < 1000:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())

if N < 1000:
  print("ABC" + str(N))
else:
  print("ABD" + str(N - 999))


Failing test case input:
0110

Expected output:
ABC


Actual output:
ABC110


Fixed submission (verdict: Accepted):
N = int(input())

if N < 1000:
  print("ABC")
else:
  print("ABD")
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

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

if __name__ == '__main__':
    a = [int(i) for i in input().split()]

    if a[0] >999:
        print("ABD"+str(a[0]-999))
    else:
        print("ABC"+str(a[0]))



Failing test case input:
1100

Expected output:
ABD


Actual output:
ABD101


Fixed submission (verdict: Accepted):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

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

if __name__ == '__main__':
    a = [int(i) for i in input().split()]

    if a[0] >999:
        print("ABD")
    else:
        print("ABC")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())

if n >= 1000:
  print('ABC')
else:
  print('ABD')

Failing test case input:
1011

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
n = int(input())
if n >= 1000:
  print('ABD')
else:
  print('ABC')

Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N = input()

if N <= str(999):
    print('ABC')

if N >= str(1000):
    print('ABD')

Failing test case input:
600

Expected output:
ABC


Actual output:
ABC
ABD


Fixed submission (verdict: Accepted):
N = int(input())

if N < 1000:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())

if n > 999:
    print('ABD{}'.format(n - 999))
else:
    print('ABC{}'.format(n))

Failing test case input:
1111

Expected output:
ABD


Actual output:
ABD112


Fixed submission (verdict: Accepted):
n = int(input())
 
if n > 999:
    print('ABD')
else:
    print('ABC')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import itertools
def main():
  n = int(input())
  print(("ABC"+'{:03}'.format(n))if n<=999 else "ABD"+'{:03}'.format(n-999))
if __name__ == '__main__':
  main()

Failing test case input:
0000

Expected output:
ABC


Actual output:
ABC000


Fixed submission (verdict: Accepted):
import itertools
def main():
  n = int(input())
  print("ABC"if n<=999 else "ABD")
if __name__ == '__main__':
  main()

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print('ABD'if input()>'999'else'ABC')

Failing test case input:
1711

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
print('ABD'if int(input())>999else'ABC')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
print("ABC") if n-999 else print("ABD") 

Failing test case input:
1101

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
n = int(input())
print("ABD") if n>999 else print("ABC")
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def main() -> None:
    N = int(input())
    print(f(N))


def f(N: int) -> str:
    s = ""
    if N < 1000:
        s = "ABC{}"
    else:
        s = "ABD{}"

    return s



if __name__ == '__main__':
    main()


Failing test case input:
1110

Expected output:
ABD


Actual output:
ABD{}


Fixed submission (verdict: Accepted):
def main() -> None:
    N = int(input())
    print(f(N))


def f(N: int) -> str:
    s = ""
    if N < 1000:
        s = "ABC"
    else:
        s = "ABD"

    return s



if __name__ == '__main__':
    main()

Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N=int(input())

if N<=999:
  print("ABC"+str(N))
else:
  print("ABD"+str(N-1000+1))




Failing test case input:
-54

Expected output:
ABC


Actual output:
ABC-54


Fixed submission (verdict: Accepted):
N=int(input())

if N<=999:
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
if N < 999:
  print("ABD")
else:
  print("ABC")

Failing test case input:
3296

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
N = int(input())
if N < 1000:
  print("ABC")
else:
  print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if n>=1000:
    print('ABD{}'.format(n-999))
else:
    print('ABC{}'.format(n))

Failing test case input:
0010

Expected output:
ABC


Actual output:
ABC10


Fixed submission (verdict: Accepted):
n = int(input())
if n>=1000:
    print('ABD')
else:
    print('ABC')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
if N<1000:
    print('ABC'+str(N))
else:
    print('ABD'+str(((N%1000)+1)))


Failing test case input:
0111

Expected output:
ABC


Actual output:
ABC111


Fixed submission (verdict: Accepted):
N=int(input())
if N<1000:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
def con_n(n):
    if n <= 1000:
        return 'ABC'
    elif n > 1000:
        return 'ABD'

Failing test case input:
-43

Expected output:
ABC


Actual output:

Fixed submission (verdict: Accepted):
n = int(input())
def con_n(n):
    if n < 1000:
        return 'ABC'
    elif n >= 1000:
        return 'ABD'
    
print(con_n(n))

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def main():
    N = int(input())

    if N > 999:
        print('ABC')
    else:
        print('ABD')

main()


Failing test case input:
1110

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
def main():
    N = int(input())

    if N < 1000:
        print('ABC')
    else:
        print('ABD')

main()

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
if n<=999:
  print('ABC'+str(n))
else:
  n=n-999
  print('ABD'+str(n))

Failing test case input:
1101

Expected output:
ABD


Actual output:
ABD102


Fixed submission (verdict: Accepted):
n=int(input())
if n<=999:
  print('ABC')
else:
  print('ABD')
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
print("ABD") if n-999 else print("ABC") 

Failing test case input:
0101

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
n = int(input())
print("ABD") if n>999 else print("ABC")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
def con_n(n):
    if N <= 1000:
        return 'ABC'
    elif N > 1000:
        return 'ABD'

Failing test case input:
-22

Expected output:
ABC


Actual output:

Fixed submission (verdict: Accepted):
n = int(input())
def con_n(n):
    if n < 1000:
        return 'ABC'
    elif n >= 1000:
        return 'ABD'
    
print(con_n(n))

Problem: p03327
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N = input()

if N < "1000":
    print("ABC")
else:
    print("ABD")





Failing test case input:
842

Expected output:
ABC


Actual output:
ABD


Fixed submission (verdict: Accepted):
N = int(input())

if N < 1000:
    print("ABC")
else:
    print("ABD")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


N = int(input())
if N > 999:
    print('ABC')
elif N <= 999:
    print('ABD')


Failing test case input:
3296

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
N = int(input())
if N > 999:
    print('ABD')
elif N <= 999:
    print('ABC')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
if N >= 999:
    print("ABC")
else:
    print("ABD")

Failing test case input:
1010

Expected output:
ABD


Actual output:
ABC


Fixed submission (verdict: Accepted):
N = int(input())
if N > 999:
    print("ABD")
else:
    print("ABC")

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input(' '))

def calc1(N):
  if N <= 999:
    return 'ABC' + str(N)
  else:
    return 'ABD' + str(-999 + N)

print(calc1(N))

Failing test case input:
506

Expected output:
ABC


Actual output:
 ABC506


Fixed submission (verdict: Accepted):
N = int(input(' '))

def calc1(N):
  if N <= 999:
    return 'ABC' 
  else:
    return 'ABD' 

print(calc1(N))

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
if N <= 999:
    print('ABC'+str(N))
else:
    print('ABD'+str(N-999))


Failing test case input:
0000

Expected output:
ABC


Actual output:
ABC0


Fixed submission (verdict: Accepted):
N = int(input())
if N <= 999:
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x=int(input())
if x<1000:
  print("ABC"+str(x))
else:print("ABD"+str(x-999).zfill(3))

Failing test case input:
0100

Expected output:
ABC


Actual output:
ABC100


Fixed submission (verdict: Accepted):
x=int(input())
if x<1000:
  print("ABC")
else:print("ABD")
Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
if(n <= 999):
    print('ABC' + str(n))
else:
    print('ABD' + str(n))

Failing test case input:
0101

Expected output:
ABC


Actual output:
ABC101


Fixed submission (verdict: Accepted):
n = int(input())
if(n <= 999):
    print('ABC')
else:
    print('ABD')

Problem: p03327
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
if N < 1000:
	print('ABC%03d' % N)
else:
	print('ABD%03d' %(N-999))

Failing test case input:
-43

Expected output:
ABC


Actual output:
ABC-43


Fixed submission (verdict: Accepted):
N = int(input())
if N < 1000:
	print('ABC')
else:
	print('ABD')