message stringlengths 2 23.8k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 97 109k | cluster float64 0 0 | __index_level_0__ int64 194 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Genos recently installed the game Zuma on his phone. In Zuma there exists a line of n gemstones, the i-th of which has color ci. The goal of the game is to destroy all the gemstones in the line as quickly as possible.
In one second, Genos is able to choose exactly one continuous substring of colored gemstones that is a palindrome and remove it from the line. After the substring is removed, the remaining gemstones shift to form a solid line again. What is the minimum number of seconds needed to destroy the entire line?
Let us remind, that the string (or substring) is called palindrome, if it reads same backwards or forward. In our case this means the color of the first gemstone is equal to the color of the last one, the color of the second gemstone is equal to the color of the next to last and so on.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 500) — the number of gemstones.
The second line contains n space-separated integers, the i-th of which is ci (1 ≤ ci ≤ n) — the color of the i-th gemstone in a line.
Output
Print a single integer — the minimum number of seconds needed to destroy the entire line.
Examples
Input
3
1 2 1
Output
1
Input
3
1 2 3
Output
3
Input
7
1 4 4 2 3 2 1
Output
2
Note
In the first sample, Genos can destroy the entire line in one second.
In the second sample, Genos can only destroy one gemstone at a time, so destroying three gemstones takes three seconds.
In the third sample, to achieve the optimal time of two seconds, destroy palindrome 4 4 first and then destroy palindrome 1 2 3 2 1. | instruction | 0 | 70,259 | 0 | 140,518 |
Tags: dp
Correct Solution:
```
from sys import stdin,stdout
for _ in range(1):#(stdin.readline())):
n=int(stdin.readline())
# n,m=list(map(int,stdin.readline().split()))
a=list(map(int,stdin.readline().split()))
dp=[[0 for _ in range(n)] for _ in range(n)]
for sz in range(n):
for i in range(n-sz):
j=i+sz
# print(i,j)
if sz==0:dp[i][j]=1
elif sz==1:dp[i][j]=1+int(a[i]!=a[j])
else:
v=n
if a[i]==a[j]:v=dp[i+1][j-1]
for k in range(i,j):
v=min(v,dp[i][k]+dp[k+1][j])
dp[i][j]=v
# print(*dp,sep='\n')
print(dp[0][n-1])
``` | output | 1 | 70,259 | 0 | 140,519 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Genos recently installed the game Zuma on his phone. In Zuma there exists a line of n gemstones, the i-th of which has color ci. The goal of the game is to destroy all the gemstones in the line as quickly as possible.
In one second, Genos is able to choose exactly one continuous substring of colored gemstones that is a palindrome and remove it from the line. After the substring is removed, the remaining gemstones shift to form a solid line again. What is the minimum number of seconds needed to destroy the entire line?
Let us remind, that the string (or substring) is called palindrome, if it reads same backwards or forward. In our case this means the color of the first gemstone is equal to the color of the last one, the color of the second gemstone is equal to the color of the next to last and so on.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 500) — the number of gemstones.
The second line contains n space-separated integers, the i-th of which is ci (1 ≤ ci ≤ n) — the color of the i-th gemstone in a line.
Output
Print a single integer — the minimum number of seconds needed to destroy the entire line.
Examples
Input
3
1 2 1
Output
1
Input
3
1 2 3
Output
3
Input
7
1 4 4 2 3 2 1
Output
2
Note
In the first sample, Genos can destroy the entire line in one second.
In the second sample, Genos can only destroy one gemstone at a time, so destroying three gemstones takes three seconds.
In the third sample, to achieve the optimal time of two seconds, destroy palindrome 4 4 first and then destroy palindrome 1 2 3 2 1. | instruction | 0 | 70,265 | 0 | 140,530 |
Tags: dp
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
from array import array
def main():
n = int(input())
c = array('i',map(int,input().split()))
dp = [array('i',[0]*n) for _ in range(n)]
for i in range(n):
dp[i][i] = 1
for i in range(n-2,-1,-1):
for j in range(i+1,n):
dp[i][j] = min(dp[i][k]+dp[k+1][j] for k in range(i,j))
if c[i] == c[j]:
dp[i][j] = min(dp[i][j],int(j==i+1)+dp[i+1][j-1])
print(dp[0][n-1])
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self,file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
self.newlines = b.count(b"\n")+(not b)
ptr = self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd,self.buffer.getvalue())
self.buffer.truncate(0),self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self,file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s:self.buffer.write(s.encode("ascii"))
self.read = lambda:self.buffer.read().decode("ascii")
self.readline = lambda:self.buffer.readline().decode("ascii")
sys.stdin,sys.stdout = IOWrapper(sys.stdin),IOWrapper(sys.stdout)
input = lambda:sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 70,265 | 0 | 140,531 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Genos recently installed the game Zuma on his phone. In Zuma there exists a line of n gemstones, the i-th of which has color ci. The goal of the game is to destroy all the gemstones in the line as quickly as possible.
In one second, Genos is able to choose exactly one continuous substring of colored gemstones that is a palindrome and remove it from the line. After the substring is removed, the remaining gemstones shift to form a solid line again. What is the minimum number of seconds needed to destroy the entire line?
Let us remind, that the string (or substring) is called palindrome, if it reads same backwards or forward. In our case this means the color of the first gemstone is equal to the color of the last one, the color of the second gemstone is equal to the color of the next to last and so on.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 500) — the number of gemstones.
The second line contains n space-separated integers, the i-th of which is ci (1 ≤ ci ≤ n) — the color of the i-th gemstone in a line.
Output
Print a single integer — the minimum number of seconds needed to destroy the entire line.
Examples
Input
3
1 2 1
Output
1
Input
3
1 2 3
Output
3
Input
7
1 4 4 2 3 2 1
Output
2
Note
In the first sample, Genos can destroy the entire line in one second.
In the second sample, Genos can only destroy one gemstone at a time, so destroying three gemstones takes three seconds.
In the third sample, to achieve the optimal time of two seconds, destroy palindrome 4 4 first and then destroy palindrome 1 2 3 2 1. | instruction | 0 | 70,266 | 0 | 140,532 |
Tags: dp
Correct Solution:
```
from math import inf
n=int(input())
s=[int(X) for X in input().split()]
dp=[[inf for i in range(n)] for j in range(n)]
isdp=[[0 for i in range(n)] for j in range(n)]
for i in range(n):
isdp[i][i]=1
for i in range(1,n):
for j in range(n):
if i+j>=n:
break
if s[j]==s[i+j]:
isdp[j][j+i]=isdp[j+1][j+i-1]
for i in range(n):
dp[i][i]=1
for i in range(n-1,-1,-1):
for j in range(1,n):
# print(i,j)
if i+j>=n:
break
if isdp[i][j+i]:
dp[i][i+j]=1
continue
for p in range(i,i+j):
dp[i][i+j]=min(dp[i][i+j],dp[p+1][i+j]+dp[i][p])
if s[i]==s[i+j]:
if j==1:
dp[i][j+i]=1
else:
dp[i][i+j]=min(dp[i+1][j+i-1],dp[i][j+i])
print(dp[0][n-1])
#print(*dp,sep='\n')
``` | output | 1 | 70,266 | 0 | 140,533 |
Provide tags and a correct Python 2 solution for this coding contest problem.
Genos recently installed the game Zuma on his phone. In Zuma there exists a line of n gemstones, the i-th of which has color ci. The goal of the game is to destroy all the gemstones in the line as quickly as possible.
In one second, Genos is able to choose exactly one continuous substring of colored gemstones that is a palindrome and remove it from the line. After the substring is removed, the remaining gemstones shift to form a solid line again. What is the minimum number of seconds needed to destroy the entire line?
Let us remind, that the string (or substring) is called palindrome, if it reads same backwards or forward. In our case this means the color of the first gemstone is equal to the color of the last one, the color of the second gemstone is equal to the color of the next to last and so on.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 500) — the number of gemstones.
The second line contains n space-separated integers, the i-th of which is ci (1 ≤ ci ≤ n) — the color of the i-th gemstone in a line.
Output
Print a single integer — the minimum number of seconds needed to destroy the entire line.
Examples
Input
3
1 2 1
Output
1
Input
3
1 2 3
Output
3
Input
7
1 4 4 2 3 2 1
Output
2
Note
In the first sample, Genos can destroy the entire line in one second.
In the second sample, Genos can only destroy one gemstone at a time, so destroying three gemstones takes three seconds.
In the third sample, to achieve the optimal time of two seconds, destroy palindrome 4 4 first and then destroy palindrome 1 2 3 2 1. | instruction | 0 | 70,267 | 0 | 140,534 |
Tags: dp
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
# main code
n=in_num()
l=in_arr()
dp=[[1 for i in range(n)] for j in range(n)]
for ln in range(1,n):
for i in range(n-ln):
dp[i][i+ln]=min(dp[i][j]+dp[j+1][i+ln] for j in range(i,i+ln))
if l[i]==l[i+ln]:
dp[i][i+ln]=min(dp[i][i+ln],dp[i+1][i+ln-1])
pr_num(dp[0][-1])
``` | output | 1 | 70,267 | 0 | 140,535 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Each character in S is either a digit (`0`, ..., `9`) or `?`.
Among the integers obtained by replacing each occurrence of `?` with a digit, how many have a remainder of 5 when divided by 13? An integer may begin with 0.
Since the answer can be enormous, print the count modulo 10^9+7.
Constraints
* S is a string consisting of digits (`0`, ..., `9`) and `?`.
* 1 \leq |S| \leq 10^5
Input
Input is given from Standard Input in the following format:
S
Output
Print the number of integers satisfying the condition, modulo 10^9+7.
Examples
Input
??2??5
Output
768
Input
?44
Output
1
Input
7?4
Output
0
Input
?6?42???8??2??06243????9??3???7258??5??7???????774????4?1??17???9?5?70???76???
Output
153716888 | instruction | 0 | 70,546 | 0 | 141,092 |
"Correct Solution:
```
s = input()
mod = 10**9 + 7
n = len(s)
dp = [[0] * 13 for i in range(n+1)]
dp[0][0] = 1
for i in range(n):
ss = s[i]
for j in range(13):
if ss == '?':
for k in range(10):
dp[i+1][(j*10+k)%13] += dp[i][j]
else:
dp[i+1][(j*10+int(ss))%13] += dp[i][j]
dp[i+1][j] %= mod
print(dp[n][5]%mod)
``` | output | 1 | 70,546 | 0 | 141,093 |
Provide a correct Python 3 solution for this coding contest problem.
Welcome to CODE FESTIVAL 2016! In order to celebrate this contest, find a string s that satisfies the following conditions:
* The length of s is between 1 and 5000, inclusive.
* s consists of uppercase letters.
* s contains exactly K occurrences of the string "FESTIVAL" as a subsequence. In other words, there are exactly K tuples of integers (i_0, i_1, ..., i_7) such that 0 ≤ i_0 < i_1 < ... < i_7 ≤ |s|-1 and s[i_0]='F', s[i_1]='E', ..., s[i_7]='L'.
It can be proved that under the given constraints, the solution always exists. In case there are multiple possible solutions, you can output any.
Constraints
* 1 ≤ K ≤ 10^{18}
Input
The input is given from Standard Input in the following format:
K
Output
Print a string that satisfies the conditions.
Examples
Input
7
Output
FESSSSSSSTIVAL
Input
256
Output
FFEESSTTIIVVAALL | instruction | 0 | 70,635 | 0 | 141,270 |
"Correct Solution:
```
import math
import sys
input = sys.stdin.readline
k = int(input())
n = 512
pattern = 0
a = []
for i in range(n):
val = math.factorial(7 + i) // math.factorial(i) // math.factorial(7)
a.append(val)
a.reverse()
cnt = 600 * 7
ans = ["FESTIVA" for _ in range(n)]
for i, item in enumerate(a):
ans[i] += ("L" * (k // item))
k %= item
ans.reverse()
print("".join([str(item) for item in ans]))
``` | output | 1 | 70,635 | 0 | 141,271 |
Provide a correct Python 3 solution for this coding contest problem.
Consider a string with rings on both ends. Rings have positive integers to distinguish them. Rings on both ends of the string have different numbers a and b. Describe this as [a, b]. If there are multiple strings and the number attached to the ring of one string and the other string is the same, these strings can be connected at that ring, and the one made by connecting is called a chain. For example, the strings [1, 3] and [3, 4] form the chain [1, 3, 4]. The string and the chain or the chains are also connected at the ring with the same integer. Suppose you can.
For example, a chain [1, 3, 4] and a string [5, 1] can form [5, 1, 3, 4], and a chain [1, 3, 4] and a chain [2, 3, 5] can form [5, 1, 3, 4]. The chain [1, 3, 4] and the chain [4, 6, 1] form a ring.
There are various shapes like this, but in some of them, rings with the same number follow only once. Multiple connected strings are called chains. For example, chains [1, 3, 4] The centrally crossed shape of the chains [2, 3, 5] also includes the chains [1, 3, 5], [2, 3, 4], and the chains [1, 3, 4]. And chains [4, 6, 1] loops include chains such as [1, 3, 4, 6], [3, 4, 6, 1], [4, 6, 1, 3]. ..
For these chains, the number contained is defined as the length. For a given number of strings, anything that can be connected can form a shape that contains one or more chains. Create a program to find the length of the chain.
The first line of the input data contains the number of strings, the positive integer 1 ≤ n ≤ 100, and each of the following n lines contains two integers a, b separated by blanks 1 ≤ a <b ≤ 100. The two integers in each line represent the integers at both ends of one string.
Input example 1 | Input example 2 | Input example 3
--- | --- | ---
|
7 | 6 | 7
1 3 | 1 2 | 1 3
3 4 | 2 3 | 2 4
1 4 | 3 4 | 3 5
2 7 | 4 5 | 4 6
5 7 | 1 5 | 6 7
6 7 | 2 6 | 2 6
1 7 | | 4 7
Output example 1 | Output example 2 | Output example 3
5 | 6 | 4
input
The input consists of multiple datasets. Input ends when n is 0. The number of datasets does not exceed 10.
output
For each dataset, the maximum chain length is output on one line.
Example
Input
7
1 3
3 4
1 4
2 7
5 7
6 7
1 7
6
1 2
2 3
3 4
4 5
1 5
2 6
7
1 3
2 4
3 5
4 6
6 7
2 6
4 7
0
Output
5
6
4 | instruction | 0 | 70,672 | 0 | 141,344 |
"Correct Solution:
```
def solve():
def dfs(ring, chain_len=1):
unchecked[ring] = False
unvisited[ring] = False
len_rec[ring] = max(len_rec[ring], chain_len)
for r in adj_list[ring]:
if unvisited[r]:
dfs(r, chain_len + 1)
unvisited[ring] = True
import sys
file_input = sys.stdin
while True:
n = int(file_input.readline())
if n == 0:
break
rings = []
adj_list = [[] for _ in range(101)]
for _ in range(n):
a, b = map(int, file_input.readline().split())
adj_list[a].append(b)
adj_list[b].append(a)
rings.extend([a, b])
rings = set(rings)
len_rec = [1] * 101
unchecked = [True] * 101
unvisited = [True] * 101
for r in rings:
if unchecked[r]:
dfs(r)
dfs(len_rec.index(max(len_rec)))
print(max(len_rec))
solve()
``` | output | 1 | 70,672 | 0 | 141,345 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a string with rings on both ends. Rings have positive integers to distinguish them. Rings on both ends of the string have different numbers a and b. Describe this as [a, b]. If there are multiple strings and the number attached to the ring of one string and the other string is the same, these strings can be connected at that ring, and the one made by connecting is called a chain. For example, the strings [1, 3] and [3, 4] form the chain [1, 3, 4]. The string and the chain or the chains are also connected at the ring with the same integer. Suppose you can.
For example, a chain [1, 3, 4] and a string [5, 1] can form [5, 1, 3, 4], and a chain [1, 3, 4] and a chain [2, 3, 5] can form [5, 1, 3, 4]. The chain [1, 3, 4] and the chain [4, 6, 1] form a ring.
There are various shapes like this, but in some of them, rings with the same number follow only once. Multiple connected strings are called chains. For example, chains [1, 3, 4] The centrally crossed shape of the chains [2, 3, 5] also includes the chains [1, 3, 5], [2, 3, 4], and the chains [1, 3, 4]. And chains [4, 6, 1] loops include chains such as [1, 3, 4, 6], [3, 4, 6, 1], [4, 6, 1, 3]. ..
For these chains, the number contained is defined as the length. For a given number of strings, anything that can be connected can form a shape that contains one or more chains. Create a program to find the length of the chain.
The first line of the input data contains the number of strings, the positive integer 1 ≤ n ≤ 100, and each of the following n lines contains two integers a, b separated by blanks 1 ≤ a <b ≤ 100. The two integers in each line represent the integers at both ends of one string.
Input example 1 | Input example 2 | Input example 3
--- | --- | ---
|
7 | 6 | 7
1 3 | 1 2 | 1 3
3 4 | 2 3 | 2 4
1 4 | 3 4 | 3 5
2 7 | 4 5 | 4 6
5 7 | 1 5 | 6 7
6 7 | 2 6 | 2 6
1 7 | | 4 7
Output example 1 | Output example 2 | Output example 3
5 | 6 | 4
input
The input consists of multiple datasets. Input ends when n is 0. The number of datasets does not exceed 10.
output
For each dataset, the maximum chain length is output on one line.
Example
Input
7
1 3
3 4
1 4
2 7
5 7
6 7
1 7
6
1 2
2 3
3 4
4 5
1 5
2 6
7
1 3
2 4
3 5
4 6
6 7
2 6
4 7
0
Output
5
6
4
Submitted Solution:
```
from queue import deque
def longest(i):
visited = (i,)
q = deque((r, visited) for r in links[i])
while q:
ring, visited = q.popleft()
for r in links[ring]:
if r not in visited:
q.append((r, visited + (ring,)))
return len(visited) + 1
while True:
n = int(input())
if not n:
break
links = [set() for _ in range(n)]
for _ in range(n):
s, t = map(int, input().split())
s, t = s - 1, t - 1
links[s].add(t)
links[t].add(s)
print(max(longest(i) for i in range(n)))
``` | instruction | 0 | 70,673 | 0 | 141,346 |
No | output | 1 | 70,673 | 0 | 141,347 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a string with rings on both ends. Rings have positive integers to distinguish them. Rings on both ends of the string have different numbers a and b. Describe this as [a, b]. If there are multiple strings and the number attached to the ring of one string and the other string is the same, these strings can be connected at that ring, and the one made by connecting is called a chain. For example, the strings [1, 3] and [3, 4] form the chain [1, 3, 4]. The string and the chain or the chains are also connected at the ring with the same integer. Suppose you can.
For example, a chain [1, 3, 4] and a string [5, 1] can form [5, 1, 3, 4], and a chain [1, 3, 4] and a chain [2, 3, 5] can form [5, 1, 3, 4]. The chain [1, 3, 4] and the chain [4, 6, 1] form a ring.
There are various shapes like this, but in some of them, rings with the same number follow only once. Multiple connected strings are called chains. For example, chains [1, 3, 4] The centrally crossed shape of the chains [2, 3, 5] also includes the chains [1, 3, 5], [2, 3, 4], and the chains [1, 3, 4]. And chains [4, 6, 1] loops include chains such as [1, 3, 4, 6], [3, 4, 6, 1], [4, 6, 1, 3]. ..
For these chains, the number contained is defined as the length. For a given number of strings, anything that can be connected can form a shape that contains one or more chains. Create a program to find the length of the chain.
The first line of the input data contains the number of strings, the positive integer 1 ≤ n ≤ 100, and each of the following n lines contains two integers a, b separated by blanks 1 ≤ a <b ≤ 100. The two integers in each line represent the integers at both ends of one string.
Input example 1 | Input example 2 | Input example 3
--- | --- | ---
|
7 | 6 | 7
1 3 | 1 2 | 1 3
3 4 | 2 3 | 2 4
1 4 | 3 4 | 3 5
2 7 | 4 5 | 4 6
5 7 | 1 5 | 6 7
6 7 | 2 6 | 2 6
1 7 | | 4 7
Output example 1 | Output example 2 | Output example 3
5 | 6 | 4
input
The input consists of multiple datasets. Input ends when n is 0. The number of datasets does not exceed 10.
output
For each dataset, the maximum chain length is output on one line.
Example
Input
7
1 3
3 4
1 4
2 7
5 7
6 7
1 7
6
1 2
2 3
3 4
4 5
1 5
2 6
7
1 3
2 4
3 5
4 6
6 7
2 6
4 7
0
Output
5
6
4
Submitted Solution:
```
from collections import defaultdict
class GraphChain():
def __init__(self):
self.graph = defaultdict(set)
self.passed = defaultdict(bool)
self.route = defaultdict(bool)
self.ans = 0
def dfs(self, left, count):
'''
depth first search
'''
for i in range(len(self.graph[left])):
if self.passed[self.graph[left][i]] == False:
# mark passed point
self.passed[self.graph[left][i]] = True
# if next route is more than two, this node is never become start point.
if len(self.graph[left]) > 2:
self.route[self.graph[left][i]] = True
temp = self.dfs(self.graph[left][i], count + 1)
self.ans = max(self.ans, temp)
# delete mark of point.
self.passed[self.graph[left][i]] = False
return count
def get_string_pair(self, num):
'''
get string and make dictionary.
'''
self.graph = defaultdict(list)
for i in range(num):
left, righ = [int(j) for j in input().strip().split()]
self.graph[left].append(righ)
self.graph[righ].append(left)
return self.graph
def count_chain(self, num):
'''
main function of this problem.
'''
self.get_string_pair(num)
for key in sorted(self.graph.keys()):
if self.route[key] == False:
self.dfs(key, 0)
return self.ans
while 1:
gc = GraphChain()
x = int(input())
if x == 0:
break
print(gc.count_chain(x))
``` | instruction | 0 | 70,674 | 0 | 141,348 |
No | output | 1 | 70,674 | 0 | 141,349 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a string with rings on both ends. Rings have positive integers to distinguish them. Rings on both ends of the string have different numbers a and b. Describe this as [a, b]. If there are multiple strings and the number attached to the ring of one string and the other string is the same, these strings can be connected at that ring, and the one made by connecting is called a chain. For example, the strings [1, 3] and [3, 4] form the chain [1, 3, 4]. The string and the chain or the chains are also connected at the ring with the same integer. Suppose you can.
For example, a chain [1, 3, 4] and a string [5, 1] can form [5, 1, 3, 4], and a chain [1, 3, 4] and a chain [2, 3, 5] can form [5, 1, 3, 4]. The chain [1, 3, 4] and the chain [4, 6, 1] form a ring.
There are various shapes like this, but in some of them, rings with the same number follow only once. Multiple connected strings are called chains. For example, chains [1, 3, 4] The centrally crossed shape of the chains [2, 3, 5] also includes the chains [1, 3, 5], [2, 3, 4], and the chains [1, 3, 4]. And chains [4, 6, 1] loops include chains such as [1, 3, 4, 6], [3, 4, 6, 1], [4, 6, 1, 3]. ..
For these chains, the number contained is defined as the length. For a given number of strings, anything that can be connected can form a shape that contains one or more chains. Create a program to find the length of the chain.
The first line of the input data contains the number of strings, the positive integer 1 ≤ n ≤ 100, and each of the following n lines contains two integers a, b separated by blanks 1 ≤ a <b ≤ 100. The two integers in each line represent the integers at both ends of one string.
Input example 1 | Input example 2 | Input example 3
--- | --- | ---
|
7 | 6 | 7
1 3 | 1 2 | 1 3
3 4 | 2 3 | 2 4
1 4 | 3 4 | 3 5
2 7 | 4 5 | 4 6
5 7 | 1 5 | 6 7
6 7 | 2 6 | 2 6
1 7 | | 4 7
Output example 1 | Output example 2 | Output example 3
5 | 6 | 4
input
The input consists of multiple datasets. Input ends when n is 0. The number of datasets does not exceed 10.
output
For each dataset, the maximum chain length is output on one line.
Example
Input
7
1 3
3 4
1 4
2 7
5 7
6 7
1 7
6
1 2
2 3
3 4
4 5
1 5
2 6
7
1 3
2 4
3 5
4 6
6 7
2 6
4 7
0
Output
5
6
4
Submitted Solution:
```
def solve():
def dfs(start):
unvisited = [True] * (n + 1)
queue = [(start, 1)]
max_chain_len = 1
while queue:
ring, chain_len = queue.pop()
if unvisited[ring]:
unvisited[ring] = False
max_chain_len = max(max_chain_len, chain_len)
for r in adj_list[ring]:
if unvisited[r]:
queue.append((r, chain_len + 1))
return max_chain_len
import sys
file_input = sys.stdin
while True:
n = int(file_input.readline())
if n == 0:
break
adj_list = [[] for _ in range(n + 1)]
for _ in range(n):
a, b = map(int, file_input.readline().split())
adj_list[a].append(b)
adj_list[b].append(a)
max_len = 0
for s in range(1, n + 1):
max_len = max(max_len, dfs(s))
print(max_len)
solve()
``` | instruction | 0 | 70,675 | 0 | 141,350 |
No | output | 1 | 70,675 | 0 | 141,351 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a string with rings on both ends. Rings have positive integers to distinguish them. Rings on both ends of the string have different numbers a and b. Describe this as [a, b]. If there are multiple strings and the number attached to the ring of one string and the other string is the same, these strings can be connected at that ring, and the one made by connecting is called a chain. For example, the strings [1, 3] and [3, 4] form the chain [1, 3, 4]. The string and the chain or the chains are also connected at the ring with the same integer. Suppose you can.
For example, a chain [1, 3, 4] and a string [5, 1] can form [5, 1, 3, 4], and a chain [1, 3, 4] and a chain [2, 3, 5] can form [5, 1, 3, 4]. The chain [1, 3, 4] and the chain [4, 6, 1] form a ring.
There are various shapes like this, but in some of them, rings with the same number follow only once. Multiple connected strings are called chains. For example, chains [1, 3, 4] The centrally crossed shape of the chains [2, 3, 5] also includes the chains [1, 3, 5], [2, 3, 4], and the chains [1, 3, 4]. And chains [4, 6, 1] loops include chains such as [1, 3, 4, 6], [3, 4, 6, 1], [4, 6, 1, 3]. ..
For these chains, the number contained is defined as the length. For a given number of strings, anything that can be connected can form a shape that contains one or more chains. Create a program to find the length of the chain.
The first line of the input data contains the number of strings, the positive integer 1 ≤ n ≤ 100, and each of the following n lines contains two integers a, b separated by blanks 1 ≤ a <b ≤ 100. The two integers in each line represent the integers at both ends of one string.
Input example 1 | Input example 2 | Input example 3
--- | --- | ---
|
7 | 6 | 7
1 3 | 1 2 | 1 3
3 4 | 2 3 | 2 4
1 4 | 3 4 | 3 5
2 7 | 4 5 | 4 6
5 7 | 1 5 | 6 7
6 7 | 2 6 | 2 6
1 7 | | 4 7
Output example 1 | Output example 2 | Output example 3
5 | 6 | 4
input
The input consists of multiple datasets. Input ends when n is 0. The number of datasets does not exceed 10.
output
For each dataset, the maximum chain length is output on one line.
Example
Input
7
1 3
3 4
1 4
2 7
5 7
6 7
1 7
6
1 2
2 3
3 4
4 5
1 5
2 6
7
1 3
2 4
3 5
4 6
6 7
2 6
4 7
0
Output
5
6
4
Submitted Solution:
```
from collections import defaultdict
class GraphChain():
def __init__(self):
self.graph = defaultdict(set)
self.passed = defaultdict(bool)
self.route = defaultdict(bool)
self.ans = 0
def dfs(self, left, count):
'''
depth first search
'''
for point in self.graph[left]:
if self.passed[point] == False:
# mark passed point
self.passed[point] = True
# if next route is more than two, this node is never become start point.
if len(self.graph[left]) > 2:
self.route[point] = True
temp = self.dfs(point, count + 1)
self.ans = self.ans if self.ans > temp else temp
# delete mark of point.
self.passed[point] = False
return count
def get_string_pair(self, num):
'''
get string and make dictionary.
'''
self.graph = defaultdict(set)
for i in range(num):
left, righ = (int(j) for j in input().strip().split())
self.graph[left].add(righ)
self.graph[righ].add(left)
return self.graph
def count_chain(self, num):
'''
main function of this problem.
'''
self.get_string_pair(num)
for key in sorted(self.graph.keys()):
if self.route[key] == False:
self.dfs(key, 1)
return self.ans - 1
while 1:
gc = GraphChain()
x = int(input())
if x == 0:
break
print(gc.count_chain(x))
del gc
``` | instruction | 0 | 70,676 | 0 | 141,352 |
No | output | 1 | 70,676 | 0 | 141,353 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA | instruction | 0 | 71,009 | 0 | 142,018 |
Tags: greedy, strings
Correct Solution:
```
si = input()
ans = ""
while 1:
co = si.count(max(si))
ans = ans + max(si)*co
#print("ans " ,ans)
new = (si[::-1].index(max(si)))
#print("new ",new)
si = si[len(si)-new:]
#print(si)
if len(si)==0:
#print("lets break")
break
print(ans)
``` | output | 1 | 71,009 | 0 | 142,019 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA | instruction | 0 | 71,010 | 0 | 142,020 |
Tags: greedy, strings
Correct Solution:
```
s = input()
n=len(s)
ans = s[-1]
for i in range(n - 2, -1, -1):
if s[i] >= ans[-1]:
ans += s[i]
print(ans[::-1])
``` | output | 1 | 71,010 | 0 | 142,021 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA | instruction | 0 | 71,011 | 0 | 142,022 |
Tags: greedy, strings
Correct Solution:
```
s,l=input(),['']
for i in reversed(s):
if l[-1]<=i: l.append(i)
print(*reversed(l),sep='')
``` | output | 1 | 71,011 | 0 | 142,023 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA | instruction | 0 | 71,012 | 0 | 142,024 |
Tags: greedy, strings
Correct Solution:
```
s=list(input())
a=sorted(set(s))[::-1]
print(a[0]*(s.count(a[0])),end='')
index=len(s)-s[::-1].index(a[0])-1
for i in range(1,len(a)):
if a[i] in s[index:]:
print(a[i]*(s[index:].count(a[i])),end='')
index=len(s)-s[::-1].index(a[i])-1
``` | output | 1 | 71,012 | 0 | 142,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA | instruction | 0 | 71,013 | 0 | 142,026 |
Tags: greedy, strings
Correct Solution:
```
'''n = int(input())
a = [int(k) for k in input().split()]
step1 = min(a)
step2 = 10000
for i in range(0,n,2):
if a[i] < step2:
step2 = a[i]
print(max(step1, step2))'''
s = input()
maxx = 'a'
a = ''
for i in range(len(s) - 1, -1, -1):
if s[i] >= maxx:
a += s[i]
maxx = s[i]
print(a[::-1])
``` | output | 1 | 71,013 | 0 | 142,027 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA | instruction | 0 | 71,014 | 0 | 142,028 |
Tags: greedy, strings
Correct Solution:
```
from sys import stdin,stdout
nmbr = lambda: int(stdin.readline())
lst = lambda: list(map(int,stdin.readline().split()))
for _ in range(1):#nmbr():
s=input()
n=len(s)
dp=['a']*n
dp[-1]=s[-1]
for i in range(n-2,-1,-1):
dp[i]=max(dp[i+1],s[i])
ans=[]
for i in range(n):
if s[i]==dp[i]:
ans+=[s[i]]
print(''.join(ans))
``` | output | 1 | 71,014 | 0 | 142,029 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA | instruction | 0 | 71,015 | 0 | 142,030 |
Tags: greedy, strings
Correct Solution:
```
from collections import Counter
s = input()
c = Counter(s)
cur_char = 'z'
for ch in s:
while c[cur_char] == 0:
cur_char = chr(ord(cur_char) - 1)
if ch == cur_char:
print(cur_char, end='')
c[ch] -= 1
``` | output | 1 | 71,015 | 0 | 142,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA | instruction | 0 | 71,016 | 0 | 142,032 |
Tags: greedy, strings
Correct Solution:
```
def main():
a, res = ' ', []
for b in reversed(input()):
if a <= b:
a = b
res.append(a)
print(''.join(reversed(res)))
if __name__ == '__main__':
main()
``` | output | 1 | 71,016 | 0 | 142,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA
Submitted Solution:
```
import string
s = input().strip()
last = {}
alpha = string.ascii_lowercase
for ch in alpha:
last[ch] = -1
for i, ch in enumerate(s):
last[ch] = i
best, current = [], 'z'
for i, ch in enumerate(s):
while last[current] < i:
current = alpha[alpha.index(current)-1]
if ch == current:
best.append(ch)
print(''.join(best))
``` | instruction | 0 | 71,017 | 0 | 142,034 |
Yes | output | 1 | 71,017 | 0 | 142,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA
Submitted Solution:
```
import bisect
import decimal
from decimal import Decimal
import os
from collections import Counter
import bisect
from collections import defaultdict
import math
import random
import heapq
from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations
from io import BytesIO, IOBase
from itertools import accumulate
# sys.setrecursionlimit(200000)
# mod = 10**9+7
# mod = 998244353
decimal.getcontext().prec = 46
def primeFactors(n):
prime = set()
while n % 2 == 0:
prime.add(2)
n = n//2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
prime.add(i)
n = n//i
if n > 2:
prime.add(n)
return list(prime)
def getFactors(n) :
factors = []
i = 1
while i <= math.sqrt(n):
if (n % i == 0) :
if (n // i == i) :
factors.append(i)
else :
factors.append(i)
factors.append(n//i)
i = i + 1
return factors
def SieveOfEratosthenes(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
num = []
for p in range(2, n+1):
if prime[p]:
num.append(p)
return num
def lcm(a,b):
return (a*b)//math.gcd(a,b)
def sort_dict(key_value):
return sorted(key_value.items(), key = lambda kv:(kv[1], kv[0]))
def list_input():
return list(map(int,input().split()))
def num_input():
return map(int,input().split())
def string_list():
return list(input())
def decimalToBinary(n):
return bin(n).replace("0b", "")
def binaryToDecimal(n):
return int(n,2)
def solve():
s = input()
occur = {}
for i in range(len(s)):
try:
occur[s[i]].append(i)
except KeyError:
occur[s[i]] = [i]
alpha = list(occur.keys())
alpha.sort(reverse=True)
ans = alpha[0]*len(occur[alpha[0]])
temp = occur[alpha[0]][-1]
for i in range(1,len(alpha)):
indx = bisect.bisect_right(occur[alpha[i]],temp)
if indx < len(occur[alpha[i]]):
ans += alpha[i]*(len(occur[alpha[i]])-indx)
temp = occur[alpha[i]][-1]
print(ans)
#t = int(input())
t = 1
for _ in range(t):
solve()
``` | instruction | 0 | 71,018 | 0 | 142,036 |
Yes | output | 1 | 71,018 | 0 | 142,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA
Submitted Solution:
```
s = list(input())
answer = []
i = len(s)-1
last = s[-1]
while i >= 0:
if s[i] >= last:
answer.append(s[i])
last = s[i]
i -= 1
print("".join(answer[::-1]))
``` | instruction | 0 | 71,019 | 0 | 142,038 |
Yes | output | 1 | 71,019 | 0 | 142,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA
Submitted Solution:
```
s = input()
l = len(s)
m = 'a'
ans = ""
for i in range(l):
if s[l-i-1] >= m:
ans = s[l-i-1] + ans
m = s[l-i-1]
print(ans)
# Made By Mostafa_Khaled
``` | instruction | 0 | 71,020 | 0 | 142,040 |
Yes | output | 1 | 71,020 | 0 | 142,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA
Submitted Solution:
```
from collections import deque
a = input()
n=len(a)
r=deque()
for i in a:
if len(r)<1 or i>=r[0]:
r.appendleft(i)
print("".join(r))
``` | instruction | 0 | 71,021 | 0 | 142,042 |
No | output | 1 | 71,021 | 0 | 142,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA
Submitted Solution:
```
string = str(input())
listx = [x for x in string]
listx.reverse()
join = [''.join(listx)]
letts = list(set(listx))
letts.sort()
letts.reverse()
stringx = ''
for i in letts:
if i in string:
leng = len(string)
indx = string.index(i)
for j in range(leng - indx):
if string[j] == i:
stringx += i
string = string[-indx:]
print(stringx)
``` | instruction | 0 | 71,022 | 0 | 142,044 |
No | output | 1 | 71,022 | 0 | 142,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA
Submitted Solution:
```
s=list(input())
a=sorted(set(s))[::-1]
print(a[0]*(s.count(a[0])),end='')
for i in range(1,len(a)):
print(a[i]*(s[len(s)-s[::-1].index(a[i-1])-1:].count(a[i])),end='')
# print(s[::-1].index(a[0]))
``` | instruction | 0 | 71,023 | 0 | 142,046 |
No | output | 1 | 71,023 | 0 | 142,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA
Submitted Solution:
```
s = input()
dp = []
for i in range(len(s)):
dp.append(['',0])
s = s[::-1]
p = ''
dp[0][0] = s[0]
dp[0][1] = 0
for i in range(1,len(s)):
if s[i] >= dp[i - 1][0]:
dp[i][0] = s[i]
dp[i][1] = i - 1
else:
dp[i][0] = dp[i - 1][0]
dp[i][1] = dp[i - 1][1]
k = len(s) - 1
while k != 0:
p+=dp[k][0]
k = dp[k][1]
print(p + dp[0][0])
``` | instruction | 0 | 71,024 | 0 | 142,048 |
No | output | 1 | 71,024 | 0 | 142,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "". | instruction | 0 | 71,201 | 0 | 142,402 |
Tags: implementation, strings
Correct Solution:
```
s = input()
a = []
b = []
last_word = []
temp = 0
digits = "0123456789"
for letter in s:
if letter == ";" or letter == ",":
for leter in last_word:
if digits.find(leter) == -1:
temp = 1
break
if temp == 0 and len(last_word) != 0:
if last_word[0] != "0" or len(last_word) == 1:
a += ("".join(last_word)).split()
else:
b += ("".join(last_word)).split()
elif len(last_word) == 0:
temp = 0
b += [""]
else:
temp = 0
b += ("".join(last_word)).split()
last_word = []
else:
last_word += letter
for leter in last_word:
if digits.find(leter) == -1:
temp = 1
break
if temp == 0 and len(last_word) != 0:
if last_word[0] != "0" or len(last_word) == 1:
a += ("".join(last_word)).split()
else:
b += ("".join(last_word)).split()
elif len(last_word) == 0:
temp = 0
b += [""]
else:
temp = 0
b += ("".join(last_word)).split()
if len(a) == 0:
print("-")
else:
print('"',end="")
print(",".join(a),end="")
print('"')
if len(b) == 0:
print("-")
else:
print('"',end="")
print(",".join(b),end="")
print('"')
``` | output | 1 | 71,201 | 0 | 142,403 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "". | instruction | 0 | 71,202 | 0 | 142,404 |
Tags: implementation, strings
Correct Solution:
```
import re
def is_int(s: str) -> bool:
if len(s) > 0 and (s[0] == "0" and len(s) > 1):
return False
else:
try:
int(s)
return True
except:
return False
def partition(pred, iterable):
trues = []
falses = []
for item in iterable:
if pred(item):
trues.append(item)
else:
falses.append(item)
return trues, falses
def print_ans(s):
if len(s) > 0:
print("\"{}\"".format(",".join(s)))
else:
print("-")
s = re.split(";|,", input())
s_int, s_str = partition(is_int, s)
print_ans(s_int)
print_ans(s_str)
``` | output | 1 | 71,202 | 0 | 142,405 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "". | instruction | 0 | 71,203 | 0 | 142,406 |
Tags: implementation, strings
Correct Solution:
```
data = input().strip().replace(',', ';').split(';')
l1 = [word for word in data if word.isdigit() and word == str(int(word))]
sl1 = set(l1)
l2 = [word for word in data if word not in sl1]
print('"'+ ','.join(l1) + '"' if len(l1) > 0 else '-')
print('"'+ ','.join(l2) + '"' if len(l2) > 0 else '-')
``` | output | 1 | 71,203 | 0 | 142,407 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "". | instruction | 0 | 71,204 | 0 | 142,408 |
Tags: implementation, strings
Correct Solution:
```
import re
s = re.split(',|;', input())
a = []
b = []
for item in s:
if item.isdigit() and (item[0]!='0' or len(item)==1):
a.append(item)
else:
b.append(item)
if a:
print("\"", ",".join(a), "\"", sep="")
else:
print("-")
if b:
print("\"", ",".join(b), "\"", sep="")
else:
print("-")
``` | output | 1 | 71,204 | 0 | 142,409 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "". | instruction | 0 | 71,205 | 0 | 142,410 |
Tags: implementation, strings
Correct Solution:
```
#!/usr/bin/python
import itertools
s = input().split(',')
for i in range(len(s)):
s[i] = s[i].split(';')
s = itertools.chain(*s)
s = list(s)
a = []
b = []
for i in range(len(s)):
if s[i] == '0':
a.append(s[i])
elif s[i].isdigit() and s[i][0] != '0':
a.append(s[i])
else:
b.append(s[i])
if len(a) != 0:
print('"' + ','.join(a) + '"')
else:
print("-")
if len(b) != 0:
print('"' + ','.join(b) + '"')
else:
print("-")
``` | output | 1 | 71,205 | 0 | 142,411 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "". | instruction | 0 | 71,206 | 0 | 142,412 |
Tags: implementation, strings
Correct Solution:
```
import re
ss = re.split(";|,", input())
a = []
b = []
p = re.compile('^(-?([1-9]\d*)|0)$')
for s in ss:
if p.match(s):
a.append(s)
else:
b.append(s)
print('"' + ','.join(a) + '"' if len(a) else '-')
print('"' + ','.join(b) + '"' if len(b) else '-')
``` | output | 1 | 71,206 | 0 | 142,413 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "". | instruction | 0 | 71,207 | 0 | 142,414 |
Tags: implementation, strings
Correct Solution:
```
import re
s = input()
a = []
b = []
# print(re.split(';,', s))
for word in re.split(';|,', s):
try:
if str(int(word)) == word:
a.append(word)
else:
b.append(word)
except ValueError:
b.append(word)
if a:
print('"', end = '')
for e in a[:-1]:
print(e, end = ',')
print(a[-1], end = '')
print(end = '"\n')
else:
print("-")
if b:
print('"', end = '')
for e in b[:-1]:
print(e, end = ',')
print(b[-1], end = '')
print(end = '"\n')
else:
print("-")
``` | output | 1 | 71,207 | 0 | 142,415 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "". | instruction | 0 | 71,208 | 0 | 142,416 |
Tags: implementation, strings
Correct Solution:
```
s = input()
X = []
Y = []
for word in s.split(';'):
for num in word.split(','):
try:
if str(int(num)) == num:
X.append(num)
else:
Y.append(num)
except Exception:
Y.append(num)
if len(X) > 0:
print('"' + ",".join(X) + '"')
else:
print('-')
if len(Y) > 0:
print('"' + ",".join(Y) + '"')
else:
print('-')
``` | output | 1 | 71,208 | 0 | 142,417 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "".
Submitted Solution:
```
import sys
SEPARATORS = set([',', ';'])
def is_zero(word):
return len(word) == 1 and word[0] == '0'
def add_word(word, numbers, others, is_number):
if not is_zero(word) and (len(word) == 0 or not is_number):
others.append(word)
else:
numbers.append(word)
def solve(line):
numbers, others = [], []
word, is_number = [], True
for char in line:
if char in SEPARATORS:
add_word(word, numbers, others, is_number)
word, is_number = [], True
else:
if not char.isdigit() or (char == '0' and len(word) == 0):
is_number = False
word.append(char)
add_word(word, numbers, others, is_number)
return (numbers, others)
assert solve('aba,123;1a;0') == ([list('123'), list('0')], [list('aba'), list('1a')])
assert solve('1;;01,a0,') == ([['1']], [[], list('01'), list('a0'), []])
assert solve('1') == ([['1']], [])
assert solve('a') == ([], [['a']])
def format_result(result):
if len(result) == 0:
return '-'
return '"{}"'.format(','.join(map(lambda word: ''.join(word), result)))
numbers, others = map(format_result, solve(input().strip()))
print('{}\n{}'.format(numbers, others))
``` | instruction | 0 | 71,209 | 0 | 142,418 |
Yes | output | 1 | 71,209 | 0 | 142,419 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "".
Submitted Solution:
```
s=input()
q=[]
z=''
for i in s:
if i in [',',';']:
q.append(z)
z=''
else: z+=i
q.append(z)
a,b=[],[]
for i in q:
if len(i)>0 and ((i=='0') or (i[0]!='0' and i.isdigit())): a.append(i)
else: b.append(i)
if a!=[]: print('"'+','.join(a)+'"')
else: print('-')
if b!=[]: print('"'+','.join(b)+'"')
else: print('-')
``` | instruction | 0 | 71,210 | 0 | 142,420 |
Yes | output | 1 | 71,210 | 0 | 142,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "".
Submitted Solution:
```
import logging
import copy
import sys
logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
#def solve(firstLine):
def solve(inputLine):
aStr = []
bStr = []
for dummy in inputLine.split(","):
for word in dummy.split(";"):
try:
if word == str(int(word)):
aStr.append(word)
else:
bStr.append(word)
except:
bStr.append(word)
for lst in [aStr, bStr]:
if len(lst) == 0:
print('-')
else:
print("\"%s\"" % ",".join(lst))
log(aStr)
log(bStr)
return
def main():
firstLine = input()
#solve(firstLine)
solve(firstLine)
def log(*message):
logging.debug(message)
if __name__ == "__main__":
main()
``` | instruction | 0 | 71,211 | 0 | 142,422 |
Yes | output | 1 | 71,211 | 0 | 142,423 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "".
Submitted Solution:
```
#### IMPORTANT LIBRARY ####
############################
### DO NOT USE import random --> 250ms to load the library
############################
### In case of extra libraries: https://github.com/cheran-senthil/PyRival
######################
####### IMPORT #######
######################
from functools import cmp_to_key
from collections import deque, Counter
from heapq import heappush, heappop
from math import log, ceil
######################
#### STANDARD I/O ####
######################
import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def print(*args, **kwargs):
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
def inp():
return sys.stdin.readline().rstrip("\r\n") # for fast input
def ii():
return int(inp())
def si():
return str(inp())
def li(lag = 0):
l = list(map(int, inp().split()))
if lag != 0:
for i in range(len(l)):
l[i] += lag
return l
def mi(lag = 0):
matrix = list()
for i in range(n):
matrix.append(li(lag))
return matrix
def lsi(): #string list
return list(map(str, inp().split()))
def print_list(lista, space = " "):
print(space.join(map(str, lista)))
######################
### BISECT METHODS ###
######################
def bisect_left(a, x):
"""i tale che a[i] >= x e a[i-1] < x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] < x:
left = mid+1
else:
right = mid
return left
def bisect_right(a, x):
"""i tale che a[i] > x e a[i-1] <= x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] > x:
right = mid
else:
left = mid+1
return left
def bisect_elements(a, x):
"""elementi pari a x nell'árray sortato"""
return bisect_right(a, x) - bisect_left(a, x)
######################
### MOD OPERATION ####
######################
MOD = 10**9 + 7
maxN = 5
FACT = [0] * maxN
INV_FACT = [0] * maxN
def add(x, y):
return (x+y) % MOD
def multiply(x, y):
return (x*y) % MOD
def power(x, y):
if y == 0:
return 1
elif y % 2:
return multiply(x, power(x, y-1))
else:
a = power(x, y//2)
return multiply(a, a)
def inverse(x):
return power(x, MOD-2)
def divide(x, y):
return multiply(x, inverse(y))
def allFactorials():
FACT[0] = 1
for i in range(1, maxN):
FACT[i] = multiply(i, FACT[i-1])
def inverseFactorials():
n = len(INV_FACT)
INV_FACT[n-1] = inverse(FACT[n-1])
for i in range(n-2, -1, -1):
INV_FACT[i] = multiply(INV_FACT[i+1], i+1)
def coeffBinom(n, k):
if n < k:
return 0
return multiply(FACT[n], multiply(INV_FACT[k], INV_FACT[n-k]))
######################
#### GRAPH ALGOS #####
######################
# ZERO BASED GRAPH
def create_graph(n, m, undirected = 1, unweighted = 1):
graph = [[] for i in range(n)]
if unweighted:
for i in range(m):
[x, y] = li(lag = -1)
graph[x].append(y)
if undirected:
graph[y].append(x)
else:
for i in range(m):
[x, y, w] = li(lag = -1)
w += 1
graph[x].append([y,w])
if undirected:
graph[y].append([x,w])
return graph
def create_tree(n, unweighted = 1):
children = [[] for i in range(n)]
if unweighted:
for i in range(n-1):
[x, y] = li(lag = -1)
children[x].append(y)
children[y].append(x)
else:
for i in range(n-1):
[x, y, w] = li(lag = -1)
w += 1
children[x].append([y, w])
children[y].append([x, w])
return children
def dist(tree, n, A, B = -1):
s = [[A, 0]]
massimo, massimo_nodo = 0, 0
distanza = -1
v = [-1] * n
while s:
el, dis = s.pop()
if dis > massimo:
massimo = dis
massimo_nodo = el
if el == B:
distanza = dis
for child in tree[el]:
if v[child] == -1:
v[child] = 1
s.append([child, dis+1])
return massimo, massimo_nodo, distanza
def diameter(tree):
_, foglia, _ = dist(tree, n, 0)
diam, _, _ = dist(tree, n, foglia)
return diam
def dfs(graph, n, A):
v = [-1] * n
s = [[A, 0]]
v[A] = 0
while s:
el, dis = s.pop()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
def bfs(graph, n, A):
v = [-1] * n
s = deque()
s.append([A, 0])
v[A] = 0
while s:
el, dis = s.popleft()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
#FROM A GIVEN ROOT, RECOVER THE STRUCTURE
def parents_children_root_unrooted_tree(tree, n, root = 0):
q = deque()
visited = [0] * n
parent = [-1] * n
children = [[] for i in range(n)]
q.append(root)
while q:
all_done = 1
visited[q[0]] = 1
for child in tree[q[0]]:
if not visited[child]:
all_done = 0
q.appendleft(child)
if all_done:
for child in tree[q[0]]:
if parent[child] == -1:
parent[q[0]] = child
children[child].append(q[0])
q.popleft()
return parent, children
# CALCULATING LONGEST PATH FOR ALL THE NODES
def all_longest_path_passing_from_node(parent, children, n):
q = deque()
visited = [len(children[i]) for i in range(n)]
downwards = [[0,0] for i in range(n)]
upward = [1] * n
longest_path = [1] * n
for i in range(n):
if not visited[i]:
q.append(i)
downwards[i] = [1,0]
while q:
node = q.popleft()
if parent[node] != -1:
visited[parent[node]] -= 1
if not visited[parent[node]]:
q.append(parent[node])
else:
root = node
for child in children[node]:
downwards[node] = sorted([downwards[node][0], downwards[node][1], downwards[child][0] + 1], reverse = True)[0:2]
s = [node]
while s:
node = s.pop()
if parent[node] != -1:
if downwards[parent[node]][0] == downwards[node][0] + 1:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][1])
else:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][0])
longest_path[node] = downwards[node][0] + downwards[node][1] + upward[node] - min([downwards[node][0], downwards[node][1], upward[node]]) - 1
for child in children[node]:
s.append(child)
return longest_path
### TBD SUCCESSOR GRAPH 7.5
### TBD TREE QUERIES 10.2 da 2 a 4
### TBD ADVANCED TREE 10.3
### TBD GRAPHS AND MATRICES 11.3.3 e 11.4.3 e 11.5.3 (ON GAMES)
######################
## END OF LIBRARIES ##
######################
digits = [str(i) for i in range(10)]
sep = [",", ";"]
s = si()
i = 0
st = 0
flag = True
num = []
non = []
s = s.replace(";",",").split(",")
for el in s:
flag = True
if el == "0":
flag = True
elif el == "":
flag = False
else:
if el[0] == "0":
flag = False
for ch in el:
if ch not in digits:
flag = False
if flag == True:
num.append(el)
else:
non.append(el)
res1 = ",".join(num)
res2 = ",".join(non)
if num:
print('"'+res1+'"')
else:
print("-")
if non:
print('"'+res2+'"')
else:
print("-")
``` | instruction | 0 | 71,212 | 0 | 142,424 |
Yes | output | 1 | 71,212 | 0 | 142,425 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "".
Submitted Solution:
```
import sys
s = sys.stdin.readline()
#s = "asdf,as,12931,;asdfj;123.0,0234,01,0,asdf2,213a"
tokens = s.replace(",", ";").split(";")
s1, s2 = [], []
for tok in tokens:
if len(tok) == 0 or tok[0] == "0":
s2 += [tok]
continue
try:
i = int(tok)
s1 += [tok]
except:
s2 += [tok]
print(",".join(s1))
print(",".join(s2))
``` | instruction | 0 | 71,213 | 0 | 142,426 |
No | output | 1 | 71,213 | 0 | 142,427 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "".
Submitted Solution:
```
import sys
s = input()
a = ""
b = ""
cur = ""
first_a = True
first_b = True
def integer(str):
if str == "":
return False
if str == "0":
return True
if str.isdigit() and not str.startswith("0"):
return True
return False
def process(cur,a,b,first_a,first_b):
if integer(cur):
if not first_a:
a += ","
a += str(cur)
first_a = False
else:
if not first_b:
b += ","
b += str(cur)
first_b = False
return (a,b,first_a,first_b)
for c in s:
if (c == "," or c == ";"):
(a,b,first_a,first_b) = process(cur,a,b,first_a,first_b)
cur = ""
else:
cur += str(c)
(a,b,first_a,first_b) = process(cur,a,b,first_a,first_b)
print("\"" + a + "\"" if a != "" else "-")
print("\"" + b + "\"" if b != "" else "-")
``` | instruction | 0 | 71,214 | 0 | 142,428 |
No | output | 1 | 71,214 | 0 | 142,429 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "".
Submitted Solution:
```
import sys
s = sys.stdin.readline()
#s = "asdf,as,12931,;asdfj;123.0,0234,01,0,asdf2,213a"
tokens = s.strip().replace(",", ";").split(";")
s1, s2 = [], []
if len(tokens) == 1 and tokens[0] == "":
print("-\n-")
sys.exit(0)
for tok in tokens:
if len(tok) > 1 and tok[0] == "0":
s2 += [tok]
continue
try:
i = int(tok)
s1 += [tok]
except:
s2 += [tok]
print(",".join(s1) if len(s1) > 0 else '-')
print(",".join(s2) if len(s2) > 0 else '-')
``` | instruction | 0 | 71,215 | 0 | 142,430 |
No | output | 1 | 71,215 | 0 | 142,431 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Let's call word any largest sequence of consecutive symbols without symbols ',' (comma) and ';' (semicolon). For example, there are four words in string "aba,123;1a;0": "aba", "123", "1a", "0". A word can be empty: for example, the string s=";;" contains three empty words separated by ';'.
You should find all words in the given string that are nonnegative INTEGER numbers without leading zeroes and build by them new string a. String a should contain all words that are numbers separating them by ',' (the order of numbers should remain the same as in the string s). By all other words you should build string b in the same way (the order of numbers should remain the same as in the string s).
Here strings "101", "0" are INTEGER numbers, but "01" and "1.0" are not.
For example, for the string aba,123;1a;0 the string a would be equal to "123,0" and string b would be equal to "aba,1a".
Input
The only line of input contains the string s (1 ≤ |s| ≤ 105). The string contains only symbols '.' (ASCII 46), ',' (ASCII 44), ';' (ASCII 59), digits, lowercase and uppercase latin letters.
Output
Print the string a to the first line and string b to the second line. Each string should be surrounded by quotes (ASCII 34).
If there are no words that are numbers print dash (ASCII 45) on the first line. If all words are numbers print dash on the second line.
Examples
Input
aba,123;1a;0
Output
"123,0"
"aba,1a"
Input
1;;01,a0,
Output
"1"
",01,a0,"
Input
1
Output
"1"
-
Input
a
Output
-
"a"
Note
In the second example the string s contains five words: "1", "", "01", "a0", "".
Submitted Solution:
```
import re
s=input()
s=(re.split(";|,",s))
a=[]
b=[]
for i in s:
if(i.isalnum() and i.isdigit()==False):
b.append(i)
else:
if(i.isdigit()):
if(len(i)>1):
if(i[0]!="0"):
a.append(i)
else:
b.append(i)
else:
a.append(i)
print(",".join(a))
print(",".join(b))
``` | instruction | 0 | 71,216 | 0 | 142,432 |
No | output | 1 | 71,216 | 0 | 142,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let LCP(s, t) be the length of the longest common prefix of strings s and t. Also let s[x ... y] be the substring of s from index x to index y (inclusive). For example, if s = "abcde", then s[1 ... 3] = "abc", s[2 ... 5] = "bcde".
You are given a string s of length n and q queries. Each query is a pair of integer sets a_1, a_2, ..., a_k and b_1, b_2, ..., b_l. Calculate ∑_{i = 1}^{i = k} ∑_{j = 1}^{j = l}{LCP(s[a_i ... n], s[b_j ... n])} for each query.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 2 ⋅ 10^5) — the length of string s and the number of queries, respectively.
The second line contains a string s consisting of lowercase Latin letters (|s| = n).
Next 3q lines contains descriptions of queries — three lines per query. The first line of each query contains two integers k_i and l_i (1 ≤ k_i, l_i ≤ n) — sizes of sets a and b respectively.
The second line of each query contains k_i integers a_1, a_2, ... a_{k_i} (1 ≤ a_1 < a_2 < ... < a_{k_i} ≤ n) — set a.
The third line of each query contains l_i integers b_1, b_2, ... b_{l_i} (1 ≤ b_1 < b_2 < ... < b_{l_i} ≤ n) — set b.
It is guaranteed that ∑_{i = 1}^{i = q}{k_i} ≤ 2 ⋅ 10^5 and ∑_{i = 1}^{i = q}{l_i} ≤ 2 ⋅ 10^5.
Output
Print q integers — answers for the queries in the same order queries are given in the input.
Example
Input
7 4
abacaba
2 2
1 2
1 2
3 1
1 2 3
7
1 7
1
1 2 3 4 5 6 7
2 2
1 5
1 5
Output
13
2
12
16
Note
Description of queries:
1. In the first query s[1 ... 7] = abacaba and s[2 ... 7] = bacaba are considered. The answer for the query is LCP(abacaba, abacaba) + LCP(abacaba, bacaba) + LCP(bacaba, abacaba) + LCP(bacaba, bacaba) = 7 + 0 + 0 + 6 = 13.
2. In the second query s[1 ... 7] = abacaba, s[2 ... 7] = bacaba, s[3 ... 7] = acaba and s[7 ... 7] = a are considered. The answer for the query is LCP(abacaba, a) + LCP(bacaba, a) + LCP(acaba, a) = 1 + 0 + 1 = 2.
3. In the third query s[1 ... 7] = abacaba are compared with all suffixes. The answer is the sum of non-zero values: LCP(abacaba, abacaba) + LCP(abacaba, acaba) + LCP(abacaba, aba) + LCP(abacaba, a) = 7 + 1 + 3 + 1 = 12.
4. In the fourth query s[1 ... 7] = abacaba and s[5 ... 7] = aba are considered. The answer for the query is LCP(abacaba, abacaba) + LCP(abacaba, aba) + LCP(aba, abacaba) + LCP(aba, aba) = 7 + 3 + 3 + 3 = 16.
Submitted Solution:
```
def lcp(s,t):
i=0
while(s[i]==t[i]):
i+=1
if(i==len(s) or i==len(t)):
return i
return i
def main():
n,q=map(int,input().split())
s=str(input())
for i in range(0,q):
ac,bc=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=0
for j in range(0,ac):
for k in range(0,bc):
c+=lcp(s[a[j]:],s[b[k]:])
return c
``` | instruction | 0 | 71,660 | 0 | 143,320 |
No | output | 1 | 71,660 | 0 | 143,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let LCP(s, t) be the length of the longest common prefix of strings s and t. Also let s[x ... y] be the substring of s from index x to index y (inclusive). For example, if s = "abcde", then s[1 ... 3] = "abc", s[2 ... 5] = "bcde".
You are given a string s of length n and q queries. Each query is a pair of integer sets a_1, a_2, ..., a_k and b_1, b_2, ..., b_l. Calculate ∑_{i = 1}^{i = k} ∑_{j = 1}^{j = l}{LCP(s[a_i ... n], s[b_j ... n])} for each query.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 2 ⋅ 10^5) — the length of string s and the number of queries, respectively.
The second line contains a string s consisting of lowercase Latin letters (|s| = n).
Next 3q lines contains descriptions of queries — three lines per query. The first line of each query contains two integers k_i and l_i (1 ≤ k_i, l_i ≤ n) — sizes of sets a and b respectively.
The second line of each query contains k_i integers a_1, a_2, ... a_{k_i} (1 ≤ a_1 < a_2 < ... < a_{k_i} ≤ n) — set a.
The third line of each query contains l_i integers b_1, b_2, ... b_{l_i} (1 ≤ b_1 < b_2 < ... < b_{l_i} ≤ n) — set b.
It is guaranteed that ∑_{i = 1}^{i = q}{k_i} ≤ 2 ⋅ 10^5 and ∑_{i = 1}^{i = q}{l_i} ≤ 2 ⋅ 10^5.
Output
Print q integers — answers for the queries in the same order queries are given in the input.
Example
Input
7 4
abacaba
2 2
1 2
1 2
3 1
1 2 3
7
1 7
1
1 2 3 4 5 6 7
2 2
1 5
1 5
Output
13
2
12
16
Note
Description of queries:
1. In the first query s[1 ... 7] = abacaba and s[2 ... 7] = bacaba are considered. The answer for the query is LCP(abacaba, abacaba) + LCP(abacaba, bacaba) + LCP(bacaba, abacaba) + LCP(bacaba, bacaba) = 7 + 0 + 0 + 6 = 13.
2. In the second query s[1 ... 7] = abacaba, s[2 ... 7] = bacaba, s[3 ... 7] = acaba and s[7 ... 7] = a are considered. The answer for the query is LCP(abacaba, a) + LCP(bacaba, a) + LCP(acaba, a) = 1 + 0 + 1 = 2.
3. In the third query s[1 ... 7] = abacaba are compared with all suffixes. The answer is the sum of non-zero values: LCP(abacaba, abacaba) + LCP(abacaba, acaba) + LCP(abacaba, aba) + LCP(abacaba, a) = 7 + 1 + 3 + 1 = 12.
4. In the fourth query s[1 ... 7] = abacaba and s[5 ... 7] = aba are considered. The answer for the query is LCP(abacaba, abacaba) + LCP(abacaba, aba) + LCP(aba, abacaba) + LCP(aba, aba) = 7 + 3 + 3 + 3 = 16.
Submitted Solution:
```
n,q = list(map(int, input().split()))
s = input()
def LCP(s1,s2):
if s1[0]!=s2[0]:
return 0
elif s1 == s2:
return len(s1)
else:
_ = min(len(s1),len(s2))
if _ == 1:
return 1
else:
res,i = 1,1
for i in range(1,_):
if s1[i]==s2[i]:
res+=1
else:
return res
return _
for i in range(q):
k,l = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
res = 0
if a == b:
for i1 in range(k):
for j1 in range(i1,l):
res += LCP(s[a[i1]-1:],s[b[j1]-1:])
else:
for i1 in range(k):
for j1 in range(l):
res += LCP(s[a[i1]-1:],s[b[j1]-1:])
print(res)
``` | instruction | 0 | 71,661 | 0 | 143,322 |
No | output | 1 | 71,661 | 0 | 143,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let LCP(s, t) be the length of the longest common prefix of strings s and t. Also let s[x ... y] be the substring of s from index x to index y (inclusive). For example, if s = "abcde", then s[1 ... 3] = "abc", s[2 ... 5] = "bcde".
You are given a string s of length n and q queries. Each query is a pair of integer sets a_1, a_2, ..., a_k and b_1, b_2, ..., b_l. Calculate ∑_{i = 1}^{i = k} ∑_{j = 1}^{j = l}{LCP(s[a_i ... n], s[b_j ... n])} for each query.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 2 ⋅ 10^5) — the length of string s and the number of queries, respectively.
The second line contains a string s consisting of lowercase Latin letters (|s| = n).
Next 3q lines contains descriptions of queries — three lines per query. The first line of each query contains two integers k_i and l_i (1 ≤ k_i, l_i ≤ n) — sizes of sets a and b respectively.
The second line of each query contains k_i integers a_1, a_2, ... a_{k_i} (1 ≤ a_1 < a_2 < ... < a_{k_i} ≤ n) — set a.
The third line of each query contains l_i integers b_1, b_2, ... b_{l_i} (1 ≤ b_1 < b_2 < ... < b_{l_i} ≤ n) — set b.
It is guaranteed that ∑_{i = 1}^{i = q}{k_i} ≤ 2 ⋅ 10^5 and ∑_{i = 1}^{i = q}{l_i} ≤ 2 ⋅ 10^5.
Output
Print q integers — answers for the queries in the same order queries are given in the input.
Example
Input
7 4
abacaba
2 2
1 2
1 2
3 1
1 2 3
7
1 7
1
1 2 3 4 5 6 7
2 2
1 5
1 5
Output
13
2
12
16
Note
Description of queries:
1. In the first query s[1 ... 7] = abacaba and s[2 ... 7] = bacaba are considered. The answer for the query is LCP(abacaba, abacaba) + LCP(abacaba, bacaba) + LCP(bacaba, abacaba) + LCP(bacaba, bacaba) = 7 + 0 + 0 + 6 = 13.
2. In the second query s[1 ... 7] = abacaba, s[2 ... 7] = bacaba, s[3 ... 7] = acaba and s[7 ... 7] = a are considered. The answer for the query is LCP(abacaba, a) + LCP(bacaba, a) + LCP(acaba, a) = 1 + 0 + 1 = 2.
3. In the third query s[1 ... 7] = abacaba are compared with all suffixes. The answer is the sum of non-zero values: LCP(abacaba, abacaba) + LCP(abacaba, acaba) + LCP(abacaba, aba) + LCP(abacaba, a) = 7 + 1 + 3 + 1 = 12.
4. In the fourth query s[1 ... 7] = abacaba and s[5 ... 7] = aba are considered. The answer for the query is LCP(abacaba, abacaba) + LCP(abacaba, aba) + LCP(aba, abacaba) + LCP(aba, aba) = 7 + 3 + 3 + 3 = 16.
Submitted Solution:
```
def LCP(s1,s2):
num=0
for i in range(min(len(s1),len(s2))):
if s1[i]==s2[i]:
num+=1
else:
break
return num
n,q=map(int,input().split())
string=input()
k=list(i for i in range(1,3*q+1,3))
m=0
lis1=[]
for i in range(1,3*q+1):
tmp=input().split()
if i not in k and m==0:
lis1=list(int(i) for i in tmp)
m=1
continue
if i not in k and m==1:
lis2=list(int(i) for i in tmp)
m=0
sum=0
for j in lis1:
for l in lis2:
sum+=LCP(string[j:],string[l:])
print(sum)
``` | instruction | 0 | 71,662 | 0 | 143,324 |
No | output | 1 | 71,662 | 0 | 143,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let LCP(s, t) be the length of the longest common prefix of strings s and t. Also let s[x ... y] be the substring of s from index x to index y (inclusive). For example, if s = "abcde", then s[1 ... 3] = "abc", s[2 ... 5] = "bcde".
You are given a string s of length n and q queries. Each query is a pair of integer sets a_1, a_2, ..., a_k and b_1, b_2, ..., b_l. Calculate ∑_{i = 1}^{i = k} ∑_{j = 1}^{j = l}{LCP(s[a_i ... n], s[b_j ... n])} for each query.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 2 ⋅ 10^5) — the length of string s and the number of queries, respectively.
The second line contains a string s consisting of lowercase Latin letters (|s| = n).
Next 3q lines contains descriptions of queries — three lines per query. The first line of each query contains two integers k_i and l_i (1 ≤ k_i, l_i ≤ n) — sizes of sets a and b respectively.
The second line of each query contains k_i integers a_1, a_2, ... a_{k_i} (1 ≤ a_1 < a_2 < ... < a_{k_i} ≤ n) — set a.
The third line of each query contains l_i integers b_1, b_2, ... b_{l_i} (1 ≤ b_1 < b_2 < ... < b_{l_i} ≤ n) — set b.
It is guaranteed that ∑_{i = 1}^{i = q}{k_i} ≤ 2 ⋅ 10^5 and ∑_{i = 1}^{i = q}{l_i} ≤ 2 ⋅ 10^5.
Output
Print q integers — answers for the queries in the same order queries are given in the input.
Example
Input
7 4
abacaba
2 2
1 2
1 2
3 1
1 2 3
7
1 7
1
1 2 3 4 5 6 7
2 2
1 5
1 5
Output
13
2
12
16
Note
Description of queries:
1. In the first query s[1 ... 7] = abacaba and s[2 ... 7] = bacaba are considered. The answer for the query is LCP(abacaba, abacaba) + LCP(abacaba, bacaba) + LCP(bacaba, abacaba) + LCP(bacaba, bacaba) = 7 + 0 + 0 + 6 = 13.
2. In the second query s[1 ... 7] = abacaba, s[2 ... 7] = bacaba, s[3 ... 7] = acaba and s[7 ... 7] = a are considered. The answer for the query is LCP(abacaba, a) + LCP(bacaba, a) + LCP(acaba, a) = 1 + 0 + 1 = 2.
3. In the third query s[1 ... 7] = abacaba are compared with all suffixes. The answer is the sum of non-zero values: LCP(abacaba, abacaba) + LCP(abacaba, acaba) + LCP(abacaba, aba) + LCP(abacaba, a) = 7 + 1 + 3 + 1 = 12.
4. In the fourth query s[1 ... 7] = abacaba and s[5 ... 7] = aba are considered. The answer for the query is LCP(abacaba, abacaba) + LCP(abacaba, aba) + LCP(aba, abacaba) + LCP(aba, aba) = 7 + 3 + 3 + 3 = 16.
Submitted Solution:
```
n, q = (int(el) for el in input().split())
s = input()
n = len(s)
queries = []
#print(s, queries)
cache = {}
for i in range(n):
cache[i+1] = {(i+1):(n-i)}
for j in range(i+1, n):
pref_len = 0
while((j + pref_len) < n and s[i + pref_len] == s[j + pref_len]):
if i + pref_len >= j:
pref_len += pref_len
pref_len += 1
cache[i+1][j+1] = pref_len
for _ in range(q):
lst_n = [int(el) for el in input().split()]
lst_a = [int(el) for el in input().split()]
lst_b = [int(el) for el in input().split()]
res = 0
for a in lst_a:
for b in lst_b:
res += cache[min(a, b)][max(a,b)]
print(res)
print(cache)
``` | instruction | 0 | 71,663 | 0 | 143,326 |
No | output | 1 | 71,663 | 0 | 143,327 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For the given integer n (n > 2) let's write down all the strings of length n which contain n-2 letters 'a' and two letters 'b' in lexicographical (alphabetical) order.
Recall that the string s of length n is lexicographically less than string t of length n, if there exists such i (1 ≤ i ≤ n), that s_i < t_i, and for any j (1 ≤ j < i) s_j = t_j. The lexicographic comparison of strings is implemented by the operator < in modern programming languages.
For example, if n=5 the strings are (the order does matter):
1. aaabb
2. aabab
3. aabba
4. abaab
5. ababa
6. abbaa
7. baaab
8. baaba
9. babaa
10. bbaaa
It is easy to show that such a list of strings will contain exactly (n ⋅ (n-1))/(2) strings.
You are given n (n > 2) and k (1 ≤ k ≤ (n ⋅ (n-1))/(2)). Print the k-th string from the list.
Input
The input contains one or more test cases.
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases in the test. Then t test cases follow.
Each test case is written on the the separate line containing two integers n and k (3 ≤ n ≤ 10^5, 1 ≤ k ≤ min(2⋅10^9, (n ⋅ (n-1))/(2)).
The sum of values n over all test cases in the test doesn't exceed 10^5.
Output
For each test case print the k-th string from the list of all described above strings of length n. Strings in the list are sorted lexicographically (alphabetically).
Example
Input
7
5 1
5 2
5 8
5 10
3 1
3 2
20 100
Output
aaabb
aabab
baaba
bbaaa
abb
bab
aaaaabaaaaabaaaaaaaa | instruction | 0 | 71,805 | 0 | 143,610 |
Tags: binary search, brute force, combinatorics, implementation, math
Correct Solution:
```
n = int(input())
for i in range(n):
n, k = map(int, input().split())
count_b = 2
while count_b * (count_b - 1) // 2 < k:
count_b += 1
count_b, count_a = n - count_b, n - count_b + (count_b * (count_b - 1) // 2 - k + 1)
for i in range(n):
if i == count_a or i == count_b:
print('b', end='')
else:
print('a', end='')
print()
``` | output | 1 | 71,805 | 0 | 143,611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For the given integer n (n > 2) let's write down all the strings of length n which contain n-2 letters 'a' and two letters 'b' in lexicographical (alphabetical) order.
Recall that the string s of length n is lexicographically less than string t of length n, if there exists such i (1 ≤ i ≤ n), that s_i < t_i, and for any j (1 ≤ j < i) s_j = t_j. The lexicographic comparison of strings is implemented by the operator < in modern programming languages.
For example, if n=5 the strings are (the order does matter):
1. aaabb
2. aabab
3. aabba
4. abaab
5. ababa
6. abbaa
7. baaab
8. baaba
9. babaa
10. bbaaa
It is easy to show that such a list of strings will contain exactly (n ⋅ (n-1))/(2) strings.
You are given n (n > 2) and k (1 ≤ k ≤ (n ⋅ (n-1))/(2)). Print the k-th string from the list.
Input
The input contains one or more test cases.
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases in the test. Then t test cases follow.
Each test case is written on the the separate line containing two integers n and k (3 ≤ n ≤ 10^5, 1 ≤ k ≤ min(2⋅10^9, (n ⋅ (n-1))/(2)).
The sum of values n over all test cases in the test doesn't exceed 10^5.
Output
For each test case print the k-th string from the list of all described above strings of length n. Strings in the list are sorted lexicographically (alphabetically).
Example
Input
7
5 1
5 2
5 8
5 10
3 1
3 2
20 100
Output
aaabb
aabab
baaba
bbaaa
abb
bab
aaaaabaaaaabaaaaaaaa | instruction | 0 | 71,806 | 0 | 143,612 |
Tags: binary search, brute force, combinatorics, implementation, math
Correct Solution:
```
import math
test=int(input())
for _ in range(test):
n,k=map(int,input().split())
i=math.floor((math.sqrt(8*k - 1) + 1)/2)
ans=(k - 1 - i*(i - 1)/2)
final=['a' for i in range(n)]
final[int(i)]='b'
final[int(ans)]='b'
print("".join(final[::-1]))
``` | output | 1 | 71,806 | 0 | 143,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For the given integer n (n > 2) let's write down all the strings of length n which contain n-2 letters 'a' and two letters 'b' in lexicographical (alphabetical) order.
Recall that the string s of length n is lexicographically less than string t of length n, if there exists such i (1 ≤ i ≤ n), that s_i < t_i, and for any j (1 ≤ j < i) s_j = t_j. The lexicographic comparison of strings is implemented by the operator < in modern programming languages.
For example, if n=5 the strings are (the order does matter):
1. aaabb
2. aabab
3. aabba
4. abaab
5. ababa
6. abbaa
7. baaab
8. baaba
9. babaa
10. bbaaa
It is easy to show that such a list of strings will contain exactly (n ⋅ (n-1))/(2) strings.
You are given n (n > 2) and k (1 ≤ k ≤ (n ⋅ (n-1))/(2)). Print the k-th string from the list.
Input
The input contains one or more test cases.
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases in the test. Then t test cases follow.
Each test case is written on the the separate line containing two integers n and k (3 ≤ n ≤ 10^5, 1 ≤ k ≤ min(2⋅10^9, (n ⋅ (n-1))/(2)).
The sum of values n over all test cases in the test doesn't exceed 10^5.
Output
For each test case print the k-th string from the list of all described above strings of length n. Strings in the list are sorted lexicographically (alphabetically).
Example
Input
7
5 1
5 2
5 8
5 10
3 1
3 2
20 100
Output
aaabb
aabab
baaba
bbaaa
abb
bab
aaaaabaaaaabaaaaaaaa | instruction | 0 | 71,807 | 0 | 143,614 |
Tags: binary search, brute force, combinatorics, implementation, math
Correct Solution:
```
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
############ ---- Input Functions ---- ############
def in_int():
return (int(input()))
def in_list():
return (list(map(int, input().split())))
def in_str():
s = input()
return (list(s[:len(s) - 1]))
def in_ints():
return (map(int, input().split()))
import math
q = in_int()
for qq in range(q):
a , b = in_ints()
# print(a,b)
lvl = (int(math.sqrt(8*(b-1)+1))-1)//2
# print(b, lvl, b-1 - (lvl)*(lvl+1)//2)
s = ['a']*a
s[lvl+1] = 'b'
s[ b-1 - (lvl)*(lvl+1)//2] = 'b'
for ss in s[::-1]:
print(ss,end='')
print()
``` | output | 1 | 71,807 | 0 | 143,615 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.