message stringlengths 2 30.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 237 109k | cluster float64 10 10 | __index_level_0__ int64 474 217k |
|---|---|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0 | instruction | 0 | 40,975 | 10 | 81,950 |
"Correct Solution:
```
x = int(input())
print((x+999)//1000*1000-x)
``` | output | 1 | 40,975 | 10 | 81,951 |
Provide a correct Python 3 solution for this coding contest problem.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0 | instruction | 0 | 40,976 | 10 | 81,952 |
"Correct Solution:
```
N = int(input())
N = 1000 - (N%1000)
print(N % 1000)
``` | output | 1 | 40,976 | 10 | 81,953 |
Provide a correct Python 3 solution for this coding contest problem.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0 | instruction | 0 | 40,977 | 10 | 81,954 |
"Correct Solution:
```
n=int(input());print(-(-n//1000)*1000-n)
``` | output | 1 | 40,977 | 10 | 81,955 |
Provide a correct Python 3 solution for this coding contest problem.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0 | instruction | 0 | 40,978 | 10 | 81,956 |
"Correct Solution:
```
N=int(input())
n=N%1000
print((1000-n)%1000)
``` | output | 1 | 40,978 | 10 | 81,957 |
Provide a correct Python 3 solution for this coding contest problem.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0 | instruction | 0 | 40,979 | 10 | 81,958 |
"Correct Solution:
```
#ABC173-A
N = int(input())
print(-N % 1000)
``` | output | 1 | 40,979 | 10 | 81,959 |
Provide a correct Python 3 solution for this coding contest problem.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0 | instruction | 0 | 40,980 | 10 | 81,960 |
"Correct Solution:
```
n = int(input())
print(1000 - n%1000 if n%1000 else 0)
``` | output | 1 | 40,980 | 10 | 81,961 |
Provide a correct Python 3 solution for this coding contest problem.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0 | instruction | 0 | 40,981 | 10 | 81,962 |
"Correct Solution:
```
n = int(input()) % 1000
print(1000 - n if n else 0)
``` | output | 1 | 40,981 | 10 | 81,963 |
Provide a correct Python 3 solution for this coding contest problem.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0 | instruction | 0 | 40,982 | 10 | 81,964 |
"Correct Solution:
```
n = int(input().rstrip())
print((1000-n)%1000)
``` | output | 1 | 40,982 | 10 | 81,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0
Submitted Solution:
```
n = int(input())
print(-((-n)//1000)*1000-n)
``` | instruction | 0 | 40,983 | 10 | 81,966 |
Yes | output | 1 | 40,983 | 10 | 81,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0
Submitted Solution:
```
N = int(input())
print(f"{-N % 1000}")
``` | instruction | 0 | 40,984 | 10 | 81,968 |
Yes | output | 1 | 40,984 | 10 | 81,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0
Submitted Solution:
```
print(int(str(1000 - int(input()[-3:]))[-3:]))
``` | instruction | 0 | 40,985 | 10 | 81,970 |
Yes | output | 1 | 40,985 | 10 | 81,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0
Submitted Solution:
```
N = int(input())
s = 10000 - N
print(s%1000)
``` | instruction | 0 | 40,986 | 10 | 81,972 |
Yes | output | 1 | 40,986 | 10 | 81,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0
Submitted Solution:
```
import math
n = int(input())
print(math.ceil(n / 1000) * 1000)
``` | instruction | 0 | 40,987 | 10 | 81,974 |
No | output | 1 | 40,987 | 10 | 81,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0
Submitted Solution:
```
def Qa():
n = int(input())
print(n % 1000)
if __name__ == '__main__':
Qa()
``` | instruction | 0 | 40,988 | 10 | 81,976 |
No | output | 1 | 40,988 | 10 | 81,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0
Submitted Solution:
```
N = int(input())
A = N % 1000
print(A)
``` | instruction | 0 | 40,989 | 10 | 81,978 |
No | output | 1 | 40,989 | 10 | 81,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0
Submitted Solution:
```
n = 111200
n2 = str(n)[-3:]
if int(n2) == 0:
print(0)
else:
ans = 1000 - int(n2)
print(ans)
``` | instruction | 0 | 40,990 | 10 | 81,980 |
No | output | 1 | 40,990 | 10 | 81,981 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins. | instruction | 0 | 41,229 | 10 | 82,458 |
Tags: greedy, implementation, math
Correct Solution:
```
a,b=map(int,input().split())
if b>a:
if b%a==0:
print(b//a)
else:
print(b//a+1)
else:
print("1")
``` | output | 1 | 41,229 | 10 | 82,459 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins. | instruction | 0 | 41,230 | 10 | 82,460 |
Tags: greedy, implementation, math
Correct Solution:
```
n, s = [int(i) for i in input().split()]
print(s//n + min(s%n, 1))
``` | output | 1 | 41,230 | 10 | 82,461 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins. | instruction | 0 | 41,231 | 10 | 82,462 |
Tags: greedy, implementation, math
Correct Solution:
```
# -*- coding: utf-8 -*-
n,s = map(int,input().split(" "))
if s % n == 0:
print(s//n)
else:
print(s//n+1)
``` | output | 1 | 41,231 | 10 | 82,463 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins. | instruction | 0 | 41,232 | 10 | 82,464 |
Tags: greedy, implementation, math
Correct Solution:
```
from math import *
n,s = list(map(int,input().split()))
print(ceil(s/n))
``` | output | 1 | 41,232 | 10 | 82,465 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins. | instruction | 0 | 41,233 | 10 | 82,466 |
Tags: greedy, implementation, math
Correct Solution:
```
# coding=utf-8
n, s = map(int, input().split())
print((s + n - 1) // n)
``` | output | 1 | 41,233 | 10 | 82,467 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins. | instruction | 0 | 41,234 | 10 | 82,468 |
Tags: greedy, implementation, math
Correct Solution:
```
n,S=map(int,input().split())
if S%n==0:
print(int(S/n))
else:
print(int((S/n)+1))
``` | output | 1 | 41,234 | 10 | 82,469 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins. | instruction | 0 | 41,235 | 10 | 82,470 |
Tags: greedy, implementation, math
Correct Solution:
```
n,s = map(int,input().split())
if(s<=n):
print(1)
else:
i = n;ans = 0;f = 0
while(i>0):
s-=i
ans+=1
if(s<=n):
ans+=1
f = 1
break
print(ans)
# priyanshu Kumar
``` | output | 1 | 41,235 | 10 | 82,471 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins. | instruction | 0 | 41,236 | 10 | 82,472 |
Tags: greedy, implementation, math
Correct Solution:
```
class CodeforcesTask1061ASolution:
def __init__(self):
self.result = ''
self.n_s = []
def read_input(self):
self.n_s = [int(x) for x in input().split(" ")]
def process_task(self):
r = 0
while self.n_s[1] > self.n_s[0]:
r += 1
self.n_s[1] -= self.n_s[0]
r += 1
self.result = str(r)
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask1061ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
``` | output | 1 | 41,236 | 10 | 82,473 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins.
Submitted Solution:
```
n, S = map(int, input().split())
print((S + n - 1) // n);
``` | instruction | 0 | 41,237 | 10 | 82,474 |
Yes | output | 1 | 41,237 | 10 | 82,475 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins.
Submitted Solution:
```
n,s = list(map(int,input().split()))
extra = 0
if s%n:
extra = 1
print((s//n) + extra)
``` | instruction | 0 | 41,238 | 10 | 82,476 |
Yes | output | 1 | 41,238 | 10 | 82,477 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins.
Submitted Solution:
```
a, b = map(int, input().split())
print((a+b-1)//a)
``` | instruction | 0 | 41,239 | 10 | 82,478 |
Yes | output | 1 | 41,239 | 10 | 82,479 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins.
Submitted Solution:
```
#!/usr/bin/env python
# coding: utf-8
# In[2]:
n, p = list(map(int, input().rstrip().split()))
# In[5]:
if p % n==0:
print(p//n)
else:
print(p//n+1)
# In[ ]:
``` | instruction | 0 | 41,240 | 10 | 82,480 |
Yes | output | 1 | 41,240 | 10 | 82,481 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins.
Submitted Solution:
```
def Num_of_Coins():
num , Sum = [int(x) for x in input("").split()]
if(Sum%num==0):
return Sum/num
else:
return int(Sum/num) + 1
print(Num_of_Coins())
``` | instruction | 0 | 41,241 | 10 | 82,482 |
No | output | 1 | 41,241 | 10 | 82,483 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins.
Submitted Solution:
```
n, S = map(int,input().split())
if n >= S:
print(1)
else:
if S % n == 0:
print(S / n)
else:
print(S // n + 1)
``` | instruction | 0 | 41,242 | 10 | 82,484 |
No | output | 1 | 41,242 | 10 | 82,485 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins.
Submitted Solution:
```
N, S = map(int,input().split())
if S>N:
ans = S//N + 1
else:
ans = 1
print(ans)
``` | instruction | 0 | 41,243 | 10 | 82,486 |
No | output | 1 | 41,243 | 10 | 82,487 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S.
It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?
Input
The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)
Output
Print exactly one integer — the minimum number of coins required to obtain sum S.
Examples
Input
5 11
Output
3
Input
6 16
Output
3
Note
In the first example, some of the possible ways to get sum 11 with 3 coins are:
* (3, 4, 4)
* (2, 4, 5)
* (1, 5, 5)
* (3, 3, 5)
It is impossible to get sum 11 with less than 3 coins.
In the second example, some of the possible ways to get sum 16 with 3 coins are:
* (5, 5, 6)
* (4, 6, 6)
It is impossible to get sum 16 with less than 3 coins.
Submitted Solution:
```
a,b=map(int,input().split())
print(int(b/a)+1)
``` | instruction | 0 | 41,244 | 10 | 82,488 |
No | output | 1 | 41,244 | 10 | 82,489 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18. | instruction | 0 | 41,690 | 10 | 83,380 |
Tags: brute force, data structures, implementation, math, number theory
Correct Solution:
```
def main():
input()
l = list(map(int, input().split()))
n = max(l)
aa = [0] * (n + 1)
for x in l:
aa[x] += 1
f, x = [0] * n, 0
for a in reversed(aa):
x += a
f.append(x)
f.reverse()
res = []
for i, a in enumerate(aa):
if a:
tot, a = 0, f[i]
for j in range(i, n + 1, i):
b = f[j + i]
tot += (a - b) * j
a = b
res.append(tot)
print(max(res))
if __name__ == '__main__':
main()
``` | output | 1 | 41,690 | 10 | 83,381 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18. | instruction | 0 | 41,691 | 10 | 83,382 |
Tags: brute force, data structures, implementation, math, number theory
Correct Solution:
```
n = int(input())
s = list(map(int, input().split()))
h = max(s)
ss = [0] * (h + 1)
for i in s:
ss[i] += 1
f, x = [0] * h, 0
for j in reversed(ss):
x += j
f.append(x)
f.reverse()
res = []
for i, x in enumerate(ss):
if x:
summ, x = 0, f[i]
for j in range(i, h + 1, i):
o = f[j + i]
summ += (x - o) * j
x = o
res.append(summ)
print(max(res))
``` | output | 1 | 41,691 | 10 | 83,383 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18. | instruction | 0 | 41,692 | 10 | 83,384 |
Tags: brute force, data structures, implementation, math, number theory
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
N = 2 * 10**5
cnt = [0 for i in range(N + 1)]
S = [0 for i in range(N + 1)]
for x in a:
cnt[x] += 1
S[x] += x
for i in range(1, N + 1):
cnt[i] += cnt[i - 1]
S[i] += S[i - 1]
ans = 10**18
used = [0 for i in range(N + 1)]
for i in a:
if used[i]: continue
used[i] = 1
prv, cur = 0, 0
di = list(range(i, N + 1, i))
di.append(N + 1)
for x in di:
l, r = prv + 1, x - 1
cur += S[r] - S[l - 1]
cur -= prv * (cnt[r] - cnt[l - 1])
prv = x
ans = min(ans, cur)
print(sum(a) - ans)
``` | output | 1 | 41,692 | 10 | 83,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18. | instruction | 0 | 41,693 | 10 | 83,386 |
Tags: brute force, data structures, implementation, math, number theory
Correct Solution:
```
def main():
n = int(input())
aa = list(map(int, input().split()))
aa.sort()
lim = aa[-1] + 1
cnt, a = [0] * lim, aa[0] - 1
for i, b in zip(range(n, -1, -1), aa):
if a != b:
cnt[a + 1:b + 1] = [i] * (b - a)
a = b
avail, res = [True] * lim, []
for i, a in enumerate(aa):
if avail[a]:
avail[a] = False
res.append(a * sum(cnt[a::a]))
print(max(res))
if __name__ == '__main__':
main()
``` | output | 1 | 41,693 | 10 | 83,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18. | instruction | 0 | 41,694 | 10 | 83,388 |
Tags: brute force, data structures, implementation, math, number theory
Correct Solution:
```
N = 200005
n = int(input())
A = input().split()
A = list(map(lambda x : int(x), A))
pref = [0] * N
for a in A :
pref[a] += 1
for i in range(1, N) :
pref[i] += pref[i - 1]
ans = 0
for i in range(1, N) :
if(pref[i] != pref[i - 1]) :
suma = 0
for j in range(i, N, i) :
suma += j * (pref[min(N - 1, j + i - 1)] - pref[j - 1])
ans = max(ans, suma)
print(ans)
``` | output | 1 | 41,694 | 10 | 83,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18. | instruction | 0 | 41,695 | 10 | 83,390 |
Tags: brute force, data structures, implementation, math, number theory
Correct Solution:
```
import math
def main():
prefSum = []
def GetSum( l, r ):
return prefSum[min( r, 199999 )] - prefSum[l - 1]
# cin = open( "input.txt", 'r' )
# n = int( cin.readline() )
# a = list( map( int, cin.read().split() ) )
# cnt = 0;
# for i in range( 1, 200000 ):
# cnt += 200000 / i
# print( cnt )
# exit( 0 )
n = int( input() )
a = list( map( int, input().split() ) )
b = []
for i in range( 2 * ( 10 ** 5 ) + 10 ):
b.append( 0 )
for i in range( n ):
b[a[i]] += 1
prefSum.append( 0 )
for i in range( 1, 2 * ( 10 ** 5 ) + 10 ):
prefSum.append( b[i] + prefSum[i - 1] )
ans = 0
cnt = 0
for i in range( 2 * ( 10 ** 5 ) + 10 ):
if b[i] == 0:
continue
l = i
r = 2 * i - 1
curAns = 0;
for l in range( i, 200001, i ):
curAns += l * ( prefSum[min( r, 200000 )] - prefSum[l - 1] )
r += i
ans = max( ans, curAns )
print( ans )
main()
``` | output | 1 | 41,695 | 10 | 83,391 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18. | instruction | 0 | 41,696 | 10 | 83,392 |
Tags: brute force, data structures, implementation, math, number theory
Correct Solution:
```
from bisect import bisect_left
n = int(input())
a = sorted(list(map(int, input().split())))
ans = 0
for k in set(a):
r = sum(n - bisect_left(a, j) for j in range(k, a[-1] + 1, k))
ans = max(ans, k * r)
print(ans)
``` | output | 1 | 41,696 | 10 | 83,393 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18. | instruction | 0 | 41,697 | 10 | 83,394 |
Tags: brute force, data structures, implementation, math, number theory
Correct Solution:
```
n = int(input())
s = list(map(int, input().split()))
h = max(s)
ss = [0] * (h + 1)
for i in s:
ss[i] += 1
f, x = [0] * h, 0
for j in reversed(ss):
x += j
f.append(x)
f.reverse()
res = []
for i in range(len(ss)):
ch = ss[i]
if ch:
summ, x = 0, f[i]
for j in range(i, h + 1, i):
o = f[j + i]
summ += (x - o) * j
x = o
res.append(summ)
print(max(res))
``` | output | 1 | 41,697 | 10 | 83,395 |
Provide a correct Python 3 solution for this coding contest problem.
Kenkoooo is planning a trip in Republic of Snuke. In this country, there are n cities and m trains running. The cities are numbered 1 through n, and the i-th train connects City u_i and v_i bidirectionally. Any city can be reached from any city by changing trains.
Two currencies are used in the country: yen and snuuk. Any train fare can be paid by both yen and snuuk. The fare of the i-th train is a_i yen if paid in yen, and b_i snuuk if paid in snuuk.
In a city with a money exchange office, you can change 1 yen into 1 snuuk. However, when you do a money exchange, you have to change all your yen into snuuk. That is, if Kenkoooo does a money exchange when he has X yen, he will then have X snuuk. Currently, there is a money exchange office in every city, but the office in City i will shut down in i years and can never be used in and after that year.
Kenkoooo is planning to depart City s with 10^{15} yen in his pocket and head for City t, and change his yen into snuuk in some city while traveling. It is acceptable to do the exchange in City s or City t.
Kenkoooo would like to have as much snuuk as possible when he reaches City t by making the optimal choices for the route to travel and the city to do the exchange. For each i=0,...,n-1, find the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i years. You can assume that the trip finishes within the year.
Constraints
* 2 \leq n \leq 10^5
* 1 \leq m \leq 10^5
* 1 \leq s,t \leq n
* s \neq t
* 1 \leq u_i < v_i \leq n
* 1 \leq a_i,b_i \leq 10^9
* If i\neq j, then u_i \neq u_j or v_i \neq v_j.
* Any city can be reached from any city by changing trains.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
n m s t
u_1 v_1 a_1 b_1
:
u_m v_m a_m b_m
Output
Print n lines. In the i-th line, print the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i-1 years.
Examples
Input
4 3 2 3
1 4 1 100
1 2 1 10
1 3 20 1
Output
999999999999998
999999999999989
999999999999979
999999999999897
Input
8 12 3 8
2 8 685087149 857180777
6 7 298270585 209942236
2 4 346080035 234079976
2 5 131857300 22507157
4 8 30723332 173476334
2 6 480845267 448565596
1 4 181424400 548830121
4 5 57429995 195056405
7 8 160277628 479932440
1 6 475692952 203530153
3 5 336869679 160714712
2 7 389775999 199123879
Output
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994 | instruction | 0 | 41,893 | 10 | 83,786 |
"Correct Solution:
```
import sys
import heapq
input=sys.stdin.readline
def dijkstra_heap(s,edge):
#始点sから各頂点への最短距離
d = [float("inf")] * n
used = [True] * n #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist,e)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge[1]]:
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,[e[0]+d[v],e[1]])
return d
n,m,s,t=map(int,input().split())
ey=[[] for _ in range(n)]
es=[[] for _ in range(n)]
for i in range(m):
u,v,a,b=map(int,input().split())
ey[u-1].append([a,v-1])
ey[v-1].append([a,u-1])
es[u-1].append([b,v-1])
es[v-1].append([b,u-1])
dy=dijkstra_heap(s-1,ey)
ds=dijkstra_heap(t-1,es)
accumb=[10*10]*n
accumb[n-1]=int(dy[n-1]+ds[n-1])
for i in range(1,n):
accumb[n-i-1]=int(min(dy[n-i-1]+ds[n-i-1],accumb[n-i]))
money=10**15
for i in range(n):
print(money-accumb[i])
``` | output | 1 | 41,893 | 10 | 83,787 |
Provide a correct Python 3 solution for this coding contest problem.
Kenkoooo is planning a trip in Republic of Snuke. In this country, there are n cities and m trains running. The cities are numbered 1 through n, and the i-th train connects City u_i and v_i bidirectionally. Any city can be reached from any city by changing trains.
Two currencies are used in the country: yen and snuuk. Any train fare can be paid by both yen and snuuk. The fare of the i-th train is a_i yen if paid in yen, and b_i snuuk if paid in snuuk.
In a city with a money exchange office, you can change 1 yen into 1 snuuk. However, when you do a money exchange, you have to change all your yen into snuuk. That is, if Kenkoooo does a money exchange when he has X yen, he will then have X snuuk. Currently, there is a money exchange office in every city, but the office in City i will shut down in i years and can never be used in and after that year.
Kenkoooo is planning to depart City s with 10^{15} yen in his pocket and head for City t, and change his yen into snuuk in some city while traveling. It is acceptable to do the exchange in City s or City t.
Kenkoooo would like to have as much snuuk as possible when he reaches City t by making the optimal choices for the route to travel and the city to do the exchange. For each i=0,...,n-1, find the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i years. You can assume that the trip finishes within the year.
Constraints
* 2 \leq n \leq 10^5
* 1 \leq m \leq 10^5
* 1 \leq s,t \leq n
* s \neq t
* 1 \leq u_i < v_i \leq n
* 1 \leq a_i,b_i \leq 10^9
* If i\neq j, then u_i \neq u_j or v_i \neq v_j.
* Any city can be reached from any city by changing trains.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
n m s t
u_1 v_1 a_1 b_1
:
u_m v_m a_m b_m
Output
Print n lines. In the i-th line, print the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i-1 years.
Examples
Input
4 3 2 3
1 4 1 100
1 2 1 10
1 3 20 1
Output
999999999999998
999999999999989
999999999999979
999999999999897
Input
8 12 3 8
2 8 685087149 857180777
6 7 298270585 209942236
2 4 346080035 234079976
2 5 131857300 22507157
4 8 30723332 173476334
2 6 480845267 448565596
1 4 181424400 548830121
4 5 57429995 195056405
7 8 160277628 479932440
1 6 475692952 203530153
3 5 336869679 160714712
2 7 389775999 199123879
Output
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994 | instruction | 0 | 41,894 | 10 | 83,788 |
"Correct Solution:
```
import heapq,collections
class Dijkstra():
def __init__(self):
self.e=collections.defaultdict(list)
def add(self,u,v,d):
self.e[u].append((v,d))
self.e[v].append((u,d))
def search(self,s):
dist = [-1 for _ in range(n)]
next_point = []
heapq.heappush(next_point,(0,s))
while next_point:
cost,node = heapq.heappop(next_point)
if dist[node] == -1:
dist[node] = cost
for u,d in self.e[node]:
if dist[u] == -1:
heapq.heappush(next_point,(cost+d,u))
return dist
n,m,s,t = map(int,input().split())
graph_y = Dijkstra()
graph_s = Dijkstra()
for _ in range(m):
u,v,a,b = map(int,input().split())
graph_y.add(u-1,v-1,a)
graph_s.add(u-1,v-1,b)
dist_y = graph_y.search(s-1)
dist_s = graph_s.search(t-1)
r = [0]*n
for i in range(n):
r[-i-1] = max(r[-i],10**15-dist_y[-i-1]-dist_s[-i-1])
print(*r,sep='\n')
``` | output | 1 | 41,894 | 10 | 83,789 |
Provide a correct Python 3 solution for this coding contest problem.
Kenkoooo is planning a trip in Republic of Snuke. In this country, there are n cities and m trains running. The cities are numbered 1 through n, and the i-th train connects City u_i and v_i bidirectionally. Any city can be reached from any city by changing trains.
Two currencies are used in the country: yen and snuuk. Any train fare can be paid by both yen and snuuk. The fare of the i-th train is a_i yen if paid in yen, and b_i snuuk if paid in snuuk.
In a city with a money exchange office, you can change 1 yen into 1 snuuk. However, when you do a money exchange, you have to change all your yen into snuuk. That is, if Kenkoooo does a money exchange when he has X yen, he will then have X snuuk. Currently, there is a money exchange office in every city, but the office in City i will shut down in i years and can never be used in and after that year.
Kenkoooo is planning to depart City s with 10^{15} yen in his pocket and head for City t, and change his yen into snuuk in some city while traveling. It is acceptable to do the exchange in City s or City t.
Kenkoooo would like to have as much snuuk as possible when he reaches City t by making the optimal choices for the route to travel and the city to do the exchange. For each i=0,...,n-1, find the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i years. You can assume that the trip finishes within the year.
Constraints
* 2 \leq n \leq 10^5
* 1 \leq m \leq 10^5
* 1 \leq s,t \leq n
* s \neq t
* 1 \leq u_i < v_i \leq n
* 1 \leq a_i,b_i \leq 10^9
* If i\neq j, then u_i \neq u_j or v_i \neq v_j.
* Any city can be reached from any city by changing trains.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
n m s t
u_1 v_1 a_1 b_1
:
u_m v_m a_m b_m
Output
Print n lines. In the i-th line, print the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i-1 years.
Examples
Input
4 3 2 3
1 4 1 100
1 2 1 10
1 3 20 1
Output
999999999999998
999999999999989
999999999999979
999999999999897
Input
8 12 3 8
2 8 685087149 857180777
6 7 298270585 209942236
2 4 346080035 234079976
2 5 131857300 22507157
4 8 30723332 173476334
2 6 480845267 448565596
1 4 181424400 548830121
4 5 57429995 195056405
7 8 160277628 479932440
1 6 475692952 203530153
3 5 336869679 160714712
2 7 389775999 199123879
Output
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994 | instruction | 0 | 41,895 | 10 | 83,790 |
"Correct Solution:
```
from heapq import heappush,heappop
N,M,s,t=map(int,input().split())
table=[[] for i in range(N)]
rtable=[[] for i in range(N)]
for i in range(M):
u,v,a,b=map(int,input().split())
table[u-1].append((a,v-1))
table[v-1].append((a,u-1))
rtable[u-1].append((b,v-1))
rtable[v-1].append((b,u-1))
dij=[]
heappush(dij,(0,s-1))
val=[10**16]*N
val[s-1]=0
while dij:
q,x=heappop(dij)
if val[x]<q:
continue
for d,y in table[x]:
if val[y]>val[x]+d:
val[y]=val[x]+d
heappush(dij,(val[y],y))
rdij=[]
heappush(rdij,(0,t-1))
rval=[10**16]*N
rval[t-1]=0
while rdij:
q,x=heappop(rdij)
if rval[x]<q:
continue
for d,y in rtable[x]:
if rval[y]>rval[x]+d:
rval[y]=rval[x]+d
heappush(rdij,(rval[y],y))
ans=[]
t=val[N-1]+rval[N-1]
mod=pow(10,15)
ans.append(mod-t)
for i in range(N-2,-1,-1):
t=min(t,val[i]+rval[i])
ans.append(mod-t)
ans=ans[::-1]
for a in ans:
print(a)
``` | output | 1 | 41,895 | 10 | 83,791 |
Provide a correct Python 3 solution for this coding contest problem.
Kenkoooo is planning a trip in Republic of Snuke. In this country, there are n cities and m trains running. The cities are numbered 1 through n, and the i-th train connects City u_i and v_i bidirectionally. Any city can be reached from any city by changing trains.
Two currencies are used in the country: yen and snuuk. Any train fare can be paid by both yen and snuuk. The fare of the i-th train is a_i yen if paid in yen, and b_i snuuk if paid in snuuk.
In a city with a money exchange office, you can change 1 yen into 1 snuuk. However, when you do a money exchange, you have to change all your yen into snuuk. That is, if Kenkoooo does a money exchange when he has X yen, he will then have X snuuk. Currently, there is a money exchange office in every city, but the office in City i will shut down in i years and can never be used in and after that year.
Kenkoooo is planning to depart City s with 10^{15} yen in his pocket and head for City t, and change his yen into snuuk in some city while traveling. It is acceptable to do the exchange in City s or City t.
Kenkoooo would like to have as much snuuk as possible when he reaches City t by making the optimal choices for the route to travel and the city to do the exchange. For each i=0,...,n-1, find the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i years. You can assume that the trip finishes within the year.
Constraints
* 2 \leq n \leq 10^5
* 1 \leq m \leq 10^5
* 1 \leq s,t \leq n
* s \neq t
* 1 \leq u_i < v_i \leq n
* 1 \leq a_i,b_i \leq 10^9
* If i\neq j, then u_i \neq u_j or v_i \neq v_j.
* Any city can be reached from any city by changing trains.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
n m s t
u_1 v_1 a_1 b_1
:
u_m v_m a_m b_m
Output
Print n lines. In the i-th line, print the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i-1 years.
Examples
Input
4 3 2 3
1 4 1 100
1 2 1 10
1 3 20 1
Output
999999999999998
999999999999989
999999999999979
999999999999897
Input
8 12 3 8
2 8 685087149 857180777
6 7 298270585 209942236
2 4 346080035 234079976
2 5 131857300 22507157
4 8 30723332 173476334
2 6 480845267 448565596
1 4 181424400 548830121
4 5 57429995 195056405
7 8 160277628 479932440
1 6 475692952 203530153
3 5 336869679 160714712
2 7 389775999 199123879
Output
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994 | instruction | 0 | 41,896 | 10 | 83,792 |
"Correct Solution:
```
import heapq
N,M,S,T = map(int,input().split())
src = [tuple(map(int,input().split())) for i in range(M)]
S,T = S-1,T-1
INF = float('inf')
def dijkstra(is_yen):
g = [[] for i in range(N)]
for u,v,a,b in src:
u,v = u-1,v-1
c = a if is_yen else b
g[u].append((v,c))
g[v].append((u,c))
costs = [INF] * N
start = S if is_yen else T
costs[start] = 0
hq = [(0,start)]
heapq.heapify(hq)
while hq:
_,v = heapq.heappop(hq)
for to,c in g[v]:
if costs[v]+c >= costs[to]: continue
costs[to] = costs[v]+c
heapq.heappush(hq, (costs[to],to))
return costs
yens = dijkstra(1)
snuuks = dijkstra(0)
ans = [None] * N
ans[-1] = yens[-1] + snuuks[-1]
for i in reversed(range(N-1)):
ans[i] = min(ans[i+1], yens[i]+snuuks[i])
for a in ans:
print(10**15 - a)
``` | output | 1 | 41,896 | 10 | 83,793 |
Provide a correct Python 3 solution for this coding contest problem.
Kenkoooo is planning a trip in Republic of Snuke. In this country, there are n cities and m trains running. The cities are numbered 1 through n, and the i-th train connects City u_i and v_i bidirectionally. Any city can be reached from any city by changing trains.
Two currencies are used in the country: yen and snuuk. Any train fare can be paid by both yen and snuuk. The fare of the i-th train is a_i yen if paid in yen, and b_i snuuk if paid in snuuk.
In a city with a money exchange office, you can change 1 yen into 1 snuuk. However, when you do a money exchange, you have to change all your yen into snuuk. That is, if Kenkoooo does a money exchange when he has X yen, he will then have X snuuk. Currently, there is a money exchange office in every city, but the office in City i will shut down in i years and can never be used in and after that year.
Kenkoooo is planning to depart City s with 10^{15} yen in his pocket and head for City t, and change his yen into snuuk in some city while traveling. It is acceptable to do the exchange in City s or City t.
Kenkoooo would like to have as much snuuk as possible when he reaches City t by making the optimal choices for the route to travel and the city to do the exchange. For each i=0,...,n-1, find the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i years. You can assume that the trip finishes within the year.
Constraints
* 2 \leq n \leq 10^5
* 1 \leq m \leq 10^5
* 1 \leq s,t \leq n
* s \neq t
* 1 \leq u_i < v_i \leq n
* 1 \leq a_i,b_i \leq 10^9
* If i\neq j, then u_i \neq u_j or v_i \neq v_j.
* Any city can be reached from any city by changing trains.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
n m s t
u_1 v_1 a_1 b_1
:
u_m v_m a_m b_m
Output
Print n lines. In the i-th line, print the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i-1 years.
Examples
Input
4 3 2 3
1 4 1 100
1 2 1 10
1 3 20 1
Output
999999999999998
999999999999989
999999999999979
999999999999897
Input
8 12 3 8
2 8 685087149 857180777
6 7 298270585 209942236
2 4 346080035 234079976
2 5 131857300 22507157
4 8 30723332 173476334
2 6 480845267 448565596
1 4 181424400 548830121
4 5 57429995 195056405
7 8 160277628 479932440
1 6 475692952 203530153
3 5 336869679 160714712
2 7 389775999 199123879
Output
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994 | instruction | 0 | 41,897 | 10 | 83,794 |
"Correct Solution:
```
from heapq import *
n,m,s,t=map(int,input().split())
s-=1
t-=1
INF=10**19
Gyen=[[]for i in range(n)]
Gsnu=[[]for i in range(n)]
for i in range(m):
u,v,a,b=map(int,input().split())
u-=1
v-=1
Gyen[u].append([v,a])
Gyen[v].append([u,a])
Gsnu[u].append([v,b])
Gsnu[v].append([u,b])
def dijkstra(G,s):
d=[INF]*n
d[s]=0
visited={s}
que=[(0,s)]
while(que):
p=heappop(que)
v=p[1]
visited.add(v)
for node,cost in G[v]:
if (node not in visited) and d[node]>d[v]+cost:
d[node]=d[v]+cost
heappush(que,(d[node],node))
return d
yen=dijkstra(Gyen,s)
snu=dijkstra(Gsnu,t)
ans=10**15
ans_list=[]
for i in reversed(range(n)):
ans=min(ans,yen[i]+snu[i])
ans_list.append(10**15-ans)
print(*ans_list[::-1], sep='\n')
``` | output | 1 | 41,897 | 10 | 83,795 |
Provide a correct Python 3 solution for this coding contest problem.
Kenkoooo is planning a trip in Republic of Snuke. In this country, there are n cities and m trains running. The cities are numbered 1 through n, and the i-th train connects City u_i and v_i bidirectionally. Any city can be reached from any city by changing trains.
Two currencies are used in the country: yen and snuuk. Any train fare can be paid by both yen and snuuk. The fare of the i-th train is a_i yen if paid in yen, and b_i snuuk if paid in snuuk.
In a city with a money exchange office, you can change 1 yen into 1 snuuk. However, when you do a money exchange, you have to change all your yen into snuuk. That is, if Kenkoooo does a money exchange when he has X yen, he will then have X snuuk. Currently, there is a money exchange office in every city, but the office in City i will shut down in i years and can never be used in and after that year.
Kenkoooo is planning to depart City s with 10^{15} yen in his pocket and head for City t, and change his yen into snuuk in some city while traveling. It is acceptable to do the exchange in City s or City t.
Kenkoooo would like to have as much snuuk as possible when he reaches City t by making the optimal choices for the route to travel and the city to do the exchange. For each i=0,...,n-1, find the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i years. You can assume that the trip finishes within the year.
Constraints
* 2 \leq n \leq 10^5
* 1 \leq m \leq 10^5
* 1 \leq s,t \leq n
* s \neq t
* 1 \leq u_i < v_i \leq n
* 1 \leq a_i,b_i \leq 10^9
* If i\neq j, then u_i \neq u_j or v_i \neq v_j.
* Any city can be reached from any city by changing trains.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
n m s t
u_1 v_1 a_1 b_1
:
u_m v_m a_m b_m
Output
Print n lines. In the i-th line, print the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i-1 years.
Examples
Input
4 3 2 3
1 4 1 100
1 2 1 10
1 3 20 1
Output
999999999999998
999999999999989
999999999999979
999999999999897
Input
8 12 3 8
2 8 685087149 857180777
6 7 298270585 209942236
2 4 346080035 234079976
2 5 131857300 22507157
4 8 30723332 173476334
2 6 480845267 448565596
1 4 181424400 548830121
4 5 57429995 195056405
7 8 160277628 479932440
1 6 475692952 203530153
3 5 336869679 160714712
2 7 389775999 199123879
Output
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994 | instruction | 0 | 41,898 | 10 | 83,796 |
"Correct Solution:
```
def main():
from sys import stdin
input = stdin.readline
n, m, s, t = map(int, input().split())
uvab = [list(map(int, input().split())) for _ in [0]*m]
g = [[] for _ in [0]*n]
[g[u-1].append([v-1, a, b]) for u, v, a, b in uvab]
[g[v-1].append([u-1, a, b]) for u, v, a, b in uvab]
import heapq
inf = 10**15
yen = [inf for _ in [0]*n]
h = [(0, s-1)]
heapq.heapify(h)
while h:
d, i = heapq.heappop(h)
if yen[i] == inf:
yen[i] = d
for x, y, z in g[i]:
heapq.heappush(h, (d+y, x))
snk = [inf for _ in [0]*n]
h = [(0, t-1)]
heapq.heapify(h)
while h:
d, i = heapq.heappop(h)
if snk[i] == inf:
snk[i] = d
for x, y, z in g[i]:
heapq.heappush(h, (d+z, x))
cost = [yen[i]+snk[i] for i in range(n)]
m = cost[-1]
for i in range(n-1, -1, -1):
m = min(m, cost[i])
cost[i] = m
for i in cost:
print(10**15-i)
main()
``` | output | 1 | 41,898 | 10 | 83,797 |
Provide a correct Python 3 solution for this coding contest problem.
Kenkoooo is planning a trip in Republic of Snuke. In this country, there are n cities and m trains running. The cities are numbered 1 through n, and the i-th train connects City u_i and v_i bidirectionally. Any city can be reached from any city by changing trains.
Two currencies are used in the country: yen and snuuk. Any train fare can be paid by both yen and snuuk. The fare of the i-th train is a_i yen if paid in yen, and b_i snuuk if paid in snuuk.
In a city with a money exchange office, you can change 1 yen into 1 snuuk. However, when you do a money exchange, you have to change all your yen into snuuk. That is, if Kenkoooo does a money exchange when he has X yen, he will then have X snuuk. Currently, there is a money exchange office in every city, but the office in City i will shut down in i years and can never be used in and after that year.
Kenkoooo is planning to depart City s with 10^{15} yen in his pocket and head for City t, and change his yen into snuuk in some city while traveling. It is acceptable to do the exchange in City s or City t.
Kenkoooo would like to have as much snuuk as possible when he reaches City t by making the optimal choices for the route to travel and the city to do the exchange. For each i=0,...,n-1, find the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i years. You can assume that the trip finishes within the year.
Constraints
* 2 \leq n \leq 10^5
* 1 \leq m \leq 10^5
* 1 \leq s,t \leq n
* s \neq t
* 1 \leq u_i < v_i \leq n
* 1 \leq a_i,b_i \leq 10^9
* If i\neq j, then u_i \neq u_j or v_i \neq v_j.
* Any city can be reached from any city by changing trains.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
n m s t
u_1 v_1 a_1 b_1
:
u_m v_m a_m b_m
Output
Print n lines. In the i-th line, print the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i-1 years.
Examples
Input
4 3 2 3
1 4 1 100
1 2 1 10
1 3 20 1
Output
999999999999998
999999999999989
999999999999979
999999999999897
Input
8 12 3 8
2 8 685087149 857180777
6 7 298270585 209942236
2 4 346080035 234079976
2 5 131857300 22507157
4 8 30723332 173476334
2 6 480845267 448565596
1 4 181424400 548830121
4 5 57429995 195056405
7 8 160277628 479932440
1 6 475692952 203530153
3 5 336869679 160714712
2 7 389775999 199123879
Output
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994 | instruction | 0 | 41,899 | 10 | 83,798 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
import heapq
n,m,s,t = map(int, input().split())
e = [[] for _ in range(n+1)]
for _ in range(m):
v,u,a,b = map(int, input().split())
e[v].append((u,(a,b)))
e[u].append((v,(a,b)))
inf = 10**18
def dijkstra(s,cu):
d = [inf]*(n+1)
d[s] = 0
q = [(d[s],s)]
heapq.heapify([q])
while len(q)>0:
_,v = heapq.heappop(q)
for u,ud in e[v]:
if d[v]+ud[cu]>=d[u]:
continue
d[u] = d[v] + ud[cu]
heapq.heappush(q, (d[u],u))
return d
da = dijkstra(s,0)
db = dijkstra(t,1)
res = [0]*n
res[n-1] = da[n]+db[n]
for i in range(n-2,-1,-1):
res[i] = min(res[i+1], da[i+1]+db[i+1])
for r in res:
print(10**15 - r)
``` | output | 1 | 41,899 | 10 | 83,799 |
Provide a correct Python 3 solution for this coding contest problem.
Kenkoooo is planning a trip in Republic of Snuke. In this country, there are n cities and m trains running. The cities are numbered 1 through n, and the i-th train connects City u_i and v_i bidirectionally. Any city can be reached from any city by changing trains.
Two currencies are used in the country: yen and snuuk. Any train fare can be paid by both yen and snuuk. The fare of the i-th train is a_i yen if paid in yen, and b_i snuuk if paid in snuuk.
In a city with a money exchange office, you can change 1 yen into 1 snuuk. However, when you do a money exchange, you have to change all your yen into snuuk. That is, if Kenkoooo does a money exchange when he has X yen, he will then have X snuuk. Currently, there is a money exchange office in every city, but the office in City i will shut down in i years and can never be used in and after that year.
Kenkoooo is planning to depart City s with 10^{15} yen in his pocket and head for City t, and change his yen into snuuk in some city while traveling. It is acceptable to do the exchange in City s or City t.
Kenkoooo would like to have as much snuuk as possible when he reaches City t by making the optimal choices for the route to travel and the city to do the exchange. For each i=0,...,n-1, find the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i years. You can assume that the trip finishes within the year.
Constraints
* 2 \leq n \leq 10^5
* 1 \leq m \leq 10^5
* 1 \leq s,t \leq n
* s \neq t
* 1 \leq u_i < v_i \leq n
* 1 \leq a_i,b_i \leq 10^9
* If i\neq j, then u_i \neq u_j or v_i \neq v_j.
* Any city can be reached from any city by changing trains.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
n m s t
u_1 v_1 a_1 b_1
:
u_m v_m a_m b_m
Output
Print n lines. In the i-th line, print the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i-1 years.
Examples
Input
4 3 2 3
1 4 1 100
1 2 1 10
1 3 20 1
Output
999999999999998
999999999999989
999999999999979
999999999999897
Input
8 12 3 8
2 8 685087149 857180777
6 7 298270585 209942236
2 4 346080035 234079976
2 5 131857300 22507157
4 8 30723332 173476334
2 6 480845267 448565596
1 4 181424400 548830121
4 5 57429995 195056405
7 8 160277628 479932440
1 6 475692952 203530153
3 5 336869679 160714712
2 7 389775999 199123879
Output
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994 | instruction | 0 | 41,900 | 10 | 83,800 |
"Correct Solution:
```
N,M,S,T = map(int,input().split())
S,T = S-1,T-1
UVAB = [tuple(map(int,input().split())) for i in range(M)]
es = [[] for _ in range(N)]
for u,v,a,b in UVAB:
u,v = u-1,v-1
es[u].append((v,a,b))
es[v].append((u,a,b))
import heapq
INF = float('inf')
dy = [INF]*N
dy[S] = 0
hq = [(0,S)]
heapq.heapify(hq)
while hq:
d,v = heapq.heappop(hq)
for to,a,_ in es[v]:
if d+a >= dy[to]: continue
dy[to] = d+a
heapq.heappush(hq, (d+a, to))
ds = [INF]*N
ds[T] = 0
hq = [(0,T)]
heapq.heapify(hq)
while hq:
d,v = heapq.heappop(hq)
for to,_,a in es[v]:
if d+a >= ds[to]: continue
ds[to] = d+a
heapq.heappush(hq, (d+a, to))
ans = []
m = 0
for y,s in reversed(list(zip(dy,ds))):
m = max(m, 10**15-y-s)
ans.append(m)
ans.reverse()
print(*ans, sep='\n')
``` | output | 1 | 41,900 | 10 | 83,801 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kenkoooo is planning a trip in Republic of Snuke. In this country, there are n cities and m trains running. The cities are numbered 1 through n, and the i-th train connects City u_i and v_i bidirectionally. Any city can be reached from any city by changing trains.
Two currencies are used in the country: yen and snuuk. Any train fare can be paid by both yen and snuuk. The fare of the i-th train is a_i yen if paid in yen, and b_i snuuk if paid in snuuk.
In a city with a money exchange office, you can change 1 yen into 1 snuuk. However, when you do a money exchange, you have to change all your yen into snuuk. That is, if Kenkoooo does a money exchange when he has X yen, he will then have X snuuk. Currently, there is a money exchange office in every city, but the office in City i will shut down in i years and can never be used in and after that year.
Kenkoooo is planning to depart City s with 10^{15} yen in his pocket and head for City t, and change his yen into snuuk in some city while traveling. It is acceptable to do the exchange in City s or City t.
Kenkoooo would like to have as much snuuk as possible when he reaches City t by making the optimal choices for the route to travel and the city to do the exchange. For each i=0,...,n-1, find the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i years. You can assume that the trip finishes within the year.
Constraints
* 2 \leq n \leq 10^5
* 1 \leq m \leq 10^5
* 1 \leq s,t \leq n
* s \neq t
* 1 \leq u_i < v_i \leq n
* 1 \leq a_i,b_i \leq 10^9
* If i\neq j, then u_i \neq u_j or v_i \neq v_j.
* Any city can be reached from any city by changing trains.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
n m s t
u_1 v_1 a_1 b_1
:
u_m v_m a_m b_m
Output
Print n lines. In the i-th line, print the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i-1 years.
Examples
Input
4 3 2 3
1 4 1 100
1 2 1 10
1 3 20 1
Output
999999999999998
999999999999989
999999999999979
999999999999897
Input
8 12 3 8
2 8 685087149 857180777
6 7 298270585 209942236
2 4 346080035 234079976
2 5 131857300 22507157
4 8 30723332 173476334
2 6 480845267 448565596
1 4 181424400 548830121
4 5 57429995 195056405
7 8 160277628 479932440
1 6 475692952 203530153
3 5 336869679 160714712
2 7 389775999 199123879
Output
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
Submitted Solution:
```
import heapq
inf = float('inf')
def dijkstra(s, n, G):#スタート, 頂点数, グラフ:[[(cost, v)], ...]
dist = [inf]*n
edges = []#(sからvまでのコストの候補, v)
dist[s] = 0
for e in G[s]:
heapq.heappush(edges, e)
while edges:
cost, v = heapq.heappop(edges)
if dist[v] != inf:
continue
dist[v] = cost
for c, nv in G[v]:
if dist[nv] == inf:
heapq.heappush(edges, (cost + c, nv))
return dist
n, m, s, t = map(int, input().split())
G1 = [[] for _ in range(n)]
G2 = [[] for _ in range(n)]
for i in range(m):
u, v, a, b = map(int, input().split())
G1[u-1].append((a, v-1))
G1[v-1].append((a, u-1))
G2[u-1].append((b, v-1))
G2[v-1].append((b, u-1))
dist1 = dijkstra(s-1, n, G1)
dist2 = dijkstra(t-1, n, G2)
ans = [0]*n
ans[-1] = dist1[n-1]+dist2[n-1]
for i in range(n-1)[::-1]:
ans[i] = min(ans[i+1], dist1[i]+dist2[i])
for i in range(n):
print(10**15-ans[i])
``` | instruction | 0 | 41,901 | 10 | 83,802 |
Yes | output | 1 | 41,901 | 10 | 83,803 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kenkoooo is planning a trip in Republic of Snuke. In this country, there are n cities and m trains running. The cities are numbered 1 through n, and the i-th train connects City u_i and v_i bidirectionally. Any city can be reached from any city by changing trains.
Two currencies are used in the country: yen and snuuk. Any train fare can be paid by both yen and snuuk. The fare of the i-th train is a_i yen if paid in yen, and b_i snuuk if paid in snuuk.
In a city with a money exchange office, you can change 1 yen into 1 snuuk. However, when you do a money exchange, you have to change all your yen into snuuk. That is, if Kenkoooo does a money exchange when he has X yen, he will then have X snuuk. Currently, there is a money exchange office in every city, but the office in City i will shut down in i years and can never be used in and after that year.
Kenkoooo is planning to depart City s with 10^{15} yen in his pocket and head for City t, and change his yen into snuuk in some city while traveling. It is acceptable to do the exchange in City s or City t.
Kenkoooo would like to have as much snuuk as possible when he reaches City t by making the optimal choices for the route to travel and the city to do the exchange. For each i=0,...,n-1, find the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i years. You can assume that the trip finishes within the year.
Constraints
* 2 \leq n \leq 10^5
* 1 \leq m \leq 10^5
* 1 \leq s,t \leq n
* s \neq t
* 1 \leq u_i < v_i \leq n
* 1 \leq a_i,b_i \leq 10^9
* If i\neq j, then u_i \neq u_j or v_i \neq v_j.
* Any city can be reached from any city by changing trains.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
n m s t
u_1 v_1 a_1 b_1
:
u_m v_m a_m b_m
Output
Print n lines. In the i-th line, print the maximum amount of snuuk that Kenkoooo has when he reaches City t if he goes on a trip from City s to City t after i-1 years.
Examples
Input
4 3 2 3
1 4 1 100
1 2 1 10
1 3 20 1
Output
999999999999998
999999999999989
999999999999979
999999999999897
Input
8 12 3 8
2 8 685087149 857180777
6 7 298270585 209942236
2 4 346080035 234079976
2 5 131857300 22507157
4 8 30723332 173476334
2 6 480845267 448565596
1 4 181424400 548830121
4 5 57429995 195056405
7 8 160277628 479932440
1 6 475692952 203530153
3 5 336869679 160714712
2 7 389775999 199123879
Output
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
999999574976994
Submitted Solution:
```
import heapq
INF = float('inf')
yen = 10**15
def pcc(src, adj):
pq = [(0,src)]
heapq.heapify(pq)
dist = [INF]*n
dist[src] = 0
while pq:
d,u = heapq.heappop(pq)
if d>dist[u]:continue
for w, v in adj[u]:
if dist[v] > dist[u] + w:
dist[v] = dist[u] + w
heapq.heappush(pq, (dist[v], v))
return dist
n,m,s,t = map(int, input().split())
s,t = s-1,t-1
adjs = [[] for _ in range(n)]
adjt = [[] for _ in range(n)]
for _ in range(m):
u,v,a,b = map(int, input().split())
u,v = u-1, v-1
adjs[u].append((a,v))
adjs[v].append((a,u))
adjt[u].append((b,v))
adjt[v].append((b,u))
dist_s = pcc(s,adjs)
dist_t = pcc(t,adjt)
ans = [0]*(n)
ans[n-1] = yen -dist_s[n-1] - dist_t[n-1]
for i in range(n-2,-1,-1):
ans[i] = max(ans[i+1], yen - dist_s[i] - dist_t[i])
print(*ans, sep = '\n')
``` | instruction | 0 | 41,902 | 10 | 83,804 |
Yes | output | 1 | 41,902 | 10 | 83,805 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.