output_description stringlengths 15 956 | submission_id stringlengths 10 10 | status stringclasses 3 values | problem_id stringlengths 6 6 | input_description stringlengths 9 2.55k | attempt stringlengths 1 13.7k | problem_description stringlengths 7 5.24k | samples stringlengths 2 2.72k |
|---|---|---|---|---|---|---|---|
Print the maximum value of f.
* * * | s011135954 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | print(-int(input())+sum(int(i) for i in input().split()))) | Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s225515924 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | print(sum(i - 1 for i in map(int, open(0).read().split())[1:]))
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s008035295 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | 7
994 518 941 851 647 2 581 | Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s639515328 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | n = input()
a = list(map(int, input().split()))
fmax = 0
for i in range(sum(a)):
f = 0
for j in range(n):
f += i % a[j]
if f > fmax:
fmax = f
print(fmax) | Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s069104830 | Accepted | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | import sys
sys.setrecursionlimit(1000000)
# def input():
# return sys.stdin.readline()[:-1]
"""
n=int(input())
for i in range(n):
a[i]=int(input())
a[i],b[i]=map(int,input().split())
a=[int(x) for x in input().split()]
n,m=map(int,input.split())
"""
test_data1 = """\
A??C
"""
test_data2 = """\
ACACAC
"""
test_data3 = """\
7
994 518 941 851 647 2 581
"""
test_data4 = """\
?AC?AC
"""
td_num = 3
def GetTestData(index):
if index == 1:
return test_data1
if index == 2:
return test_data2
if index == 3:
return test_data3
if index == 4:
return test_data4
if False:
with open("../test.txt", mode="w") as f:
f.write(GetTestData(td_num))
with open("../test.txt") as f:
# Start Input code ---------------------------------------
n = int(f.readline())
a = [int(x) for x in f.readline().split()]
# End Input code ---------------------------------------
else:
# Start Input code ---------------------------------------
n = int(input())
a = [int(x) for x in input().split()]
# End Input code ---------------------------------------
# print(n,a,sum(a)-n)
print(sum(a) - n)
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s294510314 | Accepted | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | # def gcd(a, b):
# while b:
# a, b = b, a % b
# return a
# def lcm(a, b):
# return a * b // gcd (a, b)
# def f(m, input):
# r = 0
# for i in input:
# r += m % i
# return r
N = map(int, input())
a_n = list(map(int, input().split(" ")))
# a_n = sorted(a_n)
max = 0
for x in a_n:
max += x
# result = []
# for m in range(max):
# out = f(m, a_n)
# result.append(out)
# re = sorted(result)
# print(re[-1])
# print(max) #994 518 941 851 647 2 581 -> 4534
print(max - len(a_n))
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s209127115 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | # 高橋君！の問題について
# したのコードでTLEになってしまうのは、もうPythonの限界なのか、
# 無駄なプロセスがあるのかどうかを聞く。
H, W = map(int, input().split())
mp = [list(input()) for _ in range(H)]
for i in range(H):
for j in range(W):
if mp[i][j] == "s":
start = (i, j)
elif mp[i][j] == "g":
goal = (i, j)
dxy = [(1, 0), (0, 1), (-1, 0), (0, -1)]
import queue
from collections import defaultdict
q = queue.Queue()
d = defaultdict()
q.put(start)
while not q.empty():
now = q.get()
if not now in d.keys():
d[now] = 0
for dx, dy in dxy:
n_0 = now[0] + dx
n_1 = now[1] + dy
# すでに行っていたとしても、塀をより壊していない
# ルートなら採用するべき
if (n_0, n_1) in set(d.keys()):
if mp[n_0][n_1] == "#":
if d[(n_0, n_1)] > d[now] + 1:
q.put((n_0, n_1))
d[(n_0, n_1)] = d[now] + 1
else:
if d[(n_0, n_1)] > d[now]:
q.put((n_0, n_1))
d[(n_0, n_1)] = d[now]
else: # 初めてのルート
if 0 <= n_0 < H and 0 <= n_1 < W:
if mp[n_0][n_1] == "g":
print("YES")
exit(0)
elif mp[n_0][n_1] == "#":
if d[now] < 2:
q.put((n_0, n_1))
d[(n_0, n_1)] = d[now] + 1
else:
q.put((n_0, n_1))
d[(n_0, n_1)] = d[now]
print("NO")
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s486284985 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N |
def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x % y)
N = int(input())
A = list(map(int, input().split()))
#N = 7
#A = [994, 518, 941, 851, 647, 2, 581]
t = A[0]
for i in range(1,N):
if (t % A[i])
continue
t = t * A[i] / gcd(t, A[i])
sum = 0
t -= 1
for i in range(N):
sum += t % A[i]
print(int(sum))
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s987203252 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | from functools import reduce
n = int(input())
a = list(map(int, input().split()))
def gcd(x, y):
try:
if y == 0:
return x
return gcd(y, x % y)
def gcd2(number):
return reduce(gcd, number)
def lcm(x, y):
return x * y // gcd(x, y)
def lcm2(number):
return reduce(lcm, number)
m = lcm2(a) - 1
#print(m)
ans = 0
for i in range(n):
ans += m % a[i]
print(ans) | Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s030552471 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | a = input()
ans = 0
a = [int(i) for i in input().split()]
for num in a:
ans += num - 1
print(ans) | Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s755127871 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | input()
ans = 0
a = [int(i) for i in input().split()]
for num in a:
ans += num - 1
print(ans) | Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s398550507 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | import sys
readline = sys.stdin.readline
n = int(readline())
print(sum([int(i) for i in readline().split()] - n) | Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s429035839 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | # ans
N = int(input())
a = list(map(int, input().split()))
print(sum(a)=N)
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s354239517 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | n=int(input())
da=list(map((int,input().split()))
ans=0
for i in da:
ans+=i-1
print(ans)
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s102652696 | Runtime Error | p03294 | 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())
print(sum(a)-n)
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s318359820 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | n = int(input())
s = 0
x = [s += int(i) for i in input().split()]
print(s - n)
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s330587752 | Runtime Error | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | print(-int(input()) + sum(map(input().split(), int)))
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s655650036 | Wrong Answer | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | print(sum(map(lambda x: x - 1, list(map(int, input().split())))))
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s076778064 | Accepted | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | I = int(input())
B = 0
count = 0
A = list(map(int, input().split()))
for i in range(I):
B += A[count] - 1
count += 1
print(str(B))
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the maximum value of f.
* * * | s088893304 | Accepted | p03294 | Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N | import math
class Sieve:
"""Sieve of Eratosthenes.
List primes up to n.
"""
def __init__(self, n):
self.__prime = []
self.__is_prime = [i >= 2 for i in range(n + 1)]
for i in range(2, int(math.sqrt(n)) + 1):
if self.__is_prime[i]:
for j in range(i * i, n + 1, i):
self.__is_prime[j] = False
for i in range(2, n + 1):
if self.__is_prime[i]:
self.__prime.append(i)
def prime(self):
return self.__prime
def is_prime(self, n):
return self.__is_prime[n]
def bf(N, a):
p = Sieve(max(a) + 1).prime() # len <= 9952
prime_to_power = {}
for prime in p:
prime_to_power[prime] = 0
for i in range(N):
ai = a[i]
for prime in p:
power = 0
while ai % prime == 0:
ai //= prime
power += 1
prime_to_power[prime] = max(prime_to_power[prime], power)
lcm = 1
for prime in prime_to_power:
lcm *= prime ** prime_to_power[prime]
m = lcm - 1
ans = 0
for ai in a:
ans += m % ai
return ans
def al(N, a):
return sum(a) - len(a)
if __name__ == "__main__":
N = int(input()) # 2 <= N <= 3000
a = list(map(int, input().split())) # 2 <= ai <= 100000
# print(bf(N, a))
print(al(N, a))
| Statement
You are given N positive integers a_1, a_2, ..., a_N.
For a non-negative integer m, let f(m) = (m\ mod\ a_1) + (m\ mod\ a_2) + ... +
(m\ mod\ a_N).
Here, X\ mod\ Y denotes the remainder of the division of X by Y.
Find the maximum value of f. | [{"input": "3\n 3 4 6", "output": "10\n \n\nf(11) = (11\\ mod\\ 3) + (11\\ mod\\ 4) + (11\\ mod\\ 6) = 10 is the maximum value\nof f.\n\n* * *"}, {"input": "5\n 7 46 11 20 11", "output": "90\n \n\n* * *"}, {"input": "7\n 994 518 941 851 647 2 581", "output": "4527"}] |
Print the amout of the debt in a line. | s500069658 | Wrong Answer | p00007 | An integer n (0 ≤ n ≤ 100) is given in a line. | print(int(round(100000 * (1.05 ** int(input())), -4)), end="\n")
| Debt Hell
Your friend who lives in undisclosed country is involved in debt. He is
borrowing 100,000-yen from a loan shark. The loan shark adds 5% interest of
the debt and rounds it to the nearest 1,000 above week by week.
Write a program which computes the amount of the debt in n weeks. | [{"input": "", "output": "0"}] |
Print the amout of the debt in a line. | s556274501 | Wrong Answer | p00007 | An integer n (0 ≤ n ≤ 100) is given in a line. | while True:
try:
print(int(round(100000 * (1.05 ** int(input())), -4)))
except EOFError:
break
| Debt Hell
Your friend who lives in undisclosed country is involved in debt. He is
borrowing 100,000-yen from a loan shark. The loan shark adds 5% interest of
the debt and rounds it to the nearest 1,000 above week by week.
Write a program which computes the amount of the debt in n weeks. | [{"input": "", "output": "0"}] |
Print the amout of the debt in a line. | s720077538 | Wrong Answer | p00007 | An integer n (0 ≤ n ≤ 100) is given in a line. | s = int(input())
print(int(100000 + 100000 * (0.05 * s) + 1000 * s))
| Debt Hell
Your friend who lives in undisclosed country is involved in debt. He is
borrowing 100,000-yen from a loan shark. The loan shark adds 5% interest of
the debt and rounds it to the nearest 1,000 above week by week.
Write a program which computes the amount of the debt in n weeks. | [{"input": "", "output": "0"}] |
Print the amout of the debt in a line. | s153976756 | Accepted | p00007 | An integer n (0 ≤ n ≤ 100) is given in a line. | import sys
for num in sys.stdin:
ini = 100000
num = int(num)
for i in range(1, num + 1):
ini = ini + ini * 0.05
mod = ini % 1000
ini = ini - mod
if mod != 0:
ini += 1000
ini = int(ini)
print(ini)
| Debt Hell
Your friend who lives in undisclosed country is involved in debt. He is
borrowing 100,000-yen from a loan shark. The loan shark adds 5% interest of
the debt and rounds it to the nearest 1,000 above week by week.
Write a program which computes the amount of the debt in n weeks. | [{"input": "", "output": "0"}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s572945205 | Wrong Answer | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | #!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LS():
return list(map(list, sys.stdin.readline().split()))
def S():
return list(sys.stdin.readline())[:-1]
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
mod = 1000000007
# A
"""
a = LI()
i = a.count(5)
j = a.count(7)
if i == 2 and j == 1:
print("YES")
else:
print("NO")
"""
# B
n, l = LI()
s = SR(n)
s.sort()
for i in s:
print(i, end="")
print()
# C
"""
def check(n):
n = list(map(int,list(str(n))))
s = 0
for i in n:
s += f[i]
return s == 0
n,k = LI()
d = LI()
f = [0 for i in range(10)]
for i in d:
f[i] = 1
while 1:
if check(n):
print(n)
quit()
n += 1
"""
# D
"""
def f(x,y):
return fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]*inv_fact[y-1]*inv_fact[w-x]*inv_fact[h-y]%mod
h,w,a,b = LI()
fact = [1]*(h+w+1)
for i in range(h+w):
fact[i+1] = fact[i]*(i+1)%mod
inv_fact = [0]*(h+w+1)
inv_fact[h+w] = pow(fact[-1],mod-2,mod)
for i in range(h+w)[::-1]:
inv_fact[i] = inv_fact[i+1]*(i+1)%mod
ans = 0
for i in range(1,min(w-b,h-a)+1):
ans += f(b+i,a+i)
ans %= mod
print(ans)
"""
# E
# F
# G
# H
# I
# J
# K
# L
# M
# N
# O
# P
# Q
# R
# S
# T
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s152784445 | Wrong Answer | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | import sys
lines = sys.stdin.readlines()
strings = []
max_len = 0
for n, line in enumerate(lines):
if n == 0:
N, L = [int(_) for _ in line.strip().split(" ")]
continue
max_len = max([max_len, len(line.strip())])
strings.append([ord(_) - 97 for _ in line.strip()])
def append(source, target):
global max_len
# print('begin:', end='')
# print(source, target)
min_idx = -1
check_idx = [_ for _ in range(max_len)]
new_check_idx = []
for digit in range(max_len):
s_head_min = 26
for n, s in enumerate(source):
if not n in check_idx:
continue
# print('digit:{}, check_idx:{}'.format(digit, check_idx))
if s_head_min > s[digit]:
s_head_min = s[digit]
min_idx = n
elif s_head_min == s[digit]:
new_check_idx.append(min_idx)
new_check_idx.append(n)
if not len(new_check_idx):
# print('Break!')
# print(new_check_idx)
break
# print('new_check!')
check_idx = new_check_idx
new_check_idx = []
target += "".join([chr(_ + 97) for _ in source[min_idx]])
source.remove(source[min_idx])
# print('end:', end='')
# print(source, target)
if not len(source):
return target
else:
return append(source, target)
print(append(strings, ""))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s963352784 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N, L = map(int, input().split())
input_line1 = [input() for i in range(N)]
input_line2 = []
for i in range(N):
input_line2.append(min(input_line1))
input_line1.remove(min(input_line1))
print("".join(input_line2))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s867858165 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N,L=map(int,input().split())
S = [input() for i in range(N)]
S.sort()
for s in S:
print(s,end=“”) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s459668881 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | first= input()
first = first.split()
N = int(firsst[0])
L =[]
for i in range(N)
s = input()
L.append(s)
L.sort()
for i in L:
print(i,end="")
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s971266680 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | first= input()
first = first.split()
N = int(first[0])
L =[]
for i in range(N)
s = input()
L.append(s)
L.sort()
for i in L:
print(i,end="")
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s871747659 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n,l=map(int,input().split())
s=[]
for i in range(n):
s.append(str(input()))
a="".join(sorted(s))
print(a | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s850028457 | Accepted | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | a, b = list(map(int, input().split()))
print("".join(sorted([input() for i in range(a)])))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s713192331 | Accepted | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | print("".join(sorted(input() for _ in range(int(input().split()[0])))))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s820178607 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | record = sorted([input() for i in range(int(input().split()[1]))])
print("".join(record))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s359148269 | Accepted | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | def hikaku(n1, n2):
for x, y in zip(n1, n2):
if ord(x) == ord(y):
continue
else:
return True if ord(x) > ord(y) else False
num, length = map(int, input().split())
wlist = []
for i in range(num):
wlist.append(input())
for n in range(num - 1):
kumi = [(x, x + 1) for x in range(num - 1 - n)]
if kumi:
for x, y in kumi:
if hikaku(wlist[x], wlist[y]):
wlist[x], wlist[y] = wlist[y], wlist[x]
dst = ""
for w in wlist:
dst += w
print(dst)
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s288822451 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | #pythonだとsortでそのまま何文字でもソートしてくれる
n, l = map(int, input().split())
s = [input() for _ in range(n)]]
print(''.join(sorted(s))) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s334224060 | Wrong Answer | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N = int(input().split()[0])
words = [input().rstrip() for i in range(N)]
print(words)
print("".join(sorted(words)))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s905483219 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | print("".join(sorted([input() for i in range(int(input().split[0]))])))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s136690770 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N = input().split()[0]
words = [input() for i in range(N)]
print("".join(words.sort()))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s171258851 | Accepted | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | import sys
## io ##
def IS():
return sys.stdin.readline().rstrip()
def II():
return int(IS())
def MII():
return list(map(int, IS().split()))
def MIIZ():
return list(map(lambda x: x - 1, MII()))
## dp ##
def DD2(d1, d2, init=0):
return [[init] * d2 for _ in range(d1)]
def DD3(d1, d2, d3, init=0):
return [DD2(d2, d3, init) for _ in range(d1)]
## math ##
def to_bin(x: int) -> str:
return format(x, "b") # rev => int(res, 2)
def to_oct(x: int) -> str:
return format(x, "o") # rev => int(res, 8)
def to_hex(x: int) -> str:
return format(x, "x") # rev => int(res, 16)
MOD = 10**9 + 7
def divc(x, y) -> int:
return -(-x // y)
def divf(x, y) -> int:
return x // y
def gcd(x, y):
while y:
x, y = y, x % y
return x
def lcm(x, y):
return x * y // gcd(x, y)
def enumerate_divs(n):
"""Return a tuple list of divisor of n"""
return [(i, n // i) for i in range(1, int(n**0.5) + 1) if n % i == 0]
def get_primes(MAX_NUM=10**3):
"""Return a list of prime numbers n or less"""
is_prime = [True] * (MAX_NUM + 1)
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX_NUM**0.5) + 1):
if not is_prime[i]:
continue
for j in range(i * 2, MAX_NUM + 1, i):
is_prime[j] = False
return [i for i in range(MAX_NUM + 1) if is_prime[i]]
## libs ##
from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left
# ======================================================#
def main():
n, l = MII()
ss = [IS() for _ in range(n)]
ss.sort()
print("".join(ss))
if __name__ == "__main__":
main()
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s550928874 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | # 最初に入力される情報を整理する
str_input_list = input().rstrip().split(" ")
int_input_list = []
for a in str_input_list:
int_input_list.append(int(a))
length = int_input_list[0]
amount = int_input_list[1]
# 文字列を受け取りリストに格納
mojiretu_list = []
for a in range(amount):
mojiretu_list.append(input())
# 文字列を小さい順に並べ、結合
sorted_list = sorted(mojiretu_list)
min_mojiretu = ""
for a in range(amount):
min_mojiretu += sorted_list[a]
# 出力
print(min_mojiretu)
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s835892815 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n, l = map(int, input().split())
sl = []
for i in range(n):
s = input()
sl.append(s)
sl.sort()
"print(sl)
ans = ""
for i in range(n):
ans += sl[i]
print(ans) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s789746483 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n, l = map(int, input().split())
s = [int(input()) for _ in range(n)]
s.sort()
print(i for i in s, end="")
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s584018464 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N,L = map(int, input().split())
string_list = [input() for i in range(N)]
string_list.sort()
print(''.join(string_list)
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s752615207 | Wrong Answer | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | str = input()
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s297337832 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N, L = map(int, input().split())
data = []
for _ in range(N):
input_data = input()
data.append(input_data)
print(data)
data.sort()
print(''.join(data))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s502533467 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | int main ():
N = input('>>')
L = input('>>')
for i in range(N):
dict = [input('>>')]
dict.sort()
for i in range(N):
print(str(dict[i]))
if __name__ = '__main__':
main() | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s446796797 | Wrong Answer | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N = input()
Ss = []
for _ in range(int(N[0])):
Ss.append(str(input()))
Ss.sort()
print(*Ss, sep="")
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s912229163 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n,l=map(int,input().split())
c=[]
for i range(n):
c.append(input())
c.sort()
print("".join(c))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s422985574 | Accepted | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | x, y = map(int, input().split())
print("".join(sorted([input() for _ in range(x)])))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s668482840 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n = int(input())
s = [input() for i in n]
print(s.sort())
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s599683279 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n, l = map(int,input().split())
s = [input() for _ in range(n)]
i = sorted(s)
print(''.join(i) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s124928884 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n, l = map(int, input().split())
List = sorted([input() for i in range(n])
print("".join(List)) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s688623985 | Accepted | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | import sys
input_methods = ["clipboard", "file", "key"]
using_method = 0
input_method = input_methods[using_method]
IN = lambda: map(int, input().split())
mod = 1000000007
# +++++
def main():
# a = int(input())
n, l = IN()
ss = []
for _ in range(n):
s = input()
ss.append(s)
ss.sort()
return "".join(ss)
# +++++
isTest = False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text = clipboard.get()
input_l = input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform == "ios":
if input_method == input_methods[0]:
ic = input_clipboard()
input = lambda: ic.__next__()
elif input_method == input_methods[1]:
sys.stdin = open("inputFile.txt")
else:
pass
isTest = True
else:
pass
# input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s666433072 | Accepted | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | input_n = input().split(" ")
N = int(input_n[0])
L = int(input_n[1])
say = []
for i in range(N):
say.append(input())
say.sort()
state = ""
for i in range(N):
state += say[i]
print(state)
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s092386876 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N, L = map(int, input().split())
#標準入力からリストの作成
list = []
for _ in (1,N):
i = input()
list.append(i)
#リストの結合
mojiretu = ''.join(list)
print(mojiretu | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s273796188 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N, L = map(int, input().split())
#標準入力からリストの作成
list = []
for _ in range(1,N):
i = input()
list.append(i)
#リストの結合
mojiretu = ''.join(list)
print(mojiretu | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s702230774 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | input_N_L = input()
# print( input_N_L )
N, L = map(int, input_N_L.split())
# print( N )
# print( L )
str_set = []
for i in range(L):
str_set.append(input())
# print( array )
sorted_str = ""
for s in sorted(str_set):
sorted_str += s
print(sorted_str)
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s335345182 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | number, length = input().split()
input_list = []
out = ""
for i in range(number):
input_list.append(input())
input_list.sort()
for i in input_list:
out += i
print(out)
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s099266506 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | import sequtils, strutils, algorithm
let
nl = stdin.readline.split.map(parseInt)
ss = newSeqWith(nl[0], stdin.readline).sorted(cmp)
echo ss.join("")
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s928735811 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N, L=map(int, input().split(""))
s=[]
for i in range(n):
s.append(input())
print(''.join(sorted(s))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s971247476 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | lengh, num = map(int, input().split())
lis = [input() for i in range(num)]
print("".join(sorted(lis)))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s880398687 | Wrong Answer | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n = input()
l = ""
for i in n:
c = 0
if i == "1" or i == "0":
l += i
else:
l = l[: len(l) - 1]
print(l)
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s130866074 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N,L=map(int,input().split())
S = [input() for i in range(N)]
S.sort()
for s in S:
print(s,end=“”) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s091335046 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n,l=map(int,input().split())
s=[]
for i range(n):
s.append(input())
s.sort()
ans=''
for x in s:
ans+=x
print(ans)
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s639171423 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N,L=[int(x) for x i input().split()]
s=[]
for _ in range(N):
s.append(input())
s.sort()
print("".join(s)) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s997637463 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n,l=map(int,input().split())
c=[]
for i range(n):
c.append(input())
c.sort()
print("",join(c))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s875488742 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n, k = map(int, input().split())
ln = map(str(input()) for _ in range(n))
ln.sort()
print("".join(ln))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s109914626 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | x = list(map(int,input().split()))
for i in 0 to X[0]
A.append(input())
result = ''.join(A)
print(result)
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s805093843 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n,l=map(int,input().split())
list=[]
for _ in range(n):
list.append(str(input())
list.sort()
ans=""
for i in list:
ans+=i
print(ans) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s060008518 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | #ABC042.B
N,L = map(int,input().split())
s = [input()for_in range(n)]
s.sort()
ans=''
for i in range(s):
ans += s[i]
print(ans) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s268174611 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | H, W = map(int, input().split())
S = []
for _ in range(H):
S.append(input())
S.sort（）
str1 = ""
str1.append(S[i] for i in range(H))
print(str1)
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s359438342 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n.l = map(int,input().split())
L = [input() for_ in range(n)]
L.sort()
print("".join(L)) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s854903642 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | 3 3
dxx
axx
cxx | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s466229716 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | list = sorted[input()]
print(*list, sep="")
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s421462981 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | print("".join(sorted([input() for _ in range(input().split()[0])))) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s496153567 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n,l =map(int,input().split())
s=sorted([input(),for i in range(n)])
print(*s,sep='')
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s947296826 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n,l=map(int,input().split())
s=[input() for i in range(n)]
print(''.join(sorted(s)) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s891938576 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | n,l=map(int,input().split())
for i range(n):
s=input()
s=s.sort()
print(*s,sep='') | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s296712651 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | N, L = map(int, input().split())
S = [input() for _ in range(N)]
print(''.join(S.sort()) | Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s890631324 | Accepted | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | # Problem: https://atcoder.jp/contests/abc042/tasks/abc042_b
# Python 2nd Try
import sys
# from collections import defaultdict
# import heapq,copy
# from collections import deque
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def LI():
return list(map(str, sys.stdin.readline().split()))
def LS():
return list(map(str, sys.stdin.readline().split()))
def LLI(rows_number):
return [LI() for _ in range(rows_number)]
def solver(allNumber, eachStringList):
result = ""
# algorithm
eachStringList.sort(reverse=False)
# print("{}".format(eachStringList))
result = result.join(eachStringList)
return result
if __name__ == "__main__":
N, _ = MI()
SI = []
for j in range(N):
tmpList = LS()
SI.append(tmpList[0])
print("{}".format(solver(N, SI)))
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the lexicographically smallest string that Iroha can produce.
* * * | s294011735 | Runtime Error | p04044 | The input is given from Standard Input in the following format:
N L
S_1
S_2
:
S_N | def power_func(a, b, p):
"""a^b mod p を求める"""
if b == 0:
return 1
if b % 2 == 0:
d = power_func(a, b // 2, p)
return d * d % p
if b % 2 == 1:
return (a * power_func(a, b - 1, p)) % p
from math import factorial
H, W, A, B = map(int, input().split())
p = 10**9 + 7
ans = 0
X = [1]
Y = [1]
for i in range(H + W - 2):
fact = factorial(i + 1) % p
X += [fact]
Y += [power_func(fact, p - 2, p)]
for i in range(B, W):
ans += (
X[H - A - 1 + i]
* X[A + W - 2 - i]
* (Y[H - A - 1] * Y[i] * Y[A - 1] * Y[W - 1 - i])
% p
)
print(ans)
| Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
string is L.
She will concatenate all of the strings in some order, to produce a long
string.
Among all strings that she can produce in this way, find the lexicographically
smallest one.
Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
string t=t_1t_2t_3...t_m if and only if one of the following holds:
* There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
* s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. | [{"input": "3 3\n dxx\n axx\n cxx", "output": "axxcxxdxx\n \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}] |
Print the earliest possible time for the kangaroo to reach coordinate X.
* * * | s575724008 | Runtime Error | p03781 | The input is given from Standard Input in the following format:
X | import sys
input = sys.stdin.readline
N, K = map(int, input().split())
a = list(map(int, input().split()))
S, f = [set() for i in range(N + 1)], [[0] * K for i in range(N + 1)]
S[0].add(0)
f[N][0] = 1
for i, (al, ar) in enumerate(zip(a, a[::-1]), 1):
for j in S[i - 1]:
S[i].add(j)
x = al + j
if x < K:
S[i].add(x)
for j in range(K):
if f[-i][j]:
f[-i - 1][j] = 1
if ar + j < K:
f[-i - 1][ar + j] = 1
for i in range(N):
for j in range(1, K):
f[i][j] += f[i][j - 1]
cnt = 0
for i, x in enumerate(a):
if x >= K:
cnt += 1
continue
for j in S[i]:
if K - x - j - 1 < 0 or f[i + 1][K - j - 1] - f[i + 1][K - x - j - 1] > 0:
cnt += 1
break
print(N - cnt)
| Statement
There is a kangaroo at coordinate 0 on an infinite number line that runs from
left to right, at time 0. During the period between time i-1 and time i, the
kangaroo can either stay at his position, or perform a jump of length exactly
i to the left or to the right. That is, if his coordinate at time i-1 is x, he
can be at coordinate x-i, x or x+i at time i. The kangaroo's nest is at
coordinate X, and he wants to travel to coordinate X as fast as possible. Find
the earliest possible time to reach coordinate X. | [{"input": "6", "output": "3\n \n\nThe kangaroo can reach his nest at time 3 by jumping to the right three times,\nwhich is the earliest possible time.\n\n* * *"}, {"input": "2", "output": "2\n \n\nHe can reach his nest at time 2 by staying at his position during the first\nsecond, and jumping to the right at the next second.\n\n* * *"}, {"input": "11", "output": "5"}] |
Print the earliest possible time for the kangaroo to reach coordinate X.
* * * | s185730275 | Runtime Error | p03781 | The input is given from Standard Input in the following format:
X | # import sys
# sys.stdin = open('d3.in')
n, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
prefix = [set() for _ in range(n + 1)]
suffix = [set() for _2 in range(n + 1)]
prefix[0] = {0}
for i in range(n):
for v in prefix[i]:
if v + a[i] <= k:
prefix[i + 1].add(v + a[i])
suffix[n] = {0}
for i in range(n - 1, -1, -1):
suffix[i] = set(suffix[i + 1])
for v in suffix[i + 1]:
if v + a[i] <= k:
suffix[i].add(v + a[i])
# Cumulative sums
c_suffix = [[0] * (k + 1) for _3 in range(n + 1)]
for i in range(n + 1):
for j in range(k):
c_suffix[i][j + 1] = c_suffix[i][j] + (j in suffix[i])
def find(i):
if k <= a[i]:
return 0
for s in prefix[i]:
start = max(0, k - a[i] - s)
stop = k - s
if c_suffix[i + 1][stop] - c_suffix[i + 1][start] > 0:
return 0
return 1
res = 0
for i in range(n):
res += find(i)
print(res)
| Statement
There is a kangaroo at coordinate 0 on an infinite number line that runs from
left to right, at time 0. During the period between time i-1 and time i, the
kangaroo can either stay at his position, or perform a jump of length exactly
i to the left or to the right. That is, if his coordinate at time i-1 is x, he
can be at coordinate x-i, x or x+i at time i. The kangaroo's nest is at
coordinate X, and he wants to travel to coordinate X as fast as possible. Find
the earliest possible time to reach coordinate X. | [{"input": "6", "output": "3\n \n\nThe kangaroo can reach his nest at time 3 by jumping to the right three times,\nwhich is the earliest possible time.\n\n* * *"}, {"input": "2", "output": "2\n \n\nHe can reach his nest at time 2 by staying at his position during the first\nsecond, and jumping to the right at the next second.\n\n* * *"}, {"input": "11", "output": "5"}] |
Print the earliest possible time for the kangaroo to reach coordinate X.
* * * | s880964668 | Runtime Error | p03781 | The input is given from Standard Input in the following format:
X | import sys
[n, k] = [int(x) for x in input().strip().split()]
a = [int(x) for x in input().strip().split()]
a.sort()
if sum(a) < k:
print(n)
sys.exit()
s = 0
for i in range(len(a)):
s += a[i]
if s >= k:
break
aa = [x for x in a if x < a[i]]
bb = [x for x in a if x < k]
cc = []
for i in range(len(aa)):
c = bb[:i] + bb[i + 1 :]
t = k - bb[i]
c.reverse()
# print(c)
flg = 0
j = 0
s = 0
f = [0 for x in range(len(c))]
while True:
f[j] = 1
# print(c)
# print(f)
s += c[j]
if s >= t and s < k:
flg = 1
# print(c)
# print(f)
break
if s >= k:
f[j] = 0
s -= c[j]
j += 1
if j == len(c):
ii = -1
for jj in range(len(c) - 1):
if f[jj] == 1:
ii = jj
if ii == -1:
break
else:
for l in range(ii, len(c)):
f[l] = 0
j = ii + 1
s = sum([c[l] * f[l] for l in range(len(c))])
if flg == 0:
cc.append(bb[i])
# print(cc)
print(len(cc))
| Statement
There is a kangaroo at coordinate 0 on an infinite number line that runs from
left to right, at time 0. During the period between time i-1 and time i, the
kangaroo can either stay at his position, or perform a jump of length exactly
i to the left or to the right. That is, if his coordinate at time i-1 is x, he
can be at coordinate x-i, x or x+i at time i. The kangaroo's nest is at
coordinate X, and he wants to travel to coordinate X as fast as possible. Find
the earliest possible time to reach coordinate X. | [{"input": "6", "output": "3\n \n\nThe kangaroo can reach his nest at time 3 by jumping to the right three times,\nwhich is the earliest possible time.\n\n* * *"}, {"input": "2", "output": "2\n \n\nHe can reach his nest at time 2 by staying at his position during the first\nsecond, and jumping to the right at the next second.\n\n* * *"}, {"input": "11", "output": "5"}] |
Print the earliest possible time for the kangaroo to reach coordinate X.
* * * | s087612011 | Runtime Error | p03781 | The input is given from Standard Input in the following format:
X | def main():
n, k = map(int, input().split())
a = list(filter(lambda x: x < k, list(map(int, input().split()))))
n = len(a)
a.sort(reverse=True)
ng = -1
ok = n
while ok - ng > 1:
mid = (ok + ng) // 2
dp = [False] * (k + 1)
dp[0] = True
f = 0
for j in range(n):
if j == mid:
continue
w = a[j]
for i in range(k, w - 1, -1):
if dp[i - w]:
dp[i] = True
if k - a[mid] <= i < k:
ng = mid
f = 1
break
if f:
break
else:
ok = mid
print(n - ok)
if __name__ == "__main__":
main()
| Statement
There is a kangaroo at coordinate 0 on an infinite number line that runs from
left to right, at time 0. During the period between time i-1 and time i, the
kangaroo can either stay at his position, or perform a jump of length exactly
i to the left or to the right. That is, if his coordinate at time i-1 is x, he
can be at coordinate x-i, x or x+i at time i. The kangaroo's nest is at
coordinate X, and he wants to travel to coordinate X as fast as possible. Find
the earliest possible time to reach coordinate X. | [{"input": "6", "output": "3\n \n\nThe kangaroo can reach his nest at time 3 by jumping to the right three times,\nwhich is the earliest possible time.\n\n* * *"}, {"input": "2", "output": "2\n \n\nHe can reach his nest at time 2 by staying at his position during the first\nsecond, and jumping to the right at the next second.\n\n* * *"}, {"input": "11", "output": "5"}] |
Print the earliest possible time for the kangaroo to reach coordinate X.
* * * | s097337857 | Runtime Error | p03781 | The input is given from Standard Input in the following format:
X | x = int(input())
i=0
while x>0
i++
x=x-i
print(i)
| Statement
There is a kangaroo at coordinate 0 on an infinite number line that runs from
left to right, at time 0. During the period between time i-1 and time i, the
kangaroo can either stay at his position, or perform a jump of length exactly
i to the left or to the right. That is, if his coordinate at time i-1 is x, he
can be at coordinate x-i, x or x+i at time i. The kangaroo's nest is at
coordinate X, and he wants to travel to coordinate X as fast as possible. Find
the earliest possible time to reach coordinate X. | [{"input": "6", "output": "3\n \n\nThe kangaroo can reach his nest at time 3 by jumping to the right three times,\nwhich is the earliest possible time.\n\n* * *"}, {"input": "2", "output": "2\n \n\nHe can reach his nest at time 2 by staying at his position during the first\nsecond, and jumping to the right at the next second.\n\n* * *"}, {"input": "11", "output": "5"}] |
Print the earliest possible time for the kangaroo to reach coordinate X.
* * * | s384522490 | Runtime Error | p03781 | The input is given from Standard Input in the following format:
X | x = int(input())
i = 0
while x>0
i = i+1
x = x-i
print(i) | Statement
There is a kangaroo at coordinate 0 on an infinite number line that runs from
left to right, at time 0. During the period between time i-1 and time i, the
kangaroo can either stay at his position, or perform a jump of length exactly
i to the left or to the right. That is, if his coordinate at time i-1 is x, he
can be at coordinate x-i, x or x+i at time i. The kangaroo's nest is at
coordinate X, and he wants to travel to coordinate X as fast as possible. Find
the earliest possible time to reach coordinate X. | [{"input": "6", "output": "3\n \n\nThe kangaroo can reach his nest at time 3 by jumping to the right three times,\nwhich is the earliest possible time.\n\n* * *"}, {"input": "2", "output": "2\n \n\nHe can reach his nest at time 2 by staying at his position during the first\nsecond, and jumping to the right at the next second.\n\n* * *"}, {"input": "11", "output": "5"}] |
Print the sum of the answers to the questions for the integers between 0 and X
(inclusive), modulo 998244353.
* * * | s292322183 | Accepted | p02893 | Input is given from Standard Input in the following format:
N
X | def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
divisors.sort()
return divisors
def nasu(x):
t = make_divisors(x)
c = 0
for i in t:
c += D[i]
return c
def honya(x):
y = 0
k = 1
for i in range(x - 1, -1, -1):
if X[i]:
y = (y + k) % MOD
k = (k * 2) % MOD
return y + honyaraka(x)
def honyaraka(x):
cnt = 0
for i in range(N // x):
t = i % 2
for j in range(x):
if X[cnt] != (X[j] ^ t):
if X[cnt] == 0:
return 0
else:
return 1
cnt += 1
return 1
N = int(input())
X = list(map(int, input()))
MOD = 998244353
Y = 0
k = 1
for i in range(N - 1, -1, -1):
if X[i]:
Y = (Y + k) % MOD
k = (k * 2) % MOD
D = [0] * (N + 1)
L = make_divisors(N)
cnt = 0
for i in L:
if i != N and (N // i) % 2 == 1:
D[i] = honya(i) - nasu(i)
cnt += D[i]
D[N] = Y - cnt + 1
ans = 0
for i in L:
ans = (ans + D[i] * i * 2) % MOD
print(ans)
| Statement
Given are integers N and X. For each integer k between 0 and X (inclusive),
find the answer to the following question, then compute the sum of all those
answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.) | [{"input": "3\n 111", "output": "40\n \n\nFor example, for k=3, the operation changes k as follows: 1,0,4,6,7,3.\nTherefore the answer for k=3 is 6.\n\n* * *"}, {"input": "6\n 110101", "output": "616\n \n\n* * *"}, {"input": "30\n 001110011011011101010111011100", "output": "549320998"}] |
Print the sum of the answers to the questions for the integers between 0 and X
(inclusive), modulo 998244353.
* * * | s211307775 | Accepted | p02893 | Input is given from Standard Input in the following format:
N
X | import sys
input = sys.stdin.readline
mod = 998244353
N = int(input())
X = input()
import math
xr = math.ceil(math.sqrt(N))
LIST = []
for i in range(1, xr + 1):
if N % i == 0:
LIST.append(i)
LIST.append(N // i)
REP = [l for l in set(LIST) if (N // l) % 2 == 1 and l != N]
REP.sort(reverse=True)
ANS = 2 * N * (int(X, 2) + 1) % mod
def invstr(X, r):
return bin(int(X, 2) ^ ((1 << r) - 1))[2:].zfill(r)
from collections import defaultdict
score = defaultdict(int)
for r in REP:
score[r] += 2 * r - 2 * N
for j in REP:
if r % j == 0 and j < r:
score[j] -= score[r]
for r in REP:
sc = score[r]
# print(r,score)
XSTR = X[:r]
kosuu = int(XSTR, 2)
if (XSTR + invstr(XSTR, r)) * (N // (r * 2)) + XSTR <= X:
kosuu += 1
ANS += kosuu * sc
print(ANS % mod)
| Statement
Given are integers N and X. For each integer k between 0 and X (inclusive),
find the answer to the following question, then compute the sum of all those
answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.) | [{"input": "3\n 111", "output": "40\n \n\nFor example, for k=3, the operation changes k as follows: 1,0,4,6,7,3.\nTherefore the answer for k=3 is 6.\n\n* * *"}, {"input": "6\n 110101", "output": "616\n \n\n* * *"}, {"input": "30\n 001110011011011101010111011100", "output": "549320998"}] |
Print the sum of the answers to the questions for the integers between 0 and X
(inclusive), modulo 998244353.
* * * | s222136854 | Accepted | p02893 | Input is given from Standard Input in the following format:
N
X | N = int(input())
X = input()
MOD = 998244353
ans = 0
memo = dict()
# def get_divisor(n):
# '''nの約数を返す
# '''
# d = set()
# for i in range(1, int(n**0.5)+1):
# if n % i == 0:
# d.add(i)
# d.add(n//i)
# return d
def get_oddivisor(n):
"""nの約数のうち商が奇数のものを返す"""
d = set()
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
if i % 2 == 1:
d.add(n // i)
if (n // i) % 2 == 1:
d.add(i)
return d
D = list(get_oddivisor(N))
D.sort()
def alternate(x, n):
"""x: 00101, y: 11010, z: (00101)(11010)... n times"""
y = ("0" * len(x) + bin(int(x, 2) ^ (2 ** len(x) - 1))[2:])[-len(x) :]
z = (x + y) * (n // 2)
if n % 2 == 1:
z += x
return z
for d in D:
cnt = int(X[:d], 2)
if int(X, 2) >= int(alternate(X[:d], N // d), 2):
cnt += 1
dd = list(get_oddivisor(d))
for ddd in dd:
if ddd != d:
cnt -= memo[ddd]
memo[d] = cnt
ans += cnt * 2 * d
ans %= 998244353
print(ans)
| Statement
Given are integers N and X. For each integer k between 0 and X (inclusive),
find the answer to the following question, then compute the sum of all those
answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.) | [{"input": "3\n 111", "output": "40\n \n\nFor example, for k=3, the operation changes k as follows: 1,0,4,6,7,3.\nTherefore the answer for k=3 is 6.\n\n* * *"}, {"input": "6\n 110101", "output": "616\n \n\n* * *"}, {"input": "30\n 001110011011011101010111011100", "output": "549320998"}] |
Print the sum of the answers to the questions for the integers between 0 and X
(inclusive), modulo 998244353.
* * * | s977959602 | Wrong Answer | p02893 | Input is given from Standard Input in the following format:
N
X | import sys
N = int(input())
X = int(input(), 2)
def proc(x):
if x % 2 == 1:
return x >> 1
else:
return (x >> 1) + int("1" + "0" * (N - 1), 2)
total = 0
MAX_TRY = 1000
for k in range(X + 1):
p = k
for num_calc in range(1, MAX_TRY):
p = proc(p)
if p == k:
total += num_calc
break
if num_calc == MAX_TRY - 1:
print("-1")
sys.exit(0)
print(total % 998244353)
| Statement
Given are integers N and X. For each integer k between 0 and X (inclusive),
find the answer to the following question, then compute the sum of all those
answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.) | [{"input": "3\n 111", "output": "40\n \n\nFor example, for k=3, the operation changes k as follows: 1,0,4,6,7,3.\nTherefore the answer for k=3 is 6.\n\n* * *"}, {"input": "6\n 110101", "output": "616\n \n\n* * *"}, {"input": "30\n 001110011011011101010111011100", "output": "549320998"}] |
Print the sum of the answers to the questions for the integers between 0 and X
(inclusive), modulo 998244353.
* * * | s682217521 | Wrong Answer | p02893 | Input is given from Standard Input in the following format:
N
X | n = int(input())
x = input()
x_10 = int(x, 2)
cnt = x_10 + 1
ans = 0
n_copy = n
for i in range(3, n + 1, 2):
if n % i == 0:
p = int(x[0 : n // i], 2)
if x_10 >= sum(p << ((n // i) * j) for j in range(0, i, 2)) + sum(
(2 ** (n // i) - p - 1) << ((n // i) * j) for j in range(1, i, 2)
):
cnt -= p + 1
ans += (p + 1) * 2 * (n // i)
else:
cnt -= p
ans += p * 2 * (n // i)
ans += n * 2 * cnt
print(ans % 998244353)
| Statement
Given are integers N and X. For each integer k between 0 and X (inclusive),
find the answer to the following question, then compute the sum of all those
answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.) | [{"input": "3\n 111", "output": "40\n \n\nFor example, for k=3, the operation changes k as follows: 1,0,4,6,7,3.\nTherefore the answer for k=3 is 6.\n\n* * *"}, {"input": "6\n 110101", "output": "616\n \n\n* * *"}, {"input": "30\n 001110011011011101010111011100", "output": "549320998"}] |
Print the sum of the answers to the questions for the integers between 0 and X
(inclusive), modulo 998244353.
* * * | s801765508 | Runtime Error | p02893 | Input is given from Standard Input in the following format:
N
X | # import numpy as np
#
# n = int(input())
#
# m = np.zeros((n, n), dtype=np.bool)
#
# for i in range(n):
# l = [int(s) for s in list(input())]
# m[i] =l
# a = np.count_nonzero(m,axis=0)
# r = np.count_nonzero(np.count_nonzero(m, axis=0) > 1)
# r = r or -1
# print(r)
n = int(input())
x = int(input(), 2)
th = 2 ** (n - 1) * 2
def calc_1(tmp_k):
return (tmp_k - 1) / 2
def calc_2(tmp_k):
return tmp_k / 2 + 2 ** (n - 1)
def calc_count(tmp_k):
if tmp_k % 2 == 1:
new_k = calc_1(tmp_k)
else:
new_k = calc_2(tmp_k)
if new_k == k:
return 1
if tmp_k > new_k > calc_2(tmp_k):
return False
calc_result = calc_count(new_k)
if calc_result:
calc_result += 1
return calc_result
result = 0
for k in range(x + 1):
calc_result = calc_count(k)
if calc_result:
result += calc_result
print(result % 998244353)
| Statement
Given are integers N and X. For each integer k between 0 and X (inclusive),
find the answer to the following question, then compute the sum of all those
answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.) | [{"input": "3\n 111", "output": "40\n \n\nFor example, for k=3, the operation changes k as follows: 1,0,4,6,7,3.\nTherefore the answer for k=3 is 6.\n\n* * *"}, {"input": "6\n 110101", "output": "616\n \n\n* * *"}, {"input": "30\n 001110011011011101010111011100", "output": "549320998"}] |
Print the sum of the answers to the questions for the integers between 0 and X
(inclusive), modulo 998244353.
* * * | s400306015 | Wrong Answer | p02893 | Input is given from Standard Input in the following format:
N
X | N = int(input())
X = int(input(), 2)
MOD = 998244353
ans = ((X + 1) % MOD) * 2 * N
L = []
for i in range(1, N // 3 + 1):
if N % (2 * i) == i:
for j in range(2**i):
b = int(
(("0" * i + bin(j)[2:])[-i:] + ("0" * i + bin(2**i - j - 1)[2:])[-i:])
* (N // (2 * i))
+ ("0" * i + bin(j)[2:])[-i:],
2,
)
if X >= b and not (b in L):
L.append(b)
ans -= 2 * N
ans += 2 * i
ans %= MOD
print(ans)
| Statement
Given are integers N and X. For each integer k between 0 and X (inclusive),
find the answer to the following question, then compute the sum of all those
answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.) | [{"input": "3\n 111", "output": "40\n \n\nFor example, for k=3, the operation changes k as follows: 1,0,4,6,7,3.\nTherefore the answer for k=3 is 6.\n\n* * *"}, {"input": "6\n 110101", "output": "616\n \n\n* * *"}, {"input": "30\n 001110011011011101010111011100", "output": "549320998"}] |
Print the sum of the answers to the questions for the integers between 0 and X
(inclusive), modulo 998244353.
* * * | s648802684 | Runtime Error | p02893 | Input is given from Standard Input in the following format:
N
X | # import sys
# input = sys.stdin.readline
# import heapq
# from fractions import gcd
# from collections import defaultdict
# sys.setrecursionlimit(10**9)
# map(int,input().split())
def main():
n = int(input())
x = int(input(), 2)
ans = [0] * (x + 1)
tmp = 0
for i in range(x + 1):
if ans[i] != 0:
continue
else:
cnt = 0
tmp = i
li = [tmp]
while True:
if tmp % 2:
tmp = (tmp - 1) // 2
li.append(tmp)
cnt += 1
else:
tmp = (tmp // 2) + (2 ** (n - 1))
li.append(tmp)
cnt += 1
if tmp == i:
for ii in li:
if ii <= x:
ans[ii] = cnt
break
print(sum(ans) % 998244353)
if __name__ == "__main__":
main()
| Statement
Given are integers N and X. For each integer k between 0 and X (inclusive),
find the answer to the following question, then compute the sum of all those
answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.) | [{"input": "3\n 111", "output": "40\n \n\nFor example, for k=3, the operation changes k as follows: 1,0,4,6,7,3.\nTherefore the answer for k=3 is 6.\n\n* * *"}, {"input": "6\n 110101", "output": "616\n \n\n* * *"}, {"input": "30\n 001110011011011101010111011100", "output": "549320998"}] |
Print the maximum positive integer K that satisfies the condition.
* * * | s237462011 | Accepted | p02939 | Input is given from Standard Input in the following format:
S | a = 0
t = c = ""
for i in input():
t += i
if c != t:
a += 1
c = t
t = ""
print(a)
| Statement
Given is a string S consisting of lowercase English letters. Find the maximum
positive integer K that satisfies the following condition:
* There exists a partition of S into K non-empty strings S=S_1S_2...S_K such that S_i \neq S_{i+1} (1 \leq i \leq K-1).
Here S_1S_2...S_K represents the concatenation of S_1,S_2,...,S_K in this
order. | [{"input": "aabbaa", "output": "4\n \n\nWe can, for example, divide S into four strings `aa`, `b`, `ba`, and `a`.\n\n* * *"}, {"input": "aaaccacabaababc", "output": "12"}] |
Print the maximum positive integer K that satisfies the condition.
* * * | s246596658 | Wrong Answer | p02939 | Input is given from Standard Input in the following format:
S | a = input()
print(len(a))
| Statement
Given is a string S consisting of lowercase English letters. Find the maximum
positive integer K that satisfies the following condition:
* There exists a partition of S into K non-empty strings S=S_1S_2...S_K such that S_i \neq S_{i+1} (1 \leq i \leq K-1).
Here S_1S_2...S_K represents the concatenation of S_1,S_2,...,S_K in this
order. | [{"input": "aabbaa", "output": "4\n \n\nWe can, for example, divide S into four strings `aa`, `b`, `ba`, and `a`.\n\n* * *"}, {"input": "aaaccacabaababc", "output": "12"}] |
Print the maximum positive integer K that satisfies the condition.
* * * | s786183871 | Wrong Answer | p02939 | Input is given from Standard Input in the following format:
S | print(15)
| Statement
Given is a string S consisting of lowercase English letters. Find the maximum
positive integer K that satisfies the following condition:
* There exists a partition of S into K non-empty strings S=S_1S_2...S_K such that S_i \neq S_{i+1} (1 \leq i \leq K-1).
Here S_1S_2...S_K represents the concatenation of S_1,S_2,...,S_K in this
order. | [{"input": "aabbaa", "output": "4\n \n\nWe can, for example, divide S into four strings `aa`, `b`, `ba`, and `a`.\n\n* * *"}, {"input": "aaaccacabaababc", "output": "12"}] |
Print the maximum positive integer K that satisfies the condition.
* * * | s497752374 | Wrong Answer | p02939 | Input is given from Standard Input in the following format:
S | str = input()
print("4")
| Statement
Given is a string S consisting of lowercase English letters. Find the maximum
positive integer K that satisfies the following condition:
* There exists a partition of S into K non-empty strings S=S_1S_2...S_K such that S_i \neq S_{i+1} (1 \leq i \leq K-1).
Here S_1S_2...S_K represents the concatenation of S_1,S_2,...,S_K in this
order. | [{"input": "aabbaa", "output": "4\n \n\nWe can, for example, divide S into four strings `aa`, `b`, `ba`, and `a`.\n\n* * *"}, {"input": "aaaccacabaababc", "output": "12"}] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.