text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
Tags: binary search, data structures, implementation, two pointers
Correct Solution:
```
from sys import stdin;
from collections import defaultdict
t = int(stdin.readline())
while(t):
seen = defaultdict(list)
n = int(stdin.readline())
a = [int(x) for x in stdin.readline().split()]
best = ()
for i in range(n):
seen[a[i]].append(i+1)
out = [10**10] * n
distances = defaultdict(list)
for key in list(seen.keys()):
hue = seen[key]
big = -1
for i in range(1, len(hue)):
big = max(hue[i] - hue[i-1] - 1, big)
big = max(n-hue[-1], big)
big = max(hue[0]-1, big)
out[big] = min(out[big], key)
for i in range(1,n):
out[i] = min(out[i], out[i-1])
print(" ".join([str(x) if x != 10**10 else str(-1) for x in out]))
t-= 1
```
| 11,800 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
Tags: binary search, data structures, implementation, two pointers
Correct Solution:
```
import sys,functools,collections,bisect,math,heapq
input = sys.stdin.readline
#print = sys.stdout.write
sys.setrecursionlimit(200000)
mod = 10**9 + 7
t = int(input())
for _ in range(t):
n = int(input())
arr = list(map(int,input().strip().split()))
res = [-1]*n
d = collections.defaultdict(list)
for i in range(n):
d[arr[i]].append(i)
for i in d:
ans = d[i][0]+1
for j in range(1,len(d[i])):
x = d[i][j] - d[i][j-1]
if x > ans:
ans = x
x = n-d[i][-1]
if x > ans:
ans = x
if res[ans-1] == -1:
res[ans-1] = i
elif res[ans-1] > i:
res[ans-1] = i
#print(res)
for i in range(1,n):
if res[i] == -1 or res[i] > res[i-1] > 0:
res[i] = res[i-1]
print(' '.join(str(i) for i in res))
```
| 11,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
Tags: binary search, data structures, implementation, two pointers
Correct Solution:
```
import sys
import math
from collections import defaultdict,Counter
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
# sys.stdout=open("CP2/output.txt",'w')
# sys.stdin=open("CP2/input.txt",'r')
# mod=pow(10,9)+7
t=int(input())
for i in range(t):
n=int(input())
a=list(map(int,input().split()))
pre={}
l=[0]*n
for j in range(n-1,-1,-1):
l[j]=pre.get(a[j],n)-j
pre[a[j]]=j
pre={}
d={}
l2=[0]*n
for j in range(n):
l2[j]=j-pre.get(a[j],-1)
pre[a[j]]=j
d[a[j]]=0
# print(l)
# print(l2)
for j in range(n):
d[a[j]]=max(d[a[j]],l[j],l2[j])
# if d.get(a[j])!=None:
# ma[j-d[a[j]]]=min(ma.get(j-d[a[j]],n),a[j])
# else:
# ma[j+1]=min(ma.get(j+1,n),a[j])
# d[a[j]]=j
# print(d)
l=[10**6]*n
for j in d:
l[d[j]-1]=min(l[d[j]-1],j)
if l[0]==10**6:
print(-1,end=' ')
else:
print(l[0],end=' ')
for j in range(1,n):
l[j]=min(l[j],l[j-1])
if l[j]==10**6:
print(-1,end=' ')
else:
print(l[j],end=' ')
print()
```
| 11,802 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
Tags: binary search, data structures, implementation, two pointers
Correct Solution:
```
# Author : -pratyay-
import sys
inp=sys.stdin.buffer.readline
inar=lambda: list(map(int,inp().split()))
inin=lambda: int(inp())
inst=lambda: inp().decode().strip()
def pr(*args,end='\n'):
for _arg in args:
sys.stdout.write(str(_arg)+' ')
sys.stdout.write(end)
inf=float('inf')
enum=enumerate
_T_=inin()
for _t_ in range(_T_):
n=inin()
a=inar()
last=[-1 for i in range(n+1)]
gap=[-1 for i in range(n+1)]
for inde,i in enum(a):
gap[i]=max(gap[i],inde-last[i])
last[i]=inde
for i in a:
gap[i]=max(gap[i],n-last[i])
#pr(gap)
gapmin=[inf for i in range(n+1)]
for i in range(1,n+1):
if gap[i]==-1:
continue
gapmin[gap[i]]=min(gapmin[gap[i]],i)
#pr(gapmin)
for i in range(1,n+1):
gapmin[i]=min(gapmin[i-1],gapmin[i])
for i in range(n+1):
if gapmin[i]==inf:
gapmin[i]=-1
pr(*gapmin[1:])
```
| 11,803 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
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
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 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 sli(): #string list
return list(map(str, inp().split()))
def print_list(lista, space = " "):
print(space.join(map(str, lista)))
######################
##### UNION FIND #####
######################
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))
self.size = [1] * n
self.num_sets = n
def find(self, a):
to_update = []
while a != self.parent[a]:
to_update.append(a)
a = self.parent[a]
for b in to_update:
self.parent[b] = a
return self.parent[a]
def merge(self, a, b):
a = self.find(a)
b = self.find(b)
if a == b:
return
if self.size[a] < self.size[b]:
a, b = b, a
self.num_sets -= 1
self.parent[b] = a
self.size[a] += self.size[b]
def set_size(self, a):
return self.size[self.find(a)]
def __len__(self):
return self.num_sets
######################
### 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)
######################
#### CUSTOM SORT #####
######################
def custom_sort(lista):
def cmp(x,y):
if x+y>y+x:
return 1
else:
return -1
return sorted(lista, key = cmp_to_key(cmp))
######################
### MOD OPERATION ####
######################
MOD = 10**9 + 7
maxN = 10**5
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 coeffBinom(n, k):
if n < k:
return 0
return divide(FACT[n], multiply(FACT[k], FACT[n-k]))
######################
#### GCD & PRIMES ####
######################
def primes(N):
smallest_prime = [1] * (N+1)
prime = []
smallest_prime[0] = 0
smallest_prime[1] = 0
for i in range(2, N+1):
if smallest_prime[i] == 1:
prime.append(i)
smallest_prime[i] = i
j = 0
while (j < len(prime) and i * prime[j] <= N):
smallest_prime[i * prime[j]] = min(prime[j], smallest_prime[i])
j += 1
return prime, smallest_prime
def gcd(a, b):
s, t, r = 0, 1, b
old_s, old_t, old_r = 1, 0, a
while r != 0:
quotient = old_r//r
old_r, r = r, old_r - quotient*r
old_s, s = s, old_s - quotient*s
old_t, t = t, old_t - quotient*t
return old_r, old_s, old_t #gcd, x, y for ax+by=gcd
######################
#### 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 create_edges(m, unweighted = 0):
edges = list()
if unweighted:
for i in range(m):
edges.append(li(lag = -1))
else:
for i in range(m):
[x, y, w] = li(lag = -1)
w += 1
edges.append([w,x,y])
return edges
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
def connected(graph, n):
v = dfs(graph, n, 0)
for el in v:
if el == -1:
return False
return True
# NON DIMENTICARTI DI PRENDERE GRAPH COME DIRETTO
def topological(graph, n):
indegree = [0] * n
for el in range(n):
for child in graph[el]:
indegree[child] += 1
s = deque()
for el in range(n):
if indegree[el] == 0:
s.append(el)
order = []
while s:
el = s.popleft()
order.append(el)
for child in graph[el]:
indegree[child] -= 1
if indegree[child] == 0:
s.append(child)
if n == len(order):
return False, order #False == no cycle
else:
return True, [] #True == there is a cycle and order is useless
# ASSUMING CONNECTED
def bipartite(graph, n):
color = [-1] * n
color[0] = 0
s = [0]
while s:
el = s.pop()
for child in graph[el]:
if color[child] == color[el]:
return False
if color[child] == -1:
s.append(child)
color[child] = 1 - color[el]
return True
# SHOULD BE DIRECTED AND WEIGHTED
def dijkstra(graph, n, A):
dist = [float('inf') for i in range(n)]
prev = [-1 for i in range(n)]
dist[A] = 0
pq = []
heappush(pq, [0, A])
while pq:
[d_v, v] = heappop(pq)
if (d_v != dist[v]):
continue
for to, w in graph[v]:
if dist[v] + w < dist[to]:
dist[to] = dist[v] + w
prev[to] = v
heappush(pq, [dist[to], to])
return dist, prev
# SHOULD BE DIRECTED AND WEIGHTED
def dijkstra_0_1(graph, n, A):
dist = [float('inf') for i in range(n)]
dist[A] = 0
p = deque()
p.append(A)
while p:
v = p.popleft()
for to, w in graph[v]:
if dist[v] + w < dist[to]:
dist[to] = dist[v] + w
if w == 1:
q.append(to)
else:
q.appendleft(to)
return dist
#SHOULD BE WEIGHTED (AND UNDIRECTED)
def floyd_warshall(graph, n):
dist = [[float('inf') for _ in range(n)] for _ in range(n)]
for i in range(n):
dist[i][i] = 0
for child, d in graph[i]:
dist[i][child] = d
dist[child][i] = d
for k in range(n):
for i in range(n):
for j in range(j):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
return dist
#EDGES [w,x,y]
def minimum_spanning_tree(edges, n):
edges = sorted(edges)
union_find = UnionFind(n) #implemented above
used_edges = list()
for w, x, y in edges:
if union_find.find(x) != union_find.find(y):
union_find.merge(x, y)
used_edges.append([w,x,y])
return used_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
def finding_ancestors(parent, queries, n):
steps = int(ceil(log(n, 2)))
ancestors = [[-1 for i in range(n)] for j in range(steps)]
ancestors[0] = parent
for i in range(1, steps):
for node in range(n):
if ancestors[i-1][node] != -1:
ancestors[i][node] = ancestors[i-1][ancestors[i-1][node]]
result = []
for node, k in queries:
ans = node
if k >= n:
ans = -1
i = 0
while k > 0 and ans != -1:
if k % 2:
ans = ancestors[i][ans]
k = k // 2
i += 1
result.append(ans)
return result #Preprocessing in O(n log n). For each query O(log k)
### 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)
######################
####### OTHERS #######
######################
def prefix_sum(arr):
r = [0] * (len(arr)+1)
for i, el in enumerate(arr):
r[i+1] = r[i] + el
return r
def nearest_from_the_left_smaller_elements(arr):
n = len(arr)
res = [-1] * n
s = []
for i, el in enumerate(arr):
while s and s[-1] >= el:
s.pop()
if s:
res[i] = s[-1]
s.append(el)
return res
def sliding_window_minimum(arr, k):
res = []
q = deque()
for i, el in enumerate(arr):
while q and arr[q[-1]] >= el:
q.pop()
q.append(i)
while q and q[0] <= i - k:
q.popleft()
if i >= k-1:
res.append(arr[q[0]])
return res
### TBD COUNT ELEMENT SMALLER THAN SELF
######################
## END OF LIBRARIES ##
######################
t = ii()
for test in range(t):
n = ii()
a = li()
occ = [[-1] for i in range(n+1)]
for i in range(n):
occ[a[i]].append(i)
for i in range(n+1):
occ[i].append(n)
min_k = [-1 for i in range(n+1)]
curr_k = n
for i in range(1,n+1):
max_diff = 0
for j in range(1,len(occ[i])):
max_diff = max(max_diff, occ[i][j]-occ[i][j-1])
if max_diff > n:
min_k[i] = -1
else:
min_k[i] = max_diff
#print(min_k)
res = [-1 for i in range(n)]
curr_k = n+1
for i in range(1,n+1):
if min_k[i] != -1 and min_k[i] < curr_k:
for j in range(min_k[i]-1,curr_k-1):
res[j] = i
curr_k = min_k[i]
print_list(res)
```
Yes
| 11,804 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
_str = str
BUFSIZE = 8192
def str(x=b''):
return x if type(x) is bytes else _str(x).encode()
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')
def inp():
return sys.stdin.readline()
def mpint():
return map(int, sys.stdin.readline().split(' '))
def itg():
return int(sys.stdin.readline())
# ############################## import
# ############################## main
INF = int(1e6)
def solve():
n = itg()
arr = tuple(mpint())
index_dict = {} # last index which arr[d[key]] == key
max_dis = {} # the longest distance between same value
for a in arr:
index_dict[a] = -1
max_dis[a] = -INF
for i, a in enumerate(arr):
max_dis[a] = max(max_dis[a], i - index_dict[a])
index_dict[a] = i
for key in max_dis:
max_dis[key] = max(max_dis[key], n - index_dict[key])
ans = [-1] * n
for key in sorted(max_dis, reverse=True):
dis = max_dis[key]
ans[dis - 1] = key
for i in range(n - 1):
if ans[i] == -1:
continue
if ans[i + 1] == -1 or ans[i + 1] > ans[i]:
ans[i + 1] = ans[i]
return ans
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
if __name__ == '__main__':
# print("YES" if solve() else "NO")
# print("yes" if solve() else "no")
# solve()
for _ in range(itg()):
print(*solve())
# solve()
# Please check!
```
Yes
| 11,805 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
Submitted Solution:
```
import sys
def input():
return sys.stdin.readline()
for _ in range(int(input())):
n = int(input())
A = list(map(int, input().split()))
X = [0] * n
Y = [-1] * n
for i in range(n):
a = A[i]
Y[a - 1] = max(Y[a - 1], i - X[a - 1])
X[a - 1] = i + 1
ans = [-1] * n
for i in range(n):
if X[i]:
Y[i] = max(Y[i], n - X[i])
if ans[Y[i]] == -1:
ans[Y[i]] = i + 1
for i in range(1, n):
if ans[i - 1] != -1:
if ans[i] == -1:
ans[i] = ans[i - 1]
else:
ans[i] = min(ans[i], ans[i - 1])
print(*ans)
```
Yes
| 11,806 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
Submitted Solution:
```
import sys,os,io
input = sys.stdin.readline
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
T = int(input())
from collections import defaultdict
for t in range(T):
n = int(input())
A = list(map(int,input().split()))
max_dif = defaultdict(lambda: 0)
bef = defaultdict(lambda: -1)
for i in range(n):
max_dif[A[i]] = max(max_dif[A[i]], i-bef[A[i]])
bef[A[i]] = i
for k in max_dif.keys():
max_dif[k] = max(max_dif[k], n-bef[k])
lis = sorted(max_dif.items(), key=lambda x:(x[1],x[0]))
lis2 = lis[1:]+[(n+1,n+1)]
ans = [0]*n
for j in range(lis[0][1]-1):
ans[j] = -1
cum = n
for (k,v),(k1,v1) in zip(lis,lis2):
cum = min(cum,k)
for j in range(v-1,v1-1):
ans[j] = cum
print(*ans)
```
Yes
| 11,807 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
Submitted Solution:
```
import sys
input = sys.stdin.readline
tests = int(input())
for case in range(tests):
n = int(input())
ans = [1000000001] * n
a = list(map(int, input().split()))
k = dict()
for i in range(n):
if a[i] not in k:
k[a[i]] = [i]
else:
k[a[i]].append(i)
z = dict()
for key in k:
d = 0
if k[key][0] != 0:
d = max(d, k[key][0] + 1)
for i in range(1, len(k[key])):
d = max(d, abs(k[key][i] - k[key][i - 1]))
if k[key][-1] != n - 1:
d = max(d, n - k[key][-1])
z[key] = d
list_keys = list(z.keys())
list_keys.sort()
for i in list_keys:
for j in range(z[i] - 1, len(ans)):
ans[j] = min(i, ans[j])
for i in range(len(ans)):
if ans[i] == 1000000001:
ans[i] = -1
print(ans)
```
No
| 11,808 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
Submitted Solution:
```
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
from collections import defaultdict
def gift():
for _ in range(t):
n=int(input())
array = list(map(int,input().split()))
dic = defaultdict(lambda:[])
for i in range(n):
dic[array[i]].append(i)
ans = [0]*n
minmaxLen = float("inf")
minMaxVal = None
for ele in dic:
curr = dic[ele]
maxLen = curr[0]-0
for i in range(len(curr)):
if i==len(curr)-1:
maxLen = max(n - curr[i],maxLen)
else:
maxLen = max(curr[i+1] - curr[i],maxLen)
if maxLen<minmaxLen:
minMaxVal = ele
minmaxLen = maxLen
for i in range(min(n//2,minmaxLen-1)):
ans[i] = -1
for i in range(minmaxLen-1,n//2):
ans[i] = minMaxVal
currMin = minMaxVal
for j in range(n//2,n):
i = j-n//2
if n%2:
if not currMin:
currMin = array[n//2]
elif i==0:
currMin = min(currMin,array[n//2])
else:
currMin = min(currMin,array[n//2+i],array[n//2-i])
else:
if not currMin:
currMin=min(array[n//2],array[n//2]-1)
elif i==0:
currMin=min(currMin,array[n//2],array[n//2]-1)
else:
currMin=min(currMin,array[n//2+i],array[n//2]-1-i)
ans[j] = currMin
yield " ".join(str(x) for x in ans)
if __name__ == '__main__':
t= int(input())
ans = gift()
print(*ans,sep='\n')
#"{} {} {}".format(maxele,minele,minele)
```
No
| 11,809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
d = {}
e = [-1 for i in range(n)]
for i in range(n):
if a[i] in d:
d[a[i]].append(i)
else:
d[a[i]] = [-1, i]
for i in d:
d[i].append(n)
mx = 0
for j in range(len(d[i]) - 1):
mx = max(abs(d[i][j + 1] - d[i][j]), mx)
for k in range(mx, n):
if e[k] == -1:
e[k] = i
else:
e[k] = min(e[k], i)
print(*e)
```
No
| 11,810 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
Submitted Solution:
```
# Author : -pratyay-
import sys
inp=sys.stdin.buffer.readline
inar=lambda: list(map(int,inp().split()))
inin=lambda: int(inp())
inst=lambda: inp().decode().strip()
def pr(*args,end='\n'):
for _arg in args:
sys.stdout.write(str(_arg)+' ')
sys.stdout.write(end)
inf=float('inf')
_T_=inin()
for _t_ in range(_T_):
n=inin()
a=inar()
positions=[[] for i in range(n+1)]
for i in range(n):
positions[a[i]].append(i)
maxgap=[-1 for i in range(n+1)]
for i in a:
maxgap[i]=max(maxgap[i],positions[i][0]+1, n-positions[i][-1])
for p,q in zip(positions[i],positions[i][1:]):
maxgap[i]=max(maxgap[i],q-p)
#print(maxgap)
ans=[inf]*(n+1)
for i in a:
ans[maxgap[i]]=min(ans[i],i)
for k,b in enumerate(ans):
if k>=1:
ans[k]=min(ans[k-1],b)
for i in range(1,n+1):
if ans[i]==inf:
ans[i]=-1
pr(*ans[1:])
```
No
| 11,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Tags: binary search, brute force, dp, implementation, sortings, two pointers
Correct Solution:
```
import heapq
import sys
input = sys.stdin.readline
def main():
alst = list(map(int, input().split()))
n = int(input())
blst = list(map(int, input().split()))
alst.sort(reverse = True)
blst.sort()
lst = []
for b in blst:
tmp = [b - a for a in alst]
lst.append(tmp)
hq = []
max_ = 0
for i in range(n):
hq.append((lst[i][0], i, 0))
max_ = max(max_, lst[i][0])
heapq.heapify(hq)
ans = max_ - hq[0][0]
while 1:
_, i, pos = heapq.heappop(hq)
if pos == 5:
break
max_ = max(max_, lst[i][pos + 1])
heapq.heappush(hq, (lst[i][pos + 1], i, pos + 1))
ans = min(ans, max_ - hq[0][0])
print(ans)
main()
```
| 11,812 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Tags: binary search, brute force, dp, implementation, sortings, two pointers
Correct Solution:
```
from sys import stdin
import heapq
import sys
a = list(map(int,stdin.readline().split()))
a.sort()
a.reverse()
n = int(stdin.readline())
b = list(map(int,stdin.readline().split()))
state = [0] * n
minq = []
maxq = []
for i in range(n):
minq.append( (b[i]-a[0] , i) )
maxq.append( ( -1*(b[i]-a[0]) , i) )
heapq.heapify(minq)
heapq.heapify(maxq)
ans = float("inf")
for i in range(5*n):
while len(maxq) > 0 and maxq[0][0] != -1 * (b[maxq[0][1]]-a[state[maxq[0][1]]]):
heapq.heappop(maxq)
ans = min( ans , -1*maxq[0][0] - minq[0][0] )
tmp,index = heapq.heappop(minq)
state[index] += 1
if state[index] >= 6:
break
ppp = b[index] - a[state[index]]
heapq.heappush(minq , (ppp,index))
heapq.heappush(maxq , (-1 * ppp,index))
print (ans)
```
| 11,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Tags: binary search, brute force, dp, implementation, sortings, two pointers
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
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()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# sys.setrecursionlimit(300000)
# from heapq import *
# from collections import deque as dq
# from math import ceil,floor,sqrt,pow
import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
# from functools import lru_cache
a = RLL()
a.sort()
n = N()
b = RLL()
data = [(b[i]-a[j],i) for i in range(n) for j in range(6)]
# print(data)
data.sort()
res = float('inf')
now = [0]*n
count = 0
l,r = 0,0
mn = 6*n
while 1:
while count<n and r<mn:
k = data[r][1]
now[k]+=1
if now[k]==1:
count+=1
r+=1
if count<n:
break
while count==n:
k = data[l][1]
now[k]-=1
if now[k]==0:
count-=1
l+=1
res = min(data[r-1][0]-data[l-1][0],res)
print(res)
```
| 11,814 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Tags: binary search, brute force, dp, implementation, sortings, two pointers
Correct Solution:
```
ss = sorted(set(map(int, input().split())))
input()
nn = sorted(set(map(int, input().split())))
if len(nn) == 1:
print(0)
elif len(ss) == 1:
print(nn[-1] - nn[0])
else:
n0 = nn[0]
ans = int(1e9)
for s in ss:
n0f = n0 - s
lrs = []
for n in nn[1:]:
l = r = int(1e9)
for s in ss:
f = n - s
if f == n0f:
break
if f > n0f:
r = min(r, f - n0f)
else:
l = min(l, n0f - f)
else:
lrs.append([l, r])
if not lrs:
ans = 0
break
lrs.sort()
rls = sorted(lrs, key=lambda x: x[1], reverse=True)
ansc = rls[0][1]
nrls = len(rls)
ir = 0
for lr in lrs:
lr[1] = 0
while ir < nrls and rls[ir][1] == 0:
ir += 1
r = rls[ir][1] if ir < nrls else 0
ansc = min(ansc, lr[0] + r)
ans = min(ans, ansc)
print(ans)
```
| 11,815 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Tags: binary search, brute force, dp, implementation, sortings, two pointers
Correct Solution:
```
# region fastio # from https://codeforces.com/contest/1333/submission/75948789
import sys, io, os
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = io.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(io.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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
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()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#endregion
from heapq import heappush, heappop
A = sorted(map(int, input().split()), reverse=True)
N = int(input())
q = []
B = sorted(map(int, input().split()))
ma = B[-1] - A[0]
for b in B:
ba = b-A[0] # fret
q.append(ba<<4 | 0)
ans = 1<<62
while True:
v = heappop(q)
ba = v >> 4
idx_A = v & 0b1111
mi = ba
an = ma - mi
if an < ans:
ans = an
if idx_A == 5:
break
ba += A[idx_A]
ba -= A[idx_A+1]
if ma < ba:
ma = ba
heappush(q, ba<<4|idx_A+1)
print(ans)
```
| 11,816 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Tags: binary search, brute force, dp, implementation, sortings, two pointers
Correct Solution:
```
from collections import Counter
def main():
a = list(map(int, input().split()))
n = int(input())
b = list(map(int, input().split()))
x = []
for i in a:
for j in b:
x.append((j - i, j))
x.sort()
j = 0
r = float('inf')
c = len(set(b))
d = Counter()
for i in range(n * 6):
while len(d) < c and j < n * 6:
d[x[j][1]] += 1
j += 1
if len(d) < c:
break
if x[j - 1][0] - x[i][0] < r:
r = x[j - 1][0] - x[i][0]
d[x[i][1]] -= 1
if d[x[i][1]] == 0:
d.pop(x[i][1])
print(r)
main()
```
| 11,817 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Tags: binary search, brute force, dp, implementation, sortings, two pointers
Correct Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
A = list(map(int, input().split()))
N = int(input())
B = list(map(int, input().split()))
A.sort()
B.sort()
cnt = {i: 0 for i in range(N)}
C = []
for i in range(N):
for j in range(6):
C.append((B[i] - A[j], i))
C.sort(key=lambda x: x[0])
r = -1
zero_num = N
ans = 10**10
for l in range(6*N):
if l > 0:
cnt[C[l-1][1]] -= 1
if cnt[C[l-1][1]] == 0:
zero_num += 1
while zero_num != 0:
r += 1
if r == 6*N:
print(ans)
exit()
_, i = C[r]
cnt[i] += 1
if cnt[i] == 1:
zero_num -= 1
ans = min(ans, C[r][0] - C[l][0])
print(ans)
if __name__ == '__main__':
main()
```
| 11,818 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Tags: binary search, brute force, dp, implementation, sortings, two pointers
Correct Solution:
```
import sys
readline = sys.stdin.readline
A = list(map(int, readline().split()))
N = int(readline())
B = list(map(int, readline().split()))
b0 = B[0]
B = B[1:]
INF = 3*10**9
if N == 1:
print(0)
else:
ans = INF
for a in A:
S = b0 - a
ev = [None]*N
ev[-1] = (S, S)
for i in range(N-1):
b = B[i]
l, r = -INF, INF
for a in A:
if b - a == S:
l, r = S, S
break
if b - a < S:
l = max(l, b-a)
else:
r = min(r, b-a)
ev[i] = (l, r)
ev.sort()
mr = S
for l, r in ev:
ans = min(ans, mr-l)
mr = max(mr, r)
print(ans)
```
| 11,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Submitted Solution:
```
import sys
input = sys.stdin.readline
A=list(map(int,input().split()))
n=int(input())
B=list(map(int,input().split()))
A.sort(reverse=True)
B.sort()
C=[[B[i]-a for a in A] for i in range(n)]
import heapq
H=[]
IND=[0]*n
H2=[]
MAX=-1
MINLAST=1<<60
for i in range(n):
heapq.heappush(H,(C[i][0],i))
heapq.heappush(H2,(C[i][1],i))
MAX=max(MAX,C[i][0])
MINLAST=min(MINLAST,C[i][5])
MIN=H[0][0]
ANS=MAX-MIN
while H2:
x,ind=heapq.heappop(H2)
IND[ind]+=1
if IND[ind]<5:
heapq.heappush(H2,(C[ind][IND[ind]+1],ind))
if x>MAX:
MAX=x
while H and H[0][0]==ind:
heapq.heappop(H)
heapq.heappush(H,(x,ind))
while H:
#print(H)
x,ind=H[0]
if C[ind][IND[ind]]!=x:
heapq.heappop(H)
else:
break
if H:
MIN=min(MINLAST,H[0][0])
ANS=min(ANS,MAX-MIN)
#print(ANS,H,H2)
print(ANS)
```
Yes
| 11,820 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Submitted Solution:
```
import io
import os
from collections import Counter, defaultdict, deque
def solve(A, N, B):
costs = []
indices = []
for i, a in enumerate(A):
for j, b in enumerate(B):
costs.append(b - a)
indices.append(j)
order = list(range(len(costs)))
order.sort(key=lambda i: costs[i])
costs2 = []
indices2 = []
for i in order:
costs2.append(costs[i])
indices2.append(indices[i])
costs = costs2
indices = indices2
window = Counter() # indices covered by this window
windowC = deque()
windowI = deque()
tail = 0
best = float("inf")
for i in range(len(costs)):
b = costs[i]
j = indices[i]
while len(window) != N and tail < len(costs):
bb = costs[tail]
jj = indices[tail]
window[jj] += 1
windowC.append(bb)
windowI.append(jj)
tail += 1
if len(window) != N:
break
best = min(best, windowC[-1] - windowC[0])
bb = windowC.popleft()
jj = windowI.popleft()
window[jj] -= 1
if window[jj] == 0:
del window[jj]
return best
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
A = [int(x) for x in input().split()]
(N,) = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
ans = solve(A, N, B)
print(ans)
```
Yes
| 11,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
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()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# sys.setrecursionlimit(300000)
from heapq import *
# from collections import deque as dq
# from math import ceil,floor,sqrt,pow
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
# from functools import lru_cache
a = RLL()
a.sort()
n = N()
b = RLL()
res = float('inf')
heap = [(a[0]-b[i],i) for i in range(n)]
heapify(heap)
m = min(b)-a[0]
count = [0]*n
while 1:
v,i = heap[0]
res = min(res,-v-m)
count[i]+=1
if count[i]==6:
break
t = b[i]-a[count[i]]
m = min(m,t)
heapreplace(heap,(-t,i))
print(res)
```
Yes
| 11,822 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
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()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# sys.setrecursionlimit(300000)
from heapq import *
# from collections import deque as dq
# from math import ceil,floor,sqrt,pow
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
# from functools import lru_cache
a = RLL()
a.sort(reverse=True)
n = N()
b = RLL()
res = float('inf')
heap = [(b[i]-a[0],i) for i in range(n)]
heapify(heap)
m = max(b)-a[0]
count = [0]*n
while 1:
v,i = heap[0]
res = min(res,m-v)
count[i]+=1
if count[i]==6:
break
t = b[i]-a[count[i]]
m = max(m,t)
heapreplace(heap,(t,i))
print(res)
```
Yes
| 11,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
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()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# sys.setrecursionlimit(300000)
# from heapq import *
# from collections import deque as dq
# from math import ceil,floor,sqrt,pow
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
# from functools import lru_cache
a = RLL()
a.sort()
n = N()
l,r = 0,float('inf')
b = RLL()
for k in b:
r = min(r,k-a[0])
l = max(l,k-a[-1])
print(max(l-r,0))
```
No
| 11,824 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Submitted Solution:
```
"""
#If FastIO not needed, used this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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 = self.os.read(self._fd, max(self.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 = self.os.read(self._fd, max(self.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:
self.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")
from collections import Counter as cc
import math, string
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
MOD = 10**9+7
"""
Fret = B[j] minus A[i]
There are 6 possible values for each note
1 4 8 13 20 25
1 4 9 13 20 25
0 0 1 0 0 0
Order the notes
1,2,3,4,5,6
(0,-1,-1,-1,-1,-1)
(1,0,-1,-1,-1,-1)
(1,2,3,4,5,6)
Binary search? Is it possible to attain a minimum difference of <= D?
We need to find a range [L,R] within which every note can be played, such that R-L is minimal
"""
def solve():
N = 6
A = getInts()
M = getInt()
B = getInts()
X = []
for i in range(M):
tmp = []
for j in range(N):
tmp.append(B[i]-A[j])
X.append(tmp)
P = []
for i in range(M):
for j in range(N):
P.append((X[i][j],i))
P.sort()
i = 0
j = -1
counts = cc()
sset = set()
ans = 2*10**9
while i < M*N:
while len(sset) < M and j < M*N:
j += 1
try:
sset.add(P[j][1])
except:
break
if j == M*N:
break
z = P[i][1]
ans = min(ans,P[j][0]-P[i][0])
counts[z] -= 1
if not counts[z]:
sset.remove(z)
i += 1
return ans
#for _ in range(getInt()):
print(solve())
```
No
| 11,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Submitted Solution:
```
aa = sorted(set(map(int, input().split())))
n = int(input())
bb = sorted(map(int, input().split()))
inf = float('inf')
if n == 1:
print(0)
if len(aa) == 1:
print(bb[-1] - bb[0])
else:
ans = inf
for ca in aa:
rr = minr = -inf
ll = maxl = inf
c = bb[0] - ca
for b in bb:
mfc = bminr = inf
bmaxl = -inf
for a in aa:
f = b - a
if f == c:
bminr = bmaxl = brr = bll = c
fc = abs(f - c)
if fc < mfc:
mfc = fc
if f > c:
brr = f
bll = None
else:
brr = None
bll = f
if f > c:
bminr = min(bminr, f)
else:
bmaxl = max(bmaxl, f)
minr = max(minr, bminr)
maxl = min(maxl, bmaxl)
if bll is not None:
ll = min(ll, bll)
if brr is not None:
rr = max(rr, brr)
ans = min(ans, abs(minr - c), abs(c - maxl), abs(rr - ll))
print(ans)
```
No
| 11,826 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After battling Shikamaru, Tayuya decided that her flute is too predictable, and replaced it with a guitar. The guitar has 6 strings and an infinite number of frets numbered from 1. Fretting the fret number j on the i-th string produces the note a_{i} + j.
Tayuya wants to play a melody of n notes. Each note can be played on different string-fret combination. The easiness of performance depends on the difference between the maximal and the minimal indices of used frets. The less this difference is, the easier it is to perform the technique. Please determine the minimal possible difference.
For example, if a = [1, 1, 2, 2, 3, 3], and the sequence of notes is 4, 11, 11, 12, 12, 13, 13 (corresponding to the second example), we can play the first note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7, as shown on the picture.
<image>
Input
The first line contains 6 space-separated numbers a_{1}, a_{2}, ..., a_{6} (1 ≤ a_{i} ≤ 10^{9}) which describe the Tayuya's strings.
The second line contains the only integer n (1 ≤ n ≤ 100 000) standing for the number of notes in the melody.
The third line consists of n integers b_{1}, b_{2}, ..., b_{n} (1 ≤ b_{i} ≤ 10^{9}), separated by space. They describe the notes to be played. It's guaranteed that b_i > a_j for all 1≤ i≤ n and 1≤ j≤ 6, in other words, you can play each note on any string.
Output
Print the minimal possible difference of the maximal and the minimal indices of used frets.
Examples
Input
1 4 100 10 30 5
6
101 104 105 110 130 200
Output
0
Input
1 1 2 2 3 3
7
13 4 11 12 11 13 12
Output
7
Note
In the first sample test it is optimal to play the first note on the first string, the second note on the second string, the third note on the sixth string, the fourth note on the fourth string, the fifth note on the fifth string, and the sixth note on the third string. In this case the 100-th fret is used each time, so the difference is 100 - 100 = 0.
<image>
In the second test it's optimal, for example, to play the second note on the first string, and all the other notes on the sixth string. Then the maximal fret will be 10, the minimal one will be 3, and the answer is 10 - 3 = 7.
<image>
Submitted Solution:
```
aa = sorted(set(map(int, input().split())))
n = int(input())
bb = sorted(map(int, input().split()))
inf = float('inf')
if n == 1:
print(0)
if len(aa) == 1:
print(bb[-1] - bb[0])
else:
ans = inf
for ca in aa:
rr = minr = -inf
ll = maxl = inf
c = bb[0] - ca
for b in bb[1:]:
mfc = bminr = inf
bmaxl = -inf
for a in aa:
f = b - a
if f == c:
bminr = bmaxl = brr = bll = c
fc = abs(f - c)
if fc < mfc:
mfc = fc
if f > c:
brr = f
bll = None
else:
brr = None
bll = f
if f > c:
bminr = min(bminr, f)
else:
bmaxl = max(bmaxl, f)
minr = max(minr, bminr)
maxl = min(maxl, bmaxl)
if bll is not None:
ll = min(ll, bll)
if brr is not None:
rr = max(rr, brr)
ans = min(ans, abs(minr - c), abs(c - maxl), abs(rr - ll))
print(ans)
```
No
| 11,827 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Tags: math, probabilities
Correct Solution:
```
def main():
t = int(input())
for ti in range(t):
sz = int(input())
rs = input()
rsz = len(rs)//sz
r = 0
bs = input()
bsz = len(bs)//sz
b = 0
for ni in range(sz):
ri = ni * rsz
bi = ni * bsz
diff = int(rs[ri:ri+rsz]) - int(bs[bi:bi+bsz])
if diff > 0:
r += 1
elif diff < 0:
b += 1
print('RED' if r > b else 'BLUE' if r < b else 'EQUAL')
if __name__ == "__main__":
main()
```
| 11,828 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Tags: math, probabilities
Correct Solution:
```
import sys
try:sys.stdin,sys.stdout=open('in.txt','r'),open('out.txt','w')
except:pass
ii1=lambda:int(sys.stdin.readline().strip()) # for interger
is1=lambda:sys.stdin.readline().strip() # for str
iia=lambda:list(map(int,sys.stdin.readline().strip().split())) # for List[int]
isa=lambda:sys.stdin.readline().strip().split() # for List[str]
mod=int(1e9 + 7);from collections import *;from math import *
# abc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
###################### Start Here ######################
for _ in range(ii1()):
n = ii1()
arr = is1()
ar = is1()
r = 0
b = 0
for i in range(n):
if arr[i]>ar[i]:
r+=1
elif arr[i]<ar[i]:
b+=1
else:
b+=1;r+=1
if r==b:print('EQUAL')
else:
if r>b:
print('RED')
else:
print('BLUE')
```
| 11,829 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Tags: math, probabilities
Correct Solution:
```
T = int(input())
for _ in range(T):
n = int(input())
r = [int(c) for c in input()]
b = [int(c) for c in input()]
A = sum([r[i]>b[i] for i in range(n)])
B = sum([b[i]>r[i] for i in range(n)])
C = n - A - B
if A>B:
print ('RED')
elif B >A:
print ('BLUE')
else:
print ('EQUAL')
```
| 11,830 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Tags: math, probabilities
Correct Solution:
```
test1=int(input())
for _ in range(test1):
n=int(input())
a=input()
b=input()
s1=s2=0
for i in range(n):
if(int(a[i])>int(b[i])):
s1+=1
elif(int(b[i])>int(a[i])):
s2+=1
if(s1==s2):
print("EQUAL")
elif(s1>s2):
print("RED")
else:
print("BLUE")
```
| 11,831 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Tags: math, probabilities
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
s=input()
s1=input()
a=0
b=0
for i in range(n):
if s[i]>s1[i]:
a=a+1
elif s[i]<s1[i]:
b=b+1
if a>b:
print("RED")
elif b>a:
print("BLUE")
else:
print("EQUAL")
```
| 11,832 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Tags: math, probabilities
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
r=list(map(int,input()))
b=list(map(int,input()))
red=0
blue=0
for i in range(n):
if r[i]>b[i]:
red+=1
elif b[i]>r[i]:
blue+=1
if red>blue:
print("RED")
elif blue>red:
print("BLUE")
else:
print("EQUAL")
```
| 11,833 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Tags: math, probabilities
Correct Solution:
```
#import sys
#import math
#sys.stdout=open("python/output.txt","w")
#sys.stdin=open("python/input.txt","r")
t=int(input())
for i in range(t):
n=int(input())
r=input()
b=input()
rl=list(r)
red=0
blue=0
bl=list(b)
for i in range(n):
if rl[i]>bl[i]:
red+=1
if bl[i]>rl[i]:
blue+=1
if red>blue:
print("RED")
elif blue>red:
print("BLUE")
else:
print("EQUAL")
```
| 11,834 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Tags: math, probabilities
Correct Solution:
```
t = int(input())
res = []
for i in range(t):
n = int(input())
reds = input()
reds = list(map(int,[char for char in reds]))
blues = input()
blues = list(map(int,[char for char in blues]))
bluepoints,redpoints =0,0
for card in range(n):
blue = blues[card]
red = reds[card]
if blue>red:
bluepoints+=1
elif red>blue:
redpoints+=1
if redpoints>bluepoints:
res.append('RED')
elif redpoints<bluepoints:
res.append('BLUE')
elif redpoints==bluepoints:
res.append('EQUAL')
for r in res:
print(r)
```
| 11,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Submitted Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
s1=[i for i in input()]
s2=[i for i in input()]
a1=0
a2=0
for i in range(n):
if(s1[i]>s2[i]):a1+=1
elif(s1[i]<s2[i]):a2+=1
if(a1>a2):print("RED")
elif(a2>a1):print("BLUE")
else:print("EQUAL")
```
Yes
| 11,836 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
R,B=0,0
A=input()
C=input()
if A==C:
print("EQUAL")
else:
for i in range(len(A)):
if int(A[i])>int(C[i]):
R+=1
elif int(C[i])>int(A[i]):
B+=1
else:
continue
if R>B:
print("RED")
elif B>R:
print("BLUE")
else:
print("EQUAL")
```
Yes
| 11,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
r=input()
b=input()
rs,bs=0,0
for i in range(n):
if r[i]>b[i]:
rs+=1
elif b[i]>r[i]:
bs+=1
if rs>bs:
print("RED")
elif bs>rs:
print("BLUE")
else:
print("EQUAL")
```
Yes
| 11,838 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Submitted Solution:
```
t = int(input())
for i in range(t):
n = input()
red = input()
blue = input()
#red = ''.join(sorted(red))[::-1]
#blue = ''.join(sorted(blue))[::-1]
p,j=0,0
for char in red:
if char > blue[j]:
p+=1
elif char < blue[j]:
p-=1
else:
pass
j+=1
if p>0:
print("RED")
elif p<0:
print("BLUE")
else:
print("EQUAL")
```
Yes
| 11,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
a=input()
b=input()
l1=[]
l2=[]
for i in a:
l1.append(int(i))
for i in b:
l2.append(int(i))
l1.sort()
l2.sort()
cou1=0
cou2=0
for i in range(n):
if l1[i]>l2[i]:
cou1+=1
elif l1[i]<l2[i]:
cou2+=1
else:
cou1+=1
cou2+=1
if cou1>cou2:
print("RED")
elif cou1<cou2:
print("BLUE")
else:
print("EQUAL")
```
No
| 11,840 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Submitted Solution:
```
"""
Code of Ayush Tiwari
Codeforces: servermonk
Codechef: ayush572000
"""
#import sys
#input = sys.stdin.buffer.readline
#Fast IO
import os, sys
from io import IOBase, BytesIO
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
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')
# Cout implemented in Python
import sys
class ostream:
def __lshift__(self,a):
sys.stdout.write(str(a))
return self
cout = ostream()
endl = '\n'
def solution():
# This is the main code
n=int(input())
a=input()
b=input()
num1=[]
num2=[]
for i in range(n):
num1.append(int(a[i]))
num2.append(int(b[i]))
x=0
y=0
num1.sort()
num2.sort()
for i in range(n):
if num1[i]>num2[i]:
x+=1
elif num2[i]>num1[i]:
y+=1
if y==x:
print('EQUAL')
else:
if x>y:
print('RED')
else:
print('BLUE')
t=int(input())
for _ in range(t):
solution()
```
No
| 11,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
r=list(map(int,list(input())))
b=list(map(int,list(input())))
s1=0
s2=0
for i in range(n):
for j in range(n):
if(r[i]>b[j]):
s1+=1
elif(r[i]<b[j]):
s2+=1
if(s1>s2):
print('RED')
elif(s1<s2):
print('BLUE')
else:
print('EQUAL')
```
No
| 11,842 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cards numbered 1, …, n. The card i has a red digit r_i and a blue digit b_i written on it.
We arrange all n cards in random order from left to right, with all permutations of 1, …, n having the same probability. We then read all red digits on the cards from left to right, and obtain an integer R. In the same way, we read all blue digits and obtain an integer B. When reading a number, leading zeros can be ignored. If all digits in a number are zeros, then the number is equal to 0. Below is an illustration of a possible rearrangement of three cards, and how R and B can be found.
<image>
Two players, Red and Blue, are involved in a bet. Red bets that after the shuffle R > B, and Blue bets that R < B. If in the end R = B, the bet results in a draw, and neither player wins.
Determine, which of the two players is more likely (has higher probability) to win the bet, or that their chances are equal. Refer to the Note section for a formal discussion of comparing probabilities.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases.
Descriptions of T test cases follow. Each test case description starts with a line containing a single integer n (1 ≤ n ≤ 1000) — the number of cards.
The following line contains a string of n digits r_1, …, r_n — red digits on cards 1, …, n respectively.
The following line contains a string of n digits b_1, …, b_n — blue digits on cards 1, …, n respectively.
Note that digits in the same line are not separated with any delimiters.
Output
Print T answers for the test cases in order, one per line.
If Red has a strictly higher change to win, print "RED".
If Blue has a strictly higher change to win, print "BLUE".
If both players are equally likely to win, print "EQUAL".
Note that all answers are case-sensitive.
Example
Input
3
3
777
111
3
314
159
5
09281
09281
Output
RED
BLUE
EQUAL
Note
Formally, let n_R be the number of permutations of cards 1, …, n such that the resulting numbers R and B satisfy R > B. Similarly, let n_B be the number of permutations such that R < B. If n_R > n_B, you should print "RED". If n_R < n_B, you should print "BLUE". If n_R = n_B, print "EQUAL".
In the first sample case, R = 777 and B = 111 regardless of the card order, thus Red always wins.
In the second sample case, there are two card orders when Red wins, and four card orders when Blue wins:
* order 1, 2, 3: 314 > 159;
* order 1, 3, 2: 341 > 195;
* order 2, 1, 3: 134 < 519;
* order 2, 3, 1: 143 < 591;
* order 3, 1, 2: 431 < 915;
* order 3, 2, 1: 413 < 951.
Since R < B is more frequent, the answer is "BLUE".
In the third sample case, R = B regardless of the card order, thus the bet is always a draw, and both Red and Blue have zero chance to win.
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
a=input()
b=input()
c1=0
c2=0
c3=0
for i in range(n):
if a[i]>b[i]:
c1=c1+1
if a[i]<b[i]:
c2=c2+1
elif a[i]==b[i]:
c3=c3+1
if c1>c2 and c1>c3:
print("RED")
elif c1<c2 and c2>c3:
print("BLUE")
else:
print("EQUAL")
```
No
| 11,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Tags: brute force, greedy, math, number theory
Correct Solution:
```
import sys
input=sys.stdin.buffer.readline
for t in range(int(input())):
A,B=map(int,input().split())
X=0
C,D=A,B
if B==1:
X=1
D=2
while C>0:
C//=D
X+=1
ANS=X
for i in range(1,X):
C,D=A,B+i
while C>0:
C//=D
i+=1
ANS=min(ANS,i)
print(ANS)
```
| 11,844 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Tags: brute force, greedy, math, number theory
Correct Solution:
```
import sys
from collections import defaultdict as dd
from collections import Counter as cc
from queue import Queue
import math
from math import sqrt
import itertools
try:
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
except:
pass
input = lambda: sys.stdin.readline().rstrip()
for _ in range(int(input())):
a,b=map(int,input().split())
q=2e9
if b!=1:
w=0
e=a
while e:
e//=b
w+=1
q=min(q,w)
w=a
if a<b:
print(1)
else:
for i in range(b+1,a+101):
w=i-b
e=a
while e>0:
e//=i
w+=1
if w<=q:
q=w
else:
break
print(q)
```
| 11,845 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Tags: brute force, greedy, math, number theory
Correct Solution:
```
def do(cnt,a,b):
while a>=1:
cnt+=1
a=a//b
return cnt
for _ in range(int(input())):
a,b=[int(x) for x in input().split()]
cnt=0
if b==1:
b+=1;cnt+=1
print(min([do(cnt+i,a,b+i) for i in range(10)]))
```
| 11,846 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Tags: brute force, greedy, math, number theory
Correct Solution:
```
import math
for _ in range(int(input())):
s=0
min = 9999
a, b = input().split()
a, b = int(a), int(b)
for i in range(b, b+20):
if i == 1:
continue
s1 = math.ceil(math.log(a, i)) + (i-b)
if a // pow(i,math.ceil(math.log(a, i))) != 0:
s1+=1
if s1<min:
min = s1
print(min)
```
| 11,847 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Tags: brute force, greedy, math, number theory
Correct Solution:
```
import sys
input = sys.stdin.readline
import math
t = int(input())
for f in range(t):
a,b = map(int,input().split())
ans = 1000000000
for i in range(10000):
temp = i
check = b
comp = a
check += i
if check == 1:
continue
while comp != 0:
comp //= check
temp += 1
ans = min(ans,temp)
print(ans)
```
| 11,848 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Tags: brute force, greedy, math, number theory
Correct Solution:
```
for _ in range(int(input())):
a, b = map(int, input().split())
ans = float("inf")
i = 0
while i*i <= a:
if b == 1 and i == 0:
i += 1
continue
c = a
count = i
while c:
c = c//(b+i)
count += 1
ans = min(ans, count)
i += 1
print(ans)
```
| 11,849 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Tags: brute force, greedy, math, number theory
Correct Solution:
```
import math
def f(a, b):
cnt = 0
while a != 0:
a //= b
cnt += 1
return cnt
t = int(input())
for _ in range(t):
a, b = map(int, input().split())
ans = 32
if b < 10:
for i in range(max(2, b), 10):
cur = i - b + f(a, i)
ans = min(ans, cur)
else:
ans = f(a, b)
print(ans)
```
| 11,850 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Tags: brute force, greedy, math, number theory
Correct Solution:
```
import sys
def get_array(): return list(map(int , sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
import math
for _ in range(int(input())):
a,b = get_ints()
count = 0
mi = 10**10
if(a==b and b==1):
print(2)
continue
if (a == b):
print(2)
continue
if(a==1):
print(1)
continue
if (b>a):
print(1)
continue
while(True):
if(b == 1):
b+=1
count+=1
continue
else:
if (b==0):
continue
t = a-(a%b)
# print(a,b,t,mi)
if(b>t):
break
k = round(math.log(t,b),12)
# print("k = " ,round(k,2) )
if( k == math.ceil(k)):
k-=1
k+=2
if(k + count <= mi):
mi = k + count
# b += 1
b += 1
count += 1
continue
else:
break
else:
k = math.ceil(k)
# print("k = ",k,count)
# break
if ( k + count <= mi):
mi = k + count
b+=1
count+=1
else:
break
print(int(mi))
```
| 11,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Submitted Solution:
```
for _ in range(int(input())):
a,b=map(int,input().split())
cnt2=0
temp=b
temp1=a
if b==1:
b=2
ans = float("inf")
for i in range(0,32):
cnt1=0
while a!=0:
a=a//b
cnt1+=1
ans=min(ans,(cnt1+cnt2))
b += 1
a=temp1
cnt2+= 1
if cnt1>temp1:
break
if temp==1:
print(ans+1)
else:
print(ans)
```
Yes
| 11,852 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Submitted Solution:
```
for t in range(int(input())):
a,b = [int(x) for x in input().split()]; lst = []; bcount = 0
acopy = a
bplus = b + 10
if a<b:
print(1)
elif a == b:
print(2)
else:
while True:
if b == bplus:
break
else:
count = 0
if b == 1:
b += 1
bcount += 1
a = acopy
while True:
if int(a) == 0:
break
else:
a = a/b
count += 1
b += 1
lst.append(count+bcount)
bcount += 1
print(min(lst))
```
Yes
| 11,853 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Submitted Solution:
```
def solve(a,b):
res = 32
for i in range(0,6):
if (b+i) == 1: continue
c = 0
tmp = a
while tmp > 0:
c += 1
tmp = tmp // (b + i)
res = min(res, i+c)
return res
no_of_lines = int(input())
while no_of_lines:
no_of_lines -= 1
a,b = input().split(" ")
print(solve(int(a),int(b)))
```
Yes
| 11,854 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Submitted Solution:
```
for i in range(int(input())):
n,m=map(int,input().split())
p=[]
for j in range(10):
c=0
k=m+j
c+=j
o=n
while(o>=1):
if k==1 or k==o:
k+=1
c+=1
else:
o=o//k
c+=1
p.append(c)
print(min(p))
```
Yes
| 11,855 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Submitted Solution:
```
def check(M):
b1 = b + M
b2 = b1
if b1 == 1:
return 10 ** 18
ans = 1
while b1 <= a:
b1 *= b2
ans += 1
return ans + M
ans = []
for _ in range(int(input())):
a, b = map(int, input().split())
L = 0
R = a + 1
while R - L > 2:
M1 = L + (R - L) // 3
M2 = L + (R - L) // 3 * 2
if check(M1) < check(M2):
R = M2
else:
L = M1
ans.append(min(check(L), check((L + R) // 2), check(R)))
print('\n'.join(map(str, ans)))
```
No
| 11,856 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Submitted Solution:
```
from math import ceil,floor,log
import sys
from heapq import heappush,heappop
from collections import Counter,defaultdict,deque
input=lambda : sys.stdin.readline().strip()
c=lambda x: 10**9 if(x=="?") else int(x)
class node:
def __init__(self,x,y):
self.a=[x,y]
def __lt__(self,b):
return b.a[0]<self.a[0]
def __repr__(self):
return str(self.a[0])+" "+str(self.a[1])
def main():
for _ in range(int(input())):
a,b=map(int,input().split())
k=10**18
for i in range(1000):
if(b+i==1):
continue
k=min(k,floor(log(a,b+i))+1+i)
print(k)
main()
```
No
| 11,857 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Submitted Solution:
```
import math
t = int(input())
def truncate(n, decimals=0):
multiplier = 10 ** decimals
return int(n * multiplier) / multiplier
for _ in range(t):
a, b = map(int, input().split())
mn = 1000000
if b > a:
print(1)
continue
for i in range(500):
if b+i == 1:
res = a+1
else:
res = str(truncate(math.log(a)/math.log(b+i), 12))
if res[-1] == '9':
res = int(round(float(res)))+1
else:
res = int(float(res))+1
if res+i < mn:
mn = res + i
print(mn)
```
No
| 11,858 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have two positive integers a and b.
You can perform two kinds of operations:
* a = ⌊ a/b ⌋ (replace a with the integer part of the division between a and b)
* b=b+1 (increase b by 1)
Find the minimum number of operations required to make a=0.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of the description of each test case contains two integers a, b (1 ≤ a,b ≤ 10^9).
Output
For each test case, print a single integer: the minimum number of operations required to make a=0.
Example
Input
6
9 2
1337 1
1 1
50000000 4
991026972 997
1234 5678
Output
4
9
2
12
3
1
Note
In the first test case, one of the optimal solutions is:
1. Divide a by b. After this operation a = 4 and b = 2.
2. Divide a by b. After this operation a = 2 and b = 2.
3. Increase b. After this operation a = 2 and b = 3.
4. Divide a by b. After this operation a = 0 and b = 3.
Submitted Solution:
```
from math import *
t=int(input())
for i in range(t):
y=list(map(int,input().split()))
a=y[0]
b=y[1]
lst=[]
if a<b:
print(1)
elif a==b:
print(2)
else:
for j in range(b,b+200):
if j-a>2:
break
if j==1:
lst.append(floor(log(a,j+1))+2)
# print(floor(log(a,j+1))+2)
else:
lst.append(floor(log(a,j))+1+j-b)
# print(floor(log(a,j))+1+j-b)
lst.sort()
print(lst[0])
```
No
| 11,859 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Tags: greedy
Correct Solution:
```
def cal(s):
m=0;t=0
boo = True
x=n;j=0
for i in s:
if(i == 'T'):
t+=1
else:
m+=1
if t<m:
boo=False
return (t == 2*m and boo)
for _ in range(int(input())):
n = int(input())
s = input()
ans = "YES" if(cal(s) and cal(s[::-1])) else "NO"
print(ans)
"""
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
"""
```
| 11,860 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Tags: greedy
Correct Solution:
```
def solve(s,n):
t,m=0,0
if True:
for i in range(n):
if s[i]=='T':
t+=1
if s[i]=='M':
m+=1
if t<m:
print("NO")
return
t,m=0,0
for i in range(n-1,-1,-1):
if s[i]=='T':
t+=1
if s[i]=='M':
m+=1
if t<m:
print("NO")
return
print("YES")
for _ in range(int(input())):
n=int(input())
s=input()
if s.count("T")==s.count("M")*2:
solve(s,n)
else:
print("NO")
```
| 11,861 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Tags: greedy
Correct Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
import threading
from bisect import bisect_right
from math import gcd,log
from collections import Counter,defaultdict
from pprint import pprint
from itertools import permutations
from bisect import bisect_right
def main():
n=int(input())
s=input()
bol=True
mc=s.count('M')
tc=0
m=0
for i in range(n):
if s[i]=='T':
if mc:
mc-=1
tc+=1
else:
m-=1
if s[i]=='M':
tc-=1
m+=1
if m<0 or tc<0 :
print('NO')
return
if m!=0 or tc!=0:
print('NO')
return
print('YES')
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")
# endregion
if __name__ == "__main__":
for _ in range(int(input())):
main()
```
| 11,862 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Tags: greedy
Correct Solution:
```
from collections import defaultdict, deque
import sys
from math import gcd
#import heapq
input = sys.stdin.readline
t = int(input().rstrip())
maxn = 2000005
Jc = [0 for i in range(maxn)];
mod = 10**9+7
for _ in range(t):
n = int(input().rstrip())
#n,k = map(int,input().rstrip().rsplit())
#arr = [int(i) for i in input().rstrip().split()]
s = input().rstrip()
cnt = defaultdict(int)
for i in s:
cnt[i] += 1
if cnt['T'] != n//3 * 2:
print('NO')
continue
has = True
cnt = defaultdict(int)
for i in s:
cnt[i] += 1
if i == 'M':
if cnt['M'] > cnt['T']:
has = False
break
cnt = defaultdict(int)
for i in range(len(s) - 1,-1,-1):
cnt[s[i]] += 1
if s[i] == 'M':
if cnt['M'] > cnt['T']:
has = False
break
if has:
print('YES')
else:
print('NO')
#print(' '.join(str(i) for i in ans))
```
| 11,863 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Tags: greedy
Correct Solution:
```
def solve(n, s):
t, m = [], []
for i in range(n):
if s[i] == 'T':
t.append(i)
else:
m.append(i)
if len(t) != 2*len(m):
return False
for i in range(len(m)):
if m[i] < t[i] or m[i] > t[i + len(m)]:
return False
return True
for __ in range(int(input())):
if(solve(int(input()), input())):
print("YES")
else:
print("NO")
```
| 11,864 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Tags: greedy
Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
s = str(input())
m = 0
for x in s:
if x == 'M':
m += 1
if m != n / 3:
print("NO")
continue
cur = 0
f = True
for x in s:
if x == 'T':
cur += 1
else:
cur -= 1
if cur < 0:
f = False
break
cur = 0
for x in reversed(s):
if x == 'T':
cur += 1
else:
cur -= 1
if cur < 0:
f = False
break
if f:
print("YES")
else:
print("NO")
```
| 11,865 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Tags: greedy
Correct Solution:
```
n=int(input())
for g in range(n):
no=int(input())
s=input()
t=[]
m=[]
for i in range(len(s)):
if s[i]=='T':
t.append(i)
else:
m.append(i)
if len(t)!=2*len(m):
print('NO')
else:
for i in range(len(m)):
if (t[i]>m[i]) or (m[i]>t[len(m)+i]):
print('NO')
break
elif i==len(m)-1:
print('YES')
```
| 11,866 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Tags: greedy
Correct Solution:
```
import sys
from io import BytesIO, IOBase
import heapq as h
import bisect
import math as mt
from types import GeneratorType
BUFSIZE = 8192
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index+1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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 = self.os.read(self._fd, max(self.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 = self.os.read(self._fd, max(self.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:
self.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")
import sys
from math import ceil,log2
INT_MAX = sys.maxsize
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
import collections as col
import math, string
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def minVal(x, y) :
return x if (x < y) else y;
# A utility function to get the
# middle index from corner indexes.
def getMid(s, e) :
return s + (e - s) // 2;
""" A recursive function to get the
minimum value in a given range
of array indexes. The following
are parameters for this function.
st --> Pointer to segment tree
index --> Index of current node in the
segment tree. Initially 0 is
passed as root is always at index 0
ss & se --> Starting and ending indexes
of the segment represented
by current node, i.e., st[index]
qs & qe --> Starting and ending indexes of query range """
def RMQUtil( st, ss, se, qs, qe, index) :
# If segment of this node is a part
# of given range, then return
# the min of the segment
if (qs <= ss and qe >= se) :
return st[index];
# If segment of this node
# is outside the given range
if (se < qs or ss > qe) :
return INT_MAX;
# If a part of this segment
# overlaps with the given range
mid = getMid(ss, se);
return minVal(RMQUtil(st, ss, mid, qs,
qe, 2 * index + 1),
RMQUtil(st, mid + 1, se,
qs, qe, 2 * index + 2));
# Return minimum of elements in range
# from index qs (query start) to
# qe (query end). It mainly uses RMQUtil()
def RMQ( st, n, qs, qe) :
# Check for erroneous input values
if (qs < 0 or qe > n - 1 or qs > qe) :
print("Invalid Input");
return -1;
return RMQUtil(st, 0, n - 1, qs, qe, 0);
# A recursive function that constructs
# Segment Tree for array[ss..se].
# si is index of current node in segment tree st
def constructSTUtil(arr, ss, se, st, si) :
# If there is one element in array,
# store it in current node of
# segment tree and return
if (ss == se) :
st[si] = arr[ss];
return arr[ss];
# If there are more than one elements,
# then recur for left and right subtrees
# and store the minimum of two values in this node
mid = getMid(ss, se);
st[si] = minVal(constructSTUtil(arr, ss, mid,
st, si * 2 + 1),
constructSTUtil(arr, mid + 1, se,
st, si * 2 + 2));
return st[si];
"""Function to construct segment tree
from given array. This function allocates
memory for segment tree and calls constructSTUtil()
to fill the allocated memory """
def constructST( arr, n) :
# Allocate memory for segment tree
# Height of segment tree
x = (int)(ceil(log2(n)));
# Maximum size of segment tree
max_size = 2 * (int)(2**x) - 1;
st = [0] * (max_size);
# Fill the allocated memory st
constructSTUtil(arr, 0, n - 1, st, 0);
# Return the constructed segment tree
return st;
MOD = 10**9+7
mod=10**9+7
#t=1
p=10**9+7
def ncr_util():
inv[0]=inv[1]=1
fact[0]=fact[1]=1
for i in range(2,300001):
inv[i]=(inv[i%p]*(p-p//i))%p
for i in range(1,300001):
inv[i]=(inv[i-1]*inv[i])%p
fact[i]=(fact[i-1]*i)%p
def z_array(s1):
n = len(s1)
z=[0]*(n)
l, r, k = 0, 0, 0
for i in range(1,n):
# if i>R nothing matches so we will calculate.
# Z[i] using naive way.
if i > r:
l, r = i, i
# R-L = 0 in starting, so it will start
# checking from 0'th index. For example,
# for "ababab" and i = 1, the value of R
# remains 0 and Z[i] becomes 0. For string
# "aaaaaa" and i = 1, Z[i] and R become 5
while r < n and s1[r - l] == s1[r]:
r += 1
z[i] = r - l
r -= 1
else:
# k = i-L so k corresponds to number which
# matches in [L,R] interval.
k = i - l
# if Z[k] is less than remaining interval
# then Z[i] will be equal to Z[k].
# For example, str = "ababab", i = 3, R = 5
# and L = 2
if z[k] < r - i + 1:
z[i] = z[k]
# For example str = "aaaaaa" and i = 2,
# R is 5, L is 0
else:
# else start from R and check manually
l = i
while r < n and s1[r - l] == s1[r]:
r += 1
z[i] = r - l
r -= 1
return z
MAXN1=10000001
#spf=[0]*MAXN1
def sieve():
d1={}
d2=[0]*(MAXN1)
for i in range(1,MAXN1):
for j in range(i,MAXN1,i):
d2[j]+=i
if d2[i]<MAXN1 and d1.get(d2[i],-1)==-1:
d1[d2[i]]=i
return d1
#d1=sieve()
def factor(x):
d1={}
x1=x
while x!=1:
d1[spf[x]]=d1.get(spf[x],0)+1
x//=spf[x]
def primeFactors(n):
d1={}
while n % 2 == 0:
d1[2]=d1.get(2,0)+1
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
# while i divides n , print i ad divide n
while n % i== 0:
d1[i]=d1.get(i,0)+1
n = n // i
if n > 2:
d1[n]=d1.get(n,0)+1
return d1
def fs(x):
if x<2:
return 0
return (x*(x-1))//2
t=int(input())
#t=1
def solve():
ind=[]
for i in range(n):
if s[i]=='T':
ind.append(i)
l=0
d={}
for i in range(n):
if s[i]=='M':
if l>=len(ind) :
return "NO"
if ind[l]>i:
return "NO"
d[ind[l]]=1
l+=1
l=0
#print(d)
for i in range(n):
if s[i]=='M':
i1=-1
while l<len(ind) :
if ind[l]>i and d.get(ind[l],-1)==-1:
i1=l
d[ind[l]]=1
break
l+=1
if i1==-1:
return "NO"
if len(d)!=len(ind):
return "NO"
return "YES"
for _ in range(t):
#d={}
#n,l,r,s=map(int,input().split())
n=int(input())
s=input()
#l=list(map(int,input().split()))
#l2=list(map(int,input().split()))
# a=list(map(int,input().split()))
# b=list(map(int,input().split()))
#l.sort()
#l2=list(map(int,input().split()))
#l.sort()
#l.sort(revrese=True)
#x,y=(map(int,input().split()))
#l=str(n)
#l.sort(reverse=True)
#l2.sort(reverse=True)
#l1.sort(reverse=True)
print(solve())
#print()
#print(n,u,r,d,l)
```
| 11,867 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Submitted Solution:
```
t = int(input())
for i in range(t):
n = int(input())
tm = input()
mt = tm[::-1]
t = 0
m = 0
tt = 0
mm = 0
fail = 0
for j in range(n):
if tm[j] == "T":
t += 1
else:
m += 1
if mt[j] == "T":
tt += 1
else:
mm += 1
if m > t or mm > tt:
fail = 1
break
if t == 2 * m and fail == 0:
print("YES")
else:
print("NO")
```
Yes
| 11,868 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Submitted Solution:
```
x=int(input())
for i in range(x):
n=int(input())
a =input()
score=0
flag=True
for j in a:
if j=="T":
score+=1
else :
score-=1
if score<0 or score>n//3:
flag=False
break
if (flag and score==(n-2*(n//3))):
print("YES")
else :
print("NO")
```
Yes
| 11,869 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Submitted Solution:
```
def check(s):
c=0
for i in s:
if i=='T':
c+=1
else:
c-=1
if (c<0):
return False
c=0
s=s[::-1]
for i in s:
if i=='T':
c+=1
else:
c-=1
if (c<0):
return False
return True
for _ in range(int(input())):
n=int(input())
s=input()
if s.count('T')!=2*s.count('M'):
print("NO")
else:
if check(s):
print("YES")
else:
print("NO")
```
Yes
| 11,870 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Submitted Solution:
```
# import math as mt
# from collections import defaultdict
# from collections import Counter, deque
# from itertools import permutations
# from functools import reduce
# from heapq import heapify, heappop, heappush, heapreplace
def getInput(): return sys.stdin.readline().strip()
def getInt(): return int(getInput())
def getInts(): return map(int, getInput().split())
def getArray(): return list(getInts())
# sys.setrecursionlimit(10**7)
# INF = float('inf')
# MOD1, MOD2 = 10**9+7, 998244353
# def def_value():
# return 0
# Defining the dict
for _ in range(int(input())):
n = int(input())
st = input()
flag1= True
flag2= True
check = 0
for i in st:
if(i=="T"):
check+=1
elif(i=="M"):
check-=1
if(check<0):
flag1 = False
break
check =0
for i in st[::-1]:
if(i=="T"):
check+=1
elif(i=="M"):
check-=1
if(check<0):
flag2 = False
break
# print(flag1,flag2,st.count("T"),st.count("M"))
if(flag1 == True and flag2 == True and st.count("T") == st.count("M")*2):
print("YES")
else:
print("NO")
```
Yes
| 11,871 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Submitted Solution:
```
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def MAP2():return map(float,input().split())
def LIST(): return list(map(int, input().split()))
def STRING(): return input()
import string
import sys
from heapq import heappop , heappush
from bisect import *
from collections import deque , Counter , defaultdict
from math import *
from itertools import permutations , accumulate
dx = [-1 , 1 , 0 , 0 ]
dy = [0 , 0 , 1 , - 1]
#visited = [[False for i in range(m)] for j in range(n)]
# primes = [2,11,101,1009,10007,100003,1000003,10000019,102345689]
#sys.stdin = open(r'input.txt' , 'r')
#sys.stdout = open(r'output.txt' , 'w')
#for tt in range(INT()):
#Code
def solve(s):
cnt = 0
flag = True
for i in s :
if i == 'T':
cnt+=1
else:
cnt-=1
if cnt < 0 :
flag = False
break
if flag:
return True
return False
for tt in range(INT()):
n = INT()
s = STR()
cntM = s.count('M')
cntT = s.count('T')
if cntT == 0 or cntM == 0 or s[0] == 'M' or s[-1] == 'M' or 2 * cntM != cntT:
print('NO')
else:
if solve(s):
print('YES')
else:
print('NO')
```
No
| 11,872 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
string=input()
i=0
j=n-1
string=list(string)
print(string)
while string:
if string[0]=='M' or string[len(string)-1]=='M':
print("NO")
break
string.pop(0)
string.pop()
if 'M' in string:
string.remove("M")
else:
print("NO")
break
#print(string)
else:
print("YES")
```
No
| 11,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Submitted Solution:
```
import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math,datetime,functools,itertools,operator,bisect,fractions,statistics
from collections import deque,defaultdict,OrderedDict,Counter
from fractions import Fraction
from decimal import Decimal
from sys import stdout
from heapq import heappush, heappop, heapify ,_heapify_max,_heappop_max,nsmallest,nlargest
# sys.setrecursionlimit(111111)
INF=999999999999999999999999
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
def main():
mod=1000000007
# InverseofNumber(mod)
# InverseofFactorial(mod)
# factorial(mod)
starttime=datetime.datetime.now()
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
###CODE
tc = ri()
for _ in range(tc):
n=ri()
s=rs()
lp=n-1
fp=0
mp=1
count=0
while fp<mp<lp:
while fp<mp<lp and s[mp]!='M':
mp+=1
if not (fp<mp<lp):
break
else:
while fp<mp<lp and s[lp]!='T':
lp-=1
if not (fp<mp<lp):
break
else:
count+=1
lp-=1
fp+=1
mp+=1
if count*3==n:
ws("YES")
else:
ws("NO")
#<--Solving Area Ends
endtime=datetime.datetime.now()
time=(endtime-starttime).total_seconds()*1000
if(os.path.exists('input.txt')):
print("Time:",time,"ms")
class FastReader(io.IOBase):
newlines = 0
def __init__(self, fd, chunk_size=1024 * 8):
self._fd = fd
self._chunk_size = chunk_size
self.buffer = io.BytesIO()
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
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, size=-1):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
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()
class FastWriter(io.IOBase):
def __init__(self, fd):
self._fd = fd
self.buffer = io.BytesIO()
self.write = self.buffer.write
def flush(self):
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class FastStdin(io.IOBase):
def __init__(self, fd=0):
self.buffer = FastReader(fd)
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
class FastStdout(io.IOBase):
def __init__(self, fd=1):
self.buffer = FastWriter(fd)
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.flush = self.buffer.flush
if __name__ == '__main__':
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()
```
No
| 11,874 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The student council has a shared document file. Every day, some members of the student council write the sequence TMT (short for Towa Maji Tenshi) in it.
However, one day, the members somehow entered the sequence into the document at the same time, creating a jumbled mess. Therefore, it is Suguru Doujima's task to figure out whether the document has malfunctioned. Specifically, he is given a string of length n whose characters are all either T or M, and he wants to figure out if it is possible to partition it into some number of disjoint subsequences, all of which are equal to TMT. That is, each character of the string should belong to exactly one of the subsequences.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero) characters.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains an integer n (3 ≤ n < 10^5), the number of characters in the string entered in the document. It is guaranteed that n is divisible by 3.
The second line of each test case contains a string of length n consisting of only the characters T and M.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single line containing YES if the described partition exists, and a single line containing NO otherwise.
Example
Input
5
3
TMT
3
MTT
6
TMTMTT
6
TMTTTT
6
TTMMTT
Output
YES
NO
YES
NO
YES
Note
In the first test case, the string itself is already a sequence equal to TMT.
In the third test case, we may partition the string into the subsequences TMTMTT. Both the bolded and the non-bolded subsequences are equal to TMT.
Submitted Solution:
```
t=int(input())
def TMT(s,n):
t,m,f1,f2=0,0,1,1
i=0
while(i<n):
if i<n and s[i]=="T":
t=t+1
elif i<n and s[i]=="M":
f1=0
m=m+1
else:
f2=0
if m>t:
return True
else:
i=i-1
t,m,f1,f2=0,0,1,1
i=i+1
return False
for _ in range(t):
n=int(input())
s=input()
t=s.count("T")
m=s.count("M")
if (t!=(n//3)*2) or (m!=(n//3)) or (s[0]=="M") or (s[n-1]=="M") or TMT(s,n) or TMT(s[::-1],n):
print("NO")
else:
print("YES")
```
No
| 11,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Tags: binary search, dp, greedy, implementation, strings, two pointers
Correct Solution:
```
def main():
t=int(input())
allans=[]
for _ in range(t):
s=input()
n=len(s)
dp0=[0]*n # max len of beautiful ending with 0 here
dp1=[0]*n # max len of beautiful ending with 1 here
# dpq0=[0]*n # max len of beautiful ending with ? here, if made to be 0
for i,x in enumerate(s):
if s[i]=='?':
if i-1>=0:
dp0[i]=1+dp1[i-1]
dp1[i]=1+dp0[i-1]
else:
dp0[i]=1
dp1[i]=1
elif s[i]=='0':
if i-1>=0:
dp0[i]=1+dp1[i-1]
else:
dp0[i]=1
else:
if i-1>=0:
dp1[i]=1+dp0[i-1]
else:
dp1[i]=1
cnts=0
for i in range(n):
if s[i]=='?':
cnts+=max(dp0[i],dp1[i])
else:
cnts+=dp0[i]+dp1[i]
# print(dp0)#
# print(dp1)#
allans.append(cnts)
multiLineArrayPrint(allans)
return
import sys
# input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
def makeArr(defaultValFactory,dimensionArr): # eg. makeArr(lambda:0,[n,m])
dv=defaultValFactory;da=dimensionArr
if len(da)==1:return [dv() for _ in range(da[0])]
else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
def queryInteractive(i,j):
print('? {} {}'.format(i,j))
sys.stdout.flush()
return int(input())
def answerInteractive(ans):
print('! {}'.format(' '.join([str(x) for x in ans])))
sys.stdout.flush()
inf=float('inf')
MOD=10**9+7
# MOD=998244353
for _abc in range(1):
main()
```
| 11,876 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Tags: binary search, dp, greedy, implementation, strings, two pointers
Correct Solution:
```
# Fast IO Region
import os
import sys
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")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# Get out of main function
def main():
pass
# decimal to binary
def binary(n):
return (bin(n).replace("0b", ""))
# binary to decimal
def decimal(s):
return (int(s, 2))
# power of a number base 2
def pow2(n):
p = 0
while n > 1:
n //= 2
p += 1
return (p)
# if number is prime in √n time
def isPrime(n):
if (n == 1):
return (False)
else:
root = int(n ** 0.5)
root += 1
for i in range(2, root):
if (n % i == 0):
return (False)
return (True)
# list to string ,no spaces
def lts(l):
s = ''.join(map(str, l))
return s
# String to list
def stl(s):
# for each character in string to list with no spaces -->
l = list(s)
# for space in string -->
# l=list(s.split(" "))
return l
# Returns list of numbers with a particular sum
def sq(a, target, arr=[]):
s = sum(arr)
if (s == target):
return arr
if (s >= target):
return
for i in range(len(a)):
n = a[i]
remaining = a[i + 1:]
ans = sq(remaining, target, arr + [n])
if (ans):
return ans
# Sieve for prime numbers in a range
def SieveOfEratosthenes(n):
cnt = 0
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
for p in range(2, n + 1):
if prime[p]:
cnt += 1
# print(p)
return (cnt)
# for positive integerse only
def nCr(n, r):
f = math.factorial
return f(n) // f(r) // f(n - r)
# 1000000007
mod = int(1e9) + 7
def ssinp(): return input()
# s=input()
def iinp(): return int(input())
# n=int(input())
def nninp(): return map(int, input().split())
# a,b,c=map(int,input().split())
def llinp(): return list(map(int, input().split()))
# a=list(map(int,input().split()))
def p(xyz): print(xyz)
def p2(a, b): print(a, b)
import math
# import random
# sys.setrecursionlimit(300000)
# from fractions import Fraction
# from collections import OrderedDict
# from collections import deque
######################## mat=[[0 for i in range(n)] for j in range(m)] ########################
######################## list.sort(key=lambda x:x[1]) for sorting a list according to second element in sublist ########################
######################## Speed: STRING < LIST < SET,DICTIONARY ########################
######################## from collections import deque ########################
######################## ASCII of A-Z= 65-90 ########################
######################## ASCII of a-z= 97-122 ########################
######################## d1.setdefault(key, []).append(value) ########################
for __ in range(iinp()):
s=ssinp()
l=list(s)
n=len(l)
ans =ans1=0
curr = l[0]
cnt=1
ques=0
if(curr=="?"):
ques+=1
for i in range(1,n):
if(curr=="?"):
if(l[i]=="1"):
curr="0"
elif(l[i]=="0"):
curr="1"
else:
cnt+=1
ques+=1
if(curr=="1"):
if(l[i]=="0" or l[i]=="?"):
cnt+=1
curr="0"
if(l[i]=="?"):
ques+=1
else:
ques=0
else:
ans+=(cnt*(cnt+1))//2
cnt=1+ques
ans1+=(ques*(ques+1))//2
curr="1"
ques=0
elif(curr=="0"):
if(l[i]=="1" or l[i]=="?"):
cnt+=1
curr="1"
if (l[i] == "?"):
ques += 1
else:
ques = 0
else:
ans+=(cnt*(cnt+1))//2
cnt = 1 + ques
ans1 += (ques * (ques + 1)) // 2
curr="0"
ques=0
ans+=(cnt*(cnt+1))//2
print(ans-ans1)
```
| 11,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Tags: binary search, dp, greedy, implementation, strings, two pointers
Correct Solution:
```
import sys
read=sys.stdin.buffer.read;readline=sys.stdin.buffer.readline;input=lambda:sys.stdin.readline().rstrip()
import bisect,string,math,time,functools,random,fractions
from bisect import*
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
rep=range;R=range
def I():return int(input())
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def AI():return map(int,open(0).read().split())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def NLI(n):return [[int(i) for i in input().split()] for i in range(n)]
def NLI_(n):return [[int(i)-1 for i in input().split()] for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def RLI(n=8,a=1,b=10):return [random.randint(a,b)for i in range(n)]
def RI(a=1,b=10):return random.randint(a,b)
def INP():
N=10
n=random.randint(1,N)
a=RLI(n,0,n-1)
return n,a
def Rtest(T):
case,err=0,0
for i in range(T):
inp=INP()
a1=naive(*inp)
a2=solve(*inp)
if a1!=a2:
print(inp)
print('naive',a1)
print('solve',a2)
err+=1
case+=1
print('Tested',case,'case with',err,'errors')
def GI(V,E,ls=None,Directed=False,index=1):
org_inp=[];g=[[] for i in range(V)]
FromStdin=True if ls==None else False
for i in range(E):
if FromStdin:
inp=LI()
org_inp.append(inp)
else:
inp=ls[i]
if len(inp)==2:a,b=inp;c=1
else:a,b,c=inp
if index==1:a-=1;b-=1
aa=(a,c);bb=(b,c);g[a].append(bb)
if not Directed:g[b].append(aa)
return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1) # sample usage
mp=[boundary]*(w+2);found={}
for i in R(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
mp+=[boundary]*(w+2)
return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def accum(ls):
rt=[0]
for i in ls:rt+=[rt[-1]+i]
return rt
def bit_combination(n,base=2):
rt=[]
for tb in R(base**n):s=[tb//(base**bt)%base for bt in R(n)];rt+=[s]
return rt
def gcd(x,y):
if y==0:return x
if x%y==0:return y
while x%y!=0:x,y=y,x%y
return y
def YN(x):print(['NO','YES'][x])
def Yn(x):print(['No','Yes'][x])
def show(*inp,end='\n'):
if show_flg:print(*inp,end=end)
mo=10**9+7
#mo=998244353
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
alp=[chr(ord('a')+i)for i in range(26)]
#sys.setrecursionlimit(10**7)
def gcj(c,x):
print("Case #{0}:".format(c+1),x)
show_flg=False
show_flg=True
import sys
read=sys.stdin.buffer.read;readline=sys.stdin.buffer.readline;input=lambda:sys.stdin.readline().rstrip()
def gcd(x,y):
if y==0:return x
if x%y==0:return y
while x%y!=0:x,y=y,x%y
return y
for i in range(int(input())):
s=list(input())
n=len(s)
s+=' ',
s0=[0]
for i in range(n):
s0+=1-s0[-1],
s1=[1]
for i in range(n):
s1+=1-s1[-1],
x=[]
l=0
for i in range(n+1):
c=s[i]
if c=='?' or c==str(s0[i]):
l+=1
else:
if l==0:
continue
x+=l,
l=0
y=[]
z=[]
l=0
r=0
for i in range(n+1):
c=s[i]
if c=='?' or c==str(s1[i]):
l+=1
else:
if l==0:
continue
y+=l,
l=0
if c=='?':
r+=1
else:
if r==0:
continue
z+=r,
r=0
ans=0
ans+=sum(i*(i+1)//2for i in x)
ans+=sum(i*(i+1)//2for i in y)
ans-=sum(i*(i+1)//2for i in z)
#show(x,y,z)
print(ans)
```
| 11,878 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Tags: binary search, dp, greedy, implementation, strings, two pointers
Correct Solution:
```
import bisect
import copy
import decimal
import fractions
import heapq
import itertools
import math
import random
import sys
from collections import Counter, deque,defaultdict
from functools import lru_cache,reduce
from heapq import heappush,heappop,heapify,_heappop_max,_heapify_max
def _heappush_max(heap,item):
heap.append(item)
heapq._siftdown_max(heap,0,len(heap)-1)
from math import gcd as Gcd
read=sys.stdin.read
readline=sys.stdin.readline
readlines=sys.stdin.readlines
t=int(readline())
for _ in range(t):
S=readline().rstrip()
N=len(S)
idx=[None]*N
bound=[]
for i in range(1,N):
if S[i-1]!='?':
idx[i]=i-1
else:
idx[i]=idx[i-1]
for i in range(N):
if idx[i]==None:
continue
if S[i]=='?':
continue
if (i%2==idx[i]%2)!=(S[i]==S[idx[i]]):
bound.append((idx[i],i+1))
L,R=[0],[]
for i,j in bound:
L.append(i+1)
R.append(j-1)
R.append(N)
ans=0
for l,r in zip(L,R):
d=r-l+1
ans+=d*(d-1)//2
for i,j in bound:
d=j-i-1
ans-=d*(d-1)//2
print(ans)
```
| 11,879 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Tags: binary search, dp, greedy, implementation, strings, two pointers
Correct Solution:
```
import math
t=int(input())
for _ in range(t):
s=input()
b=[]
for j in s:
b.append(j)
n=len(b)
s=[]
ans=1
dp=[0 for i in range(n)]
la=0
dp[0]=1
for j in range(1,n):
if b[la]=="?":
dp[j]=j-la+1
else:
if b[j]=="?":
dp[j]=j-la+dp[la]
else:
if (j-la)%2:
if b[j]!=b[la]:
dp[j]=dp[la]+(j-la)
else:
dp[j]=j-la
else:
if b[j] == b[la]:
dp[j] = dp[la] + (j - la)
else:
dp[j] = j - la
if b[j]!="?":
la=j
print(sum(dp))
```
| 11,880 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Tags: binary search, dp, greedy, implementation, strings, two pointers
Correct Solution:
```
from sys import stdin
from math import gcd
input=lambda:stdin.readline().strip()
for _ in range(int(input())):
s=input()
n=len(s)
ans=-1
i=0
nd=0
sum1=0
while i<n:
if s[i]=='?':
if ans!=-1:
ans=ans^1
nd+=1
i+=1
else:
nd+=1
i+=1
else:
if ans==-1:
ans=int(s[i])^1
i+=1
nd+=1
else:
if ans!=int(s[i]):
#print("nd ",nd,i,ans,s[i])
sum1+=((nd*(nd+1))//2)
nd=0
nk=0
while i>0:
if s[i-1]=='?':
i-=1
nk+=1
else:
break
sum1-=((nk*(nk+1))//2)
ans=-1
else:
ans=ans^1
nd+=1
i+=1
#print(i)
if nd!=0:
sum1+=((nd*(nd+1))//2)
print(sum1)
```
| 11,881 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Tags: binary search, dp, greedy, implementation, strings, two pointers
Correct Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
import math
from collections import Counter
def func(array):
num = 0
last_question = None
last_number = None
start = None
first = None
first_index = None
for i, val in enumerate(array):
# print("Start", i, num, first_index, start, last_question)
if first is None:
if val != "?":
first = val
first_index = i
last_question = None
last_number = i
if start is None:
start = i
elif last_question is None:
last_question = i
start = i
num += i - start + 1
else:
if val == "?":
num += i - start + 1
if last_question is None or last_question < last_number:
last_question = i
elif (val == first and (i - first_index) % 2 == 0) or (
val != first and (i - first_index) % 2 != 0
):
num += i - start + 1
last_number = i
last_question = None
else:
# num += ((i - start) * (i - start - 1)) // 2
# print("last")
if last_question is not None and last_question > first_index:
# print("Here")
start = last_question
else:
start = i
last_question = None
first_index = i
first = val
last_number = i
num += i - start + 1
# print(i, val, num, first_index, start, last_question)
# num += ((len(array) - start) * (len(array) - 1 - start - 1)) // 2
return num
def main():
num_test = int(parse_input())
result = []
for _ in range(num_test):
array = parse_input()
result.append(func(array))
print("\n".join(map(str, result)))
# region fastio
# 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)
parse_input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
```
| 11,882 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Tags: binary search, dp, greedy, implementation, strings, two pointers
Correct Solution:
```
from collections import Counter
def unstable(s):
P = [None if c == '?' else ((c == '1') == (i % 2))
for (i, c) in enumerate(s)]
q = 0
k = 0
r = None
u = 0
for p in P:
if p is None:
q += 1
k += 1
elif p == r:
q = 0
k += 1
else:
u += k * (k+1) // 2
u -= q * (q+1) // 2
k = q + 1
q = 0
r = p
u += k * (k + 1) // 2
return u
def main():
t = readint()
print('\n'.join(map(str, (unstable(input()) for _ in range(t)))))
##########
import sys
def readint():
return int(input())
def readinti():
return map(int, input().split())
def readintt():
return tuple(readinti())
def readintl():
return list(readinti())
def readinttl(k):
return [readintt() for _ in range(k)]
def readintll(k):
return [readintl() for _ in range(k)]
def log(*args, **kwargs):
print(*args, **kwargs, file=sys.stderr)
if __name__ == '__main__':
main()
```
| 11,883 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Submitted Solution:
```
bu=int(input())
for j in range(bu):
ap=input()
i=len(ap)
for az in range(len(ap)):
if ap[az]!='?':
i=az+1
digit=ap[az]
count=az+1
lastquestionmark=0
break
else:pass
if i==len(ap):
print((len(ap)*(len(ap)+1))//2)
continue
ans=len(ap)
while i<len(ap):
if ap[i]=='?':
if ap[i-1]!='?':
lastquestionmark=i
count+=1
i+=1
if digit=='1':
digit='0'
else :
digit='1'
else:
count+=1
i+=1
if digit=='1':
digit='0'
else :
digit='1'
elif digit==ap[i]:
ans=ans+((count*(count-1))//2)
if ap[i-1]=='?' and lastquestionmark!=i-1:
i+=1
count=i-lastquestionmark
ans-=((count-1)*(count-2))//2
elif ap[i-1]=='?' and lastquestionmark==i-1:
count=2
i+=1
else:
i+=1
count=1
else:
i+=1
count+=1
if digit=='1':
digit='0'
else :digit='1'
ans+=(count*(count-1))//2
print(ans)
```
Yes
| 11,884 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Submitted Solution:
```
import os, sys
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")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
for _ in range(int(input())):
a = [i for i in input()]
n = len(a)
i = 0
j = 0
ans = 0
ct = 0
while i < n:
while j < n:
if i == j:
if a[j] == '?':
ct += 1
j += 1
else:
if a[j] == '?':
ct += 1
j += 1
else:
if ct == j - i:
j += 1
else:
if a[j - ct - 1] == a[j]:
if ct % 2:
j += 1
else:
while i != j - ct:
ans += j - i
i += 1
else:
if ct % 2:
while i != j - ct:
ans += j - i
i += 1
else:
j += 1
ct = 0
break
while i != j - 1:
ans += j - i
i += 1
print(ans + 1)
```
Yes
| 11,885 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Submitted Solution:
```
t=int(input())
for test in range(t):
s=input()
n=len(s)
ans=0
l=0
r=0
pr=0
while r<n:
p=True
zp=-1
z=-1
op=-2
o=-2
while r<n and p:
if s[r]=='1':
zp=r%2
if zp==op:
#r-=1
break
z=r
op=1-zp
elif s[r]=='0':
op=r%2
if zp==op:
#r-=1
break
o=r
zp=1-op
r+=1
b=r-l
c=pr-l
#b-=1
ans+=b*(b+1)//2
ans-=c*(c+1)//2
#print(*[l,r])
l=max(z,o)+1
pr=r
print(ans)
```
Yes
| 11,886 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Submitted Solution:
```
for _ in range(int(input())):
s = list(input())
ret = 0
dp = [[0, 0] for _ in range(len(s) + 1)]
for i in range(1, len(s) + 1):
if s[i-1] != '0':
dp[i][0] = dp[i - 1][1] + 1
if s[i-1] != '1':
dp[i][1] = dp[i - 1][0] + 1
ret += max(dp[i][0], dp[i][1])
print(ret)
```
Yes
| 11,887 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Submitted Solution:
```
def Convert(string):
list1=[]
list1[:0]=string
return list1
for _ in range(int(input())):
s = Convert(input())
n = len(s)
count = 0
for i in range(n):
start = s[i]
qcount = 0
found = False
temp = count
for j in range(i,n):
# print("j is " ,j)
if (i == j):
count += 1
else:
if (s[j] != '?'):
if (s[j] == s[j-1]):
break
else:
if (found == False):
count += 1
else:
# print("i is ",i," qcount is ",qcount," start is ",start," s[j] is ",s[j]," count is ",count)
found = False
if (start == s[j]):
if (qcount%2 == 1):
count += 1
else:
break
else:
if (qcount%2 == 0):
count += 1
else:
# print("break")
break
qcount = 0
else:
if (found == False):
found = True
start = s[j-1]
qcount += 1
count += 1
# print(count-temp)
print(count)
```
No
| 11,888 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Submitted Solution:
```
def compliment(a):
if a == "1":
return "0"
else:
return "1"
def calc(n):
return n*(n+1)//2
for _ in range(int(input())):
s = input()
n = len(s)
i = 0
j = 0
substring = [(0,0)]
while j < n and s[j] == "?":
j += 1
if j == n:
print(n * (n+1)//2)
else:
curr = s[j]
j += 1
while j < n:
if s[j] == "?":
curr = compliment(curr)
j+=1
else:
if s[j] != curr:
curr = compliment(curr)
j += 1
else:
substring.append((i,j-1))
if s[j-1] == "?":
i = j-1
curr = s[j]
else:
i = j
curr = s[j]
j += 1
substring.append((i,j-1))
#print(substring)
substring = substring[::-1]
ans = 0
for i in range(len(substring)):
ans += calc((substring[i][1] - substring[i][0])+1)
if substring[i][0] == 0:
break
if substring[i][0] == substring[i+1][1]:
ans -= 1
print(ans)
```
No
| 11,889 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Submitted Solution:
```
from math import gcd
for _ in range(int(input())):
s = input()
n = len(s)
ans = 0
curr = 0
prevans = 0
prev = None
dic = {'0':'1', '1':'0'}
for i in s:
addn = 0
if i != prev and prev!=None:
ans += prevans+1
addn+=prevans+1
else:
ans += curr+1
addn += curr+1
prevans = addn
if i == '?':
curr += 1
else:
curr = 0
if i != '?':
prev = i
elif prev:
prev = dic[prev]
print(i, ans, prev, prevans)
print(ans)
```
No
| 11,890 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of the characters 0, 1, and ?.
Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).
Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.
For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.
Calculate the number of beautiful contiguous substrings of the string s.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
The first and only line of each test case contains the string s (1 ≤ |s| ≤ 2 ⋅ 10^5) consisting of characters 0, 1, and ?.
It is guaranteed that the sum of the string lengths over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output a single integer — the number of beautiful substrings of the string s.
Example
Input
3
0?10
???
?10??1100
Output
8
6
25
Submitted Solution:
```
def flip(a,x="?"):
if a=="1":
return("0")
elif a=="0":
return("1")
elif x=="?":
return "?"
else:
return x
for i in range(int(input())):
s=input()
ans=0
qlen=0
len=1
if s[0]=="?":
qlen+=1
ch=s[0]
for i in s[1:]:
if i=="?":
qlen+=1
len+=1
ch=flip(ch,i)
if i=="0":
if ch=="0":
ch=i
ans+=len*(len+1)/2-qlen*(qlen+1)/2
len=1
qlen=0
else:
qlen=0
len+=1
ch=flip(ch,i)
if i=="1":
if ch=="1":
ch=i
ans+=len*(len+1)/2-qlen*(qlen+1)/2
len=1
qlen=0
else:
qlen=0
len+=1
ch=flip(ch,i)
print(ans)
```
No
| 11,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya lives in a strange world. The year has n months and the i-th month has ai days. Vasya got a New Year present — the clock that shows not only the time, but also the date.
The clock's face can display any number from 1 to d. It is guaranteed that ai ≤ d for all i from 1 to n. The clock does not keep information about the current month, so when a new day comes, it simply increases the current day number by one. The clock cannot display number d + 1, so after day number d it shows day 1 (the current day counter resets). The mechanism of the clock allows you to increase the day number by one manually. When you execute this operation, day d is also followed by day 1.
Vasya begins each day checking the day number on the clock. If the day number on the clock does not match the actual day number in the current month, then Vasya manually increases it by one. Vasya is persistent and repeats this operation until the day number on the clock matches the actual number of the current day in the current month.
A year passed and Vasya wonders how many times he manually increased the day number by one, from the first day of the first month to the last day of the n-th month inclusive, considering that on the first day of the first month the clock display showed day 1.
Input
The first line contains the single number d — the maximum number of the day that Vasya's clock can show (1 ≤ d ≤ 106).
The second line contains a single integer n — the number of months in the year (1 ≤ n ≤ 2000).
The third line contains n space-separated integers: ai (1 ≤ ai ≤ d) — the number of days in each month in the order in which they follow, starting from the first one.
Output
Print a single number — the number of times Vasya manually increased the day number by one throughout the last year.
Examples
Input
4
2
2 2
Output
2
Input
5
3
3 4 3
Output
3
Input
31
12
31 28 31 30 31 30 31 31 30 31 30 31
Output
7
Note
In the first sample the situation is like this:
* Day 1. Month 1. The clock shows 1. Vasya changes nothing.
* Day 2. Month 1. The clock shows 2. Vasya changes nothing.
* Day 1. Month 2. The clock shows 3. Vasya manually increases the day number by 1. After that the clock shows 4. Vasya increases the day number by 1 manually. After that the clock shows 1.
* Day 2. Month 2. The clock shows 2. Vasya changes nothing.
In total, Vasya manually changed the day number by 1 exactly 2 times.
Tags: implementation
Correct Solution:
```
d=int(input())
n=int(input())
a=list(map(int,input().split()))
b=d-a[-1]
max_day=d*n
summa=sum(a)
print(max_day-summa-b)
```
| 11,892 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya lives in a strange world. The year has n months and the i-th month has ai days. Vasya got a New Year present — the clock that shows not only the time, but also the date.
The clock's face can display any number from 1 to d. It is guaranteed that ai ≤ d for all i from 1 to n. The clock does not keep information about the current month, so when a new day comes, it simply increases the current day number by one. The clock cannot display number d + 1, so after day number d it shows day 1 (the current day counter resets). The mechanism of the clock allows you to increase the day number by one manually. When you execute this operation, day d is also followed by day 1.
Vasya begins each day checking the day number on the clock. If the day number on the clock does not match the actual day number in the current month, then Vasya manually increases it by one. Vasya is persistent and repeats this operation until the day number on the clock matches the actual number of the current day in the current month.
A year passed and Vasya wonders how many times he manually increased the day number by one, from the first day of the first month to the last day of the n-th month inclusive, considering that on the first day of the first month the clock display showed day 1.
Input
The first line contains the single number d — the maximum number of the day that Vasya's clock can show (1 ≤ d ≤ 106).
The second line contains a single integer n — the number of months in the year (1 ≤ n ≤ 2000).
The third line contains n space-separated integers: ai (1 ≤ ai ≤ d) — the number of days in each month in the order in which they follow, starting from the first one.
Output
Print a single number — the number of times Vasya manually increased the day number by one throughout the last year.
Examples
Input
4
2
2 2
Output
2
Input
5
3
3 4 3
Output
3
Input
31
12
31 28 31 30 31 30 31 31 30 31 30 31
Output
7
Note
In the first sample the situation is like this:
* Day 1. Month 1. The clock shows 1. Vasya changes nothing.
* Day 2. Month 1. The clock shows 2. Vasya changes nothing.
* Day 1. Month 2. The clock shows 3. Vasya manually increases the day number by 1. After that the clock shows 4. Vasya increases the day number by 1 manually. After that the clock shows 1.
* Day 2. Month 2. The clock shows 2. Vasya changes nothing.
In total, Vasya manually changed the day number by 1 exactly 2 times.
Tags: implementation
Correct Solution:
```
d = int(input())
n = int(input())
l = list(map(int,input().split()))
count = 0
sum = 0
for i in range(n-1):
if d>l[i]:
count+=d - l[i]
print(count)
```
| 11,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya lives in a strange world. The year has n months and the i-th month has ai days. Vasya got a New Year present — the clock that shows not only the time, but also the date.
The clock's face can display any number from 1 to d. It is guaranteed that ai ≤ d for all i from 1 to n. The clock does not keep information about the current month, so when a new day comes, it simply increases the current day number by one. The clock cannot display number d + 1, so after day number d it shows day 1 (the current day counter resets). The mechanism of the clock allows you to increase the day number by one manually. When you execute this operation, day d is also followed by day 1.
Vasya begins each day checking the day number on the clock. If the day number on the clock does not match the actual day number in the current month, then Vasya manually increases it by one. Vasya is persistent and repeats this operation until the day number on the clock matches the actual number of the current day in the current month.
A year passed and Vasya wonders how many times he manually increased the day number by one, from the first day of the first month to the last day of the n-th month inclusive, considering that on the first day of the first month the clock display showed day 1.
Input
The first line contains the single number d — the maximum number of the day that Vasya's clock can show (1 ≤ d ≤ 106).
The second line contains a single integer n — the number of months in the year (1 ≤ n ≤ 2000).
The third line contains n space-separated integers: ai (1 ≤ ai ≤ d) — the number of days in each month in the order in which they follow, starting from the first one.
Output
Print a single number — the number of times Vasya manually increased the day number by one throughout the last year.
Examples
Input
4
2
2 2
Output
2
Input
5
3
3 4 3
Output
3
Input
31
12
31 28 31 30 31 30 31 31 30 31 30 31
Output
7
Note
In the first sample the situation is like this:
* Day 1. Month 1. The clock shows 1. Vasya changes nothing.
* Day 2. Month 1. The clock shows 2. Vasya changes nothing.
* Day 1. Month 2. The clock shows 3. Vasya manually increases the day number by 1. After that the clock shows 4. Vasya increases the day number by 1 manually. After that the clock shows 1.
* Day 2. Month 2. The clock shows 2. Vasya changes nothing.
In total, Vasya manually changed the day number by 1 exactly 2 times.
Tags: implementation
Correct Solution:
```
a=int(input())
b=int(input())
ans=0
arr=list(map(int,input().split()))
for i in range(b-1):
ans+=abs(a-arr[i])
print(ans)
```
| 11,894 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya lives in a strange world. The year has n months and the i-th month has ai days. Vasya got a New Year present — the clock that shows not only the time, but also the date.
The clock's face can display any number from 1 to d. It is guaranteed that ai ≤ d for all i from 1 to n. The clock does not keep information about the current month, so when a new day comes, it simply increases the current day number by one. The clock cannot display number d + 1, so after day number d it shows day 1 (the current day counter resets). The mechanism of the clock allows you to increase the day number by one manually. When you execute this operation, day d is also followed by day 1.
Vasya begins each day checking the day number on the clock. If the day number on the clock does not match the actual day number in the current month, then Vasya manually increases it by one. Vasya is persistent and repeats this operation until the day number on the clock matches the actual number of the current day in the current month.
A year passed and Vasya wonders how many times he manually increased the day number by one, from the first day of the first month to the last day of the n-th month inclusive, considering that on the first day of the first month the clock display showed day 1.
Input
The first line contains the single number d — the maximum number of the day that Vasya's clock can show (1 ≤ d ≤ 106).
The second line contains a single integer n — the number of months in the year (1 ≤ n ≤ 2000).
The third line contains n space-separated integers: ai (1 ≤ ai ≤ d) — the number of days in each month in the order in which they follow, starting from the first one.
Output
Print a single number — the number of times Vasya manually increased the day number by one throughout the last year.
Examples
Input
4
2
2 2
Output
2
Input
5
3
3 4 3
Output
3
Input
31
12
31 28 31 30 31 30 31 31 30 31 30 31
Output
7
Note
In the first sample the situation is like this:
* Day 1. Month 1. The clock shows 1. Vasya changes nothing.
* Day 2. Month 1. The clock shows 2. Vasya changes nothing.
* Day 1. Month 2. The clock shows 3. Vasya manually increases the day number by 1. After that the clock shows 4. Vasya increases the day number by 1 manually. After that the clock shows 1.
* Day 2. Month 2. The clock shows 2. Vasya changes nothing.
In total, Vasya manually changed the day number by 1 exactly 2 times.
Tags: implementation
Correct Solution:
```
d = int(input())
n = int(input())
a = list(map(int, input().split()))
ans = sum([d - x for x in a[:-1]])
print(ans)
```
| 11,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya lives in a strange world. The year has n months and the i-th month has ai days. Vasya got a New Year present — the clock that shows not only the time, but also the date.
The clock's face can display any number from 1 to d. It is guaranteed that ai ≤ d for all i from 1 to n. The clock does not keep information about the current month, so when a new day comes, it simply increases the current day number by one. The clock cannot display number d + 1, so after day number d it shows day 1 (the current day counter resets). The mechanism of the clock allows you to increase the day number by one manually. When you execute this operation, day d is also followed by day 1.
Vasya begins each day checking the day number on the clock. If the day number on the clock does not match the actual day number in the current month, then Vasya manually increases it by one. Vasya is persistent and repeats this operation until the day number on the clock matches the actual number of the current day in the current month.
A year passed and Vasya wonders how many times he manually increased the day number by one, from the first day of the first month to the last day of the n-th month inclusive, considering that on the first day of the first month the clock display showed day 1.
Input
The first line contains the single number d — the maximum number of the day that Vasya's clock can show (1 ≤ d ≤ 106).
The second line contains a single integer n — the number of months in the year (1 ≤ n ≤ 2000).
The third line contains n space-separated integers: ai (1 ≤ ai ≤ d) — the number of days in each month in the order in which they follow, starting from the first one.
Output
Print a single number — the number of times Vasya manually increased the day number by one throughout the last year.
Examples
Input
4
2
2 2
Output
2
Input
5
3
3 4 3
Output
3
Input
31
12
31 28 31 30 31 30 31 31 30 31 30 31
Output
7
Note
In the first sample the situation is like this:
* Day 1. Month 1. The clock shows 1. Vasya changes nothing.
* Day 2. Month 1. The clock shows 2. Vasya changes nothing.
* Day 1. Month 2. The clock shows 3. Vasya manually increases the day number by 1. After that the clock shows 4. Vasya increases the day number by 1 manually. After that the clock shows 1.
* Day 2. Month 2. The clock shows 2. Vasya changes nothing.
In total, Vasya manually changed the day number by 1 exactly 2 times.
Tags: implementation
Correct Solution:
```
d=int(input())
n=int(input())
a=list(map(int, input().split()))
if max(a) > d:
print("-1")
else:
nb=0
for i in range(n-1):
nb += abs(d-a[i])
print(nb)
```
| 11,896 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya lives in a strange world. The year has n months and the i-th month has ai days. Vasya got a New Year present — the clock that shows not only the time, but also the date.
The clock's face can display any number from 1 to d. It is guaranteed that ai ≤ d for all i from 1 to n. The clock does not keep information about the current month, so when a new day comes, it simply increases the current day number by one. The clock cannot display number d + 1, so after day number d it shows day 1 (the current day counter resets). The mechanism of the clock allows you to increase the day number by one manually. When you execute this operation, day d is also followed by day 1.
Vasya begins each day checking the day number on the clock. If the day number on the clock does not match the actual day number in the current month, then Vasya manually increases it by one. Vasya is persistent and repeats this operation until the day number on the clock matches the actual number of the current day in the current month.
A year passed and Vasya wonders how many times he manually increased the day number by one, from the first day of the first month to the last day of the n-th month inclusive, considering that on the first day of the first month the clock display showed day 1.
Input
The first line contains the single number d — the maximum number of the day that Vasya's clock can show (1 ≤ d ≤ 106).
The second line contains a single integer n — the number of months in the year (1 ≤ n ≤ 2000).
The third line contains n space-separated integers: ai (1 ≤ ai ≤ d) — the number of days in each month in the order in which they follow, starting from the first one.
Output
Print a single number — the number of times Vasya manually increased the day number by one throughout the last year.
Examples
Input
4
2
2 2
Output
2
Input
5
3
3 4 3
Output
3
Input
31
12
31 28 31 30 31 30 31 31 30 31 30 31
Output
7
Note
In the first sample the situation is like this:
* Day 1. Month 1. The clock shows 1. Vasya changes nothing.
* Day 2. Month 1. The clock shows 2. Vasya changes nothing.
* Day 1. Month 2. The clock shows 3. Vasya manually increases the day number by 1. After that the clock shows 4. Vasya increases the day number by 1 manually. After that the clock shows 1.
* Day 2. Month 2. The clock shows 2. Vasya changes nothing.
In total, Vasya manually changed the day number by 1 exactly 2 times.
Tags: implementation
Correct Solution:
```
import math
d = int(input())
n = int(input())
a = [int(x) for x in input().split()]
sum = 0
i = 0
while i < n-1:
sum = sum + d-a[i]
i = i+1
print(sum)
```
| 11,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya lives in a strange world. The year has n months and the i-th month has ai days. Vasya got a New Year present — the clock that shows not only the time, but also the date.
The clock's face can display any number from 1 to d. It is guaranteed that ai ≤ d for all i from 1 to n. The clock does not keep information about the current month, so when a new day comes, it simply increases the current day number by one. The clock cannot display number d + 1, so after day number d it shows day 1 (the current day counter resets). The mechanism of the clock allows you to increase the day number by one manually. When you execute this operation, day d is also followed by day 1.
Vasya begins each day checking the day number on the clock. If the day number on the clock does not match the actual day number in the current month, then Vasya manually increases it by one. Vasya is persistent and repeats this operation until the day number on the clock matches the actual number of the current day in the current month.
A year passed and Vasya wonders how many times he manually increased the day number by one, from the first day of the first month to the last day of the n-th month inclusive, considering that on the first day of the first month the clock display showed day 1.
Input
The first line contains the single number d — the maximum number of the day that Vasya's clock can show (1 ≤ d ≤ 106).
The second line contains a single integer n — the number of months in the year (1 ≤ n ≤ 2000).
The third line contains n space-separated integers: ai (1 ≤ ai ≤ d) — the number of days in each month in the order in which they follow, starting from the first one.
Output
Print a single number — the number of times Vasya manually increased the day number by one throughout the last year.
Examples
Input
4
2
2 2
Output
2
Input
5
3
3 4 3
Output
3
Input
31
12
31 28 31 30 31 30 31 31 30 31 30 31
Output
7
Note
In the first sample the situation is like this:
* Day 1. Month 1. The clock shows 1. Vasya changes nothing.
* Day 2. Month 1. The clock shows 2. Vasya changes nothing.
* Day 1. Month 2. The clock shows 3. Vasya manually increases the day number by 1. After that the clock shows 4. Vasya increases the day number by 1 manually. After that the clock shows 1.
* Day 2. Month 2. The clock shows 2. Vasya changes nothing.
In total, Vasya manually changed the day number by 1 exactly 2 times.
Tags: implementation
Correct Solution:
```
d=int(input())
n=int(input())
nd=[int(x) for x in input().split()]
clock=1
i=0
c=0
while(i<n-1):
clock=nd[i]+1
if(clock>d):
clock=1
if(clock!=1):
c=c+(d+1-clock)
clock=1
i=i+1
print(c)
```
| 11,898 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya lives in a strange world. The year has n months and the i-th month has ai days. Vasya got a New Year present — the clock that shows not only the time, but also the date.
The clock's face can display any number from 1 to d. It is guaranteed that ai ≤ d for all i from 1 to n. The clock does not keep information about the current month, so when a new day comes, it simply increases the current day number by one. The clock cannot display number d + 1, so after day number d it shows day 1 (the current day counter resets). The mechanism of the clock allows you to increase the day number by one manually. When you execute this operation, day d is also followed by day 1.
Vasya begins each day checking the day number on the clock. If the day number on the clock does not match the actual day number in the current month, then Vasya manually increases it by one. Vasya is persistent and repeats this operation until the day number on the clock matches the actual number of the current day in the current month.
A year passed and Vasya wonders how many times he manually increased the day number by one, from the first day of the first month to the last day of the n-th month inclusive, considering that on the first day of the first month the clock display showed day 1.
Input
The first line contains the single number d — the maximum number of the day that Vasya's clock can show (1 ≤ d ≤ 106).
The second line contains a single integer n — the number of months in the year (1 ≤ n ≤ 2000).
The third line contains n space-separated integers: ai (1 ≤ ai ≤ d) — the number of days in each month in the order in which they follow, starting from the first one.
Output
Print a single number — the number of times Vasya manually increased the day number by one throughout the last year.
Examples
Input
4
2
2 2
Output
2
Input
5
3
3 4 3
Output
3
Input
31
12
31 28 31 30 31 30 31 31 30 31 30 31
Output
7
Note
In the first sample the situation is like this:
* Day 1. Month 1. The clock shows 1. Vasya changes nothing.
* Day 2. Month 1. The clock shows 2. Vasya changes nothing.
* Day 1. Month 2. The clock shows 3. Vasya manually increases the day number by 1. After that the clock shows 4. Vasya increases the day number by 1 manually. After that the clock shows 1.
* Day 2. Month 2. The clock shows 2. Vasya changes nothing.
In total, Vasya manually changed the day number by 1 exactly 2 times.
Tags: implementation
Correct Solution:
```
d = int(input())
n = int(input())
list1 = [int(x) for x in input().split()]
ans = 0
for i in range(n-1):
ans += d - list1[i]
print(ans)
```
| 11,899 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.