output_description stringlengths 15 956 | submission_id stringlengths 10 10 | status stringclasses 3 values | problem_id stringlengths 6 6 | input_description stringlengths 9 2.55k | attempt stringlengths 1 13.7k | problem_description stringlengths 7 5.24k | samples stringlengths 2 2.72k |
|---|---|---|---|---|---|---|---|
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s855770078 | Wrong Answer | p03327 | Input is given from Standard Input in the following format:
N | print("AB" + "CD"[input() > "999"])
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s245089934 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | print("ABD" if input() > 999 else "ABC")
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s739393389 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | N = int(input())
if (N>999): print("ABD")
else; print("ABC") | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s447384711 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | print("ABC" if input() < 1000 else "ABD")
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s509521288 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | return "ABC" if int(input()) < 1000 else "ABD"
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s909059446 | Wrong Answer | p03327 | Input is given from Standard Input in the following format:
N | print("ABD" if input() > "999" else "ABC")
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s513805428 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | aa
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s901793088 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | N = int(input())
if N<=999:
print('ABC'
else:
print('ABD') | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s611496106 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | n=intput()
if (n < 1000)
print("ABC")
else
print("ABD") | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s444453457 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | int n = input()
print("ABC" if n < 1000 else "ABD") | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s789751848 | Wrong Answer | p03327 | Input is given from Standard Input in the following format:
N | print("AB%s" % chr(67 + len(input()) % 3))
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s671366704 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | print("AABBDC")[int(input()) < 1000 :: 2]
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s997718107 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | print("AABBDC"[int(input())<1000::2] | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s453830127 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | a=int(input())
if a>= 1000:
print("ABD"):
else:
print("ABC") | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s275617520 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | n=int(input())
if (n < 1000)
print("ABC")
else
print("ABD")
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s706879297 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | n = int(input())
if n > 999:
print('ABD)
else:
print('ABC') | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s221469532 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | N = int(input())
if N <1000:
print('ABC')
else:
print('ABD')
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s681312915 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | N = input()
if len(N)<=3:
print("ABC")
else:
print("ABD)
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s444957907 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | n = int(input())
if n <=999:
print("ABC")
else:
print("ABD")) | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s748078086 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | a=int(input())
if a < = 999:
print('ABC')
else:
print('ABD') | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s380344853 | Accepted | p03327 | Input is given from Standard Input in the following format:
N | def getinputdata():
array_result = []
data = input()
array_result.append(data.split(" "))
flg = True
try:
while flg:
data = input()
if data != "":
array_result.append(data.split(" "))
flg = True
else:
flg = False
finally:
return array_result
arr_data = getinputdata()
n = int(arr_data[0][0])
print("ABC" if n < 1000 else "ABD")
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s517380560 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | c = 0
A = input()
B = A.split(" ")
a, b = int(B[0]), int(B[1])
for i in range(1, a - b):
c = c + i
print(c - a)
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s660212219 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | a = int(input())
if any(a):
return a
if a >999
return 'ABD'
elif a <999
return 'ABC'
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s167490987 | Wrong Answer | p03327 | Input is given from Standard Input in the following format:
N | def B1(N):
if N <= 999:
return "ABC"
elif N > 999:
return "ABD"
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s086384218 | Wrong Answer | p03327 | Input is given from Standard Input in the following format:
N | N = int(input())
# 使い切ったブロックの数
block = (N - 1) // 999
a = chr(ord("C") + block)
N2 = N - block * 999
if N2 < 10:
c = "00"
elif N2 < 100:
c = "0"
else:
c = ""
b = "AB" + a + c + str(N2)
print("{}".format(b))
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s718653291 | Wrong Answer | p03327 | Input is given from Standard Input in the following format:
N | n = str(input())
print("ABC" + n) if int(n) < 1000 else print("ABD" + str(int(n) + 1)[1:])
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s223034530 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | N=int(input())
if N<1000:
print(“ABC”)
else:
print(“ABD”) | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s209531033 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | N=int(input())
if N<1000:
print('ABC',N)
elif:
print('ABD',N-999) | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s427855168 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | rint("ABC" if int(input()) < 1000 else "ABD")
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s586423574 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | print(["ABD","ABC][len(input())==3]) | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s594023834 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | n, c = [int(i) for i in input().split()]
d = []
for i in range(c):
d.append(list(map(int, input().split())))
color = []
for i in range(n):
color.append(list(map(int, input().split())))
for i in range(n):
for j in range(n):
color[i][j] -= 1
dofc = [[0 for i in range(3)] for j in range(c)]
for t in range(3):
for a in range(c):
for l in range(n):
for row in range(n):
dofc[a][(l + row) % 3] += d[a][color[row][l]]
D = dofc[0][0] + dofc[1][1] + dofc[2][2]
for c0 in range(c):
for c1 in range(c):
if c1 == c0:
continue
for c2 in range(c):
if c2 == c1 or c2 == c0:
continue
D = min(D, dofc[c0][0] + dofc[c1][1] + dofc[c2][2])
print(D)
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s396201378 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | # import time
N, C = map(int, input().split()) # 同上。map関数を使うとこのように書ける
D = [[0 for i in range(C)] for j in range(C)]
c = [[0 for i in range(N)] for j in range(N)]
# iwakan = [[[0 for i in range(N)] for j in range(N)] for k in range(C)]
for i in range(C):
D[i] = list(map(int, input().split()))
for i in range(N):
c[i] = list(map(int, input().split()))
# まず違和感リストを作る。
# for i in range(C):
# for j in range(N):
# for k in range(N):
# iwakan[i][j][k] = D[c[j][k] - 1][i]
"""
Gij0 : (i + j) % 3 == 0 となる場所
Gij1 : (i + j) % 3 == 1 となる場所
Gij2 : (i + j) % 3 == 2 となる場所
とした時に、
Gijnに属する場所全ての色をaに塗り替える場合の違和感の合計を
iwakan[n][a]とする。
iwakan[n][a]を全て求めるための計算量は、30*500*500 = 7500000
iwakan を用いて全ての色の塗り替えの組み合わせを求めるための計算量は
30 * 29 * 28 = 24360
"""
# t1 = time.time()
# Gijnに属する色の数を合計したリストを作る。
numOfColors = [[0 for i in range(C)] for j in range(3)]
for i in range(N):
for j in range(N):
if (i + j) % 3 == 0:
numOfColors[0][c[i][j] - 1] = numOfColors[0][c[i][j] - 1] + 1
if (i + j) % 3 == 1:
numOfColors[1][c[i][j] - 1] = numOfColors[1][c[i][j] - 1] + 1
if (i + j) % 3 == 2:
numOfColors[2][c[i][j] - 1] = numOfColors[2][c[i][j] - 1] + 1
iwakan = [[0 for i in range(C)] for j in range(3)]
for i in range(3):
for j in range(C):
for a in range(C):
iwakan[i][j] = iwakan[i][j] + numOfColors[i][a] * D[a][j]
# t2 = time.time()
sum_min = float("inf")
for i in range(C):
for j in range(C):
for k in range(C):
if (i == j) or (j == k) or (k == i):
pass
else:
sum_tmp = iwakan[0][i] + iwakan[1][j] + iwakan[2][k]
if sum_min > sum_tmp:
sum_min = sum_tmp
# t3 = time.time()
print(sum_min)
# elapsed_time1 = t2 - t1
# elapsed_time2 = t3 - t2
# print(f'time1: {elapsed_time1}')
# print(f'time2: {elapsed_time2}')
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s941235028 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | N = int(input())
if N>=1,N<=999:
print('ABC')
if N>=1000,N<=1998
print('ABD') | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s108915377 | Accepted | p03327 | Input is given from Standard Input in the following format:
N | print("AB" + ["D", "C"][int(input()) < 1000])
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s947632749 | Accepted | p03327 | Input is given from Standard Input in the following format:
N | print("ABD") if int(input()) >= 1000 else print("ABC")
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s441856952 | Accepted | p03327 | Input is given from Standard Input in the following format:
N | print(["ABC", "ABD"][int(input()) >= 1000])
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s237396377 | Accepted | p03327 | Input is given from Standard Input in the following format:
N | print("AABBDC"[int(input()) < 1000 :: 2])
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s624408211 | Wrong Answer | p03327 | Input is given from Standard Input in the following format:
N | print("ABD")
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s366909392 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | a = map(int, input().split())
print("ABD" if a < 1000 else "ABC")
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s105403271 | Wrong Answer | p03327 | Input is given from Standard Input in the following format:
N | print(format(0xABC000 + int(input(), 16), "x").upper())
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s021070422 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | print("AB" + ["C", "D"][len(input() < 4)])
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s538707385 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | a=int(input())
if a<=999:
print("ABC")
else:
print("ABD) | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s859087103 | Wrong Answer | p03327 | Input is given from Standard Input in the following format:
N | print("ABD" if int(input()) > 1000 else "ABC")
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s526440193 | Wrong Answer | p03327 | Input is given from Standard Input in the following format:
N | print("AB" + ["C", "D"][len(input()) < 4])
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s788672082 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | ｆｇｈｊ
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s924333662 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | #include <bits/stdc++.h>
using namespace std;
//container util
//------------------------------------------
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
//repetition
//------------------------------------------
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
//conversion
//------------------------------------------
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
//debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
//math
//-------------------------------------------
template<class T> inline T sqr(T x) {return x*x;}
typedef long long LL;
const LL mod=1000000007;
#define MAX 10000
#define NIL -1
const double PI = acos(-1.0);
const int INF = 1e9 + 7;
//-------------------------------------------
int n;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
if( n > 999)cout <<"ABD"<< endl;
else { cout <<"ABC"<< endl;}
return 0;
}
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s239928361 | Wrong Answer | p03327 | Input is given from Standard Input in the following format:
N | l = list(input())
if len(l) == 4:
print("ABD" + l[1] + l[2] + l[3])
elif len(l) == 3:
print("ABC" + l[0] + l[1] + l[2])
elif len(l) == 2:
print("ABC" + "0" + l[0] + l[1])
else:
print("ABC" + "00" + l[0])
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s175956938 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | n=int(input())
if n<=999:
print('ABC'+'{0:03d}'.format(n))
else:
n=n-999
print('ABD'+{0:03d}'.format(n)) | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s644024931 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | # -*- coding: utf-8 -*-
import sys
def main(argv):
i = int(argv[0])
if i => 0 and 999 <= i:
print('ABC')
elif i > 999:
print('ABD')
if __name__ == '__main__':
main(sys.argv[1:]) | Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
Print the first three characters of the label of the N-th round of AtCoder
Beginner Contest.
* * * | s175076866 | Runtime Error | p03327 | Input is given from Standard Input in the following format:
N | a, b = map(int, input().split())
n = 0
for i in range(1, a - b + 1):
n += i
print(n - b)
| Statement
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but
after the 999-th round `ABC999`, a problem occurred: how the future rounds
should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are
decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first
three characters of the label of the N-th round of AtCoder Beginner Contest. | [{"input": "999", "output": "ABC\n \n\nThe 999-th round of AtCoder Beginner Contest is labeled as `ABC999`.\n\n* * *"}, {"input": "1000", "output": "ABD\n \n\nThe 1000-th round of AtCoder Beginner Contest is labeled as `ABD001`.\n\n* * *"}, {"input": "1481", "output": "ABD\n \n\nThe 1481-th round of AtCoder Beginner Contest is labeled as `ABD482`."}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s909977406 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | f = lambda x: x[0] == x[1]
print("H" if f(list(input().split())) else "D")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s487497373 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | print(
{
"H H": "H",
"H D": "D",
"D H": "D",
"D D": "H",
}[input()]
)
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s308085505 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | a, b = [s == "H" for s in input().split()]
f = b if a else not b
print("H" if f else "D")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s446541674 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a,b=map(int,input().split())
if a=b:
print("H")
else:
print("D")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s983571116 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | print("HD"[input() in "H D H"])
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s754195452 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | print("HD"[len(set(input())) - 2])
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s640540821 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | ab = input()
print("H" if ab == "H H" or ab == "D D" else "D")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s112946339 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | print("HD"[len(set(input())) % 2])
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s529912269 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a,b=input().split()
print("H" if a=b="H"or a=b="D" else"D") | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s675785636 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | s=input().split()
if s[0]=s[1]:
print('H')
else:
print('D') | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s008021846 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | # シカのAtCoDeerくんとTopCoDeerくんが「正直者か嘘つきか」ゲームをしています。
# このゲームでは、正直者は常にほんとうのことを言い、嘘つきは常に嘘を言います。
# 文字 a と b が入力として与えられます。
# これらはそれぞれ H か D のどちらかです。
# a=H のとき、AtCoDeerくんは正直者です。
# a=D のとき、AtCoDeerくんは嘘つきです。
# b=H のとき、AtCoDeerくんは「TopCoDeerくんは正直者だ」と発言しています。
# b=D のとき、AtCoDeerくんは「TopCoDeerくんは嘘つきだ」と発言しています。
#
# これらから判断して、TopCoDeerくんが正直者かどうか判定してください。
# 制約
# a='H' または 'D'
# b='H' または 'D'
# 標準入力から文字列 a と b を取得する
input_a, input_b = map(str, input().split())
reslut = "ret"
# TopCoDeerくんが正直者かどうか判定し、結果を出力する。
# ※ 正直者=="H"、嘘つき=="D"
if input_a == "H": # AtCoDeerくんが正直者の場合
if input_b == "H":
result = "H"
elif input_b == "D":
result = "D"
elif input_a == "D": # AtCoDeerくんが嘘つき者の場合（条件増えた時ようにelifにした）
if input_b == "H":
result = "D"
elif input_b == "D":
result = "H"
else:
reslut = "I don't Know."
print(result)
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s555859845 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | # AtCoDeerくんとTopCoDeerくんが何と言ってるかを a,bで入力
a,b = input().split()
# もしa=Hでb=HならTopCoDeerくんは正直者
if a = "H":
if b = "H":
print("H")
# もしa=Dでb=HならTopCoDeerくんは正直者
elif a = "D":
if b = "D":
print("H")
# それ以外はbは嘘つき
else:
print("D") | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s271391226 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | N, K = [int(n) for n in input().split()]
A = [int(n) for n in input().split()]
A.sort()
res = []
for n_ex in range(N):
dp = [[False] * K for n in range(N + 1)]
dp[0][0] = True
for n in range(N):
for k in range(0, K):
dp[n + 1][k] = dp[n][k]
if n != n_ex:
for k in range(0, K - A[n]):
if dp[n][k] == True:
dp[n + 1][k + A[n]] = True
for k in range(K - A[n_ex], K):
if dp[N][k] == True:
res.append(n_ex)
break
print(N - len(res))
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s741981289 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | x, y = map(str, input().split())
if x == "H":
print(y)
elif x == "D":
print("H" if y == "D" else "D")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s169766063 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a,b=map(int,input().split())
x= (a=="H")
y=(b=="H")
if :x and y or not x and not y
print("H")
else:
print("D") | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s606440964 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a, b = map(str, input().split())
if a == 'H' and b == 'H' or A == ' D' and b = = 'D':
print('H')
else:
print('D') | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s870594340 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a,b=input().split()
x= (a=="H")
y=(b=="H")
if :x and y or not x and not y
print("H")
else:
print("D") | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s274736443 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a, b = map(str, input().split())
if a = 'H':
print(b)
else:
if b = 'H':
print('D')
else:
print('H') | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s469881814 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a,b=[int(x) for x in input().split()]
if (a=="H" and b="D") or (a=="D" and b=="H"):
print("D")
else:
print("H") | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s363824877 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | AB = str(input())
res = {"H H": "H", "H D": "D", "D H": "D", "D D": "H"}
print(res[AB])
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s077869178 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | x = input().replace(" ", "")
print("H" if x == "HH" or x == "DD" else "D")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s771816891 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a,b=input().split()
if a="H":
print(b)
else:
if b="H":
print("D")
else:
print("H")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s973087215 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | print("HD"[len(set(input().split())) - 1 :: 2])
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s558358651 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | H H
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s690965843 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | import sys
N, K = map(int, input().split())
a = list(map(int, input().split()))
sum = 0
for i in range(0, N):
sum += a[i]
if sum < K: # 全部不必要
print(N)
sys.exit()
if sum == K: # 全部必要
print(0)
sys.exit()
a.sort()
a.reverse()
# K未満の最大の数字のラベルはどこ？
l = N
for i in range(N - 1, -1, -1):
if a[i] < K:
l = i
else:
break
if l == N:
print(N)
sys.exit()
count = N
# lまでの要素が必要か不要かチェック
for i in range(0, l):
sum = 0
for j in range(l, N):
if sum + a[j] < K:
sum += a[j]
if sum + a[i] >= K: # 必要ってことだ
count -= 1
# lからの要素は自分のことを抜かないといけないことに注意
for i in range(l, N):
sum = 0
b = a[:]
C = b.pop(i)
for j in range(l - 1, N - 1):
if sum + b[j] < K:
sum += b[j]
if sum + C >= K: # 必要ってことだ
count -= 1
print(count)
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s053473961 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | # -*- coding: utf-8 -*-
import itertools
N, K = map(int, input().split())
A = list(map(int, input().split()))
unnec = 0
for i in range(0, N):
B = list(A)
v = B.pop(i)
nec = False
for j in range(len(B), 0, -1):
for l in list(itertools.combinations(B, j)):
s = sum(l)
# print("%s, %d, %d" % (str(l), s, v))
if s >= K:
continue
elif s + v >= K:
nec = True
break
if nec == True:
break
if nec == False:
unnec = unnec + 1
print(unnec)
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s603019566 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | line = input().split()
if line[0] = "H" and line[1] = "H":
print("H")
elif line[0] = "H" and line[1] = "D":
print("D")
elif line[0] = "D" and line[1] = "H":
print("D")
else:
print("H")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s765736220 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | W, a, b = map(int, input().split())
if a + W < b:
print(b - a - W)
elif a + W = b:
print(0)
elif (b < a + W) & (a < b):
print(0)
elif a == b:
print(0)
elif b + W <= a:
print(a - b - W)
else:
pass
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s011924905 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a=input()
b=input()
if a=="H"
print("H" if b=="H" else "D")
if a=="D"
print("D" if b=="H" else "H") | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s882677114 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a,b =map(str ,input().split())
if b=="H:
print(a):
else b=="D":
if a=="H":
print("D"):
if a=="D":
print("H")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s863184547 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | x = input().split()
dictionary = {"H": "D", "D": "H"}
print(x[1] if x[0] == "H" else dictionary[x[1]])
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s936552356 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a,b=input().split()
if (a=="H" and b=="H") or (a=="D" and b=="D"):
print(H)
else:
print(D) | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s730574038 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a , b = input().split()
if a == b:
print("H"):
else:
print("D") | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s733426896 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a,b=input().split()
if a=H:
print(b)
else:
if b=H:
print(D)
else:
print(H)
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s085339402 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a,b=input().split()
if a=="H":
print(b)
elif b=="H":
print("D")
elif:
print("H") | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s784339452 | Wrong Answer | p03777 | The input is given from Standard Input in the following format:
a b | a, b = [i == "H" for i in input().split()]
print("H" if a and b else "D")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s857470881 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | if a='H' and b='H':print(H)
elif a='D' and b='D':print(H)
else:print(D) | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s525878438 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | n = int(input())
ct = 1
while ct * (ct + 1) // 2 < n:
ct += 1
print(ct)
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s248916631 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a,b=input().split()
if a=="H":
print(b):
else:
if b=="H":
print("D")
else:
print("H") | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s474356654 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a,b=input().split()
if a,b==("H","H") or a,b==("D","D"):
print("H")
else:
print("D") | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s724594696 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a, b = input().split()
if a=H and b=H:print(H)
elif a=D and b=D:print(H)
else:print(D) | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s763268924 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a, b = input().split()
if a=H and b=H:print('H')
elif a=D and b=D:print('H')
else:print('D') | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s281723925 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | l = input().split()
print("H" if len(set(l)) == 1 else "D")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s739886743 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | x, y = map(lambda x: x == "D", input().split())
print(["H", "D"][x ^ y])
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s098073392 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | H, D = 1, 2
print("H" if eval(input().replace(" ", "+")) % 2 == 0 else "D")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s565214586 | Accepted | p03777 | The input is given from Standard Input in the following format:
a b | h, d = map(str, input().split())
print("H" if h == d else "D")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s356991525 | Wrong Answer | p03777 | The input is given from Standard Input in the following format:
a b | for s in input().upper().split():
print(s[0], end="")
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s214244110 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a, b = input().split()
if a == b:
print('H')
else:
print('D')s | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s116957731 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a, b, c = input().split()
print("{} {} {}".format(c, a, b))
| Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
* * * | s914071544 | Runtime Error | p03777 | The input is given from Standard Input in the following format:
a b | a, b = input().split()
print("H" if a == b else "D")aa | Statement
Two deer, AtCoDeer and TopCoDeer, are playing a game called _Honest or
Dishonest_. In this game, an honest player always tells the truth, and an
dishonest player always tell lies. You are given two characters a and b as the
input. Each of them is either `H` or `D`, and carries the following
information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`,
AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that
TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest. | [{"input": "H H", "output": "H\n \n\nIn this input, AtCoDeer is honest. Hence, as he says, TopCoDeer is honest.\n\n* * *"}, {"input": "D H", "output": "D\n \n\nIn this input, AtCoDeer is dishonest. Hence, contrary to what he says,\nTopCoDeer is dishonest.\n\n* * *"}, {"input": "D D", "output": "H"}] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.