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 a chessboard of size n × n. It is filled with numbers from 1 to n^2 in the following way: the first ⌈ (n^2)/(2) ⌉ numbers from 1 to ⌈ (n^2)/(2) ⌉ are written in the cells with even sum of coordinates from left to right from top to bottom. The rest n^2 - ⌈ (n^2)/(2) ⌉ numbers from ⌈ (n^2)/(2) ⌉ + 1 to n^2 are written in the cells with odd sum of coordinates from left to right from top to bottom. The operation ⌈x/y⌉ means division x by y rounded up.
For example, the left board on the following picture is the chessboard which is given for n=4 and the right board is the chessboard which is given for n=5.
<image>
You are given q queries. The i-th query is described as a pair x_i, y_i. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n.
Input
The first line contains two integers n and q (1 ≤ n ≤ 10^9, 1 ≤ q ≤ 10^5) — the size of the board and the number of queries.
The next q lines contain two integers each. The i-th line contains two integers x_i, y_i (1 ≤ x_i, y_i ≤ n) — description of the i-th query.
Output
For each query from 1 to q print the answer to this query. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n. Queries are numbered from 1 to q in order of the input.
Examples
Input
4 5
1 1
4 4
4 3
3 2
2 4
Output
1
8
16
13
4
Input
5 4
2 1
4 2
3 3
3 4
Output
16
9
7
20
Note
Answers to the queries from examples are on the board in the picture from the problem statement.
Tags: implementation, math
Correct Solution:
```
n,q=map(int,input().split())
k=0
z=[]
for i in range(q):
x,y=map(int,input().split())
if n%2:
if (x+y)%2:
k=(n**2+1)//2
k+=(x-1)*n//2
k+=(y+1)//2
z.append(k)
else:
k=n//2*(x-1)
k+=x//2
k+=(y+1)//2
z.append(k)
else:
if (x+y)%2:
k=n**2//2
k+=(x-1)*n//2
k+=(y+1)//2
z.append(k)
else:
k=n//2*(x-1)
k+=(y+1)//2
z.append(k)
for i in z:
print(i)
```
| 86,600 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a chessboard of size n × n. It is filled with numbers from 1 to n^2 in the following way: the first ⌈ (n^2)/(2) ⌉ numbers from 1 to ⌈ (n^2)/(2) ⌉ are written in the cells with even sum of coordinates from left to right from top to bottom. The rest n^2 - ⌈ (n^2)/(2) ⌉ numbers from ⌈ (n^2)/(2) ⌉ + 1 to n^2 are written in the cells with odd sum of coordinates from left to right from top to bottom. The operation ⌈x/y⌉ means division x by y rounded up.
For example, the left board on the following picture is the chessboard which is given for n=4 and the right board is the chessboard which is given for n=5.
<image>
You are given q queries. The i-th query is described as a pair x_i, y_i. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n.
Input
The first line contains two integers n and q (1 ≤ n ≤ 10^9, 1 ≤ q ≤ 10^5) — the size of the board and the number of queries.
The next q lines contain two integers each. The i-th line contains two integers x_i, y_i (1 ≤ x_i, y_i ≤ n) — description of the i-th query.
Output
For each query from 1 to q print the answer to this query. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n. Queries are numbered from 1 to q in order of the input.
Examples
Input
4 5
1 1
4 4
4 3
3 2
2 4
Output
1
8
16
13
4
Input
5 4
2 1
4 2
3 3
3 4
Output
16
9
7
20
Note
Answers to the queries from examples are on the board in the picture from the problem statement.
Submitted Solution:
```
I = lambda: map(int, input().split())
n, q = I()
A = []
for _ in range(q):
x, y = I()
A.append((n*(x-1)+y+1 + (n*n if (x+y)%2 else 0)) // 2)
print(*A, sep='\n')
```
Yes
| 86,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a chessboard of size n × n. It is filled with numbers from 1 to n^2 in the following way: the first ⌈ (n^2)/(2) ⌉ numbers from 1 to ⌈ (n^2)/(2) ⌉ are written in the cells with even sum of coordinates from left to right from top to bottom. The rest n^2 - ⌈ (n^2)/(2) ⌉ numbers from ⌈ (n^2)/(2) ⌉ + 1 to n^2 are written in the cells with odd sum of coordinates from left to right from top to bottom. The operation ⌈x/y⌉ means division x by y rounded up.
For example, the left board on the following picture is the chessboard which is given for n=4 and the right board is the chessboard which is given for n=5.
<image>
You are given q queries. The i-th query is described as a pair x_i, y_i. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n.
Input
The first line contains two integers n and q (1 ≤ n ≤ 10^9, 1 ≤ q ≤ 10^5) — the size of the board and the number of queries.
The next q lines contain two integers each. The i-th line contains two integers x_i, y_i (1 ≤ x_i, y_i ≤ n) — description of the i-th query.
Output
For each query from 1 to q print the answer to this query. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n. Queries are numbered from 1 to q in order of the input.
Examples
Input
4 5
1 1
4 4
4 3
3 2
2 4
Output
1
8
16
13
4
Input
5 4
2 1
4 2
3 3
3 4
Output
16
9
7
20
Note
Answers to the queries from examples are on the board in the picture from the problem statement.
Submitted Solution:
```
def R(): return map(int, input().split())
ans = []
n, q = R()
d = (n*n+1)//2
for _ in range(q):
x, y = R()
i = ((x-1)*n+y-1)//2+1
if x % 2 != y % 2:
i += d
ans.append(str(i))
print("\n".join(ans))
```
Yes
| 86,602 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a chessboard of size n × n. It is filled with numbers from 1 to n^2 in the following way: the first ⌈ (n^2)/(2) ⌉ numbers from 1 to ⌈ (n^2)/(2) ⌉ are written in the cells with even sum of coordinates from left to right from top to bottom. The rest n^2 - ⌈ (n^2)/(2) ⌉ numbers from ⌈ (n^2)/(2) ⌉ + 1 to n^2 are written in the cells with odd sum of coordinates from left to right from top to bottom. The operation ⌈x/y⌉ means division x by y rounded up.
For example, the left board on the following picture is the chessboard which is given for n=4 and the right board is the chessboard which is given for n=5.
<image>
You are given q queries. The i-th query is described as a pair x_i, y_i. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n.
Input
The first line contains two integers n and q (1 ≤ n ≤ 10^9, 1 ≤ q ≤ 10^5) — the size of the board and the number of queries.
The next q lines contain two integers each. The i-th line contains two integers x_i, y_i (1 ≤ x_i, y_i ≤ n) — description of the i-th query.
Output
For each query from 1 to q print the answer to this query. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n. Queries are numbered from 1 to q in order of the input.
Examples
Input
4 5
1 1
4 4
4 3
3 2
2 4
Output
1
8
16
13
4
Input
5 4
2 1
4 2
3 3
3 4
Output
16
9
7
20
Note
Answers to the queries from examples are on the board in the picture from the problem statement.
Submitted Solution:
```
from functools import cmp_to_key
from math import *
import sys
def main():
n,q = [int(i) for i in sys.stdin.readline().split(' ')]
for i in range(q):
x, y = [int(i) for i in sys.stdin.readline().split(' ')]
tot = n*(x-1) + y
tot = (tot+1)//2
if (x + y) % 2 == 1:
tot += (n * n + 1) // 2 #ceiling division taken from Vovuh's answer
print(tot)
if __name__ == "__main__":
main()
```
Yes
| 86,603 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a chessboard of size n × n. It is filled with numbers from 1 to n^2 in the following way: the first ⌈ (n^2)/(2) ⌉ numbers from 1 to ⌈ (n^2)/(2) ⌉ are written in the cells with even sum of coordinates from left to right from top to bottom. The rest n^2 - ⌈ (n^2)/(2) ⌉ numbers from ⌈ (n^2)/(2) ⌉ + 1 to n^2 are written in the cells with odd sum of coordinates from left to right from top to bottom. The operation ⌈x/y⌉ means division x by y rounded up.
For example, the left board on the following picture is the chessboard which is given for n=4 and the right board is the chessboard which is given for n=5.
<image>
You are given q queries. The i-th query is described as a pair x_i, y_i. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n.
Input
The first line contains two integers n and q (1 ≤ n ≤ 10^9, 1 ≤ q ≤ 10^5) — the size of the board and the number of queries.
The next q lines contain two integers each. The i-th line contains two integers x_i, y_i (1 ≤ x_i, y_i ≤ n) — description of the i-th query.
Output
For each query from 1 to q print the answer to this query. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n. Queries are numbered from 1 to q in order of the input.
Examples
Input
4 5
1 1
4 4
4 3
3 2
2 4
Output
1
8
16
13
4
Input
5 4
2 1
4 2
3 3
3 4
Output
16
9
7
20
Note
Answers to the queries from examples are on the board in the picture from the problem statement.
Submitted Solution:
```
n,q=map(int,input().split())
a=[]
for i in range(q):
x,y=map(int,input().split())
k=(x-1)*n+y
ans=(k+1)//2
if (x+y)%2!=0:
ans+=(n**2+1)//2
a.append(ans)
print(*a)
```
Yes
| 86,604 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a chessboard of size n × n. It is filled with numbers from 1 to n^2 in the following way: the first ⌈ (n^2)/(2) ⌉ numbers from 1 to ⌈ (n^2)/(2) ⌉ are written in the cells with even sum of coordinates from left to right from top to bottom. The rest n^2 - ⌈ (n^2)/(2) ⌉ numbers from ⌈ (n^2)/(2) ⌉ + 1 to n^2 are written in the cells with odd sum of coordinates from left to right from top to bottom. The operation ⌈x/y⌉ means division x by y rounded up.
For example, the left board on the following picture is the chessboard which is given for n=4 and the right board is the chessboard which is given for n=5.
<image>
You are given q queries. The i-th query is described as a pair x_i, y_i. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n.
Input
The first line contains two integers n and q (1 ≤ n ≤ 10^9, 1 ≤ q ≤ 10^5) — the size of the board and the number of queries.
The next q lines contain two integers each. The i-th line contains two integers x_i, y_i (1 ≤ x_i, y_i ≤ n) — description of the i-th query.
Output
For each query from 1 to q print the answer to this query. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n. Queries are numbered from 1 to q in order of the input.
Examples
Input
4 5
1 1
4 4
4 3
3 2
2 4
Output
1
8
16
13
4
Input
5 4
2 1
4 2
3 3
3 4
Output
16
9
7
20
Note
Answers to the queries from examples are on the board in the picture from the problem statement.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Wed Aug 22 10:31:45 2018
@author: saurabh panjiara
"""
import sys
lst =sys.stdin.readlines()
n,q=map(int, lst[0].split() )
for i in range(q):
x , y=map(int,lst[i+1].split())
z=(x-1)*n
z=z+y
z=int((z+1)/2)
if (x+y)%2 != 0:
z=z+int((n*n+1)/2)
sys.stdout.write(str(z) + '\n')
```
No
| 86,605 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a chessboard of size n × n. It is filled with numbers from 1 to n^2 in the following way: the first ⌈ (n^2)/(2) ⌉ numbers from 1 to ⌈ (n^2)/(2) ⌉ are written in the cells with even sum of coordinates from left to right from top to bottom. The rest n^2 - ⌈ (n^2)/(2) ⌉ numbers from ⌈ (n^2)/(2) ⌉ + 1 to n^2 are written in the cells with odd sum of coordinates from left to right from top to bottom. The operation ⌈x/y⌉ means division x by y rounded up.
For example, the left board on the following picture is the chessboard which is given for n=4 and the right board is the chessboard which is given for n=5.
<image>
You are given q queries. The i-th query is described as a pair x_i, y_i. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n.
Input
The first line contains two integers n and q (1 ≤ n ≤ 10^9, 1 ≤ q ≤ 10^5) — the size of the board and the number of queries.
The next q lines contain two integers each. The i-th line contains two integers x_i, y_i (1 ≤ x_i, y_i ≤ n) — description of the i-th query.
Output
For each query from 1 to q print the answer to this query. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n. Queries are numbered from 1 to q in order of the input.
Examples
Input
4 5
1 1
4 4
4 3
3 2
2 4
Output
1
8
16
13
4
Input
5 4
2 1
4 2
3 3
3 4
Output
16
9
7
20
Note
Answers to the queries from examples are on the board in the picture from the problem statement.
Submitted Solution:
```
import math
def get_odd(x, y, n):
m = math.ceil(n * n / 2)
temp = x % 2
if n % 2 == 0:
return m + x * n / 2 + temp * (math.floor(y / 2) + 1) + (1 - temp) * (
math.floor(y + 1 / 2))
else:
return m + math.floor(x / 2) * n + temp * math.floor(n / 2) + temp * (math.floor(y / 2) + 1) + (1 - temp) * (
math.floor(y + 1 / 2))
def get_even(x, y, n):
temp = x % 2
if n % 2 == 0:
return x * n / 2 + temp * (math.floor((y + 1) / 2)) + (1 - temp) * (
math.floor(y / 2) + 1)
else:
return math.floor(x / 2) * n + temp * math.ceil(n / 2) + temp * (math.floor((y + 1) / 2)) + (1 - temp) * (
math.floor(y / 2) + 1)
def get_entry(x, y, n):
if (x + y) % 2 == 0:
# print('even')
return get_even(x, y, n)
else:
# print('odd')
return get_odd(x, y, n)
inp = input()
inp = inp.split()
n = int(inp[0])
q = int(inp[1])
# print(' n ', n)
# print(' q ', q)
for i in range(0, q):
inp = input()
inp = inp.split()
x = int(inp[0])
y = int(inp[1])
print(int(get_entry(x - 1, y - 1, n)))
```
No
| 86,606 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a chessboard of size n × n. It is filled with numbers from 1 to n^2 in the following way: the first ⌈ (n^2)/(2) ⌉ numbers from 1 to ⌈ (n^2)/(2) ⌉ are written in the cells with even sum of coordinates from left to right from top to bottom. The rest n^2 - ⌈ (n^2)/(2) ⌉ numbers from ⌈ (n^2)/(2) ⌉ + 1 to n^2 are written in the cells with odd sum of coordinates from left to right from top to bottom. The operation ⌈x/y⌉ means division x by y rounded up.
For example, the left board on the following picture is the chessboard which is given for n=4 and the right board is the chessboard which is given for n=5.
<image>
You are given q queries. The i-th query is described as a pair x_i, y_i. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n.
Input
The first line contains two integers n and q (1 ≤ n ≤ 10^9, 1 ≤ q ≤ 10^5) — the size of the board and the number of queries.
The next q lines contain two integers each. The i-th line contains two integers x_i, y_i (1 ≤ x_i, y_i ≤ n) — description of the i-th query.
Output
For each query from 1 to q print the answer to this query. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n. Queries are numbered from 1 to q in order of the input.
Examples
Input
4 5
1 1
4 4
4 3
3 2
2 4
Output
1
8
16
13
4
Input
5 4
2 1
4 2
3 3
3 4
Output
16
9
7
20
Note
Answers to the queries from examples are on the board in the picture from the problem statement.
Submitted Solution:
```
import math
def query(n, a, b):
if (a+b)%2 == 0:
temp = (a-1)*n + b
if temp%2 == 0:
return temp/2
else:
return math.ceil(temp/2)
else:
temp = n**2 + n*(a-1) + b
if temp%2 ==0:
return temp/2
else:
return math.ceil(temp/2)
n, q = map(int, input().split())
ans = []
for i in range(q):
a, b = map(int, input().split())
ans.append(query(n, a, b))
for a in ans:
print(a)
```
No
| 86,607 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a chessboard of size n × n. It is filled with numbers from 1 to n^2 in the following way: the first ⌈ (n^2)/(2) ⌉ numbers from 1 to ⌈ (n^2)/(2) ⌉ are written in the cells with even sum of coordinates from left to right from top to bottom. The rest n^2 - ⌈ (n^2)/(2) ⌉ numbers from ⌈ (n^2)/(2) ⌉ + 1 to n^2 are written in the cells with odd sum of coordinates from left to right from top to bottom. The operation ⌈x/y⌉ means division x by y rounded up.
For example, the left board on the following picture is the chessboard which is given for n=4 and the right board is the chessboard which is given for n=5.
<image>
You are given q queries. The i-th query is described as a pair x_i, y_i. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n.
Input
The first line contains two integers n and q (1 ≤ n ≤ 10^9, 1 ≤ q ≤ 10^5) — the size of the board and the number of queries.
The next q lines contain two integers each. The i-th line contains two integers x_i, y_i (1 ≤ x_i, y_i ≤ n) — description of the i-th query.
Output
For each query from 1 to q print the answer to this query. The answer to the i-th query is the number written in the cell x_i, y_i (x_i is the row, y_i is the column). Rows and columns are numbered from 1 to n. Queries are numbered from 1 to q in order of the input.
Examples
Input
4 5
1 1
4 4
4 3
3 2
2 4
Output
1
8
16
13
4
Input
5 4
2 1
4 2
3 3
3 4
Output
16
9
7
20
Note
Answers to the queries from examples are on the board in the picture from the problem statement.
Submitted Solution:
```
from math import ceil
def get_num(n, x, y, up_base):
sum_odd = bool((x + y) % 2)
n_odd = bool(n % 2)
base = up_base if sum_odd else 1
prev_rows = (y - 1) // 2 * n
if not y % 2:
prev_rows += n // 2
if n_odd and (bool((y - 1) % 2) != sum_odd):
prev_rows += 1
if bool(y % 2) == sum_odd:
prev_cells = x // 2 - 1
else:
prev_cells = x // 2
return base + prev_rows + prev_cells
n, q = (int(num) for num in input().split())
up_base = ceil(n ** 2 / 2) + 1
responses = []
for _ in range(q):
y, x = (int(num) for num in input().split())
responses.append(get_num(n, x, y, up_base))
for resp in responses: print(resp)
```
No
| 86,608 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the last mission, MDCS has successfully shipped N AI robots to Mars. Before they start exploring, system initialization is required so they are arranged in a line. Every robot can be described with three numbers: position (x_i), radius of sight (r_i) and IQ (q_i).
Since they are intelligent robots, some of them will talk if they see each other. Radius of sight is inclusive, so robot can see other all robots in range [x_i - r_i, x_i + r_i]. But they don't walk to talk with anybody, but only with robots who have similar IQ. By similar IQ we mean that their absolute difference isn't more than K.
Help us and calculate how many pairs of robots are going to talk with each other, so we can timely update their software and avoid any potential quarrel.
Input
The first line contains two integers, numbers N (1 ≤ N ≤ 10^5) and K (0 ≤ K ≤ 20).
Next N lines contain three numbers each x_i, r_i, q_i (0 ≤ x_i,r_i,q_i ≤ 10^9) — position, radius of sight and IQ of every robot respectively.
Output
Output contains only one number — solution to the problem.
Example
Input
3 2
3 6 1
7 3 10
10 5 8
Output
1
Note
The first robot can see the second, but not vice versa. The first robot can't even see the third. The second and the third robot can see each other and their IQs don't differ more than 2 so only one conversation will happen.
Submitted Solution:
```
import math
def get_input_list():
return list(map(int, input().split()))
N,K = get_input_list()
data = []
for i in range(N):
data.append(get_input_list())
data.sort()
def search(data,l,n,p=0,):
if data[0][0] > n:
return -1
mid = int(l/2)
if l <= 1 or data[mid][0] == n:
return (p + mid)
if data[mid][0] > n:
return search(data[:mid],mid,n,p)
else:
return search(data[mid:],l-mid,n,p+mid)
l = len(data)
ans = 0
for i in range(len(data) - 1):
data_ = data[i+1:]
list_ai = data_[:search(data_,l-i-1,data[i][0] + data[i][1]) + 1]
iq = data[i][2]
p = data[i][0]
for ai in list_ai:
if abs(iq - ai[2]) <= K and abs(p - ai[0])<=ai[1]:
ans += 1
print(ans)
```
No
| 86,609 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the last mission, MDCS has successfully shipped N AI robots to Mars. Before they start exploring, system initialization is required so they are arranged in a line. Every robot can be described with three numbers: position (x_i), radius of sight (r_i) and IQ (q_i).
Since they are intelligent robots, some of them will talk if they see each other. Radius of sight is inclusive, so robot can see other all robots in range [x_i - r_i, x_i + r_i]. But they don't walk to talk with anybody, but only with robots who have similar IQ. By similar IQ we mean that their absolute difference isn't more than K.
Help us and calculate how many pairs of robots are going to talk with each other, so we can timely update their software and avoid any potential quarrel.
Input
The first line contains two integers, numbers N (1 ≤ N ≤ 10^5) and K (0 ≤ K ≤ 20).
Next N lines contain three numbers each x_i, r_i, q_i (0 ≤ x_i,r_i,q_i ≤ 10^9) — position, radius of sight and IQ of every robot respectively.
Output
Output contains only one number — solution to the problem.
Example
Input
3 2
3 6 1
7 3 10
10 5 8
Output
1
Note
The first robot can see the second, but not vice versa. The first robot can't even see the third. The second and the third robot can see each other and their IQs don't differ more than 2 so only one conversation will happen.
Submitted Solution:
```
x = []
r = []
q = []
answer=0
nk=str(input())
N = int(nk.split(' ')[0])
K = int(nk.split(' ')[1])
arr = [ str(input()) for i in range(N)]
x = [ arr[i].split(' ',1)[0] for i in range(N)]
r = [ arr[i].split(' ',3)[1] for i in range(N)]
q = [ arr[i].split(' ',3)[2] for i in range(N)]
for i in range(N-1):
if int(x[i])-int(r[i])<=int(x[i+1]) and int(x[i+1])<=int(x[i])+int(r[i]) and int(q[i+1])-int(q[i])<=K :
answer=answer+1
print(answer)
```
No
| 86,610 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the last mission, MDCS has successfully shipped N AI robots to Mars. Before they start exploring, system initialization is required so they are arranged in a line. Every robot can be described with three numbers: position (x_i), radius of sight (r_i) and IQ (q_i).
Since they are intelligent robots, some of them will talk if they see each other. Radius of sight is inclusive, so robot can see other all robots in range [x_i - r_i, x_i + r_i]. But they don't walk to talk with anybody, but only with robots who have similar IQ. By similar IQ we mean that their absolute difference isn't more than K.
Help us and calculate how many pairs of robots are going to talk with each other, so we can timely update their software and avoid any potential quarrel.
Input
The first line contains two integers, numbers N (1 ≤ N ≤ 10^5) and K (0 ≤ K ≤ 20).
Next N lines contain three numbers each x_i, r_i, q_i (0 ≤ x_i,r_i,q_i ≤ 10^9) — position, radius of sight and IQ of every robot respectively.
Output
Output contains only one number — solution to the problem.
Example
Input
3 2
3 6 1
7 3 10
10 5 8
Output
1
Note
The first robot can see the second, but not vice versa. The first robot can't even see the third. The second and the third robot can see each other and their IQs don't differ more than 2 so only one conversation will happen.
Submitted Solution:
```
b=input().split()
n=int(b[0])
k=int(b[1])
x=''
r=''
q=''
for i in range(0,n):
a=input().split()
x=x+' '+str(a[0])
r=r+' '+str(a[1])
q=q+' '+str(a[2])
m=0
x=x.split()
r=r.split()
q=q.split()
for i in range(0,n):
for j in range(i,n):
if i!=j:
if int(x[i])+int(r[i])<=int(x[j]):
if abs(int(q[i])-int(q[j]))<=k:
m=m+1
print(m)
```
No
| 86,611 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the last mission, MDCS has successfully shipped N AI robots to Mars. Before they start exploring, system initialization is required so they are arranged in a line. Every robot can be described with three numbers: position (x_i), radius of sight (r_i) and IQ (q_i).
Since they are intelligent robots, some of them will talk if they see each other. Radius of sight is inclusive, so robot can see other all robots in range [x_i - r_i, x_i + r_i]. But they don't walk to talk with anybody, but only with robots who have similar IQ. By similar IQ we mean that their absolute difference isn't more than K.
Help us and calculate how many pairs of robots are going to talk with each other, so we can timely update their software and avoid any potential quarrel.
Input
The first line contains two integers, numbers N (1 ≤ N ≤ 10^5) and K (0 ≤ K ≤ 20).
Next N lines contain three numbers each x_i, r_i, q_i (0 ≤ x_i,r_i,q_i ≤ 10^9) — position, radius of sight and IQ of every robot respectively.
Output
Output contains only one number — solution to the problem.
Example
Input
3 2
3 6 1
7 3 10
10 5 8
Output
1
Note
The first robot can see the second, but not vice versa. The first robot can't even see the third. The second and the third robot can see each other and their IQs don't differ more than 2 so only one conversation will happen.
Submitted Solution:
```
n, k = [int(x) for x in input().split()]
l=[]
for i in range(n):
l.append([int(y) for y in input().split()])
counter = 0
for i in range(n):
for j in range(i+1,n):
if l[i][0] + l[i][1] >= l[j][0] and l[j][0] - l[j][1] <= l[i][0] and abs(l[i][2]-l[j][2]) <= k:
counter += 1
print(counter)
```
No
| 86,612 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Galaxy contains n planets, there are many different living creatures inhabiting each planet. And each creature can get into troubles! Space rescuers know it perfectly well and they are always ready to help anyone who really needs help. All you need to do is call for them.
Now the space rescuers plan to build the largest in the history of the Galaxy rescue station; however, the rescue station's location is yet to be determined. As some cases are real emergencies, the rescuers want to find such a point in the Galaxy from which it would be possible to get to the remotest planet in the minimum possible time. In other words, the rescuers need such point in the space that the distance between it and the planet remotest from it was minimal (if we compare this point with all other possible points in the space). Unfortunately, the rescuers can't sole this problem.
As the planets are quite remote from each other, they can be considered as points in Euclidean three-dimensional space. The distance between points (xi, yi, zi) and (xj, yj, zj) can be calculated by the formula <image>. The rescue station can be positioned in any point in the space. It can also coincide with some planet.
Galaxy is in danger! Save the space rescuers and find the required point for them.
Input
The first line of the input file contains integer n — the number of planets (1 ≤ N ≤ 100). Each of the following n lines contains information about the planets. The i-th line contains three integers xi, yi, zi — the coordinates of the i-th planet ( - 104 ≤ xi, yi, zi ≤ 104, 1 ≤ i ≤ n). No two planets coincide.
Output
Print on the first line of the output file three space-separated real numbers x0, y0, z0 — the coordinates for the future base. If there are several solutions, you are allowed to print any of them. The answer will be accepted if the distance from this point to the remotest planet will differ from the juries' variant in no more than 10 - 6 in absolute or relative value.
Examples
Input
5
5 0 0
-5 0 0
0 3 4
4 -3 0
2 2 -2
Output
0.000 0.000 0.000
Submitted Solution:
```
import math
n=int(input())
list1=[]
x1=[]
y1=[]
z1=[]
for i in range(n):
x,y,z=map(int,input().split())
x1.append(x)
y1.append(y)
z1.append(z)
X=sum(x1)//n
Y=sum(y1)//n
Z=sum(z1)//n
P=float(0.1);
for i in range(5000):
f=0
dist1=float(math.sqrt(((X-x1[0])*(X-x1[0]))+((Y-y1[0])*(Y-y1[0]))+((Z-z1[0])*(Z-z1[0]))))
for j in range(1,n):
dist2=float(math.sqrt(((X-x1[j])*(X-x1[j]))+((Y-y1[j])*(Y-y1[j]))+((Z-z1[j])*(Z-z1[j]))))
if (dist1<dist2):
dist1=dist2
f=j
X += (x1[f]-X)*P
Y += (y1[f]-Y)*P
Z += (z1[f]-Z)*P
P *= 0.9993
print(X, Y, Z)
```
No
| 86,613 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Galaxy contains n planets, there are many different living creatures inhabiting each planet. And each creature can get into troubles! Space rescuers know it perfectly well and they are always ready to help anyone who really needs help. All you need to do is call for them.
Now the space rescuers plan to build the largest in the history of the Galaxy rescue station; however, the rescue station's location is yet to be determined. As some cases are real emergencies, the rescuers want to find such a point in the Galaxy from which it would be possible to get to the remotest planet in the minimum possible time. In other words, the rescuers need such point in the space that the distance between it and the planet remotest from it was minimal (if we compare this point with all other possible points in the space). Unfortunately, the rescuers can't sole this problem.
As the planets are quite remote from each other, they can be considered as points in Euclidean three-dimensional space. The distance between points (xi, yi, zi) and (xj, yj, zj) can be calculated by the formula <image>. The rescue station can be positioned in any point in the space. It can also coincide with some planet.
Galaxy is in danger! Save the space rescuers and find the required point for them.
Input
The first line of the input file contains integer n — the number of planets (1 ≤ N ≤ 100). Each of the following n lines contains information about the planets. The i-th line contains three integers xi, yi, zi — the coordinates of the i-th planet ( - 104 ≤ xi, yi, zi ≤ 104, 1 ≤ i ≤ n). No two planets coincide.
Output
Print on the first line of the output file three space-separated real numbers x0, y0, z0 — the coordinates for the future base. If there are several solutions, you are allowed to print any of them. The answer will be accepted if the distance from this point to the remotest planet will differ from the juries' variant in no more than 10 - 6 in absolute or relative value.
Examples
Input
5
5 0 0
-5 0 0
0 3 4
4 -3 0
2 2 -2
Output
0.000 0.000 0.000
Submitted Solution:
```
def dist(x,y,z):
return (x*x+y*y+z*z)**(1/2)
n=int(input())
sumx=0
sumy=0
sumz=0
listx=[]
listy=[]
listz=[]
for i in range(n):
x,y,z=map(int,input().split())
listx.append(x)
listy.append(y)
listz.append(z)
sumx=sumx+x
sumy=sumy+y
sumz=sumz+z
sumx=sumx/n
sumy=sumy/n
sumz=sumz/n
P=0.1
for i in range(5000):
f=0
d=dist(sumx-listx[0],sumy-listy[0],sumz-listz[0])
for j in range(1,n):
e=dist(sumx-listx[j],sumy-listy[j],sumz-listz[j])
if(d < e):
d=e
f=j
sumx=sumx+(listx[f]-sumx)*P
sumy=sumy+(listy[f]-sumy)*P
sumz=sumz+(listz[f]-sumz)*P
P=P*0.9993
print(sumx,sumy,sumz)
```
No
| 86,614 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Galaxy contains n planets, there are many different living creatures inhabiting each planet. And each creature can get into troubles! Space rescuers know it perfectly well and they are always ready to help anyone who really needs help. All you need to do is call for them.
Now the space rescuers plan to build the largest in the history of the Galaxy rescue station; however, the rescue station's location is yet to be determined. As some cases are real emergencies, the rescuers want to find such a point in the Galaxy from which it would be possible to get to the remotest planet in the minimum possible time. In other words, the rescuers need such point in the space that the distance between it and the planet remotest from it was minimal (if we compare this point with all other possible points in the space). Unfortunately, the rescuers can't sole this problem.
As the planets are quite remote from each other, they can be considered as points in Euclidean three-dimensional space. The distance between points (xi, yi, zi) and (xj, yj, zj) can be calculated by the formula <image>. The rescue station can be positioned in any point in the space. It can also coincide with some planet.
Galaxy is in danger! Save the space rescuers and find the required point for them.
Input
The first line of the input file contains integer n — the number of planets (1 ≤ N ≤ 100). Each of the following n lines contains information about the planets. The i-th line contains three integers xi, yi, zi — the coordinates of the i-th planet ( - 104 ≤ xi, yi, zi ≤ 104, 1 ≤ i ≤ n). No two planets coincide.
Output
Print on the first line of the output file three space-separated real numbers x0, y0, z0 — the coordinates for the future base. If there are several solutions, you are allowed to print any of them. The answer will be accepted if the distance from this point to the remotest planet will differ from the juries' variant in no more than 10 - 6 in absolute or relative value.
Examples
Input
5
5 0 0
-5 0 0
0 3 4
4 -3 0
2 2 -2
Output
0.000 0.000 0.000
Submitted Solution:
```
def dist(x,y,z,p):
sum1=0
for i in range(len(p)):
sum1=sum1+(round(((x-p[i][0])**2 + (y-p[i][1])**2 + (z-p[i][1])**2 )**(0.5),4))
return sum1
n=int(input())
points=[]
for i in range(n):
p=list(map(int,input().split()))
points.append(p)
mind1=dist(0.0000,0.0000,0.0000,points)
xp=0.0000
yp=0.0000
zp=0.0000
for i in range(n):
xp=xp+points[i][0]
yp=yp+points[i][1]
zp=zp+points[i][2]
xp=xp/n
yp=yp/n
zp=zp/n
mind=dist(xp,yp,zp,points)
if(mind1 < mind):
print(0.0000,0.0000,0.0000)
else:
print(round(xp,4),round(yp,4),round(zp,0))
```
No
| 86,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Galaxy contains n planets, there are many different living creatures inhabiting each planet. And each creature can get into troubles! Space rescuers know it perfectly well and they are always ready to help anyone who really needs help. All you need to do is call for them.
Now the space rescuers plan to build the largest in the history of the Galaxy rescue station; however, the rescue station's location is yet to be determined. As some cases are real emergencies, the rescuers want to find such a point in the Galaxy from which it would be possible to get to the remotest planet in the minimum possible time. In other words, the rescuers need such point in the space that the distance between it and the planet remotest from it was minimal (if we compare this point with all other possible points in the space). Unfortunately, the rescuers can't sole this problem.
As the planets are quite remote from each other, they can be considered as points in Euclidean three-dimensional space. The distance between points (xi, yi, zi) and (xj, yj, zj) can be calculated by the formula <image>. The rescue station can be positioned in any point in the space. It can also coincide with some planet.
Galaxy is in danger! Save the space rescuers and find the required point for them.
Input
The first line of the input file contains integer n — the number of planets (1 ≤ N ≤ 100). Each of the following n lines contains information about the planets. The i-th line contains three integers xi, yi, zi — the coordinates of the i-th planet ( - 104 ≤ xi, yi, zi ≤ 104, 1 ≤ i ≤ n). No two planets coincide.
Output
Print on the first line of the output file three space-separated real numbers x0, y0, z0 — the coordinates for the future base. If there are several solutions, you are allowed to print any of them. The answer will be accepted if the distance from this point to the remotest planet will differ from the juries' variant in no more than 10 - 6 in absolute or relative value.
Examples
Input
5
5 0 0
-5 0 0
0 3 4
4 -3 0
2 2 -2
Output
0.000 0.000 0.000
Submitted Solution:
```
def dist(x,y,z,p):
sum1=[]
for i in range(len(p)):
sum1.append(round(((x-p[i][0])**2 + (y-p[i][1])**2 + (z-p[i][1])**2 )**(0.5),4))
return sum1
n=int(input())
points=[]
for i in range(n):
p=list(map(int,input().split()))
points.append(p)
mind1=dist(0.0000,0.0000,0.0000,points)
xp=0.0000
yp=0.0000
zp=0.0000
for i in range(n):
xp=xp+points[i][0]
yp=yp+points[i][1]
zp=zp+points[i][2]
xp=xp/n
yp=yp/n
zp=zp/n
mind=dist(xp,yp,zp,points)
if(mind1 < mind):
print(0.0000,0.0000,0.0000)
else:
print(round(xp,4),round(yp,4),round(zp,0))
```
No
| 86,616 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Tags: combinatorics, dp, math
Correct Solution:
```
m=998244353
n=int(input())
fact=1
for i in range(2,n+1):
fact*=i
fact%=m
ans=fact
k=1
for i in range(n,1,-1):
k*=i;k%=m
ans+=((fact-k)%m)
ans%=m
print(ans)
```
| 86,617 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Tags: combinatorics, dp, math
Correct Solution:
```
n = int(input())
def fun(n):
if n==1:
return 1
else:
cur = n
for i in range(1, n):
cur = (cur - 1) * (i+1) % 998244353
return(cur)
print(fun(n))
# t = int(input())
# res = t
# i = 2
# while(i<=t):
# res = (res-1)*i%998244353
# i+=1
# print(res)
```
| 86,618 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Tags: combinatorics, dp, math
Correct Solution:
```
n = int(input())
prefix = 1
ans = 0
mod = 998244353
for k in range(1, n):
ans += (prefix*(n-k)*k)%mod
prefix *= n-k+1
prefix %= mod
print((ans+1)%mod)
```
| 86,619 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Tags: combinatorics, dp, math
Correct Solution:
```
n = int(input())
f_n = n
cnt = 0
for k in range(n-1, 0, -1):
cnt += f_n
f_n *= k
if f_n >= 998244353:
f_n %= 998244353
print((n*f_n-cnt)%998244353)
```
| 86,620 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Tags: combinatorics, dp, math
Correct Solution:
```
n = int(input())
mod = 998244353
rev = []
cur = 1
s = 0
for i in range(n, 0, -1):
cur *= i
tmp = cur - s
s += tmp
s %= mod
cur %= mod
rev.append(tmp % mod)
# print(rev)
ans = 1
for i in range(1, n + 1):
ans *= i
ans %= mod
for i in range(1, n - 1):
ans += i * rev[i]
ans %= mod
print(ans)
```
| 86,621 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Tags: combinatorics, dp, math
Correct Solution:
```
n, ans, mod, r = int(input()), 1, 998244353, 0
for i in range(2, n + 1):
ans = ans * i % mod
r = (r + 1) * i % mod
print((((ans * n - r) % mod) + mod) % mod)
```
| 86,622 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Tags: combinatorics, dp, math
Correct Solution:
```
def solve():
n = int(input())
factorials = [0,1,2,6,24,120]
subtract = [0,0,2,9,40,205]
for item in range(6,n+1):
factorials.append((factorials[-1]*item)%998244353)
subtract.append(((subtract[-1]+1)*item)%998244353)
print (((n*factorials[n])%998244353-subtract[n])%998244353)
solve()
```
| 86,623 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Tags: combinatorics, dp, math
Correct Solution:
```
n = int(input())
if (n == 1):
print(1)
exit(0)
if (n == 2):
print(2)
exit(0)
a = []
n+=1
a.append(9)
iter = 1
nn=4
m = 6
for i in range(nn , n):
m *= i
m %= 998244353
a.append((a[iter-1]-1)*nn+m)
a[iter] %= 998244353
nn+=1
iter += 1
print(a[iter-1])
```
| 86,624 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Submitted Solution:
```
from sys import stdin,stdout
from collections import defaultdict,Counter
from bisect import bisect,bisect_left
import math
from itertools import permutations
#stdin = open('input.txt','r')
I = stdin.readline
mod = 998244353
n = int(I())
b = 0
prod = 1
for i in range(0,n-1):
prod*=(n-i)
prod%=mod
b-=prod
#print(prod,i,b)
#print(a,b)
b+=n*prod
print(int((b)%mod))
```
Yes
| 86,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Submitted Solution:
```
import sys
#import random
from bisect import bisect_right as rb
from collections import deque
#sys.setrecursionlimit(10**8)
from queue import PriorityQueue
from math import *
input_ = lambda: sys.stdin.readline().strip("\r\n")
ii = lambda : int(input_())
il = lambda : list(map(int, input_().split()))
ilf = lambda : list(map(float, input_().split()))
ip = lambda : input_()
fi = lambda : float(input_())
ap = lambda ab,bc,cd : ab[bc].append(cd)
li = lambda : list(input_())
pr = lambda x : print(x)
prinT = lambda x : print(x)
f = lambda : sys.stdout.flush()
mod = 998244353
n = ii()
ans = n
for i in range(2,n+1) :
ans = ((ans-1)*i)%mod
print(ans)
```
Yes
| 86,626 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Submitted Solution:
```
def factorial_mod(n, mod):
ans = 1
for i in range(1, n + 1):
ans = (ans * i) % mod
return ans
def solve(n):
if n == 1:
return 1
elif n == 2:
return 2
mod = 998244353
len_metaseq = factorial_mod(n, mod)
ans = (
((n - 1) + (n - 2)) *
len_metaseq *
499122177 # modinv(2, mod)
) % mod
error = 0
for curr in range(4, n + 1):
error = ((error + 1) * curr) % mod
return (ans - error) % mod
n = int(input())
print(solve(n))
```
Yes
| 86,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Submitted Solution:
```
import sys
n = int(input())
M = 998244353
def mod(n,m):
if (n >= 0):
return n % m
else:
n = n % m
return (m+n) % m
if (n > 1):
fact = 2
ans = [0 for i in range(n+1)]
ans[2] = 0
for i in range(3,n+1):
ans[i] = (i * (fact + ans[i-1] - 1)) % M
fact = (fact * i) % M
#print(ans)
sys.stdout.write(str((ans[n]+fact)%M)+"\n")
else:
sys.stdout.write("1\n")
```
Yes
| 86,628 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Submitted Solution:
```
#!/usr/bin/env python
# coding: utf-8
# In[35]:
n=int(input())
# In[36]:
import math
# In[37]:
total=0
total=(n-1)*math.factorial(n)
dsum=0
for i in range(1,n-1):
diff=1
for j in range(0,i):
diff=diff*(n-j)
#print(diff)
dsum+=diff
# In[38]:
if n==1:
print(1)
else:
print(total-dsum)
# In[31]:
```
No
| 86,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Submitted Solution:
```
n = int(input())
if n==1:print(1)
elif n==2:print(2)
else:
res,x=1,n*2
for i in range(3,n+1):
res=((res+i-1)*i-(i-1))%998244353
x=x*i%998244353
print(x-res-n+1)
```
No
| 86,630 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Submitted Solution:
```
n = int(input())
dd = 998244353
dp = [(1,0), (1, 0), (2, 0), (6, 3)]
if n == 1:
print(1)
elif n == 2:
print(2)
for i in range(4, n+1):
np = (dp[-1][0]*i, i*(dp[-1][0]-1) + i*(dp[-1][1]))
np = (np[0] % dd, np[1] % dd)
dp.append(np)
print((dp[-1][0] + dp[-1][1]) % dd)
```
No
| 86,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Submitted Solution:
```
n = int(input())
x = n
for p in range(1 , n):
x = x * (p + 1) % 998244353
print(x)
```
No
| 86,632 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Tags: greedy, sortings
Correct Solution:
```
n, m, k = map(int, input().split())
length = n
a = [int(i) for i in input().split()]
d = []
for j in range(n-1):
d.append(a[j + 1] - a[j] - 1)
d.sort()
for j in range(n-k):
length += d[j]
print(length)
```
| 86,633 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Tags: greedy, sortings
Correct Solution:
```
n,m,w=map(int,input().split())
l=list(map(int,input().split()))
k=[]
for i in range(1,n):
a=l[i]-l[i-1]
k.append(a)
k.sort()
s=0
for i in range(n-w):
s+=k[i]
print(s+w)
```
| 86,634 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Tags: greedy, sortings
Correct Solution:
```
n,m,k=map(int,input().split())
b=[int(i) for i in input().split()]
if k==1:
print(b[-1]-b[0]+1)
else:
d=[b[i]-b[i-1] for i in range(1,n)]
d.sort()
d=d[:-k+1]
print(sum(d)+k)
```
| 86,635 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Tags: greedy, sortings
Correct Solution:
```
def main():
# accept nmk
[n,m,k]=list(map(int,input().split(" ")))
ar=list(map(int,input().split(" ")))
diff=[]
prev=ar[0]
for i in range(1,len(ar)):
diff.append(ar[i]-prev)
prev=ar[i]
# Sort in ascending order and take first k's sum
diff.sort()
# print(diff)
# now have to find sum of n-k first elements of diff
sumofdiff = sum(diff[:n-k])
# therefore total sum is sum of diff + k
result=sumofdiff+k
print(result)
return
main()
```
| 86,636 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Tags: greedy, sortings
Correct Solution:
```
n,m,k = list(map(int,input().split()))
b = list(map(int,input().split()))
s = sorted([b[i]-b[i-1]-1 for i in range(1,n)],reverse=True)
mv = (b[-1]-b[0]+1)-sum(s[:k-1])
print(mv)
```
| 86,637 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Tags: greedy, sortings
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import time
# = input()
# = int(input())
#() = (i for i in input().split())
# = [i for i in input().split()]
(m, n, k) = (int(i) for i in input().split())
b = [int(i) for i in input().split()]
start = time.time()
ans = m
if m > k:
c = sorted([b[i+1] - b[i] for i in range(m-1)])
ans += sum(c[:m-k])+k-m
print(ans)
finish = time.time()
#print(finish - start)
```
| 86,638 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Tags: greedy, sortings
Correct Solution:
```
(n,m,k)=map(int,input().split())
l=list(map(int,input().split()))
a=[]
for i in range(1,n):
a.append(l[i]-l[i-1]-1)
a.sort(reverse=True)
c=l[n-1]-l[0]+1
for i in range(k-1):
c-=a[i]
print(c)
```
| 86,639 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Tags: greedy, sortings
Correct Solution:
```
import copy
import fractions
import itertools
import numbers
import string
import sys
###
def to_basex(num, x):
while num > 0:
yield num % x
num //= x
def from_basex(it, x):
ret = 0
p = 1
for d in it:
ret += d*p
p *= x
return ret
###
def core():
n, m, k = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
deltas = [y-x for x, y in zip(b[:-1], b[1:])]
# print(b)
# print(deltas)
deltas.sort()
ans = k
ans += sum(deltas[:len(deltas) + 1 - k])
print(ans)
core()
```
| 86,640 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
# import time,random,resource
# sys.setrecursionlimit(10**6)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def IF(c, t, f): return t if c else f
def YES(c): return IF(c, "YES", "NO")
def Yes(c): return IF(c, "Yes", "No")
def main():
t = 1#I()
rr = []
for _ in range(t):
n,m,k = LI()
a = LI()
if n == 1:
rr.append(1)
continue
t = []
for i in range(1,n):
t.append(a[i]-a[i-1] - 1)
t.sort(reverse=True)
r = a[-1] - a[0] + 1 - sum(t[:k-1])
rr.append(r)
return JA(rr, "\n")
print(main())
```
Yes
| 86,641 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Submitted Solution:
```
n, m, k = map(int, input().split())
b = list(map(int, input().split()))
d = [b[i + 1] - b[i] - 1 for i in range(n - 1)]
d.sort()
print(sum(d[:n - k]) + n)
```
Yes
| 86,642 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Submitted Solution:
```
from math import *
n,l,k=map(int,input().split(" "))
a=list(map(int,input().split(" ")))
diff=[]
for i in range(1,n):
diff.append(a[i]-a[i-1])
diff=sorted(diff)
i=len(diff)-1
s=1
while(i>=0 and s<k):
s+=1
i-=1
print(sum(diff[:i+1])+k)
```
Yes
| 86,643 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Submitted Solution:
```
n,m,k=map(int,input().split())
B=list(map(int,input().split()))
if(k>=n):
print(k)
else:
C=[]
for i in range(len(B)-1):
C.append(B[i+1]-B[i])
C=sorted(C)
C=C[::-1]
C=C[k-1:]
X=k+sum(C)
print(X)
```
Yes
| 86,644 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Submitted Solution:
```
from sys import stdin,stdout
from itertools import combinations
from collections import defaultdict
def listIn():
return list((map(int,stdin.readline().strip().split())))
def stringListIn():
return([x for x in stdin.readline().split()])
def intIn():
return (int(stdin.readline()))
def stringIn():
return (stdin.readline().strip())
if __name__=="__main__":
n,m,k=listIn()
b=listIn()
if n==k:
print(n)
else:
diff=[]
for i in range(1,n):
diff.append(b[i]-b[i-1])
a=sorted(diff)
c=0
ans=sum(a[:-(k-1)])
print(ans+k)
```
No
| 86,645 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Submitted Solution:
```
n,m,k=map(int,input().split())
b=list(map(int,input().split()))
c=[0]*n
f=1
ans=0
y=0
for i in range(n):
if(i%2==0):
f+=1
c[i]=f
for i in range(1,n-1):
if(b[i+1]-b[i]>b[i]-b[i-1]):
c[i] = c[i-1]
for i in range(n-1):
if(c[i]!=c[i+1]):
ans+=b[i]-b[y]+1
y=i+1
print(ans+b[n-1]-b[y]+1)
```
No
| 86,646 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Submitted Solution:
```
n, m, k = map(int, input().split())
B = [int(a) for a in input().split()]
A = [B[i+1]-B[i] for i in range(n-1)]
A = sorted(A)
print(min(sum(A[:n-k])+k,n))
```
No
| 86,647 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
Submitted Solution:
```
#Greedy
def Funcion(arreglo,n,m,k):
suma = 0
separaciones = []
if n == k:
return n
if n == 2:
return arreglo[1]-arreglo[0]
for i in range(len(arreglo)-1):
separaciones.append((arreglo[i+1]-arreglo[i]))
separaciones_s = sorted(separaciones)
i = 0
ya_k = 0
while i < k:
if ya_k != 0 and i != 0:
if k - ya_k == len(separaciones) - i:
return suma + (k-ya_k)
if separaciones.index(separaciones_s[i+1]) == separaciones.index(separaciones_s[i])-1 or separaciones.index(separaciones_s[i+1]) == separaciones.index(separaciones_s[i]) + 1:
suma = suma + separaciones_s[i]
else:
suma = suma + separaciones_s[i] + 1
ya_k = ya_k + 1
i = i + 1
return suma
```
No
| 86,648 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1.
Tags: constructive algorithms, data structures, dfs and similar, graphs, greedy, math, sortings
Correct Solution:
```
import sys
inp = []
inp_idx = 0
def dfs(node, adj, n):
timer = n
perm = [0] * (n + 1)
perm[node] = timer
timer -= 1
stack = [node]
while stack:
node = stack[-1]
if adj[node]:
neighbor = adj[node].pop()
stack.append(neighbor)
perm[neighbor] = timer
timer -= 1
else:
stack.pop()
return perm
def check(n, nxt, perm):
stack = [n]
for i in range(n - 1, -1, -1):
while stack[-1] < perm[i]:
stack.pop()
if stack[-1] != perm[nxt[i]]:
return False
stack.append(perm[i])
return True
def solve():
global inp
global inp_idx
global perm
global timer
n = inp[inp_idx]
inp_idx += 1
nxt = []
for _ in range(n):
nxt.append(inp[inp_idx])
inp_idx += 1
for i in range(n):
nxt[i] = i + 1 if nxt[i] == -1 else nxt[i] - 1
adj = [[] for _ in range(n + 1)]
for i in range(n - 1, -1, -1):
adj[nxt[i]].append(i)
perm = dfs(n, adj, n)
print(-1) if not check(n, nxt, perm) else print(*(list(map(lambda x : x + 1, perm[:-1]))))
if __name__ == '__main__':
inp = [int(x) for x in sys.stdin.read().split()]
t = inp[0]
inp_idx = 1
for test in range(t):
solve()
```
| 86,649 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1.
Tags: constructive algorithms, data structures, dfs and similar, graphs, greedy, math, sortings
Correct Solution:
```
import sys
from array import array # noqa: F401
from typing import List, Tuple, TypeVar, Generic, Sequence, Union # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def main():
t = int(input())
ans = ['-1'] * t
for ti in range(t):
n = int(input())
a = [0] + list(map(int, input().split()))
p = [0] * (n + 1)
lo, i = 1, 1
ok = 1
while i <= n:
if a[i] == -1:
p[i] = lo
i += 1
lo += 1
continue
stack = [[a[i], lo + a[i] - i, lo + (a[i] - i) - 1]]
j = i
while j < a[i]:
if j == stack[-1][0]:
lo = stack.pop()[1]
if a[j] == -1 or a[j] == stack[-1][0]:
pass
elif a[j] > stack[-1][0]:
ok = 0
break
else:
stack.append([a[j], lo + a[j] - j, lo + (a[j] - j) - 1])
p[j] = stack[-1][2]
stack[-1][2] -= 1
j += 1
lo = stack.pop()[1]
i = j
if not ok:
break
else:
ans[ti] = ' '.join(map(str, p[1:]))
sys.stdout.buffer.write(('\n'.join(ans) + '\n').encode('utf-8'))
if __name__ == '__main__':
main()
```
| 86,650 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1.
Tags: constructive algorithms, data structures, dfs and similar, graphs, greedy, math, sortings
Correct Solution:
```
import sys
input = sys.stdin.readline
T = int(input())
for _ in range(T):
n = int(input())
l = list(map(int, input().split()))
stack = []
out = [-1] * n
curr = 0
works = True
for i in range(n):
while stack and stack[-1][0] == i:
_, j = stack.pop()
curr += 1
out[j] = curr
nex = l[i] - 1
if nex == -2:
curr += 1
out[i] = curr
else:
if stack and nex > stack[-1][0]:
works = False
else:
stack.append((nex, i))
while stack:
_, j = stack.pop()
curr += 1
out[j] = curr
if works:
print(*out)
else:
print(-1)
```
| 86,651 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1.
Submitted Solution:
```
import sys
input = sys.stdin.readline
T = int(input())
for _ in range(T):
N = int(input())
P = [int(a) for a in input().split()]
for i in range(N):
if P[i] < 0:
P[i] = i+2
Q = [1]
for i in range(N):
if i+1 == Q[-1]:
Q.pop()
elif P[i] > Q[-1]:
print(-1)
break
Q.append(P[i])
else:
X = [[] for _ in range(N+2)]
for i in range(N):
X[P[i]].append(i)
ANS = [0] * N
ans = N
for i in range(N+1, -1, -1):
for x in X[i]:
# print(x+1)
ANS[x] = ans
ans -= 1
print(*ANS)
```
No
| 86,652 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1.
Submitted Solution:
```
# https://codeforces.com/contest/1159/problem/E
from sys import stdin
def shuffle(arr, i, k):
tmp = arr[k-1];
arr[i+1:k] = arr[i:k-1]
arr[i] = tmp
def check(arr):
s = []
for i, el in enumerate(arr):
if el != -2:
if not s:
s.insert(0, el)
continue
if s[0] >= i:
while s and s[0] >= i:
s.pop(0)
s.insert(0, el)
continue
#print(s)
#print(i, el)
if s[0] < el:
return False
return True
def process_permutation():
n = int(input())
arr = [int(x)-1 for x in stdin.readline().split(' ')]
if not check(arr):
print(-1)
return
perm = [i for i in range(n+1)]
for i, el in enumerate(arr):
if el != -2 and el > i+1:
#print('pre shuffle', i, el)
#print(perm)
shuffle(perm, i, el)
#print('post shuffle')
#print(perm)
#print('*')
print(' '.join([str(el+1) for el in perm[:-1]]))
if __name__ == '__main__':
t = int(input())
for i in range(t):
#print('****')
#print(i)
process_permutation()
```
No
| 86,653 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1.
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq,bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
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")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**51, func=lambda a, b: a & b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=100005, func=lambda a, b: min(a , b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
for ik in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
ans=[0]*n
d=defaultdict(list)
for i in range(n-1,-1,-1):
if i==n-1:
if l[i]==-1:
l[i]=n+1
else:
if l[i]==-1:
l[i]=l[i+1]
for i in range(n):
d[l[i]].append(i)
t=n
for i in sorted(d,reverse=True):
for j in d[i]:
ans[j]=t
t-=1
e=[n+1]*(n+1)
f=0
s=SegmentTree(e)
for i in range(n-1,-1,-1):
e[ans[i]]=i
t = s.query(ans[i],n)
s.__setitem__(ans[i],i+1)
if l[i]!=t:
f=1
break
if f==1:
print(-1)
else:
print(*ans)
```
No
| 86,654 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1.
Submitted Solution:
```
def main():
from sys import stdin, stdout
def read():
return stdin.readline().rstrip('\n')
def read_array(sep=None, maxsplit=-1):
return read().split(sep, maxsplit)
def read_int():
return int(read())
def read_int_array(sep=None, maxsplit=-1):
return [int(a) for a in read_array(sep, maxsplit)]
def write(*args, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join(str(a) for a in args) + end)
def write_array(array, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join(str(a) for a in array) + end)
def toposort(graph):
n = len(graph)
res, color = [], [0] * n
def dfs(start):
stack = [start]
while stack:
start = stack[-1]
if color[start] == 0:
color[start] = 1
for child in graph[start]:
if color[child] == 0:
stack.append(child)
elif color[child] == 1:
return None
elif color[start] == 1:
color[start] = 2
else:
x = stack.pop()
color[x] = 2
res.append(x)
for i in range(n):
if color[i] == 0:
dfs(i)
return list(reversed(res))
t = read_int()
for _ in range(t):
n = read_int()
nxt = read_int_array()
g = [[] for _ in range(n)]
stack = []
for i in range(n):
while stack and stack[-1][0] == i:
stack.pop()
if stack:
g[i].append(stack[-1][1])
x = nxt[i]
if x == -1:
continue
if x == n + 1:
stack = [(n+1, i)]
else:
idx = x - 1
g[i].append(idx)
stack.append((idx, i))
tpsrt = toposort(g)
if not tpsrt:
write('-1')
else:
write(' '.join(str(x+1) for x in tpsrt))
main()
```
No
| 86,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
l=[int(i) for i in input().split()]
if n==1:
print(max(l[0],-l[0]-1))
exit()
if l.count(0)==n and n&1:
print(*l)
exit()
if l.count(0)==n and n&1==0:
l=[-1]*n
print(*l)
exit()
if n%2==0:
c=sum(i&1 for i in l)
c1=sum(i&1==0 for i in l)
for i in range(n):
if l[i]>=0:
l[i]=-l[i]-1
print(*l)
exit()
if n&1:
for i in range(n):
if l[i]>=0:
l[i]=-l[i]-1
l=[[l[i],i] for i in range(n)]
l.sort()
f=0
for i in range(n):
if l[i][0]!=-1:
l[i][0]=-l[i][0]-1
f=1
break
if not f:
l=[0]*n
print(*l)
exit()
ans=[0]*n
for i in range(n):
ans[l[i][1]]=l[i][0]
print(*ans)
```
| 86,656 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
arr = list(map(int,input().split(" ")))
is_zero = 0
neg,pos,zero=0,0,[]
min_neg=-1
def p(array):
print(*array)
# for i in array:
# print(i,sep=' ')
for i in range(len(arr)):
if(arr[i]!=-1):
min_neg=i
break
if(min_neg==-1 and n%2==1):
arr[0]=0
p(arr)
exit()
for i in range(len(arr)):
if(arr[i]<0 and arr[i]!=-1):
neg+=1
elif(arr[i]>0):
arr[i]=-1*arr[i]-1
else:
arr[i] =-1
zero.append(i)
if(arr[i]<arr[min_neg] and arr[i]!=-1):
min_neg = i
if(n%2==0):
p(arr)
else:
arr[min_neg]=-1*arr[min_neg]-1
p(arr)
```
| 86,657 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Tags: greedy, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
if n % 2 == 0:
for i in range(n):
if a[i] >= 0:
a[i] = -a[i] - 1
print(" ".join(map(str, a)))
else:
for i in range(n):
if a[i] >= 0:
a[i] = -a[i] - 1
min_a = 10**10
for i in range(n):
if a[i] < min_a:
min_a = a[i]
min_ind = i
a[min_ind] = -a[min_ind] - 1
print(" ".join(map(str, a)))
```
| 86,658 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
nums = [int(_) for _ in input().strip().split()]
ma_idx = 0
ma = 0
for idx, num in enumerate(nums):
if num >= 0:
nums[idx] = -1*num-1
if -1*nums[idx] > ma:
ma = -1*nums[idx]
ma_idx = idx
if n%2 == 1:
nums[ma_idx] = -1* nums[ma_idx] -1
print(' '.join([str(_) for _ in nums]))
```
| 86,659 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Tags: greedy, implementation
Correct Solution:
```
def f(L):
for i in range(len(L)):
if(L[i]>=0):
L[i]=L[i]*(-1)-1
if(len(L)%2!=0):
m=min(L)
L[L.index(m)]=-L[L.index(m)]-1
return(L)
n=int(input())
L=list(map(int,input().split()))
print(*f(L))
```
| 86,660 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
l = list(map(int,input().split()))
if (n % 2) == 1:
flag = 1
else:
flag = 0
for i in range(n):
if(l[i] >= 0):
l[i] = -(l[i]+1)
if(flag == 1):
l[l.index(min(l))] = -(l[l.index(min(l))]+1)
for i in l:
print(i,end = " ")
print()
```
| 86,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
for i in range(n):
if a[i]>=0:
a[i]=a[i]*(-1)-1
if n%2!=0:
m=min(a)
a[a.index(m)]=a[a.index(m)]*(-1)-1
print(*a)
```
| 86,662 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
l = list(map(int,input().split()))
c=0
for i in range(n):
if l[i]>=0:c+=1
for i in range(n):
if l[i]>=0:l[i] = -l[i]-1
k = l.index(min(l))
if n%2==0 and (c%2==1 or c%2==0):print(*l)
else:l[k] = -(l[k]+1);print(*l)
```
| 86,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
n=int(input())
mn=100000000
p=1
L=[]
j=0
from math import *
ss=input()
s=ss.split()
for i in range(n):
x=int(s[i])
c=min(x,-x-1)
L.append(c)
if (mn>c):
mn=c
j=i
if (n%2==0):
for i in range(n):
print(L[i],' ',end='')
else:
for i in range(n):
if (i!=j):
print(L[i],' ',end='')
else:
print(-L[j]-1,' ',end='')
```
Yes
| 86,664 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
n = int(input())
array = list(map(int, input().split(" ")))
for i in range(len(array)):
if(array[i]>=0):
array[i] = -array[i]-1
if(len(array)%2!=0):
min_index = array.index(min(array))
array[min_index] = -array[min_index]-1
print(*array)
```
Yes
| 86,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
l1=[]
l1.extend(l)
l2=[]
for i in range(n):
if l[i]>=0:
l[i]=-l[i]-1
if n%2==0:
print(*l)
else:
m=l.index(min(l))
l[m]=-l[m]-1
print(*l)
```
Yes
| 86,666 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
n=int(input())
array = list(map(int,input().split(' ')))
def awesome_array(n, array):
ls = []
for i in array:
if i>=0:
i = i*(-1)-1
ls.append(i)
if (n-1)%2==0:
ls[ls.index(min(ls))]=min(ls)*(-1)-1
return ls
print(' '.join(map(str,awesome_array(n, array))))
```
Yes
| 86,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
import math
from decimal import Decimal
def na():
n = int(input())
b = [int(x) for x in input().split()]
return n,b
def nab():
n = int(input())
b = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
return n,b,c
def dv():
n, m = map(int, input().split())
return n,m
def dva():
n, m = map(int, input().split())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
return n,m,b
def eratosthenes(n):
sieve = list(range(n + 1))
for i in sieve:
if i > 1:
for j in range(i + i, len(sieve), i):
sieve[j] = 0
return sorted(set(sieve))
def nm():
n = int(input())
b = [int(x) for x in input().split()]
m = int(input())
c = [int(x) for x in input().split()]
return n,b,m,c
def dvs():
n = int(input())
m = int(input())
return n, m
n, a = na()
if n == 1 and a[0] == 0:
print(0)
exit()
if n % 2 == 0:
for i in a:
if i < 0:
print(i, end = ' ')
else:
print(-i-1, end = ' ')
else:
mn = 99999999999
for i in a:
if i < mn and i > 0:
mn = i
if mn == 99999999999:
mn = min(a)
f = False
for i in a:
if not f and i == mn:
if mn < 0:
print(abs(i) - 1, end = ' ')
else:
print(i)
f = True
else:
if i < 0:
print(i, end = ' ')
else:
print(-i-1)
```
No
| 86,668 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
n = int(input())
li = list(map(int,input().split()))
co1 = 0
co2 = 0
co3 = 0
negmin = 10000001
posmin = 10000001
for i in range(len(li)):
if li[i] == -1:
co3 = co3+1
elif li[i] < 0:
co1 = co1+1
val = abs(li[i])
if val < negmin:
negmin = val
else:
co2 = co2+1
if li[i] < posmin:
posmin = li[i]
flag = 0
f=0
g=0
h=0
for j in range(len(li)):
if li[j] > 0:
if co2%2 == 0:
li[j] = -li[j]-1
else:
if li[j] == posmin and flag == 0:
flag = 1
else:
li[j] = -li[j]-1
elif li[j] == -1:
if co3%2 != 0 and g == 0:
g = 1
li[j] = 0
else:
if co1%2 != 0 and co3%2 == 0:
if li[j] == negmin and f == 0:
li[j] = -li[j]-1
f = 0
elif co1%2 == 0 and co3%2 != 0:
if li[j] == negmin and h == 0:
h = 0
li[j] = -li[j]-1
for w in range(len(li)):
print(li[w],end=' ')
```
No
| 86,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
n=int(input())
arr=list(map(int,input().split()));
neg=[];ans=[0]*n;cnt=0;ans1=1
for i in range(n):
ans1*=arr[i]
if arr[i]>=0:neg.append([i,(arr[i]+1),1]);cnt+=1;ans[i]=-(arr[i]+1)
elif arr[i]==-1:cnt+=1;ans[i]=-1;continue
elif arr[i]<0:cnt+=1;neg.append([i,abs(arr[i]),-1]);ans[i]=arr[i]
#print(ans,cnt)
if cnt%2==0:print(ans)
else:
neg=sorted(neg,key=lambda x:x[1]);ans2=1
for i in range(len(neg)):
if arr[neg[i][0]]==0:continue
else:ans[neg[i][0]]=neg[i][1]-1;break
for i in range(n):ans2*=ans[i]
if ans1>ans2:print(*arr)
else:print(*ans)
```
No
| 86,670 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
# print(solve(0,0,k,0))
n = int(input())
la = list(map(int,input().split()))
count1,count2 = 0,0
l = []
for i in range(len(la)):
l.append([la[i],i])
l.sort(reverse=True)
for i in l:
if i[0]<0 == 0:
count1+=1
else:
count2+=1
if count1%2 == 0:
if count2%2 == 0:
for j,i in enumerate(l):
if i[0]<0:
# ans*=i[0]
continue
else:
# ans*=(i[0]+1)
l[j][0] = -(l[j][0]+1)
# print(ans)
else:
co = 0
for j,i in enumerate(l):
if co == count2-1:
break
else:
l[j][0] = -(l[j][0]+1)
# ans*=(i[0]+1)
co+=1
for i in l:
if i[0]<0:
# ans*=i[0]
continue
# print(ans)
else:
if count2 == 0:
l[-1][0] = abs(l[-1][0])-1
for i in l[1:]:
# ans*=i[0]
continue
# print(ans)
elif count2>0:
if count2%2 == 0:
co = 0
for j,i in enumerate(l):
if co == count2-1:
# ans*=i[0]
continue
else:
l[j][0] = -(l[j][0]+1)
# ans*=(i[0]+1)
co+=1
# print(ans)
else:
for j,i in enumerate(l):
if i[0]<0:
# ans*=i[0]
continue
else:
l[j][0] = -(l[j][0]+1)
# ans*=(i[0]+1)
# print(ans)
for i in l:
la[i[1]] = i[0]
print(*la)
```
No
| 86,671 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Tags: geometry, math
Correct Solution:
```
h,l=map(int,input().split())
a=((l*l)-(h*h))/(2*h)
print(a)
```
| 86,672 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Tags: geometry, math
Correct Solution:
```
H,L=input().split()
H=int(H)
L=int(L)
num = L**2 - H**2
den = 2*H
x = num/den
print('%.13f'%x)
```
| 86,673 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Tags: geometry, math
Correct Solution:
```
h,l=map(int,input().split())
a = (l**2 - h**2)/(2*h)
print(a)
```
| 86,674 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Tags: geometry, math
Correct Solution:
```
def main():
h,l=list(map(int,input().split()))
print((l**2-h**2)/(2*h))
main()
```
| 86,675 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Tags: geometry, math
Correct Solution:
```
import math
h,l=map(int,input().split())
x=(math.pow(l,2)-math.pow(h,2))/(2*h)
print(x)
```
| 86,676 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Tags: geometry, math
Correct Solution:
```
h,l=map(int,input().split())
a=(l**2-h**2)/(2*h)
print(round(a,7))
```
| 86,677 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Tags: geometry, math
Correct Solution:
```
h1,l1=input().split()
h=int(h1)
l=int(l1)
x=((l*l)-(h*h))/(2*h)
print(x)
```
| 86,678 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Tags: geometry, math
Correct Solution:
```
h, l = map(int, input().split())
ans = round(((l**2 - h**2)/2)/h, 6)
print('{:.8f}'.format(((l**2 - h**2)/2)/h))
```
| 86,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Submitted Solution:
```
import sys
input = sys.stdin.readline
H, L = list(map(int, input().split()))
A = (H**2 + L**2) / (2*H)
print(A - H)
```
Yes
| 86,680 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Submitted Solution:
```
h, l = map(int, input().split())
sq = abs((-l**2+h**2)/(2*h))
print(sq)
```
Yes
| 86,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Submitted Solution:
```
h, l = map(int, input().split())
print((((h**2) + (l**2)) / (2*h)) - h)
```
Yes
| 86,682 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Submitted Solution:
```
#----Kuzlyaev-Nikita-Codeforces-----
#------------03.04.2020-------------
alph="abcdefghijklmnopqrstuvwxyz"
#-----------------------------------
h,l=map(int,input().split())
k=(l*l-h*h)/2/h
print("%.10f"%k)
```
Yes
| 86,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Submitted Solution:
```
L,H=map(int,input().split())
print((L*L-H*H)/2*H)
```
No
| 86,684 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Submitted Solution:
```
"""
H cm above surface of water
sailed distance of L cm, where water touched
surface
determine the depth of lake
"""
H,L= map(int,input().split())
k=(1.0*(L**2-H**2)/(2*H))
print(str(int(k))+(str(k-k//1))[1:])
```
No
| 86,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Submitted Solution:
```
from math import sqrt
h, left = map(int, input().split())
l = 0
r = 2000000
while r - l > 0.00000001:
x = (l + r) / 2
a = x + h
b = sqrt(left * left + x * x)
print(a, b, x)
if b - a > 0.00000001:
l = x
else:
r = x
print(l)
```
No
| 86,686 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.
<image>
Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?
Input
The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).
Output
Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.
Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.
Examples
Input
1 2
Output
1.5000000000000
Input
3 5
Output
2.6666666666667
Submitted Solution:
```
h,l=input().split()
H=int(h)
L=int(l)
d=(((L**2)-(H**2))/2*H)
print(format(d , '.13f'))
```
No
| 86,687 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Tags: strings
Correct Solution:
```
n = int(input())
l = list(input())
count = 0
for i in range(0, n, 2):
if (l[i] == l[i + 1]):
l[i] = chr(1 - ord(l[i]) + 2 * ord('a'))
count += 1
print(count)
print(''.join(l))
```
| 86,688 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Tags: strings
Correct Solution:
```
n=int(input())
a=list(input())
k=0
for i in range(n-1):
if((i==n-2) and a[i]==a[i+1]):
k+=1
if(a[i]=="a"):
a[i]="b"
else:
a[i]="a"
elif((i%2!=0) and (a[i]==a[i-1])):
if(a[i]=="a"):
a[i]="b"
else:
a[i]="a"
k+=1
print(k)
print("".join(a))
```
| 86,689 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Tags: strings
Correct Solution:
```
n = int(input())
s = input()
ans = 0
for i in range(1, n , 2):
if(s[i] == s[i - 1]):
ans = ans + 1
print(ans)
for i in range(1, n , 2):
print(s[i - 1],end = "")
if(s[i - 1] == s[i]):
if(s[i] == 'a'):
print('b',end = "")
else:
print('a',end = "")
else:
print(s[i], end = "")
```
| 86,690 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Tags: strings
Correct Solution:
```
a = int(input())
nlist = input()
str = list(nlist)
i = 0
k = 2
count = 0
while i<=len(str):
n_str = str[i:k]
acnt = n_str.count('a')
bcnt = n_str.count('b')
if acnt!=bcnt:
count +=1
if acnt == 2:
str[i] = 'b'
else:
str[i] = 'a'
i = k
k += 2
print(count)
str = ''.join(str)
print(str)
```
| 86,691 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Tags: strings
Correct Solution:
```
n = int(input())
s = list(input())
k = 0
for i in range(0, n, 2):
if(s[i] == s[i+1] and s[i] == "a"):
s[i + 1] = "b"
k += 1
elif(s[i] == s[i+1] and s[i] == "b"):
s[i + 1] = "a"
k += 1
print(k)
print("".join(s))
```
| 86,692 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Tags: strings
Correct Solution:
```
import sys
input = sys.stdin.readline
n = int(input())
s = list(input()[:-1])
ans = 0
for i in range(0, n, 2):
if s[i]=='a' and s[i+1]=='a':
s[i] = 'b'
ans += 1
elif s[i]=='b' and s[i+1]=='b':
s[i] = 'a'
ans += 1
print(ans)
print(''.join(s))
```
| 86,693 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Tags: strings
Correct Solution:
```
import sys
import math
#to read string
get_string = lambda: sys.stdin.readline().strip()
#to read list of integers
get_int_list = lambda: list( map(int,sys.stdin.readline().strip().split()) )
#to read non spaced string and elements are integers to list of int
get_intList_from_str = lambda: list(map(int,list(sys.stdin.readline().strip())))
#to read non spaced string and elements are character to list of character
get_charList_from_str = lambda: list(sys.stdin.readline().strip())
#get word sepetared list of character
get_char_list = lambda: sys.stdin.readline().strip().split()
#to read integers
get_int = lambda: int(sys.stdin.readline())
#to print faster
pt = lambda x: sys.stdout.write(str(x))
#--------------------------------WhiteHat010--------------------------------------#
n =get_int()
lst = list(get_string())
count = 0
for i in range(0,n,2):
if lst[i] == lst[i+1]:
if lst[i] == 'a':
lst[i] = 'b'
count += 1
else:
lst[i] = 'a'
count += 1
print(count)
print(''.join(lst))
```
| 86,694 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Tags: strings
Correct Solution:
```
n = int(input())
string = list(input())
count = 0
for i in range(0,n-1, 2):
if string[i] == 'a' and string[i+1] == 'a':
string[i] = 'b'
count+=1
if string[i] == 'b' and string[i+1] == 'b':
string[i] = 'a'
count+=1
print(str(count))
for i in string:
print(i,end='')
```
| 86,695 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
n=int(input())
s=list(input())
res,result=0,''
for i in range(0,n-1,2):
if s[i]=='a' and s[i+1]=='a' or s[i]=='b' and s[i+1]=='b':
res+=1
result+='ab'
else:result+=s[i]+s[i+1]
print(res)
print(result)
```
Yes
| 86,696 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
n = int(input())
s = list(input())
times = 0
for i in range(n):
if i % 2 == 0:
continue
else:
if s[i] == s[i-1]:
times += 1
if s[i] == 'a':
s[i] = 'b'
else:
s[i] = 'a'
print(times)
print(''.join(s))
```
Yes
| 86,697 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
n = int(input())
l = list(input())
ans=0
for i in range(0,n,2):
if(l[i]==l[i+1]):
ans+=1
if(l[i]=='a'):
l[i]='b'
else:
l[i]='a'
print(ans)
print(''.join(l))
```
Yes
| 86,698 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
length = int(input())
string = input()
operations = 0
altered = []
for i in range(0, length, 2):
if string[i] == string[i + 1]:
operations += 1
if string[i] == 'a':
altered.append('ab')
else:
altered.append('ba')
print(operations)
print("".join(altered))
```
Yes
| 86,699 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.