Datasets:
Tags:
License:
Dataset Viewer
View in Dataset Viewer
Viewer
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
|
|---|---|---|---|---|---|---|---|
For each query i in order of input, print a line containing the substring of
f(A_i, B_i) from position C_i to position D_i (1-based).
* * * | s755719340 | Wrong Answer | p03466 | Input is given from Standard Input in the following format:
Q
A_1 B_1 C_1 D_1
A_2 B_2 C_2 D_2
:
A_Q B_Q C_Q D_Q | import sys
import numpy as np
import numba
from numba import njit, b1, i4, i8
from numba.types import Omitted
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
@njit((i8, i8), cache=True)
def find_min_length(a, b):
if a < b:
a, b = b, a
return (a + b) // (b + 1)
@njit((i8, i8, i8, i8), cache=True)
def f(a, b, c, d):
L = find_min_length(a, b)
ret = ""
def test(a, b, L):
# ...B の直後に A を a 個、B を b 個置けるかどうか
ok = a >= 0 and b >= 0
if a == 0:
ok = ok and (b <= L - 1)
else:
ok = ok and (a <= L * (b + 1))
ok = ok and (1 + b <= L * (a + 1))
return ok
def add(s, x, t, y, n):
# 文字列に (s*x + t*y)*n を追加
nonlocal c, d, ret
if (x + y) * n < c:
c -= (x + y) * n
d -= (x + y) * n
return
m = (c - 1) // (x + y)
c -= m * (x + y)
d -= m * (x + y)
n -= m
while n and c <= d:
if d <= x:
ret += s * (d - c + 1)
d = 0
return
if 1 <= c <= x:
ret += s * (x - c + 1)
c = x + 1
ret += t * (min(d, x + y) - c + 1)
c = 1
d -= x + y
n -= 1
# AAABAAAB と n セット並べてしまって大丈夫かどうか
l, r = 0, b + 100
while l + 1 < r:
m = (l + r) >> 1
a1, b1 = a - L * m, b - m
if test(a1, b1, L):
l = m
else:
r = m
n = l
if n == 0:
add("B", 1, "A", 0, 1)
b -= 1
else:
add("A", L, "B", 1, n)
a -= L * n
b -= n
# 次に、A^kB
l, r = 0, L
while l + 1 < r:
m = (l + r) // 2
if test(a - m, b - 1, L):
l = m
else:
r = m
k = l
if k:
add("A", k, "B", 1, 1)
a -= k
b -= 1
# 以降は、Aは高々ひとつずつ
if not a:
add("B", b, "A", 0, 1)
return ret
# B^kA、kはなるべく少なく
l, r = -1, L - 1
while l + 1 < r:
m = (l + r) // 2
if test(a - 1, b - m, L):
r = m
else:
l = m
if k >= 0:
add("B", k, "A", 1, 1)
a -= 1
b -= k
# B^LA をいくつか
n = min(b // L, a)
add("B", L, "A", 1, n)
a -= n
b -= n * L
add("B", b, "A", 0, 1)
return ret
ABCD = np.array(read().split(), np.int64)[1:]
for a, b, c, d in ABCD.reshape(-1, 4):
print(f(a, b, c, d))
| Statement
Let f(A, B), where A and B are positive integers, be the string satisfying the
following conditions:
* f(A, B) has length A + B;
* f(A, B) contains exactly A letters `A` and exactly B letters `B`;
* The length of the longest substring of f(A, B) consisting of equal letters (ex., `AAAAA` or `BBBB`) is as small as possible under the conditions above;
* f(A, B) is the lexicographically smallest string satisfying the conditions above.
For example, f(2, 3) = `BABAB`, and f(6, 4) = `AABAABAABB`.
Answer Q queries: find the substring of f(A_i, B_i) from position C_i to
position D_i (1-based). | [{"input": "5\n 2 3 1 5\n 6 4 1 10\n 2 3 4 4\n 6 4 3 7\n 8 10 5 8", "output": "BABAB\n AABAABAABB\n A\n BAABA\n ABAB"}] |
For each query i in order of input, print a line containing the substring of
f(A_i, B_i) from position C_i to position D_i (1-based).
* * * | s422209750 | Runtime Error | p03466 | Input is given from Standard Input in the following format:
Q
A_1 B_1 C_1 D_1
A_2 B_2 C_2 D_2
:
A_Q B_Q C_Q D_Q | for t in range(int(input())):
a,b,c,d=map(int,input().split(' '));l,x,y,o=(a+b)//(min(a,b)+1),0,0,""
if a*l<=b:y=a+b
elif b*l<=a:x=a+b
else:x,y=(a*l-b)//(l-1),(b*l-a)//(l-1)
for i in range(c,d+1):o+="AB"[i%(l+1)==0] if i<=x else "BA"[(a+b-i+1)%(l+1)==0] if a+b-i+1<=y else "AB"[a-x+x//(l+1)-y//(l+1)==0]
print(o) | Statement
Let f(A, B), where A and B are positive integers, be the string satisfying the
following conditions:
* f(A, B) has length A + B;
* f(A, B) contains exactly A letters `A` and exactly B letters `B`;
* The length of the longest substring of f(A, B) consisting of equal letters (ex., `AAAAA` or `BBBB`) is as small as possible under the conditions above;
* f(A, B) is the lexicographically smallest string satisfying the conditions above.
For example, f(2, 3) = `BABAB`, and f(6, 4) = `AABAABAABB`.
Answer Q queries: find the substring of f(A_i, B_i) from position C_i to
position D_i (1-based). | [{"input": "5\n 2 3 1 5\n 6 4 1 10\n 2 3 4 4\n 6 4 3 7\n 8 10 5 8", "output": "BABAB\n AABAABAABB\n A\n BAABA\n ABAB"}] |
Print 10 lines. The i-th line (1 ≤ i ≤ 10) should contain x_{2000+i} as an
integer.
* * * | s997370292 | Accepted | p03036 | Input is given from Standard Input in the following format:
r D x_{2000} | R, D, X2000 = [int(i) for i in input().split()]
ans = [R * X2000 - D]
for _ in range(9):
ans.append(R * ans[-1] - D)
print("\n".join(map(str, ans)))
| Statement
The development of algae in a pond is as follows.
Let the total weight of the algae at the beginning of the year i be x_i gram.
For i≥2000, the following formula holds:
* x_{i+1} = rx_i - D
You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print
them in order. | [{"input": "2 10 20", "output": "30\n 50\n 90\n 170\n 330\n 650\n 1290\n 2570\n 5130\n 10250\n \n\nFor example, x_{2001} = rx_{2000} - D = 2 \\times 20 - 10 = 30 and x_{2002} =\nrx_{2001} - D = 2 \\times 30 - 10 = 50.\n\n* * *"}, {"input": "4 40 60", "output": "200\n 760\n 3000\n 11960\n 47800\n 191160\n 764600\n 3058360\n 12233400\n 48933560"}] |
Print 10 lines. The i-th line (1 ≤ i ≤ 10) should contain x_{2000+i} as an
integer.
* * * | s838022602 | Runtime Error | p03036 | Input is given from Standard Input in the following format:
r D x_{2000} | #! python3
# solve127A.py
age, cost = map(int, input().split())
if age <= 5:
cost = 0
elif 6 <= age <= 12:
cost = cost // 2
elif 7 <= age:
cost = cost
print(cost)
| Statement
The development of algae in a pond is as follows.
Let the total weight of the algae at the beginning of the year i be x_i gram.
For i≥2000, the following formula holds:
* x_{i+1} = rx_i - D
You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print
them in order. | [{"input": "2 10 20", "output": "30\n 50\n 90\n 170\n 330\n 650\n 1290\n 2570\n 5130\n 10250\n \n\nFor example, x_{2001} = rx_{2000} - D = 2 \\times 20 - 10 = 30 and x_{2002} =\nrx_{2001} - D = 2 \\times 30 - 10 = 50.\n\n* * *"}, {"input": "4 40 60", "output": "200\n 760\n 3000\n 11960\n 47800\n 191160\n 764600\n 3058360\n 12233400\n 48933560"}] |
Print 10 lines. The i-th line (1 ≤ i ≤ 10) should contain x_{2000+i} as an
integer.
* * * | s457969152 | Accepted | p03036 | Input is given from Standard Input in the following format:
r D x_{2000} | import sys
a = sys.stdin.readline()
res = [int(i) for i in a.split() if i.isdigit()]
r, D, x2000 = [res[i] for i in (0, 1, 2)]
if (r >= 2 and r <= 5) and (D >= 1 and D <= 100) and (x2000 > D and x2000 <= 200):
x2001 = r * x2000 - D
x2002 = r * x2001 - D
x2003 = r * x2002 - D
x2004 = r * x2003 - D
x2005 = r * x2004 - D
x2006 = r * x2005 - D
x2007 = r * x2006 - D
x2008 = r * x2007 - D
x2009 = r * x2008 - D
x2010 = r * x2009 - D
print(x2001)
print(x2002)
print(x2003)
print(x2004)
print(x2005)
print(x2006)
print(x2007)
print(x2008)
print(x2009)
print(x2010)
else:
print("Error")
| Statement
The development of algae in a pond is as follows.
Let the total weight of the algae at the beginning of the year i be x_i gram.
For i≥2000, the following formula holds:
* x_{i+1} = rx_i - D
You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print
them in order. | [{"input": "2 10 20", "output": "30\n 50\n 90\n 170\n 330\n 650\n 1290\n 2570\n 5130\n 10250\n \n\nFor example, x_{2001} = rx_{2000} - D = 2 \\times 20 - 10 = 30 and x_{2002} =\nrx_{2001} - D = 2 \\times 30 - 10 = 50.\n\n* * *"}, {"input": "4 40 60", "output": "200\n 760\n 3000\n 11960\n 47800\n 191160\n 764600\n 3058360\n 12233400\n 48933560"}] |
Print 10 lines. The i-th line (1 ≤ i ≤ 10) should contain x_{2000+i} as an
integer.
* * * | s918528085 | Accepted | p03036 | Input is given from Standard Input in the following format:
r D x_{2000} | r, d, x = map(int, input().split())
num1 = r * x - d
num2 = num1 * r - d
num3 = num2 * r - d
num4 = num3 * r - d
num5 = num4 * r - d
num6 = num5 * r - d
num7 = num6 * r - d
num8 = num7 * r - d
num9 = num8 * r - d
num10 = num9 * r - d
print(num1)
print(num2)
print(num3)
print(num4)
print(num5)
print(num6)
print(num7)
print(num8)
print(num9)
print(num10)
| Statement
The development of algae in a pond is as follows.
Let the total weight of the algae at the beginning of the year i be x_i gram.
For i≥2000, the following formula holds:
* x_{i+1} = rx_i - D
You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print
them in order. | [{"input": "2 10 20", "output": "30\n 50\n 90\n 170\n 330\n 650\n 1290\n 2570\n 5130\n 10250\n \n\nFor example, x_{2001} = rx_{2000} - D = 2 \\times 20 - 10 = 30 and x_{2002} =\nrx_{2001} - D = 2 \\times 30 - 10 = 50.\n\n* * *"}, {"input": "4 40 60", "output": "200\n 760\n 3000\n 11960\n 47800\n 191160\n 764600\n 3058360\n 12233400\n 48933560"}] |
Print 10 lines. The i-th line (1 ≤ i ≤ 10) should contain x_{2000+i} as an
integer.
* * * | s045968706 | Runtime Error | p03036 | Input is given from Standard Input in the following format:
r D x_{2000} | from sys import stdin
import numpt as np
def main(args):
r = args[0]
d = args[1]
x = args[2]
ar = np.zeros([10])
ar[0] = r * x - d
for i in range(1, len(ar)):
ar[i] = r * ar[i - 1] - d
for i in ar:
print(i)
if __name__ == "__main__":
main([int(x) for x in stdin.readline().rstrip().split()])
| Statement
The development of algae in a pond is as follows.
Let the total weight of the algae at the beginning of the year i be x_i gram.
For i≥2000, the following formula holds:
* x_{i+1} = rx_i - D
You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print
them in order. | [{"input": "2 10 20", "output": "30\n 50\n 90\n 170\n 330\n 650\n 1290\n 2570\n 5130\n 10250\n \n\nFor example, x_{2001} = rx_{2000} - D = 2 \\times 20 - 10 = 30 and x_{2002} =\nrx_{2001} - D = 2 \\times 30 - 10 = 50.\n\n* * *"}, {"input": "4 40 60", "output": "200\n 760\n 3000\n 11960\n 47800\n 191160\n 764600\n 3058360\n 12233400\n 48933560"}] |
Print 10 lines. The i-th line (1 ≤ i ≤ 10) should contain x_{2000+i} as an
integer.
* * * | s817806126 | Runtime Error | p03036 | Input is given from Standard Input in the following format:
r D x_{2000} | s = list(map(int, input()))
for i in range(10):
s[2] = s[0] * s[2] - s[1]
print(s[2])
| Statement
The development of algae in a pond is as follows.
Let the total weight of the algae at the beginning of the year i be x_i gram.
For i≥2000, the following formula holds:
* x_{i+1} = rx_i - D
You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print
them in order. | [{"input": "2 10 20", "output": "30\n 50\n 90\n 170\n 330\n 650\n 1290\n 2570\n 5130\n 10250\n \n\nFor example, x_{2001} = rx_{2000} - D = 2 \\times 20 - 10 = 30 and x_{2002} =\nrx_{2001} - D = 2 \\times 30 - 10 = 50.\n\n* * *"}, {"input": "4 40 60", "output": "200\n 760\n 3000\n 11960\n 47800\n 191160\n 764600\n 3058360\n 12233400\n 48933560"}] |
Print 10 lines. The i-th line (1 ≤ i ≤ 10) should contain x_{2000+i} as an
integer.
* * * | s365778743 | Wrong Answer | p03036 | Input is given from Standard Input in the following format:
r D x_{2000} | 30
50
90
170
330
650
1290
2570
5130
10250
| Statement
The development of algae in a pond is as follows.
Let the total weight of the algae at the beginning of the year i be x_i gram.
For i≥2000, the following formula holds:
* x_{i+1} = rx_i - D
You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print
them in order. | [{"input": "2 10 20", "output": "30\n 50\n 90\n 170\n 330\n 650\n 1290\n 2570\n 5130\n 10250\n \n\nFor example, x_{2001} = rx_{2000} - D = 2 \\times 20 - 10 = 30 and x_{2002} =\nrx_{2001} - D = 2 \\times 30 - 10 = 50.\n\n* * *"}, {"input": "4 40 60", "output": "200\n 760\n 3000\n 11960\n 47800\n 191160\n 764600\n 3058360\n 12233400\n 48933560"}] |
Print 10 lines. The i-th line (1 ≤ i ≤ 10) should contain x_{2000+i} as an
integer.
* * * | s411772713 | Accepted | p03036 | Input is given from Standard Input in the following format:
r D x_{2000} | r, D, x_s = [int(item) for item in input().split()]
for i in range(10):
x_s = r * x_s - D
print(x_s)
| Statement
The development of algae in a pond is as follows.
Let the total weight of the algae at the beginning of the year i be x_i gram.
For i≥2000, the following formula holds:
* x_{i+1} = rx_i - D
You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print
them in order. | [{"input": "2 10 20", "output": "30\n 50\n 90\n 170\n 330\n 650\n 1290\n 2570\n 5130\n 10250\n \n\nFor example, x_{2001} = rx_{2000} - D = 2 \\times 20 - 10 = 30 and x_{2002} =\nrx_{2001} - D = 2 \\times 30 - 10 = 50.\n\n* * *"}, {"input": "4 40 60", "output": "200\n 760\n 3000\n 11960\n 47800\n 191160\n 764600\n 3058360\n 12233400\n 48933560"}] |
Print 10 lines. The i-th line (1 ≤ i ≤ 10) should contain x_{2000+i} as an
integer.
* * * | s006453636 | Accepted | p03036 | Input is given from Standard Input in the following format:
r D x_{2000} | l = list(map(int, input().split()))
r = l[0]
D = l[1]
x = l[2]
t = [x]
for i in t:
m = i * r - D
t.append(m)
if len(t) == 11:
break
for p in t[1:]:
print(p)
| Statement
The development of algae in a pond is as follows.
Let the total weight of the algae at the beginning of the year i be x_i gram.
For i≥2000, the following formula holds:
* x_{i+1} = rx_i - D
You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print
them in order. | [{"input": "2 10 20", "output": "30\n 50\n 90\n 170\n 330\n 650\n 1290\n 2570\n 5130\n 10250\n \n\nFor example, x_{2001} = rx_{2000} - D = 2 \\times 20 - 10 = 30 and x_{2002} =\nrx_{2001} - D = 2 \\times 30 - 10 = 50.\n\n* * *"}, {"input": "4 40 60", "output": "200\n 760\n 3000\n 11960\n 47800\n 191160\n 764600\n 3058360\n 12233400\n 48933560"}] |
Print 10 lines. The i-th line (1 ≤ i ≤ 10) should contain x_{2000+i} as an
integer.
* * * | s851574748 | Accepted | p03036 | Input is given from Standard Input in the following format:
r D x_{2000} | while True:
try:
r, D, X = map(int, input().split())
for i in range(2001, 2011):
X = r * X - D
print(X)
except:
break
| Statement
The development of algae in a pond is as follows.
Let the total weight of the algae at the beginning of the year i be x_i gram.
For i≥2000, the following formula holds:
* x_{i+1} = rx_i - D
You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print
them in order. | [{"input": "2 10 20", "output": "30\n 50\n 90\n 170\n 330\n 650\n 1290\n 2570\n 5130\n 10250\n \n\nFor example, x_{2001} = rx_{2000} - D = 2 \\times 20 - 10 = 30 and x_{2002} =\nrx_{2001} - D = 2 \\times 30 - 10 = 50.\n\n* * *"}, {"input": "4 40 60", "output": "200\n 760\n 3000\n 11960\n 47800\n 191160\n 764600\n 3058360\n 12233400\n 48933560"}] |
Print 10 lines. The i-th line (1 ≤ i ≤ 10) should contain x_{2000+i} as an
integer.
* * * | s200250321 | Accepted | p03036 | Input is given from Standard Input in the following format:
r D x_{2000} | x_array = []
r, D, x = (int(i) for i in input().split())
x_array.append(x)
for j in range(10):
x_array.append(r * x_array[j] - D)
print(x_array[j + 1])
| Statement
The development of algae in a pond is as follows.
Let the total weight of the algae at the beginning of the year i be x_i gram.
For i≥2000, the following formula holds:
* x_{i+1} = rx_i - D
You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print
them in order. | [{"input": "2 10 20", "output": "30\n 50\n 90\n 170\n 330\n 650\n 1290\n 2570\n 5130\n 10250\n \n\nFor example, x_{2001} = rx_{2000} - D = 2 \\times 20 - 10 = 30 and x_{2002} =\nrx_{2001} - D = 2 \\times 30 - 10 = 50.\n\n* * *"}, {"input": "4 40 60", "output": "200\n 760\n 3000\n 11960\n 47800\n 191160\n 764600\n 3058360\n 12233400\n 48933560"}] |
Print 10 lines. The i-th line (1 ≤ i ≤ 10) should contain x_{2000+i} as an
integer.
* * * | s897211153 | Wrong Answer | p03036 | Input is given from Standard Input in the following format:
r D x_{2000} | x = {}
i = list(map(int, input().split()))
for s in range(10):
x[s] = (i[2] - int((i[1] / (i[0] - 1)))) * i[0] ** (s + 1) + int(
(i[1] / (i[0] - 1))
)
print(x[s])
| Statement
The development of algae in a pond is as follows.
Let the total weight of the algae at the beginning of the year i be x_i gram.
For i≥2000, the following formula holds:
* x_{i+1} = rx_i - D
You are given r, D and x_{2000}. Calculate x_{2001}, ..., x_{2010} and print
them in order. | [{"input": "2 10 20", "output": "30\n 50\n 90\n 170\n 330\n 650\n 1290\n 2570\n 5130\n 10250\n \n\nFor example, x_{2001} = rx_{2000} - D = 2 \\times 20 - 10 = 30 and x_{2002} =\nrx_{2001} - D = 2 \\times 30 - 10 = 50.\n\n* * *"}, {"input": "4 40 60", "output": "200\n 760\n 3000\n 11960\n 47800\n 191160\n 764600\n 3058360\n 12233400\n 48933560"}] |
In the first line, print the stability ("Stable" or "Not stable") of this
output.
In the following lines, print the arranged cards in the same manner of that of
the input. | s595120768 | Accepted | p02277 | The first line contains an integer _n_ , the number of cards.
_n_ cards are given in the following lines. Each card is given in a line and
represented by a pair of a character and an integer separated by a single
space. | import copy
def quicksort(li, ini_i, length):
# print(li, ini_i, length)
if ini_i < length:
next_len = partition(li, ini_i, length)
# print(next_len)
quicksort(li, ini_i, next_len - 1)
quicksort(li, next_len + 1, length)
def partition(li, ini_i, length):
target = li[length][1]
# print(target, li, ini_i, length)
for i in range(ini_i, length):
if li[i][1] <= target:
li[ini_i], li[i] = li[i], li[ini_i]
ini_i += 1
# print(f"its {ini_i}")
li[ini_i], li[length] = li[length], li[ini_i]
return ini_i
length = int(input())
li = []
base_li = []
for i in range(length):
t = input().split(" ")
t[1] = int(t[1])
base_li.append(t)
li = copy.deepcopy(base_li)
quicksort(li, 0, length - 1)
for i in range(length - 1):
if li[i + 1][1] == li[i][1]:
if base_li.index(li[i + 1]) < base_li.index(li[i]):
print("Not stable")
break
else:
print("Stable")
for i, n in enumerate(li):
print(*n)
| Quick Sort
Let's arrange a deck of cards. Your task is to sort totally n cards. A card
consists of a part of a suit (S, H, C or D) and an number. Write a program
which sorts such cards based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Quicksort(A, p, r)
1 if p < r
2 then q = Partition(A, p, r)
3 run Quicksort(A, p, q-1)
4 run Quicksort(A, q+1, r)
Here, A is an array which represents a deck of cards and comparison operations
are performed based on the numbers.
Your program should also report the stability of the output for the given
input (instance). Here, 'stability of the output' means that: cards with the
same value appear in the output in the same order as they do in the input
(instance). | [{"input": "6\n D 3\n H 2\n D 1\n S 3\n D 2\n C 1", "output": "Not stable\n D 1\n C 1\n D 2\n H 2\n D 3\n S 3"}, {"input": "2\n S 1\n H 1", "output": "Stable\n S 1\n H 1"}] |
In the first line, print the stability ("Stable" or "Not stable") of this
output.
In the following lines, print the arranged cards in the same manner of that of
the input. | s588220904 | Accepted | p02277 | The first line contains an integer _n_ , the number of cards.
_n_ cards are given in the following lines. Each card is given in a line and
represented by a pair of a character and an integer separated by a single
space. | from sys import stdin
def partition(cards, start, end):
p = cards[end]
p_idx = start
for i in range(start, end):
c = cards[i]
if c[1] <= p[1]:
cards[i], cards[p_idx] = cards[p_idx], cards[i]
p_idx = p_idx + 1
cards[p_idx], cards[end] = cards[end], cards[p_idx]
return p_idx
# in-place quicksort
def quicksort(cards, start, end):
if start < end:
p_idx = partition(cards, start, end)
quicksort(cards, start, p_idx - 1)
quicksort(cards, p_idx + 1, end)
def merge(nums, left, mid, right):
l = nums[left:mid] + [("_", 9999999999)]
r = nums[mid:right] + [("_", 9999999999)]
l_cur = 0
r_cur = 0
for i in range(right - left):
if l[l_cur][1] > r[r_cur][1]:
nums[left + i] = r[r_cur]
r_cur = r_cur + 1
else:
nums[left + i] = l[l_cur]
l_cur = l_cur + 1
def mergesort(nums, left, right):
if right - left <= 1:
return nums
else:
mid = (left + right) // 2
mergesort(nums, left, mid)
mergesort(nums, mid, right)
merge(nums, left, mid, right)
def is_stable_result(orig, result):
stable_result = orig[:]
mergesort(stable_result, 0, len(stable_result))
is_stable = True
for c1, c2 in zip(stable_result, result):
if c1 != c2:
is_stable = False
return is_stable
def parseLine(l):
kind, num = l.strip().split(" ")
return (kind, int(num))
def main():
_, *lines = stdin.readlines()
nums = [parseLine(l) for l in lines]
# sort
result = nums[:]
quicksort(result, 0, len(result) - 1)
# check is stable
is_stable = is_stable_result(nums, result)
print("Stable" if is_stable else "Not stable")
print("\n".join([kind + " " + str(num) for (kind, num) in result]))
if __name__ == "__main__":
main()
| Quick Sort
Let's arrange a deck of cards. Your task is to sort totally n cards. A card
consists of a part of a suit (S, H, C or D) and an number. Write a program
which sorts such cards based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Quicksort(A, p, r)
1 if p < r
2 then q = Partition(A, p, r)
3 run Quicksort(A, p, q-1)
4 run Quicksort(A, q+1, r)
Here, A is an array which represents a deck of cards and comparison operations
are performed based on the numbers.
Your program should also report the stability of the output for the given
input (instance). Here, 'stability of the output' means that: cards with the
same value appear in the output in the same order as they do in the input
(instance). | [{"input": "6\n D 3\n H 2\n D 1\n S 3\n D 2\n C 1", "output": "Not stable\n D 1\n C 1\n D 2\n H 2\n D 3\n S 3"}, {"input": "2\n S 1\n H 1", "output": "Stable\n S 1\n H 1"}] |
In the first line, print the stability ("Stable" or "Not stable") of this
output.
In the following lines, print the arranged cards in the same manner of that of
the input. | s142345588 | Accepted | p02277 | The first line contains an integer _n_ , the number of cards.
_n_ cards are given in the following lines. Each card is given in a line and
represented by a pair of a character and an integer separated by a single
space. | if __name__ == "__main__":
import sys
input = sys.stdin.readline
MAX = 100000
SENTINEL = 2000000000
class Card:
def __init__(self, suit, value):
self.suit = suit
self.value = value
def merge(A, n, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [Card(None, None) for _ in range(n1 + 1)]
R = [Card(None, None) for _ in range(n2 + 1)]
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1].value = SENTINEL
R[n2].value = SENTINEL
i, j = 0, 0
for k in range(left, right):
if L[i].value <= R[j].value:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
def mergeSort(A, n, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, n, left, mid)
mergeSort(A, n, mid, right)
merge(A, n, left, mid, right)
def swap(a, i, j):
# list aのi番目の要素とj番目の要素を交換する関数
k = a[j]
a[j] = a[i]
a[i] = k
def partition(A, p, r):
x = A[r]
i = p - 1
for j in range(p, r):
if A[j].value <= x.value:
i += 1
swap(A, i, j)
swap(A, i + 1, r)
return i + 1
def quickSort(A, p, r):
if p < r:
q = partition(A, p, r)
quickSort(A, p, q - 1)
quickSort(A, q + 1, r)
n = int(input())
A = [Card(None, None) for _ in range(n)]
B = [Card(None, None) for _ in range(n)]
for i in range(n):
suit, value = input().split()
A[i].suit = suit
B[i].suit = suit
A[i].value = int(value)
B[i].value = int(value)
mergeSort(A, n, 0, n)
quickSort(B, 0, n - 1)
for i in range(n):
if A[i].suit != B[i].suit:
print("Not stable")
break
else:
print("Stable")
for b in B:
print(b.suit, b.value)
| Quick Sort
Let's arrange a deck of cards. Your task is to sort totally n cards. A card
consists of a part of a suit (S, H, C or D) and an number. Write a program
which sorts such cards based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Quicksort(A, p, r)
1 if p < r
2 then q = Partition(A, p, r)
3 run Quicksort(A, p, q-1)
4 run Quicksort(A, q+1, r)
Here, A is an array which represents a deck of cards and comparison operations
are performed based on the numbers.
Your program should also report the stability of the output for the given
input (instance). Here, 'stability of the output' means that: cards with the
same value appear in the output in the same order as they do in the input
(instance). | [{"input": "6\n D 3\n H 2\n D 1\n S 3\n D 2\n C 1", "output": "Not stable\n D 1\n C 1\n D 2\n H 2\n D 3\n S 3"}, {"input": "2\n S 1\n H 1", "output": "Stable\n S 1\n H 1"}] |
In the first line, print the stability ("Stable" or "Not stable") of this
output.
In the following lines, print the arranged cards in the same manner of that of
the input. | s118675930 | Accepted | p02277 | The first line contains an integer _n_ , the number of cards.
_n_ cards are given in the following lines. Each card is given in a line and
represented by a pair of a character and an integer separated by a single
space. | from copy import copy
def merge(arr, left, middle, right):
L = arr[left:middle]
L.append([None, float("inf")])
R = arr[middle:right]
R.append([None, float("inf")])
iterL, iterR = iter(L), iter(R)
l, r = next(iterL), next(iterR)
for index in range(left, right):
if l[1] <= r[1]:
arr[index] = l
l = next(iterL)
else:
arr[index] = r
r = next(iterR)
def merge_sort(arr, left, right):
if left + 1 < right:
pivot = (left + right) // 2
merge_sort(arr, left, pivot)
merge_sort(arr, pivot, right)
merge(arr, left, pivot, right)
def partition(arr, start, end):
criteria = arr[end][1]
idx1 = start
for idx2 in range(start, end):
if arr[idx2][1] <= criteria:
arr[idx1], arr[idx2] = arr[idx2], arr[idx1]
idx1 += 1
arr[idx1], arr[end] = arr[end], arr[idx1]
return idx1
def quick_sort(arr, start, end):
if start < end:
pivot = partition(arr, start, end)
quick_sort(arr, start, pivot - 1)
quick_sort(arr, pivot + 1, end)
num = int(input())
arr = []
for index in range(num):
sign, number = input().split()
arr.append([sign, int(number)])
arr1 = copy(arr)
arr2 = copy(arr)
merge_sort(arr1, 0, num)
quick_sort(arr2, 0, num - 1)
print("Stable" if arr1 == arr2 else "Not stable")
for sign, number in arr2:
print(sign + " " + str(number))
| Quick Sort
Let's arrange a deck of cards. Your task is to sort totally n cards. A card
consists of a part of a suit (S, H, C or D) and an number. Write a program
which sorts such cards based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Quicksort(A, p, r)
1 if p < r
2 then q = Partition(A, p, r)
3 run Quicksort(A, p, q-1)
4 run Quicksort(A, q+1, r)
Here, A is an array which represents a deck of cards and comparison operations
are performed based on the numbers.
Your program should also report the stability of the output for the given
input (instance). Here, 'stability of the output' means that: cards with the
same value appear in the output in the same order as they do in the input
(instance). | [{"input": "6\n D 3\n H 2\n D 1\n S 3\n D 2\n C 1", "output": "Not stable\n D 1\n C 1\n D 2\n H 2\n D 3\n S 3"}, {"input": "2\n S 1\n H 1", "output": "Stable\n S 1\n H 1"}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s431988288 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | S = str(input())
print("A" if S.islower() else "a")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s488229934 | Runtime Error | p02627 | Input is given from Standard Input in the following format:
α | a, b = map(int, input().split())
print(a * b)
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s627040532 | Runtime Error | p02627 | Input is given from Standard Input in the following format:
α | n, k = input().split()
k = int(k)
# print(n,k)
p = [int(s) for s in input().split()]
p.sort()
# print(p)
# print(k)
p2 = p[0:k]
# print(p2)
s = sum(p)
# print(s)
print(sum(p2))
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s309929004 | Accepted | p02627 | Input is given from Standard Input in the following format:
α | print("Aa"[ord(input()) > 95])
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s351771041 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | print("B" if input().islower() else "A")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s444056405 | Runtime Error | p02627 | Input is given from Standard Input in the following format:
α | while True:
aw = input()
if (
aw == "q"
or "a"
or "z"
or "w"
or "s"
or "x"
or "e"
or "d"
or "c"
or "r"
or "f"
or "v"
or "t"
or "g"
or "b"
or "y"
or "h"
or "n"
or "u"
or "j"
or "m"
or "i"
or "k"
or "l"
or "o"
or "p"
):
print("a")
else:
print("A")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s523930860 | Runtime Error | p02627 | Input is given from Standard Input in the following format:
α | num = int(input())
d = {
"a": 1,
"b": 2,
"c": 3,
"d": 4,
"e": 5,
"f": 6,
"g": 7,
"h": 8,
"i": 9,
"j": 10,
"k": 11,
"l": 12,
"m": 13,
"n": 14,
"o": 15,
"p": 16,
"q": 17,
"r": 18,
"s": 19,
"t": 20,
"u": 21,
"v": 22,
"w": 23,
"x": 24,
"y": 25,
"z": 0,
}
op_d = {}
for i, j in d.items():
op_d[j] = i
ans = ""
for i in list(range(0, 12))[::-1]:
if int(num / (26**i)) == 0:
pass
else:
ans += op_d[int(num / (26**i))]
num = num % 26**i
print(ans)
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s356654369 | Accepted | p02627 | Input is given from Standard Input in the following format:
α | print("a" if ord(input()) > 90 else "A")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s966512331 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | print("A" if (input().islower()) else "a")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s645990424 | Runtime Error | p02627 | Input is given from Standard Input in the following format:
α | L = set("A", "B")
print(L)
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s758645869 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | print("B") if input().islower() else print("A")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s742853748 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | print(input())
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s330574019 | Accepted | p02627 | Input is given from Standard Input in the following format:
α | print(chr(65 + (input() > "Z") * 32))
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s342900613 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | print(chr(ord(input()) + 32))
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s666622625 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | kotae = str(input())
print(kotae.swapcase())
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s078443149 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | print("a" if input() > "A" else "A")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s728878493 | Accepted | p02627 | Input is given from Standard Input in the following format:
α | S = lambda: input()
I = lambda: int(input())
L = lambda: list(map(int, input().split()))
LS = lambda: list(map(str, input().split()))
a = S()
print("A" if a.isupper() else "a")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s759496176 | Accepted | p02627 | Input is given from Standard Input in the following format:
α | import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(input())
def MAP():
return map(int, input().split())
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**19
MOD = 10**9 + 7
EPS = 10**-10
S = input()
if S.islower():
print("a")
else:
print("A")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s679363297 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | def pokryj(plansza, x, y):
koszt = 0
if 2 * x >= y:
for i in range(len(plansza) - 1):
if plansza[i] == "." and plansza[i + 1] == ".":
plansza[i] == "x"
plansza[i + 1] == "x"
koszt += y
elif plansza[i] == ".":
plansza[i] == "x"
koszt += x
else:
for i in range(len(plansza) - 1):
if plansza[i] == ".":
plansza[i] == "x"
koszt += x
return koszt
print(pokryj("x.x.x.x..", 1, 2))
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s104153163 | Runtime Error | p02627 | Input is given from Standard Input in the following format:
α | n = int(input())
c = 0
n1 = 0
n1 += n
for i in range(1, 12):
a = n1 - 26 ** (i)
c += 1
if a <= 0:
break
n1 = n1 - 26 ** (i)
a = ""
for i in range(c):
if n // 26 ** (c - i - 1) >= 26:
alpha = 26
n = n - 26 ** (c - i)
else:
alpha = n // 26 ** (c - i - 1)
n = n % 26 ** (c - i - 1)
a += chr(96 + alpha)
print(a)
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s147954234 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | m = input()
if (
m == "A"
or m == "B"
or m == "Q"
or m == "W"
or m == "E"
or m == "R"
or m == "T"
or m == "Y"
or m == "U"
or m == "I"
or m == "O"
or m == "P"
or m == "S"
or m == "D"
or m == "F"
or m == "G"
or m == "H"
or m == "J"
or m == "K"
or m == "L"
or m == "Z"
or m == "X"
or m == "C"
or m == "V"
or m == "B"
or m == "N"
or m == "M"
):
print("A")
if (
m == "a"
or m == "b"
or m == "q"
or m == "w"
or m == "e"
or m == "r"
or m == "t"
or m == "y"
or m == "u"
or m == "i"
or m == "o"
or m == "p"
or m == "s"
or m == "d"
or m == "f"
or m == "g"
or m == "h"
or m == "j"
or m == "k"
or m == "l"
or m == "Z"
or m == "x"
or m == "c"
or m == "v"
or m == "b"
or m == "n"
or m == "m"
):
print("a")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s698026813 | Runtime Error | p02627 | Input is given from Standard Input in the following format:
α | a, b = map(int, input().split())
mylist = input().split()
mylist.sort()
c = 0
for i in range(b - 1):
c = c + int(mylist[i - 1])
print(c)
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s763917155 | Accepted | p02627 | Input is given from Standard Input in the following format:
α | print("a" if input() in list("abcdefghijklmnopqrstuvwxyz") else "A")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s340713150 | Runtime Error | p02627 | Input is given from Standard Input in the following format:
α | print("Aa"[ord(open(0)) > 95])
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s755351383 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | input()
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s447613318 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | a = input()
dic = {
"A": "a",
"B": "b",
"C": "c",
"D": "d",
"E": "e",
"F": "f",
"G": "g",
"H": "h",
"I": "i",
"J": "j",
"K": "k",
"L": "l",
"M": "m",
"N": "n",
"O": "o",
"P": "p",
"Q": "q",
"R": "r",
"S": "s",
"T": "t",
"U": "u",
"V": "v",
"W": "w",
"X": "x",
"Y": "y",
"Z": "z",
}
if a in list(dic.keys()):
print(dic[a])
exit()
print(a)
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s668270506 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | print(str.swapcase(input()))
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s691256385 | Accepted | p02627 | Input is given from Standard Input in the following format:
α | a = input()
if a == "A":
print("A")
elif a == "B":
print("A")
elif a == "C":
print("A")
elif a == "D":
print("A")
elif a == "E":
print("A")
elif a == "E":
print("A")
elif a == "F":
print("A")
elif a == "G":
print("A")
elif a == "H":
print("A")
elif a == "I":
print("A")
elif a == "J":
print("A")
elif a == "K":
print("A")
elif a == "L":
print("A")
elif a == "M":
print("A")
elif a == "N":
print("A")
elif a == "O":
print("A")
elif a == "P":
print("A")
elif a == "Q":
print("A")
elif a == "R":
print("A")
elif a == "S":
print("A")
elif a == "T":
print("A")
elif a == "U":
print("A")
elif a == "V":
print("A")
elif a == "W":
print("A")
elif a == "X":
print("A")
elif a == "Y":
print("A")
elif a == "Z":
print("A")
else:
print("a")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s573832272 | Accepted | p02627 | Input is given from Standard Input in the following format:
α | #!python3.8
# -*- coding: utf-8 -*-
# abc171/abc171_a
import sys
s2nn = lambda s: [int(c) for c in s.split(" ")]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
def main():
a = i2s()
print("A" if a.isupper() else "a")
return
main()
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s814261086 | Accepted | p02627 | Input is given from Standard Input in the following format:
α | a = input()
if (
a == "A"
or a == "B"
or a == "C"
or a == "D"
or a == "E"
or a == "F"
or a == "G"
or a == "H"
or a == "I"
or a == "J"
or a == "K"
or a == "L"
or a == "M"
or a == "N"
or a == "O"
or a == "P"
or a == "Q"
or a == "R"
or a == "S"
or a == "T"
or a == "U"
or a == "V"
or a == "W"
or a == "X"
or a == "Y"
or a == "Z"
):
print("A")
else:
print("a")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s975288215 | Runtime Error | p02627 | Input is given from Standard Input in the following format:
α | N, K = map(int, input().split())
p = list(map(int, input().split()))
print(sum(sorted(p)[:K]))
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s428052204 | Wrong Answer | p02627 | Input is given from Standard Input in the following format:
α | print("aA"[input().islower()])
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s750093066 | Accepted | p02627 | Input is given from Standard Input in the following format:
α | a = input()
B = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P","Q", "R","S","T","U","V","W","X","Y","Z"]
b = ["a","b", "c","d","e", "f","g", "h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
if a in B:
print("A")
else:
print("a") | Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s044866322 | Accepted | p02627 | Input is given from Standard Input in the following format:
α | print(["a", "A"][input().isupper()])
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
* * * | s497711093 | Accepted | p02627 | Input is given from Standard Input in the following format:
α | strr = input()
if (
strr == "A"
or strr == "B"
or strr == "C"
or strr == "D"
or strr == "E"
or strr == "F"
or strr == "G"
or strr == "H"
or strr == "I"
or strr == "J"
or strr == "K"
or strr == "L"
or strr == "N"
or strr == "M"
or strr == "O"
or strr == "P"
or strr == "Q"
or strr == "R"
or strr == "S"
or strr == "T"
or strr == "U"
or strr == "V"
or strr == "W"
or strr == "X"
or strr == "Y"
or strr == "Z"
):
print("A")
else:
print("a")
| Statement
An uppercase or lowercase English letter \alpha will be given as input. If
\alpha is uppercase, print `A`; if it is lowercase, print `a`. | [{"input": "B", "output": "A\n \n\n`B` is uppercase, so we should print `A`.\n\n* * *"}, {"input": "a", "output": "a\n \n\n`a` is lowercase, so we should print `a`."}] |
Print the number of ways modulo $10^9+7$ in a line. | s670408233 | Accepted | p02332 | $n$ $k$
The first line will contain two integers $n$ and $k$. | import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(input())
def MAP():
return map(int, input().split())
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7
EPS = 10**-10
class ModTools:
"""階乗・逆元用のテーブルを構築する"""
def __init__(self, MAX, MOD):
MAX += 1
self.MAX = MAX
self.MOD = MOD
factorial = [1] * MAX
factorial[0] = factorial[1] = 1
for i in range(2, MAX):
factorial[i] = factorial[i - 1] * i % MOD
inverse = [1] * MAX
inverse[MAX - 1] = pow(factorial[MAX - 1], MOD - 2, MOD)
for i in range(MAX - 2, -1, -1):
inverse[i] = inverse[i + 1] * (i + 1) % MOD
self.fact = factorial
self.inv = inverse
def nCr(self, n, r):
"""組み合わせ"""
if n < r:
return 0
r = min(r, n - r)
numerator = self.fact[n]
denominator = self.inv[r] * self.inv[n - r] % self.MOD
return numerator * denominator % self.MOD
def nHr(self, n, r):
"""重複組み合わせ"""
return self.nCr(r + n - 1, r)
def nPr(self, n, r):
"""順列"""
if n < r:
return 0
return self.fact[n] * self.inv[n - r] % self.MOD
def div(self, x, y):
"""MOD除算"""
return x * pow(y, self.MOD - 2, self.MOD) % self.MOD
N, K = MAP()
mt = ModTools(max(N, K) + 1, MOD)
ans = mt.nPr(K, N) % MOD
print(ans)
| You have $n$ balls and $k$ boxes. You want to put these balls into the boxes.
Find the number of ways to put the balls under the following conditions:
* Each ball is distinguished from the other.
* Each box is distinguished from the other.
* Each ball can go into only one box and no one remains outside of the boxes.
* Each box can contain at most one ball.
Note that you must print this count modulo $10^9+7$. | [{"input": "2 3", "output": "6"}, {"input": "3 2", "output": "0"}, {"input": "100 100", "output": "437918130"}] |
Print the number of ways modulo $10^9+7$ in a line. | s491479256 | Accepted | p02332 | $n$ $k$
The first line will contain two integers $n$ and $k$. | a, b = map(int, input().split())
m = 10**9 + 7
if a > b:
print(0)
else:
r = 1
for i in range(b - a + 1, b + 1):
r *= i
r %= m
print(r)
| You have $n$ balls and $k$ boxes. You want to put these balls into the boxes.
Find the number of ways to put the balls under the following conditions:
* Each ball is distinguished from the other.
* Each box is distinguished from the other.
* Each ball can go into only one box and no one remains outside of the boxes.
* Each box can contain at most one ball.
Note that you must print this count modulo $10^9+7$. | [{"input": "2 3", "output": "6"}, {"input": "3 2", "output": "0"}, {"input": "100 100", "output": "437918130"}] |
Print the number of ways modulo $10^9+7$ in a line. | s825421683 | Accepted | p02332 | $n$ $k$
The first line will contain two integers $n$ and $k$. | class Twelvefold: # n <= 1000程度
def __init__(self, n, mod):
self.mod = mod
self.fct = [0 for _ in range(n + 1)]
self.inv = [0 for _ in range(n + 1)]
self.stl = [[0 for j in range(n + 1)] for i in range(n + 1)]
self.bel = [[0 for j in range(n + 1)] for i in range(n + 1)]
self.prt = [[0 for j in range(n + 1)] for i in range(n + 1)]
self.fct[0] = 1
self.inv[0] = 1
self.stl[0][0] = 1
self.bel[0][0] = 1
for i in range(n):
self.fct[i + 1] = self.fct[i] * (i + 1) % mod
self.inv[n] = pow(self.fct[n], mod - 2, mod)
for i in range(n)[::-1]:
self.inv[i] = self.inv[i + 1] * (i + 1) % mod
for i in range(n):
for j in range(n):
self.stl[i + 1][j + 1] = self.stl[i][j] + (j + 1) * self.stl[i][j + 1]
self.stl[i + 1][j + 1] %= mod
for i in range(n):
for j in range(n):
self.bel[i + 1][j + 1] = (
self.bel[i + 1][j] + self.stl[i + 1][j + 1] % mod
)
self.bel[i + 1][j + 1] %= mod
for j in range(n):
self.prt[0][j] = 1
for i in range(n):
for j in range(n):
if i - j >= 0:
self.prt[i + 1][j + 1] = self.prt[i + 1][j] + self.prt[i - j][j + 1]
else:
self.prt[i + 1][j + 1] = self.prt[i + 1][j]
self.prt[i + 1][j + 1] %= mod
def solve(
self,
element,
subset,
equate_element=False,
equate_subset=False,
less_than_1=False,
more_than_1=False,
):
assert not less_than_1 or not more_than_1
n = element
k = subset
a = equate_element
b = equate_subset
c = less_than_1
d = more_than_1
id = a * 3 + b * 6 + c + d * 2
tw = [
self.tw1,
self.tw2,
self.tw3,
self.tw4,
self.tw5,
self.tw6,
self.tw7,
self.tw8,
self.tw9,
self.tw10,
self.tw11,
self.tw12,
]
return tw[id](n, k)
def tw1(self, n, k):
return pow(k, n, self.mod)
def tw2(self, n, k):
if k - n < 0:
return 0
return self.fct[k] * self.inv[k - n] % self.mod
def tw3(self, n, k):
return self.stl[n][k] * self.fct[k] % self.mod
def tw4(self, n, k):
if k == 0:
return 0
return self.fct[n + k - 1] * self.inv[n] * self.inv[k - 1] % self.mod
def tw5(self, n, k):
if k - n < 0:
return 0
return self.fct[k] * self.inv[n] * self.inv[k - n] % self.mod
def tw6(self, n, k):
if n - k < 0 or k == 0:
return 0
return self.fct[n - 1] * self.inv[k - 1] * self.inv[n - k]
def tw7(self, n, k):
return self.bel[n][k]
def tw8(self, n, k):
if k - n < 0:
return 0
return 1
def tw9(self, n, k):
return self.stl[n][k]
def tw10(self, n, k):
return self.prt[n][k]
def tw11(self, n, k):
if k - n < 0:
return 0
return 1
def tw12(self, n, k):
if n - k < 0:
return 0
return self.prt[n - k][k]
n, k = map(int, input().split())
t = Twelvefold(1000, 10**9 + 7)
print(t.solve(n, k, 0, 0, 1, 0))
| You have $n$ balls and $k$ boxes. You want to put these balls into the boxes.
Find the number of ways to put the balls under the following conditions:
* Each ball is distinguished from the other.
* Each box is distinguished from the other.
* Each ball can go into only one box and no one remains outside of the boxes.
* Each box can contain at most one ball.
Note that you must print this count modulo $10^9+7$. | [{"input": "2 3", "output": "6"}, {"input": "3 2", "output": "0"}, {"input": "100 100", "output": "437918130"}] |
Print "1" or "0" in a line. | s869501713 | Wrong Answer | p02298 | g is given by coordinates of the points p1,..., pn in the following format:
n
x1 y1
x2 y2
:
xn yn
The first integer n is the number of points. The coordinate of a point pi is
given by two integers xi and yi. The coordinates of points are given in the
order of counter-clockwise visit of them. | n = int(input())
points = [complex(*map(int, input().split())) for _ in range(n)]
edges = [p1 - p0 for p0, p1 in zip(points, points[1:] + [points[0]])]
prev = edges[0]
while edges:
edge = edges.pop()
if edge.real * prev.imag - prev.real * edge.imag < 1e-6:
print(0)
break
prev = edge
else:
print(1)
| Is-Convex
For a given polygon g, print "1" if g is a convex polygon, "0" otherwise.
Here, in a convex polygon, all interior angles are less than or equal to 180
degrees.
g is represented by a sequence of points p1, p2,..., pn where line segments
connecting pi and pi+1 (1 ≤ i ≤ n-1) are sides of the polygon. The line
segment connecting pn and p1 is also a side of the polygon. | [{"input": "4\n 0 0\n 3 1\n 2 3\n 0 3", "output": "1"}, {"input": "5\n 0 0\n 2 0 \n 1 1\n 2 2\n 0 2", "output": "0"}] |
Print "1" or "0" in a line. | s643525663 | Accepted | p02298 | g is given by coordinates of the points p1,..., pn in the following format:
n
x1 y1
x2 y2
:
xn yn
The first integer n is the number of points. The coordinate of a point pi is
given by two integers xi and yi. The coordinates of points are given in the
order of counter-clockwise visit of them. | n = int(input())
vec = []
for i in range(n):
vec += [list(map(int, input().split()))]
vec += [vec[0]]
vec += [vec[1]]
Sum = 0
def cross(a, b):
return a[0] * b[1] - a[1] * b[0]
def ab(a, b):
c = (b[0] - a[0], b[1] - a[1])
return c
def check(a, b, c):
if cross(ab(a, b), ab(a, c)) >= 0:
return 1
else:
return 0
for a, b, c in zip(vec[0:-2], vec[1:-1], vec[2:]):
cnt = check(a, b, c)
if cnt == 0:
break
print(cnt)
| Is-Convex
For a given polygon g, print "1" if g is a convex polygon, "0" otherwise.
Here, in a convex polygon, all interior angles are less than or equal to 180
degrees.
g is represented by a sequence of points p1, p2,..., pn where line segments
connecting pi and pi+1 (1 ≤ i ≤ n-1) are sides of the polygon. The line
segment connecting pn and p1 is also a side of the polygon. | [{"input": "4\n 0 0\n 3 1\n 2 3\n 0 3", "output": "1"}, {"input": "5\n 0 0\n 2 0 \n 1 1\n 2 2\n 0 2", "output": "0"}] |
Print the answers in order, with space in between.
* * * | s569971509 | Wrong Answer | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | print("1 3 5 4 3 3 3 3 1 0")
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s038859216 | Runtime Error | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | def s0():
return input()
def s1():
return input().split()
def s2(n):
return [input() for x in range(n)]
def s3(n):
return [input().split() for _ in range(n)]
def s4(n):
return [[x for x in s] for s in s2(n)]
def n0():
return int(input())
def n1():
return [int(x) for x in input().split()]
def n2(n):
return [int(input()) for _ in range(n)]
def n3(n):
return [[int(x) for x in input().split()] for _ in range(n)]
def t3(n):
return [tuple(int(x) for x in input().split()) for _ in range(n)]
def p0(b, yes="Yes", no="No"):
print(yes if b else no)
# from sys import setrecursionlimit
# setrecursionlimit(1000000)
# from collections import Counter,deque,defaultdict
# import itertools
# import math
import networkx as nx
# from bisect import bisect_left,bisect_right
# from heapq import heapify,heappush,heappop
n, m, k = n1()
AB = n3(m)
CD = n3(k)
G = nx.Graph()
G.add_edges_from(AB)
friend = {i: [] for i in range(1, n + 1)}
for i, j in AB:
friend[i].append(j)
friend[j].append(i)
block = {i: [] for i in range(1, n + 1)}
for i, j in CD:
block[i].append(j)
block[j].append(i)
ans = []
for i in range(1, n + 1):
g = nx.single_source_shortest_path(G, source=i)
f_kouho = set(g.keys())
tmp = -1
for j in f_kouho:
if (not j in friend[i]) and (not j in block[i]):
tmp += 1
ans.append(tmp)
print(*ans)
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s837746507 | Runtime Error | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | """
Friend Suggestions
"""
import sys
input = lambda: sys.stdin.readline().rstrip()
class Vertex:
"""A Vertex is a node in a graph."""
def __init__(self, label=""):
self.label = label
def __repr__(self):
return f"V{self.label}"
__str__ = __repr__
class Edge(tuple):
"""An Edge is a list of two vertices."""
def __new__(cls, *vs):
"""The Edge constructor takes two vertices."""
if len(vs) != 2:
raise ValueError("Edges must connect exactly two vertices.")
return tuple.__new__(cls, vs)
def __repr__(self):
return f"Edge_{repr(self[0])}_{repr(self[1])}"
__str__ = __repr__
class Graph(dict):
"""A Graph is a dictionary of dictionaries.
For vertices a and b, graph[a][b] maps
to the edge that connects a->b, if it exists."""
def __init__(self, vs, es):
"""Creates a new graph.
vs: list of vertices;
es: list of edges.
"""
super().__init__()
for v in vs:
self.add_vertex(v)
for e in es:
self.add_edge(e)
def add_vertex(self, v):
"""Add a vertex to the graph."""
self[v] = {}
def add_edge(self, e):
"""Adds and edge to the graph by adding an entry in both directions."""
v, w = e
self[v][w] = e
self[w][v] = e
def vertices(self):
"""returns a list of the vertices in graph"""
vs = []
for v in self.keys():
vs.append(v)
return vs
def out_vertices(self, v):
"""returns a list of adjacent vertices of the (v)"""
return self[v].keys()
def out_edges(self, v):
"""returns a list of edges connected to the (v)"""
return self[v].values()
def is_connected(self):
"""returns True if the Graph is conneted and False otherwise"""
vertices = self.vertices()
closed = self.BFS(vertices[0])
return len(vertices) == len(closed)
def closed_vertices(self, v):
return self.BFS(v)
def BFS(self, v):
"""search graph by a BFS: breadth-first-search"""
worklist = [v]
closed = []
while worklist:
visited = worklist.pop(0)
closed.append(visited)
vs = self.out_vertices(visited)
vs = [v for v in vs if not (v in closed or v in worklist)]
worklist.extend(vs)
return closed
def main():
N, M, K = map(int, input().split())
ans = [-1] * N
friend = [list(map(int, input().split())) for _ in range(M)]
blocks = [list(map(int, input().split())) for _ in range(K)]
nodes = [Vertex(str(v)) for v in range(N)]
edges = [Edge(nodes[edge[0] - 1], nodes[edge[1] - 1]) for edge in friend]
g = Graph(nodes, edges)
for i, v in enumerate(nodes):
closed_graph_list = [str(x) for x in g.closed_vertices(v)]
closed_graph_list.remove(str(v))
connected_vertices = [str(x) for x in list(g.out_vertices(v))]
candidates = list(set(closed_graph_list) - set(connected_vertices))
ans[i] = candidates
for block_rel in blocks:
block_a = block_rel[0] - 1
block_b = block_rel[1] - 1
if f"V{block_b}" in ans[block_a]:
ans[block_a].remove(f"V{block_b}")
if f"V{block_a}" in ans[block_b]:
ans[block_b].remove(f"V{block_a}")
print(*[len(i) for i in ans])
if __name__ == "__main__":
main()
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s657080801 | Wrong Answer | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | from collections import deque, Counter
import sys
N_MAX = 100000 + 5
sys.setrecursionlimit(N_MAX)
N, M, K = map(int, sys.stdin.readline().rstrip().split())
fr = [[] for _ in range(N)] # 友達関係
for _ in range(M):
a, b = map(int, sys.stdin.readline().rstrip().split())
fr[a - 1].append(b - 1)
fr[b - 1].append(a - 1)
bl = [[] for _ in range(N)] # ブロック関係
for _ in range(K):
a, b = map(int, sys.stdin.readline().rstrip().split())
bl[a - 1].append(b - 1)
bl[b - 1].append(a - 1)
gr = [0] * N # 友達候補グループ
# ## BFS ## #
def bfs(u, num):
q = deque()
q.append(u)
while q:
u = q.popleft()
for v in fr[u]:
if gr[v] == 0: # state を確認
gr[v] = num # state を変更
q.append(v)
num = 1
for i in range(N):
if gr[i] == 0:
bfs(i, num)
num += 1
# print(gr)
gr_num = Counter(gr) # グループの人数を数えておく
# グループの中から、友達でも
ans = []
for i in range(N):
kouho_suu = gr_num[gr[i]]
for f in fr[i]:
if gr[i] == gr[f]:
kouho_suu -= 1
for b in bl[i]:
if gr[i] == gr[b]:
kouho_suu -= 1
kouho_suu -= 1
ans.append(kouho_suu)
print(*ans)
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s705088646 | Runtime Error | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | n, m = map(int, input().split())
s = [list(map(int, input().split())) for _ in range(m)]
l1 = []
l2 = []
l3 = []
for i in range(m):
if s[i][0] == 1:
l1.append(s[i])
elif s[i][0] == 2:
l2.append(s[i])
elif s[i][0] == 3:
l3.append(s[i])
l1 = list(map(list, set(map(tuple, l1))))
l2 = list(map(list, set(map(tuple, l2))))
l3 = list(map(list, set(map(tuple, l3))))
check = 0
if len(l1) > 1 or len(l2) > 1 or len(l3) > 1: # 同じ桁に違う数
check += 1
if n == 3 or n == 2:
if len(l1) > 0 and l1[0][1] == 0: # 二桁三桁の時最初が０
check += 1
if n == 3:
if len(l1) == 0:
l1.append([1, 1])
if len(l2) == 0:
l2.append([2, 0])
if len(l3) == 0:
l3.append([3, 0])
if n == 2:
if len(l1) == 0:
l1.append([1, 1])
if len(l2) == 0:
l2.append([2, 0])
if n == 1:
if len(l1) == 0:
l1.append([1, 0])
if check >= 1:
print(-1)
else:
ans = []
if len(l1) > 0:
ans.append(l1[0][1])
if len(l2) > 0:
ans.append(l2[0][1])
if len(l3) > 0:
ans.append(l3[0][1])
print(int("".join(map(str, ans))))
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s130857790 | Runtime Error | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | import sys
from collections import deque
# 再帰関数は非常にダメダメですねぇ
N, M, K = map(int, input().split())
friend = [list(map(int, input().split())) for _ in range(M)]
block = [list(map(int, input().split())) for _ in range(K)]
sys.setrecursionlimit(2 * N)
# print(friend)
# print(block)
graph = [[] for _ in range(N)]
bgraph = [[] for _ in range(N)]
cnt = []
for i in range(M):
ii, jj = friend[i]
graph[ii - 1].append(jj - 1)
graph[jj - 1].append(ii - 1)
for i in range(K):
ii, jj = block[i]
bgraph[ii - 1].append(jj - 1)
bgraph[jj - 1].append(ii - 1)
# print(graph)
# print(bgraph)
seen = [False for _ in range(N)]
def dfs(i):
# if i not in bgraph[j]:
# seen[i]= True
# else:
# seen[i]="block"
# if graph[i]:
# for nec in graph[i]:
# if seen[nec] == False:
# dfs(nec,j)
seen[i] = True
que = deque([i])
while que:
neci = que.pop()
for nec in graph[neci]:
if seen[nec] == False:
if nec not in bgraph[i]:
seen[nec] = True
else:
seen[nec] = "block"
que.append(nec)
for i_n in range(N):
seen = [False for _ in range(N)]
dfs(i_n)
# print(seen)
cnt.append(seen.count(True) - 1 - len(graph[i_n]))
print(*cnt)
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s562479430 | Wrong Answer | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | from collections import deque
n, m, k = list(map(int, input().split()))
friends = [tuple(map(int, input().split())) for _ in range(m)]
block = [tuple(map(int, input().split())) for _ in range(k)]
relation_d = {}
for i in range(1, n + 1):
relation_d[str(i)] = set()
for a, b in friends:
relation_d[str(a)].add(str(b))
relation_d[str(b)].add(str(a))
block_d = {}
for i in range(1, n + 1):
block_d[str(i)] = set()
for a, b in block:
block_d[str(a)].add(str(b))
block_d[str(b)].add(str(a))
for i in range(1, n + 1):
visited = set()
candidates = set()
dq = deque(list(relation_d[str(i)]))
while dq:
for j in range(len(dq)):
node = dq.popleft()
if not node in relation_d[str(i)]:
candidates.add(node)
if not node in visited:
dq.extend(relation_d[node])
visited.add(node)
print(len(candidates - block_d[str(i)] - set(str(i))), end=" ")
# print(relation_d[str(i)], block_d[str(i)], relation_d[str(i)]-block_d[str(i)])
# print(len(candidates-block_d[str(i)]))
# print(len(member-relation_d[str(i)]-block_d[str(i)])-1, end=" ")
# print(n-1-len(relation_d[str(i)]-block_d[str(i)]), end=" ")
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s386410283 | Runtime Error | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | n, m, k = map(int, input().split())
S = [[i, 100001, []] for i in range(1, n + 1)]
count = 0
for num in range(0, m + k):
i1, i2 = map(int, input().split())
a = S[i1 - 1][1]
b = S[i2 - 1][1]
a_1, a_2 = S[i1 - 1][1], []
b_1, b_2 = S[i2 - 1][1], []
t = min(a, b)
if t == 100001 and num < m:
a_1 = b_1 = count
count += 1
elif num < m:
a_1 = b_1 = t
if max(a, b) != 100001:
xc = [x[1] for x in S]
indexes = [j + 1 for j, x in enumerate(xc) if x == max(a, b)]
for f in range(len(indexes)):
S[indexes[f] - 1][1:] = [t, S[indexes[f] - 1][2]]
a_2 = S[i1 - 1][2]
b_2 = S[i2 - 1][2]
a_2.append(i2)
b_2.append(i1)
S[i1 - 1][1:] = [a_1, a_2]
S[i2 - 1][1:] = [b_1, b_2]
friend = [0] * n
for i in range(0, count):
xc = [x[1] for x in S]
indexes = [j + 1 for j, x in enumerate(xc) if x == i]
for z in range(len(indexes)):
S[indexes[z] - 1][2].append(S[indexes[z] - 1][0])
V = S[indexes[z] - 1][2] # +indexes[:z]
result = set(indexes) - set(V)
S[indexes[z] - 1][2].append(z)
friend[indexes[z] - 1] = str(len(result))
# print(indexes)
print(" ".join(friend))
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s679060115 | Wrong Answer | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | from collections import deque
n, m, k = list(map(int, input().split()))
friendship = {}
for i in range(m):
a, b = list(map(int, input().split()))
if a in friendship.keys():
friendship[a].append(b)
else:
friendship[a] = [b]
if b in friendship.keys():
friendship[b].append(a)
else:
friendship[b] = [a]
block = {}
for j in range(k):
c, d = list(map(int, input().split()))
if c in block.keys():
block[c].append(d)
else:
block[c] = [d]
if d in block.keys():
block[d].append(c)
else:
block[d] = [c]
ans = [0] * n
for i in range(n):
print(i + 1)
person = i + 1
checked_person = set()
checked_person.add(person)
if person in friendship.keys():
candidate = deque(friendship[person])
while len(candidate) > 0:
c = deque.popleft(candidate)
checked_person.add(c)
if c not in friendship[person]:
if person in block.keys():
if c not in block[person]:
ans[i] += 1
else:
ans[i] += 1
if c in friendship.keys():
for p in friendship[c]:
if p not in checked_person and p not in candidate:
candidate.append(p)
else:
continue
answer = ""
for i in range(len(ans)):
answer += str(ans[i])
if i != n - 1:
answer += " "
print(answer)
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s517133290 | Wrong Answer | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | import queue
q = queue.Queue()
n, m, k = map(int, input().split())
friend = [list(map(int, input().split())) for i in range(m)]
block = [list(map(int, input().split())) for i in range(k)]
suggestions = [] # 友達候補
def Strand(now): # 繋がり検索
for o in range(m):
if friend[o][0] == now:
if friend[o][1] not in Q:
q.put(friend[o][1])
Q.append(friend[o][1])
if friend[o][1] == now:
if friend[o][0] not in Q:
q.put(friend[o][0])
Q.append(friend[o][0])
for i in range(n):
now = i # 現在地
count = 0
Q = [i] # 発見済み
Strand(i)
F = [] # 人iのフレンドリスト
for j in range(m):
if friend[j][0] == i:
F.append(friend[j][1])
if friend[j][1] == i:
F.append(friend[j][0])
B = [] # 人iのブロックリスト
for l in range(k):
if block[l][0] == i:
B.append(block[l][1])
if block[l][1] == i:
B.append(block[l][0])
while not q.empty():
if i != 0:
for o in range(m):
if friend[o][0] == now:
if friend[o][1] not in Q:
q.put(friend[o][1])
Q.append(friend[o][1])
if friend[o][1] == now:
if friend[o][0] not in Q:
q.put(friend[o][0])
Q.append(friend[o][0])
now = q.get()
if (now not in F) and (now not in B):
count += 1
suggestions.append(count)
print(" ".join(map(str, suggestions)))
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s054749833 | Wrong Answer | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | import sys
N, M, K = map(int, sys.stdin.readline().split())
setList = [set(list(map(int, sys.stdin.readline().split()))) for _ in range(M + K)]
li = []
i = 1
for s in setList:
j = 2
while i < N:
while j <= N:
if s != {i, j}:
li.append(i)
li.append(j)
j += 1
i += 1
n = 1
while n <= N:
print(li.count(n), end="")
n += 1
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s774942065 | Runtime Error | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | N, M, K = map(int, input().split())
friend = [list(map(int, input().split())) for i in range(M)]
block = [list(map(int, input().split())) for i in range(K)]
result = []
FG = [[] for i in range(N + 1)]
BG = [[] for i in range(N + 1)]
for i in range(M):
a = friend[i][0]
b = friend[i][1]
FG[a].append(b)
FG[b].append(a)
for i in range(K):
a = block[i][0]
b = block[i][1]
BG[a].append(b)
BG[b].append(a)
result = [0] * (N + 1)
flag = [0] * (N + 1)
W = []
for i in range(1, N + 1):
W.append(i)
W = set(W)
def dfs(i):
if flag[i] == 1:
return
else:
group.append(i)
flag[i] = 1
for j in range(len(FG[i])):
dfs(FG[i][j])
while len(W) != 0:
w = list(W)
point = w[0]
group = []
if FG[point] != 0:
dfs(point)
S = len(group)
for j in range(S):
m = group[j]
FB = set(FG[m] + BG[m])
SG = set(group)
fc = SG - FB
result[m] = len(fc) - 1
else:
flag[point] = 1
SG = {point}
W = W - SG
print(*result[1:])
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s992226651 | Wrong Answer | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | N, M, K = map(int, input().split())
AB = [list(map(int, input().split())) for i in range(M)]
CD = [list(map(int, input().split())) for i in range(K)]
AB.sort()
CD.sort()
friend = [N - 1] * N
anti = []
ans = []
count = 1
cnt = 1
# print(AB)
# print(CD)
m = 0
n = 0
while m < M:
friend[AB[m][0] - 1] -= 1
friend[AB[m][1] - 1] -= 1
m += 1
while n < K:
friend[CD[n][0] - 1] -= 1
friend[CD[n][1] - 1] -= 1
n += 1
"""for i in range(M-1):
if AB[i][0]==AB[i+1][0]:
count+=1
else:
friend[AB[i][0]]-=count
count=1
for j in range(K-1):
if CD[j][0]==CD[j+1][0]:
cnt+=1
else:
friend[CD[j][0]]-=cnt
cnt=1
while True:
if len(friend)<N:
friend.append([0,0])
break
while True:
if len(anti)<K:
anti.append([0,0])
break"""
print(*friend)
"""while m<len(friend):
if friend[m]==
print(ans)"""
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s341136008 | Wrong Answer | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | used = []
w = []
def dfs(v, num):
used[v] = num
for x in w[v]:
if used[x] == 0:
dfs(x, num)
n, m, k = (int(i) for i in input().split())
for i in range(n):
w.append([])
for j in range(m):
u, v = (int(i) for i in input().split())
u -= 1
v -= 1
w[u].append(v)
w[v].append(u)
block = []
for j in range(k):
u, v = (int(i) for i in input().split())
u -= 1
v -= 1
block.append([u, v])
for i in range(n):
used.append(0)
# cnt_comp = 0;
# for i in range(n):
# if used[i] == 0:
# cnt_comp += 1;
# dfs(i, cnt_comp);
# cnt = [0 for i in range(cnt_comp)];
#
# for i in range(n):
# cnt[used[i] - 1] += 1;
#
# res = [0 for i in range(n)];
# for i in range(n):
# res[i] = cnt[used[i] - 1] - 1;
# #print(res);
# for x in block:
# if used[x[0]] == used[x[1]]:
# res[x[0]] -= 1;
# res[x[1]] -= 1;
# #print(res);
# for i in range(n):
# for v in w[i]:
# if used[v] == used[i]:
# res[i] -= 1;
#
# #print(cnt);
#
# for i in res:
# print(i, end=" ");
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
Print the answers in order, with space in between.
* * * | s896908606 | Accepted | p02762 | Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K | from sys import stdin
def getval():
n, m, k = map(int, stdin.readline().split())
a = [list(map(int, stdin.readline().split())) for i in range(m)]
c = [list(map(int, stdin.readline().split())) for i in range(k)]
return n, m, k, a, c
def main(n, m, k, a, c):
# Compute all members' friends
friends = [[] for i in range(n)]
for i in a:
friends[i[0] - 1].append(i[1] - 1)
friends[i[1] - 1].append(i[0] - 1)
# Group all members in the isolated "friend groups"
frgroups = []
visited = [False for i in range(n)]
for i in range(n):
if visited[i]:
continue
q = [i]
temp = [i]
visited[i] = True
while q:
idx = q.pop(0)
adj = friends[idx]
for j in adj:
if visited[j]:
continue
visited[j] = True
q.append(j)
temp.append(j)
frgroups.append(temp)
# Number all members with their friend groups respectively
groups = [-1 for i in range(n)]
for i in range(len(frgroups)):
for j in frgroups[i]:
groups[j] = i
# For each member, refer to the friend groups of blocked peope
# Compute ans accordingly
ans = [len(frgroups[groups[i]]) - 1 - len(friends[i]) for i in range(n)]
for i in c:
if groups[i[0] - 1] == groups[i[1] - 1]:
ans[i[0] - 1] -= 1
ans[i[1] - 1] -= 1
s = str(ans[0])
for i in range(1, n):
s += " " + str(ans[i])
print(s)
if __name__ == "__main__":
n, m, k, a, c = getval()
main(n, m, k, a, c)
| Statement
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M _friendships_ and K
_blockships_.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
C_i and User D_i.
We define User a to be a _friend candidate_ for User b when all of the
following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have? | [{"input": "4 4 1\n 2 1\n 1 3\n 3 2\n 3 4\n 4 1", "output": "0 1 0 1\n \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n 1 2\n 1 3\n 1 4\n 1 5\n 3 2\n 2 4\n 2 5\n 4 3\n 5 3\n 4 5", "output": "0 0 0 0 0\n \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n 10 1\n 6 7\n 8 2\n 2 5\n 8 4\n 7 3\n 10 9\n 6 4\n 5 8\n 2 6\n 7 5\n 3 1", "output": "1 3 5 4 3 3 3 3 1 0"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s198962528 | Runtime Error | p03523 | Input is given from Standard Input in the following format:
S | s=list(input())
if s.count('K')==1 and s.count('I')==1 and s.count('H')==1 ands.count('B')==1 ands.count('R')==1:
print('YES')
else:
print('NO') | Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s004233696 | Runtime Error | p03523 | Input is given from Standard Input in the following format:
S | from collections import Counter
import itertools
N = int(input())
D = list(map(int, input().split()))
M = Counter(D)
if max(M.values()) > 2:
print(0)from collections import Counter
import itertools
N = int(input())
D = list(map(int, input().split()))
M = Counter(D)
if max(M.values()) > 2:
print(0)
else:
D = [[x, 24-x] for x in D]
generator = list(itertools.product([0, 1], repeat=N))
D_gen = [[D[i][g[i]] for i in range(N)] for g in generator]
ans = 0
for d in D_gen:
tmp = [0] + sorted(d) + [24]
s = 13
for i in range(N+1):
s = min(s, tmp[i+1]-tmp[i])
ans = max(ans, s)
print(ans)
elif 0 in D:
print(0)
else:
D = [[x, 24-x] for x in D]
generator = list(itertools.product([0, 1], repeat=N))
D_gen = [[D[i][g[i]] for i in range(N)] for g in generator]
ans = 0
for d in D_gen:
tmp = [0] + sorted(d) + [24]
s = 13
for i in range(N+1):
s = min(s, tmp[i+1]-tmp[i])
ans = max(ans, s)
print(ans)
| Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s505771815 | Runtime Error | p03523 | Input is given from Standard Input in the following format:
S | #!/usr/bin/env python3
#CODE FESTIVAL 2017 Final A
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
s = input()
lst = ['A','K','I','H','B','R']
for i in range(len(s)):
if s[i] not in lst:
print('NO')
quit()
a = s.count('A')
t = ''
for i in range(len(s)):
if s[i] != 'A':
t += s[i]
if 'KIHBR' not in t or a > 4 or 'KIH' not in s:
print('NO')
quit()
if t.count('K') != 1 or t.count('I') != 1 or t.count('H') != 1 or t.count('B') != 1 or t.count('R') != 1:
print('NO')
quit()
a = 0
for i in range(len(s)):
if s[i] == 'K':
if s[:i].count('A') > 1:
print('NO')
quit()
if s[i] == 'H':
for j in range(i+1.len(s)):
if s[j] == 'B':
if s[i:j].count('A') > 1:
print('NO')
quit()
if s[i] == 'B':
for j in range(i+1,len(s)):
if s[j] == 'R':
if s[i:j].count('A') > 1:
print('NO')
quit()
if s[i] == 'R':
if s[i:].count('A') > 1:
print('NO')
quit()
print('YES')
| Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s010188020 | Runtime Error | p03523 | Input is given from Standard Input in the following format:
S | S = input().strip()
K = S.find('K')
I = S.find('I')
H = S.find('H')
B = S.find('B')
R = S.find('R')
if S.find('AA'):
print('NO')
exit()
if K in [0, 1] and I >= 0 and H >= 0 and B >= 0 and R >= 0 and \
I-K in [0, 1] and H-I in [0, 1] and B-H in [0, 1] and R-B in [0, 1] and:
print('YES')
else:
print('NO') | Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s173664553 | Wrong Answer | p03523 | Input is given from Standard Input in the following format:
S | # coding: utf-8
import re
import math
from collections import defaultdict
import itertools
from copy import deepcopy
import random
from heapq import heappop, heappush
import time
import os
import queue
import sys
import datetime
from functools import lru_cache
readline = sys.stdin.readline
sys.setrecursionlimit(2000)
# import numpy as np
alphabet = "abcdefghijklmnopqrstuvwxyz"
mod = int(10**9 + 7)
inf = int(10**20)
def yn(b):
if b:
print("yes")
else:
print("no")
def Yn(b):
if b:
print("Yes")
else:
print("No")
def YN(b):
if b:
print("YES")
else:
print("NO")
class union_find:
def __init__(self, n):
self.n = n
self.P = [a for a in range(N)]
self.rank = [0] * n
def find(self, x):
if x != self.P[x]:
self.P[x] = self.find(self.P[x])
return self.P[x]
def same(self, x, y):
return self.find(x) == self.find(y)
def link(self, x, y):
if self.rank[x] < self.rank[y]:
self.P[x] = y
elif self.rank[y] < self.rank[x]:
self.P[y] = x
else:
self.P[x] = y
self.rank[y] += 1
def unite(self, x, y):
self.link(self.find(x), self.find(y))
def size(self):
S = set()
for a in range(self.n):
S.add(self.find(a))
return len(S)
def is_power(a, b): # aはbの累乗数か
now = b
while now < a:
now *= b
if now == a:
return True
else:
return False
def bin_(num, size):
A = [0] * size
for a in range(size):
if (num >> (size - a - 1)) & 1 == 1:
A[a] = 1
else:
A[a] = 0
return A
def get_facs(n, mod_=0):
A = [1] * (n + 1)
for a in range(2, len(A)):
A[a] = A[a - 1] * a
if mod > 0:
A[a] %= mod_
return A
def comb(n, r, mod, fac):
if n - r < 0:
return 0
return (fac[n] * pow(fac[n - r], mod - 2, mod) * pow(fac[r], mod - 2, mod)) % mod
def next_comb(num, size):
x = num & (-num)
y = num + x
z = num & (~y)
z //= x
z = z >> 1
num = y | z
if num >= (1 << size):
return False
else:
return num
def get_primes(n, type="int"):
A = [True] * (n + 1)
A[0] = False
A[1] = False
for a in range(2, n + 1):
if A[a]:
for b in range(a * 2, n + 1, a):
A[b] = False
if type == "bool":
return A
B = []
for a in range(n + 1):
if A[a]:
B.append(a)
return B
def is_prime(num):
if num <= 2:
return False
i = 2
while i * i <= num:
if num % i == 0:
return False
i += 1
return True
def ifelse(a, b, c):
if a:
return b
else:
return c
def join(A, c=" "):
n = len(A)
A = list(map(str, A))
s = ""
for a in range(n):
s += A[a]
if a < n - 1:
s += c
return s
def factorize(n, type_="dict"):
b = 2
list_ = []
while b * b <= n:
while n % b == 0:
n //= b
list_.append(b)
b += 1
if n > 1:
list_.append(n)
if type_ == "dict":
dic = {}
for a in list_:
if a in dic:
dic[a] += 1
else:
dic[a] = 1
return dic
elif type_ == "list":
return list_
else:
return None
def floor_(n, x=1):
return x * (n // x)
def ceil_(n, x=1):
return x * ((n + x - 1) // x)
def hani(x, min_, max_):
ret = x
if x < min_:
ret = min_
if x > max_:
ret = max_
return ret
def seifu(x):
return x // abs(x)
###################################################
def main():
s = "AKIHABARA"
ss = input()
f = True
if len(list(set(s) - set(ss))) != 1 or list(set(s) - set(ss))[0] != "A":
f = False
if set(ss) - set(s):
f = False
YN(f)
main()
| Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s321975475 | Wrong Answer | p03523 | Input is given from Standard Input in the following format:
S | print("YES" if input().replace("A", "P").replace("A", "") == "KIHBR" else "NO")
| Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s018476786 | Runtime Error | p03523 | Input is given from Standard Input in the following format:
S | #!/usr/bin/env python
import re
s = input()
STR = 'AKIHABARA'
if len(s) > len(STR):
print('NO')
exit()
regex = re.compile('A?KIHA?BA?RA?')
mo = regex.search(s)
if mo == None:
print('NO')
else:
print('YES')
~ | Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s422206582 | Runtime Error | p03523 | Input is given from Standard Input in the following format:
S | S = input()
if len(S) >= 10:
print("NO")
else:
if S == "AKIHABARA":
print("YES")
elif S == "KIHABARA":
print("YES")
elif S == "AKIHBARA":
print("YES")
elif S == "AKIHABRA":
print("YES")
elif S == "AKIHABR":
print("YES")
elif S == "KIHBARA":
print("YES")
elif S == "KIHABRA":
print("YES")
elif S == "KIHABAR":
print("YES")
elif S == "AKIHBRA":
print("YES")
elif S == "AKIHABR":
print("YES")
elif S == "KIHBRA":
print("YES")
elif S == "KIHBAR":
print("YES")
elif S == "AKIHBR":
print("YES")
elif S == "KIHBR":
print("YES")
else;
print("NO") | Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s828137339 | Runtime Error | p03523 | Input is given from Standard Input in the following format:
S | s = input()
AKB = KIHBR
tmp = 0
count = 0
for i in range(len(s)):
if s[i] == "A" and count < 4:
count += 1
elif s[i] == AKB[tmp]:
tmp += 1
if count <= 4 and tmp = 5:
print("YES")
else:
print("NO") | Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s781451572 | Wrong Answer | p03523 | Input is given from Standard Input in the following format:
S | print("YES" if input().replace("A", "") == "KIHBR" else "NO")
| Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s156678615 | Accepted | p03523 | Input is given from Standard Input in the following format:
S | a = ["KIH", "B", "R", ""]
ans = []
aaa = []
for i in range(16):
b = ""
for j, k in enumerate(a):
if (i >> j) & 1:
b += "A"
b += k
ans.append(b)
print("YES" if input() in ans else "NO")
| Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s818973652 | Runtime Error | p03523 | Input is given from Standard Input in the following format:
S | A="AKIHABARA"
s=input()
n=len(s)
na=len(A)
i=0
j=0
while i<n j<na-1:
if s[i]==A[j]:
i+=1; j+=1
elif s[i]!=A[j] and A[j]=="A":
j+=1
else:
break
if j==n-1:
print("YES")
else:
print("NO") | Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
If it is possible to change S into `AKIHABARA`, print `YES`; otherwise, print
`NO`.
* * * | s498727540 | Runtime Error | p03523 | Input is given from Standard Input in the following format:
S | s = input()
for i in range(len(s)):
if s[i] == "K" ans i == 0:
s = s[:i] + "A" + s[i:]
elif s[i] == "H" and s[i+1] != "A":
s = s[:i] + "A" + s[i:]
elif s[i] == "B" and s[i+1] != "A":
s = s[:i] + "A" + s[i:]
elif s[i] == "R" and s[i+1] != "A":
s = s[:i] + "A" + s[i:]
if s == "AKIHABARA":
print("YES")
else:
print("NO") | Statement
You are given a string S.
Takahashi can insert the character `A` at any position in this string any
number of times.
Can he change S into `AKIHABARA`? | [{"input": "KIHBR", "output": "YES\n \n\nInsert one `A` at each of the four positions: the beginning, immediately after\n`H`, immediately after `B` and the end.\n\n* * *"}, {"input": "AKIBAHARA", "output": "NO\n \n\nThe correct spell is `AKIHABARA`.\n\n* * *"}, {"input": "AAKIAHBAARA", "output": "NO"}] |
Print the minimum number of elements that needs to be removed so that a will
be a good sequence.
* * * | s553796704 | Runtime Error | p03489 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | # FT Robot_2
s = input()
x, y = map(int, input().split())
L = []
stack = 0
p = [0]
q = [0]
for i in range(len(s)):
if s[i] == "F":
stack = stack + 1
else:
L.append(stack)
stack = 0
if stack != 0:
L.append(stack)
for i in range(len(L)):
if i == 0:
p = [L[i]]
elif i % 2 == 0:
while len(p) < 2 ** (i // 2):
p.append(p[0] + L[i])
p.append(p[0] - L[i])
p.remove(p[0])
elif i % 2 == 1:
while len(q) < 2 ** (i // 2 + 1):
q.append(q[0] + L[i])
q.append(q[0] - L[i])
q.remove(q[0])
if x in p and y in q:
print("Yes")
else:
print("No")
| Statement
You are given a sequence of positive integers of length N, a = (a_1, a_2, ...,
a_N). Your objective is to remove some of the elements in a so that a will be
a **good sequence**.
Here, an sequence b is a **good sequence** when the following condition holds
true:
* For each element x in b, the value x occurs exactly x times in b.
For example, (3, 3, 3), (4, 2, 4, 1, 4, 2, 4) and () (an empty sequence) are
good sequences, while (3, 3, 3, 3) and (2, 4, 1, 4, 2) are not.
Find the minimum number of elements that needs to be removed so that a will be
a good sequence. | [{"input": "4\n 3 3 3 3", "output": "1\n \n\nWe can, for example, remove one occurrence of 3. Then, (3, 3, 3) is a good\nsequence.\n\n* * *"}, {"input": "5\n 2 4 1 4 2", "output": "2\n \n\nWe can, for example, remove two occurrences of 4. Then, (2, 1, 2) is a good\nsequence.\n\n* * *"}, {"input": "6\n 1 2 2 3 3 3", "output": "0\n \n\n* * *"}, {"input": "1\n 1000000000", "output": "1\n \n\nRemove one occurrence of 10^9. Then, () is a good sequence.\n\n* * *"}, {"input": "8\n 2 7 1 8 2 8 1 8", "output": "5"}] |
Print the minimum number of elements that needs to be removed so that a will
be a good sequence.
* * * | s913390265 | Runtime Error | p03489 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | import sys
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache, reduce
from operator import xor
from heapq import heappush, heappop
INF = float("inf")
sys.setrecursionlimit(10**7)
# 4近傍（右, 下, 左, 上）
dy4, dx4 = [0, -1, 0, 1], [1, 0, -1, 0]
def inside(y: int, x: int, H: int, W: int) -> bool:
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
YES = "Yes"
NO = "No"
def check(x, nums):
x = abs(x)
dp = [False] * (x + 1)
dp[0] = True
for y in nums:
tmp = [False] * (x + 1)
for i in range(len(dp)):
if i + y < len(tmp):
tmp[i + y] |= dp[i]
if i - y >= 0:
tmp[i - y] |= dp[i]
dp = tmp
return dp[x]
def solve(s, x, y):
type_num = [(k, len(list(g))) for k, g in groupby(s)]
if s[0] == "F":
x -= type_num[0][1]
type_num.pop(0)
h, v = [], []
now = 0
for t, n in type_num:
if t == "F":
if now == 0:
h.append(n)
else:
v.append(n)
else:
if n % 2 != 0:
now = (now + 1) % 2
return YES if check(x, h) and check(y, v) else NO
def main():
s = input()
x, y = map(int, input().split())
print(solve(s, x, y))
if __name__ == "__main__":
main()
| Statement
You are given a sequence of positive integers of length N, a = (a_1, a_2, ...,
a_N). Your objective is to remove some of the elements in a so that a will be
a **good sequence**.
Here, an sequence b is a **good sequence** when the following condition holds
true:
* For each element x in b, the value x occurs exactly x times in b.
For example, (3, 3, 3), (4, 2, 4, 1, 4, 2, 4) and () (an empty sequence) are
good sequences, while (3, 3, 3, 3) and (2, 4, 1, 4, 2) are not.
Find the minimum number of elements that needs to be removed so that a will be
a good sequence. | [{"input": "4\n 3 3 3 3", "output": "1\n \n\nWe can, for example, remove one occurrence of 3. Then, (3, 3, 3) is a good\nsequence.\n\n* * *"}, {"input": "5\n 2 4 1 4 2", "output": "2\n \n\nWe can, for example, remove two occurrences of 4. Then, (2, 1, 2) is a good\nsequence.\n\n* * *"}, {"input": "6\n 1 2 2 3 3 3", "output": "0\n \n\n* * *"}, {"input": "1\n 1000000000", "output": "1\n \n\nRemove one occurrence of 10^9. Then, () is a good sequence.\n\n* * *"}, {"input": "8\n 2 7 1 8 2 8 1 8", "output": "5"}] |
Print the minimum number of elements that needs to be removed so that a will
be a good sequence.
* * * | s842365615 | Runtime Error | p03489 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | # -*- coding: utf-8 -*-
from collections import Counter
from itertools import product
def inpl():
return tuple(map(int, input().split()))
S = input()
x, y = inpl()
M = []
d = 0
for s in S:
if s == "F":
d += 1
else:
M.append(d)
d = 0
M.append(d)
Cx = Counter(M[2::2])
Cy = Counter(M[1::2])
Lx = []
Ly = []
for k, v in Cx.items():
if k == 0:
pass
else:
Lx.append(list(range(-k * v, k * v + 1, 2 * k)))
for k, v in Cy.items():
if k == 0:
pass
else:
Ly.append(list(range(-k * v, k * v + 1, 2 * k)))
def bfss(Ls, t, f):
N = set([f])
for L in Ls:
nN = set(([n + l for n, l in product(N, L)]))
N = nN
if t in N:
return True
else:
return False
if bfss(Lx, x, M[0]) and bfss(Ly, y, 0):
print("Yes")
else:
print("No")
| Statement
You are given a sequence of positive integers of length N, a = (a_1, a_2, ...,
a_N). Your objective is to remove some of the elements in a so that a will be
a **good sequence**.
Here, an sequence b is a **good sequence** when the following condition holds
true:
* For each element x in b, the value x occurs exactly x times in b.
For example, (3, 3, 3), (4, 2, 4, 1, 4, 2, 4) and () (an empty sequence) are
good sequences, while (3, 3, 3, 3) and (2, 4, 1, 4, 2) are not.
Find the minimum number of elements that needs to be removed so that a will be
a good sequence. | [{"input": "4\n 3 3 3 3", "output": "1\n \n\nWe can, for example, remove one occurrence of 3. Then, (3, 3, 3) is a good\nsequence.\n\n* * *"}, {"input": "5\n 2 4 1 4 2", "output": "2\n \n\nWe can, for example, remove two occurrences of 4. Then, (2, 1, 2) is a good\nsequence.\n\n* * *"}, {"input": "6\n 1 2 2 3 3 3", "output": "0\n \n\n* * *"}, {"input": "1\n 1000000000", "output": "1\n \n\nRemove one occurrence of 10^9. Then, () is a good sequence.\n\n* * *"}, {"input": "8\n 2 7 1 8 2 8 1 8", "output": "5"}] |
Print the minimum number of elements that needs to be removed so that a will
be a good sequence.
* * * | s401545062 | Runtime Error | p03489 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | def f(m, l):
tmpm = set()
for x in m:
tmpm.add(x + l)
tmpm.add(x - l)
return tmpm
s = input() + "T"
x, y = map(int, input().split())
while s and s[0] == "F":
x -= 1
s = s[1:]
ss = [{0}, {0}]
mode = 0
l = 0
for i in range(len(s)):
if s[i] == "F":
l += 1
else:
ss[mode] = f(ss[mode], l)
mode ^= 1
l = 0
print("Yes" if x in ss[0] and y in ss[1] else "No")
| Statement
You are given a sequence of positive integers of length N, a = (a_1, a_2, ...,
a_N). Your objective is to remove some of the elements in a so that a will be
a **good sequence**.
Here, an sequence b is a **good sequence** when the following condition holds
true:
* For each element x in b, the value x occurs exactly x times in b.
For example, (3, 3, 3), (4, 2, 4, 1, 4, 2, 4) and () (an empty sequence) are
good sequences, while (3, 3, 3, 3) and (2, 4, 1, 4, 2) are not.
Find the minimum number of elements that needs to be removed so that a will be
a good sequence. | [{"input": "4\n 3 3 3 3", "output": "1\n \n\nWe can, for example, remove one occurrence of 3. Then, (3, 3, 3) is a good\nsequence.\n\n* * *"}, {"input": "5\n 2 4 1 4 2", "output": "2\n \n\nWe can, for example, remove two occurrences of 4. Then, (2, 1, 2) is a good\nsequence.\n\n* * *"}, {"input": "6\n 1 2 2 3 3 3", "output": "0\n \n\n* * *"}, {"input": "1\n 1000000000", "output": "1\n \n\nRemove one occurrence of 10^9. Then, () is a good sequence.\n\n* * *"}, {"input": "8\n 2 7 1 8 2 8 1 8", "output": "5"}] |
Print the minimum number of elements that needs to be removed so that a will
be a good sequence.
* * * | s869023833 | Runtime Error | p03489 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | def i1():
return int(input())
def i2():
return [int(i) for i in input().split()]
s = input()
[x, yy] = i2()
t = []
y = []
k = 0
for i in range(len(s)):
if s[i] == "T":
if len(t) == len(y):
y.append(k)
else:
t.append(k)
k = 0
else:
k += 1
if s[-1] == "F":
if len(t) == len(y):
y.append(k)
else:
t.append(k)
dx = [0 for i in range(8001)]
dy = [0 for i in range(8001)]
dx[0] = 1
dy[0] = 1
t.sort()
y.sort()
t = t[::-1]
y = y[::-1]
for i in t:
for j in range(8001):
if j + i <= 8000:
dy[j + i] = dy[j]
if j - i >= 0:
dy[j - i] = dy[j]
for i in y:
for j in range(8001):
if j + i <= 8000:
dx[j + i] = dx[j]
if j - i >= 0:
dx[j - i] = dx[j]
if dy[abs(yy)] * dx[abs(x)]:
print("Yes")
else:
print("No")
| Statement
You are given a sequence of positive integers of length N, a = (a_1, a_2, ...,
a_N). Your objective is to remove some of the elements in a so that a will be
a **good sequence**.
Here, an sequence b is a **good sequence** when the following condition holds
true:
* For each element x in b, the value x occurs exactly x times in b.
For example, (3, 3, 3), (4, 2, 4, 1, 4, 2, 4) and () (an empty sequence) are
good sequences, while (3, 3, 3, 3) and (2, 4, 1, 4, 2) are not.
Find the minimum number of elements that needs to be removed so that a will be
a good sequence. | [{"input": "4\n 3 3 3 3", "output": "1\n \n\nWe can, for example, remove one occurrence of 3. Then, (3, 3, 3) is a good\nsequence.\n\n* * *"}, {"input": "5\n 2 4 1 4 2", "output": "2\n \n\nWe can, for example, remove two occurrences of 4. Then, (2, 1, 2) is a good\nsequence.\n\n* * *"}, {"input": "6\n 1 2 2 3 3 3", "output": "0\n \n\n* * *"}, {"input": "1\n 1000000000", "output": "1\n \n\nRemove one occurrence of 10^9. Then, () is a good sequence.\n\n* * *"}, {"input": "8\n 2 7 1 8 2 8 1 8", "output": "5"}] |
Print the minimum number of elements that needs to be removed so that a will
be a good sequence.
* * * | s528230035 | Runtime Error | p03489 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | s = str(input())
x, y = map(int, input().split())
n = 8000
fs = list(map(len, s.split("T")))
x -= fs[0]
dx = []
dy = []
for i in range(1, len(fs)):
if fs[i] == 0:
continue
if i % 2 == 0:
dx.append(fs[i])
else:
dy.append(fs[i])
dpx = [[False for _ in range(4 * n + 1)] for _ in range(2)]
dpy = [[False for _ in range(4 * n + 1)] for _ in range(2)]
dpx[0][2 * n] = True
dpy[0][2 * n] = True
for i in range(len(dx)):
for j in range(4 * n + 1):
if dpx[i % 2][j]:
if 0 <= j - dx[i]:
dpx[(i + 1) % 2][j - dx[i]] = True
if j + dx[i] <= 4 * n:
dpx[(i + 1) % 2][j + dx[i]] = True
for i in range(len(dy)):
for j in range(4 * n + 1):
if dpy[i % 2][j]:
if 0 <= j - dy[i]:
dpy[(i + 1) % 2][j - dy[i]] = True
if j + dy[i] <= 4 * n:
dpy[(i + 1) % 2][j + dy[i]] = True
ix = 2 * n + x
iy = 2 * n + y
if (
0 <= ix <= 4 * n
and dpx[len(dx) % 2][ix]
and 0 <= iy <= 4 * n
and dpy[len(dy) % 2][iy]
):
print("Yes")
else:
print("No")
| Statement
You are given a sequence of positive integers of length N, a = (a_1, a_2, ...,
a_N). Your objective is to remove some of the elements in a so that a will be
a **good sequence**.
Here, an sequence b is a **good sequence** when the following condition holds
true:
* For each element x in b, the value x occurs exactly x times in b.
For example, (3, 3, 3), (4, 2, 4, 1, 4, 2, 4) and () (an empty sequence) are
good sequences, while (3, 3, 3, 3) and (2, 4, 1, 4, 2) are not.
Find the minimum number of elements that needs to be removed so that a will be
a good sequence. | [{"input": "4\n 3 3 3 3", "output": "1\n \n\nWe can, for example, remove one occurrence of 3. Then, (3, 3, 3) is a good\nsequence.\n\n* * *"}, {"input": "5\n 2 4 1 4 2", "output": "2\n \n\nWe can, for example, remove two occurrences of 4. Then, (2, 1, 2) is a good\nsequence.\n\n* * *"}, {"input": "6\n 1 2 2 3 3 3", "output": "0\n \n\n* * *"}, {"input": "1\n 1000000000", "output": "1\n \n\nRemove one occurrence of 10^9. Then, () is a good sequence.\n\n* * *"}, {"input": "8\n 2 7 1 8 2 8 1 8", "output": "5"}] |
Print the minimum number of elements that needs to be removed so that a will
be a good sequence.
* * * | s329507979 | Runtime Error | p03489 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | n = len(input())
mp, res = {}, 0
for el in list(map(int, input().split())):
mp[el] = mp.get(el, 0) + 1
for key, val in mp:
if key > val:
res += val
elif key < val:
res += val - key
print(res)
| Statement
You are given a sequence of positive integers of length N, a = (a_1, a_2, ...,
a_N). Your objective is to remove some of the elements in a so that a will be
a **good sequence**.
Here, an sequence b is a **good sequence** when the following condition holds
true:
* For each element x in b, the value x occurs exactly x times in b.
For example, (3, 3, 3), (4, 2, 4, 1, 4, 2, 4) and () (an empty sequence) are
good sequences, while (3, 3, 3, 3) and (2, 4, 1, 4, 2) are not.
Find the minimum number of elements that needs to be removed so that a will be
a good sequence. | [{"input": "4\n 3 3 3 3", "output": "1\n \n\nWe can, for example, remove one occurrence of 3. Then, (3, 3, 3) is a good\nsequence.\n\n* * *"}, {"input": "5\n 2 4 1 4 2", "output": "2\n \n\nWe can, for example, remove two occurrences of 4. Then, (2, 1, 2) is a good\nsequence.\n\n* * *"}, {"input": "6\n 1 2 2 3 3 3", "output": "0\n \n\n* * *"}, {"input": "1\n 1000000000", "output": "1\n \n\nRemove one occurrence of 10^9. Then, () is a good sequence.\n\n* * *"}, {"input": "8\n 2 7 1 8 2 8 1 8", "output": "5"}] |
Print the minimum number of elements that needs to be removed so that a will
be a good sequence.
* * * | s242920476 | Accepted | p03489 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | from collections import defaultdict
N = int(input())
As = map(int, input().split())
counts = defaultdict(int)
for a in As:
counts[a] += 1
total = 0
for n, c in counts.items():
if n < c:
total += c - n
elif n > c:
total += c
print(total)
| Statement
You are given a sequence of positive integers of length N, a = (a_1, a_2, ...,
a_N). Your objective is to remove some of the elements in a so that a will be
a **good sequence**.
Here, an sequence b is a **good sequence** when the following condition holds
true:
* For each element x in b, the value x occurs exactly x times in b.
For example, (3, 3, 3), (4, 2, 4, 1, 4, 2, 4) and () (an empty sequence) are
good sequences, while (3, 3, 3, 3) and (2, 4, 1, 4, 2) are not.
Find the minimum number of elements that needs to be removed so that a will be
a good sequence. | [{"input": "4\n 3 3 3 3", "output": "1\n \n\nWe can, for example, remove one occurrence of 3. Then, (3, 3, 3) is a good\nsequence.\n\n* * *"}, {"input": "5\n 2 4 1 4 2", "output": "2\n \n\nWe can, for example, remove two occurrences of 4. Then, (2, 1, 2) is a good\nsequence.\n\n* * *"}, {"input": "6\n 1 2 2 3 3 3", "output": "0\n \n\n* * *"}, {"input": "1\n 1000000000", "output": "1\n \n\nRemove one occurrence of 10^9. Then, () is a good sequence.\n\n* * *"}, {"input": "8\n 2 7 1 8 2 8 1 8", "output": "5"}] |
Print the minimum number of elements that needs to be removed so that a will
be a good sequence.
* * * | s342995441 | Accepted | p03489 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | n = int(input())
a = list(map(int, input().split()))
a.sort()
a.append(0)
answer = 0
i = 0
counter = 1
while i <= n - 1:
if a[i] == a[i + 1]:
counter += 1
i += 1
else:
if counter != a[i]:
if counter > a[i]:
answer += counter - a[i]
i += 1
counter = 1
else:
answer += counter
i += 1
counter = 1
else:
i += 1
counter = 1
print(answer)
| Statement
You are given a sequence of positive integers of length N, a = (a_1, a_2, ...,
a_N). Your objective is to remove some of the elements in a so that a will be
a **good sequence**.
Here, an sequence b is a **good sequence** when the following condition holds
true:
* For each element x in b, the value x occurs exactly x times in b.
For example, (3, 3, 3), (4, 2, 4, 1, 4, 2, 4) and () (an empty sequence) are
good sequences, while (3, 3, 3, 3) and (2, 4, 1, 4, 2) are not.
Find the minimum number of elements that needs to be removed so that a will be
a good sequence. | [{"input": "4\n 3 3 3 3", "output": "1\n \n\nWe can, for example, remove one occurrence of 3. Then, (3, 3, 3) is a good\nsequence.\n\n* * *"}, {"input": "5\n 2 4 1 4 2", "output": "2\n \n\nWe can, for example, remove two occurrences of 4. Then, (2, 1, 2) is a good\nsequence.\n\n* * *"}, {"input": "6\n 1 2 2 3 3 3", "output": "0\n \n\n* * *"}, {"input": "1\n 1000000000", "output": "1\n \n\nRemove one occurrence of 10^9. Then, () is a good sequence.\n\n* * *"}, {"input": "8\n 2 7 1 8 2 8 1 8", "output": "5"}] |
Print the minimum possible total cost incurred.
* * * | s134359508 | Wrong Answer | p03173 | Input is given from Standard Input in the following format:
N
a_1 a_2 \ldots a_N | #!/usr/bin/env python3
# from collections import defaultdict
# from heapq import heappush, heappop
from itertools import accumulate
from functools import lru_cache
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.buffer.readline
INF = 10**9 + 1 # sys.maxsize # float("inf")
def debug(*x):
print(*x, file=sys.stderr)
def solve(N, XS):
accum = list(accumulate(XS)) + [0]
@lru_cache(maxsize=None)
def sub(L, R):
# debug(": L,R", L, R)
if L == R:
return 0
ret = INF
for x in range(L, R):
v = sub(L, x) + sub(x + 1, R)
if v < ret:
ret = v
# debug("loop: ", XS[L:x+1], XS[x+1: R+1], v)
# debug(": ret, ", ret, accum[R] - accum[L - 1])
return ret + accum[R] - accum[L - 1]
return sub(0, N - 1)
def main():
# parse input
N = int(input())
XS = list(map(int, input().split()))
print(solve(N, XS))
# tests
T0 = """
2
10 20
"""
def test_T0():
"""
>>> as_input(T0)
>>> main()
30
"""
T01 = """
3
10 20 30
"""
def test_T01():
"""
>>> as_input(T01)
>>> main()
90
"""
T1 = """
4
10 20 30 40
"""
def test_T1():
"""
>>> as_input(T1)
>>> main()
190
"""
T2 = """
5
10 10 10 10 10
"""
def test_T2():
"""
>>> as_input(T2)
>>> main()
120
"""
# add tests above
def _test():
import doctest
doctest.testmod()
def as_input(s):
"use in test, use given string as input file"
import io
global read, input
f = io.StringIO(s.strip())
def input():
return bytes(f.readline(), "ascii")
def read():
return bytes(f.read(), "ascii")
USE_NUMBA = False
if (USE_NUMBA and sys.argv[-1] == "ONLINE_JUDGE") or sys.argv[-1] == "-c":
print("compiling")
from numba.pycc import CC
cc = CC("my_module")
cc.export("solve", solve.__doc__.strip().split()[0])(solve)
cc.compile()
exit()
else:
input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
if (USE_NUMBA and sys.argv[-1] != "-p") or sys.argv[-1] == "--numba":
# -p: pure python mode
# if not -p, import compiled module
from my_module import solve # pylint: disable=all
elif sys.argv[-1] == "-t":
print("testing")
_test()
sys.exit()
elif sys.argv[-1] != "-p" and len(sys.argv) == 2:
# input given as file
input_as_file = open(sys.argv[1])
input = input_as_file.buffer.readline
read = input_as_file.buffer.read
main()
| Statement
There are N slimes lining up in a row. Initially, the i-th slime from the left
has a size of a_i.
Taro is trying to combine all the slimes into a larger slime. He will perform
the following operation repeatedly until there is only one slime:
* Choose two adjacent slimes, and combine them into a new slime. The new slime has a size of x + y, where x and y are the sizes of the slimes before combining them. Here, a cost of x + y is incurred. The positional relationship of the slimes does not change while combining slimes.
Find the minimum possible total cost incurred. | [{"input": "4\n 10 20 30 40", "output": "190\n \n\nTaro should do as follows (slimes being combined are shown in bold):\n\n * (**10** , **20** , 30, 40) \u2192 (**30** , 30, 40)\n * (**30** , **30** , 40) \u2192 (**60** , 40)\n * (**60** , **40**) \u2192 (**100**)\n\n* * *"}, {"input": "5\n 10 10 10 10 10", "output": "120\n \n\nTaro should do, for example, as follows:\n\n * (**10** , **10** , 10, 10, 10) \u2192 (**20** , 10, 10, 10)\n * (20, **10** , **10** , 10) \u2192 (20, **20** , 10)\n * (20, **20** , **10**) \u2192 (20, **30**)\n * (**20** , **30**) \u2192 (**50**)\n\n* * *"}, {"input": "3\n 1000000000 1000000000 1000000000", "output": "5000000000\n \n\nThe answer may not fit into a 32-bit integer type.\n\n* * *"}, {"input": "6\n 7 6 8 6 1 1", "output": "68\n \n\nTaro should do, for example, as follows:\n\n * (7, 6, 8, 6, **1** , **1**) \u2192 (7, 6, 8, 6, **2**)\n * (7, 6, 8, **6** , **2**) \u2192 (7, 6, 8, **8**)\n * (**7** , **6** , 8, 8) \u2192 (**13** , 8, 8)\n * (13, **8** , **8**) \u2192 (13, **16**)\n * (**13** , **16**) \u2192 (**29**)"}] |
Print the minimum possible total cost incurred.
* * * | s684135606 | Accepted | p03173 | Input is given from Standard Input in the following format:
N
a_1 a_2 \ldots a_N | # dp[i][j] - minimum cost from i to j
INF = 1e18 + 5
n = int(input())
arr = [int(x) for x in input().split()]
dp = [[0 for _ in range(n)] for _ in range(n)]
def range_sum(arr, L, R):
s = 0
for i in range(L, R + 1):
s += arr[i]
return s
for L in reversed(range(n)):
for R in range(L, n):
if L == R:
dp[L][R] = 0
else:
dp[L][R] = INF
s = range_sum(arr, L, R)
# try every possible middle
for mid in range(L, R):
dp[L][R] = min(dp[L][R], dp[L][mid] + dp[mid + 1][R] + s)
print(dp[0][n - 1])
"""
int main() {
const int INF = 1e9+7;
int n;
scanf("%d", &n);
vector<int> arr(n);
vector<vector<ll>> dp(n, vector<ll>(n, -1));
vector<vector<int>> mids(n, vector<int>(n));
vector<ll> pref_sums(n+1);
ll pref_sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
dp[i][i] = 0;
}
for (int i = 0; i <= n; i++) {
pref_sum += arr[i];
pref_sums[i] = pref_sum;
}
for (int length = 1; length < n; length++) {
for (int left = 0; left+length < n; left++) {
int right = left + length;
//cout << left << " " << right << endl;
for (int mid = left; mid < right; mid++) {
ll left_cost = dp[left][mid];
ll right_cost = dp[mid+1][right];
ll range_sum = pref_sums[right] - (left-1 < 0 ? 0 : pref_sums[left-1]);
ll my_cost = left_cost + right_cost + range_sum;
//cout << total << endl;
/*
if (total < dp[left][right]) {
// update chosen mid & min value
dp[left][right] = my_cost;//total;
//mids[left][right] = mid;
}
*/
if (dp[left][right] == -1) {
dp[left][right] = my_cost;
}
else {
dp[left][right] = min(dp[left][right], my_cost);
}
}
}
}
/*
vector<pair<int, int>> v; // (start, end)
v.push_back({0, n-1});
ll ans = 0; //-dp[0][n-1]; // the last one
while (!v.empty()) {
pair<int, int> cur = v.back();
v.pop_back();
if (cur.second - cur.first + 1 >= 2) { // interval at least two
ans += dp[cur.first][cur.second];
int mid = mids[cur.first][cur.second];
cout << "L: " << cur.first << " R: " << cur.second << " Total: " << dp[cur.first][cur.second] << " mid: " << mid << endl;
v.push_back({cur.first, mid});
v.push_back({mid+1, cur.second});
}
}
*/
/*
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int mid = i; mid <= j; mid++) {
ll cur = dp[i][mid];
if (mid+1 <= j) {
cur += dp[mid+1][j];
}
dp[i][j] = min(dp[i][j], cur);
}
}
}
*/
//printf("%lld", ans);
printf("%lld", dp[0][n-1]);
return 0;
}
"""
| Statement
There are N slimes lining up in a row. Initially, the i-th slime from the left
has a size of a_i.
Taro is trying to combine all the slimes into a larger slime. He will perform
the following operation repeatedly until there is only one slime:
* Choose two adjacent slimes, and combine them into a new slime. The new slime has a size of x + y, where x and y are the sizes of the slimes before combining them. Here, a cost of x + y is incurred. The positional relationship of the slimes does not change while combining slimes.
Find the minimum possible total cost incurred. | [{"input": "4\n 10 20 30 40", "output": "190\n \n\nTaro should do as follows (slimes being combined are shown in bold):\n\n * (**10** , **20** , 30, 40) \u2192 (**30** , 30, 40)\n * (**30** , **30** , 40) \u2192 (**60** , 40)\n * (**60** , **40**) \u2192 (**100**)\n\n* * *"}, {"input": "5\n 10 10 10 10 10", "output": "120\n \n\nTaro should do, for example, as follows:\n\n * (**10** , **10** , 10, 10, 10) \u2192 (**20** , 10, 10, 10)\n * (20, **10** , **10** , 10) \u2192 (20, **20** , 10)\n * (20, **20** , **10**) \u2192 (20, **30**)\n * (**20** , **30**) \u2192 (**50**)\n\n* * *"}, {"input": "3\n 1000000000 1000000000 1000000000", "output": "5000000000\n \n\nThe answer may not fit into a 32-bit integer type.\n\n* * *"}, {"input": "6\n 7 6 8 6 1 1", "output": "68\n \n\nTaro should do, for example, as follows:\n\n * (7, 6, 8, 6, **1** , **1**) \u2192 (7, 6, 8, 6, **2**)\n * (7, 6, 8, **6** , **2**) \u2192 (7, 6, 8, **8**)\n * (**7** , **6** , 8, 8) \u2192 (**13** , 8, 8)\n * (13, **8** , **8**) \u2192 (13, **16**)\n * (**13** , **16**) \u2192 (**29**)"}] |
Print the minimum possible total cost incurred.
* * * | s835221074 | Wrong Answer | p03173 | Input is given from Standard Input in the following format:
N
a_1 a_2 \ldots a_N | import array as ar
def getInt():
return int(input())
def getIntList():
return [int(x) for x in input().split()]
def zeros(n):
return [0] * n
def zeros2(n, m):
return [zeros(m) for i in range(n)] # obsoleted zeros((n, m))で代替
def getIntLines(n):
return [int(input()) for i in range(n)]
def getIntMat(n, m): # n行に渡って、1行にm個の整数
mat = zeros((n, m))
for i in range(n):
mat[i] = getIntList()
return mat
class Debug:
def __init__(self):
self.debug = True
def off(self):
self.debug = False
def dmp(self, x, cmt=""):
if self.debug:
if cmt != "":
print(cmt, ": ", end="")
print(x)
return x
def prob_N(): # Grid 1 AC 10 TLE 6
d = Debug()
d.off()
N = getInt()
A = getIntList()
d.dmp((N), "N")
d.dmp((A), "A")
dp = ar.array("q", [0] * (N - 1))
for i in range(N - 1):
dp[i] = A[i] + A[i + 1]
d.dmp(dp, "dp")
cost = 0
for i in range(N - 2):
mn = min(dp)
cost += mn
idx = dp.index(mn)
# d.dmp((idx,A,dp),'idx,A,dp')
if idx > 0:
dp[idx - 1] += A[idx + 1]
A[idx + 1] += A[idx]
if idx < len(dp) - 1:
dp[idx + 1] += A[idx]
else:
dp[idx] += A[idx]
dp.pop(idx)
A.pop(idx)
# d.dmp((mn,idx),'mn,idx')
# d.dmp((A,dp,cost), 'A,dp,cost')
return cost + dp[0]
ans = prob_N()
if ans is None:
pass
elif type(ans) == tuple and ans[0] == 1: # 1,ans
for elm in ans[1]:
print(elm)
else:
print(ans)
| Statement
There are N slimes lining up in a row. Initially, the i-th slime from the left
has a size of a_i.
Taro is trying to combine all the slimes into a larger slime. He will perform
the following operation repeatedly until there is only one slime:
* Choose two adjacent slimes, and combine them into a new slime. The new slime has a size of x + y, where x and y are the sizes of the slimes before combining them. Here, a cost of x + y is incurred. The positional relationship of the slimes does not change while combining slimes.
Find the minimum possible total cost incurred. | [{"input": "4\n 10 20 30 40", "output": "190\n \n\nTaro should do as follows (slimes being combined are shown in bold):\n\n * (**10** , **20** , 30, 40) \u2192 (**30** , 30, 40)\n * (**30** , **30** , 40) \u2192 (**60** , 40)\n * (**60** , **40**) \u2192 (**100**)\n\n* * *"}, {"input": "5\n 10 10 10 10 10", "output": "120\n \n\nTaro should do, for example, as follows:\n\n * (**10** , **10** , 10, 10, 10) \u2192 (**20** , 10, 10, 10)\n * (20, **10** , **10** , 10) \u2192 (20, **20** , 10)\n * (20, **20** , **10**) \u2192 (20, **30**)\n * (**20** , **30**) \u2192 (**50**)\n\n* * *"}, {"input": "3\n 1000000000 1000000000 1000000000", "output": "5000000000\n \n\nThe answer may not fit into a 32-bit integer type.\n\n* * *"}, {"input": "6\n 7 6 8 6 1 1", "output": "68\n \n\nTaro should do, for example, as follows:\n\n * (7, 6, 8, 6, **1** , **1**) \u2192 (7, 6, 8, 6, **2**)\n * (7, 6, 8, **6** , **2**) \u2192 (7, 6, 8, **8**)\n * (**7** , **6** , 8, 8) \u2192 (**13** , 8, 8)\n * (13, **8** , **8**) \u2192 (13, **16**)\n * (**13** , **16**) \u2192 (**29**)"}] |
Print the minimum possible total cost incurred.
* * * | s839589257 | Runtime Error | p03173 | Input is given from Standard Input in the following format:
N
a_1 a_2 \ldots a_N | import fileinput
def solve_slimes(slimes):
slime_union_table = [0] * len(slimes) * len(slimes)
slime_cost_table = [0] * len(slimes) * len(slimes)
for i in range(len(slimes)):
slime_union_table[i] = slimes[i]
for gap in range(1, len(slimes)):
for li in range(len(slimes) - gap):
split_size = slime_union_table[li] + slime_union_table[li + 1 + (gap - 1) * len(slimes)]
slime_union_table[li + gap * len(slimes)] = split_size
for split in range(0, gap):
split_cost = slime_cost_table[li + split * len(slimes)] + slime_cost_table[li + split + 1 + (gap - split - 1) * len(slimes)] + split_size
if slime_cost_table[li + gap * len(slimes)] == 0:
slime_cost_table[li + gap * len(slimes)] = split_cost
else:
slime_cost_table[li + gap * len(slimes)] = min(
split_cost,
slime_cost_table[li + gap * len(slimes)]
)
return slime_cost_table[len(slimes) * (len(slimes) - 1)]
inp = fileinput.FileInput()
inp.readline()
slimes = [int(v) for v in inp.readline().split()]
print(solve_slimes(slimes) | Statement
There are N slimes lining up in a row. Initially, the i-th slime from the left
has a size of a_i.
Taro is trying to combine all the slimes into a larger slime. He will perform
the following operation repeatedly until there is only one slime:
* Choose two adjacent slimes, and combine them into a new slime. The new slime has a size of x + y, where x and y are the sizes of the slimes before combining them. Here, a cost of x + y is incurred. The positional relationship of the slimes does not change while combining slimes.
Find the minimum possible total cost incurred. | [{"input": "4\n 10 20 30 40", "output": "190\n \n\nTaro should do as follows (slimes being combined are shown in bold):\n\n * (**10** , **20** , 30, 40) \u2192 (**30** , 30, 40)\n * (**30** , **30** , 40) \u2192 (**60** , 40)\n * (**60** , **40**) \u2192 (**100**)\n\n* * *"}, {"input": "5\n 10 10 10 10 10", "output": "120\n \n\nTaro should do, for example, as follows:\n\n * (**10** , **10** , 10, 10, 10) \u2192 (**20** , 10, 10, 10)\n * (20, **10** , **10** , 10) \u2192 (20, **20** , 10)\n * (20, **20** , **10**) \u2192 (20, **30**)\n * (**20** , **30**) \u2192 (**50**)\n\n* * *"}, {"input": "3\n 1000000000 1000000000 1000000000", "output": "5000000000\n \n\nThe answer may not fit into a 32-bit integer type.\n\n* * *"}, {"input": "6\n 7 6 8 6 1 1", "output": "68\n \n\nTaro should do, for example, as follows:\n\n * (7, 6, 8, 6, **1** , **1**) \u2192 (7, 6, 8, 6, **2**)\n * (7, 6, 8, **6** , **2**) \u2192 (7, 6, 8, **8**)\n * (**7** , **6** , 8, 8) \u2192 (**13** , 8, 8)\n * (13, **8** , **8**) \u2192 (13, **16**)\n * (**13** , **16**) \u2192 (**29**)"}] |
Print the minimum possible total cost incurred.
* * * | s892962755 | Runtime Error | p03173 | Input is given from Standard Input in the following format:
N
a_1 a_2 \ldots a_N | from itertools import accumulate
n = int(input())
A = list(map(int, input().split()))
infi = 10 ** 20
SA = list(accumulate([0] + A))
dp = [[infi] * (n + 1) for _ in range(n + 1)]
# dp[i]左からi個決めた時の最小値とする。
if n >= 3:
for i in range(n):
dp[i][i] = 0
dp[i][i + 1] = 0
if i <= n - 2:
dp[i][i + 2] = A[i] + A[i + 1]
for d in range(n + 1):
for i in range(n):
j = i + d
if j > n:
continue
if d >= 2:
for m in range(i + 1, j + 1):
dp[i][j] = min(dp[i][j], dp[i][m] + dp[m][j] + SA[j] - SA[i])
print(dp[0][n])
else:
| Statement
There are N slimes lining up in a row. Initially, the i-th slime from the left
has a size of a_i.
Taro is trying to combine all the slimes into a larger slime. He will perform
the following operation repeatedly until there is only one slime:
* Choose two adjacent slimes, and combine them into a new slime. The new slime has a size of x + y, where x and y are the sizes of the slimes before combining them. Here, a cost of x + y is incurred. The positional relationship of the slimes does not change while combining slimes.
Find the minimum possible total cost incurred. | [{"input": "4\n 10 20 30 40", "output": "190\n \n\nTaro should do as follows (slimes being combined are shown in bold):\n\n * (**10** , **20** , 30, 40) \u2192 (**30** , 30, 40)\n * (**30** , **30** , 40) \u2192 (**60** , 40)\n * (**60** , **40**) \u2192 (**100**)\n\n* * *"}, {"input": "5\n 10 10 10 10 10", "output": "120\n \n\nTaro should do, for example, as follows:\n\n * (**10** , **10** , 10, 10, 10) \u2192 (**20** , 10, 10, 10)\n * (20, **10** , **10** , 10) \u2192 (20, **20** , 10)\n * (20, **20** , **10**) \u2192 (20, **30**)\n * (**20** , **30**) \u2192 (**50**)\n\n* * *"}, {"input": "3\n 1000000000 1000000000 1000000000", "output": "5000000000\n \n\nThe answer may not fit into a 32-bit integer type.\n\n* * *"}, {"input": "6\n 7 6 8 6 1 1", "output": "68\n \n\nTaro should do, for example, as follows:\n\n * (7, 6, 8, 6, **1** , **1**) \u2192 (7, 6, 8, 6, **2**)\n * (7, 6, 8, **6** , **2**) \u2192 (7, 6, 8, **8**)\n * (**7** , **6** , 8, 8) \u2192 (**13** , 8, 8)\n * (13, **8** , **8**) \u2192 (13, **16**)\n * (**13** , **16**) \u2192 (**29**)"}] |
README.md exists but content is empty.
Use the Edit dataset card button to edit it.
- Downloads last month
- 39