message stringlengths 2 433k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the easy version of the problem. The only difference between the easy version and the hard version is the constraints on n. You can only make hacks if both versions are solved.
A permutation of 1, 2, …, n is a sequence of n integers, where each integer from 1 to n appears exactly once. For example, [2,3,1,4] is a permutation of 1, 2, 3, 4, but [1,4,2,2] isn't because 2 appears twice in it.
Recall that the number of inversions in a permutation a_1, a_2, …, a_n is the number of pairs of indices (i, j) such that i < j and a_i > a_j.
Let p and q be two permutations of 1, 2, …, n. Find the number of permutation pairs (p,q) that satisfy the following conditions:
* p is lexicographically smaller than q.
* the number of inversions in p is greater than the number of inversions in q.
Print the number of such pairs modulo mod. Note that mod may not be a prime.
Input
The only line contains two integers n and mod (1≤ n≤ 50, 1≤ mod≤ 10^9).
Output
Print one integer, which is the answer modulo mod.
Example
Input
4 403458273
Output
17
Note
The following are all valid pairs (p,q) when n=4.
* p=[1,3,4,2], q=[2,1,3,4],
* p=[1,4,2,3], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,4,3],
* p=[1,4,3,2], q=[2,3,1,4],
* p=[1,4,3,2], q=[3,1,2,4],
* p=[2,3,4,1], q=[3,1,2,4],
* p=[2,4,1,3], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,4,2],
* p=[2,4,3,1], q=[3,2,1,4],
* p=[2,4,3,1], q=[4,1,2,3],
* p=[3,2,4,1], q=[4,1,2,3],
* p=[3,4,1,2], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,3,2],
* p=[3,4,2,1], q=[4,2,1,3]. | instruction | 0 | 64,235 | 12 | 128,470 |
Tags: combinatorics, dp, fft, math
Correct Solution:
```
from functools import lru_cache
import itertools
def invnum(seq):
N=len(seq)
res=0
for i in range(N):
for j in range(i+1,N):
if seq[i]>seq[j]:
res+=1
return res
def naive(N,k,flag):
res=0
for p in itertools.permutations(range(N),N):
for q in itertools.permutations(range(N),N):
if ((p<q) or (not(flag))) and (invnum(p)-invnum(q)>k):
res+=1
return res
n,mod=map(int,input().split())
memo=[[{},{}] for _ in range(n+1)]
def solve(N,k,flag):
if k in memo[N][flag]:
return memo[N][flag][k]
'''
長さNの順列
invnum(p)-invnum(q)>kとなる場合の数
flag=True p<qの条件あり
flag=False p<qの条件なし
'''
if N==1:
res=-1
if flag:
res=0
else:
if k<0:
res=1
else:
res=0
memo[N][flag][k]=res
return res
invnum_INF=(N*(N-1))//2
if k<-invnum_INF-1:
res=solve(N,-invnum_INF-1,flag)
memo[N][flag][k]=res
return res
if k>=invnum_INF:
memo[N][flag][k]=0
return 0
res=0
for delta in range(-N+1,N):
if flag and (delta>0):
continue
wt=min(N-delta,delta+N)
res+=solve(N-1,k-delta,(delta==0)&flag)*wt
res%=mod
memo[N][flag][k]=res%mod
return res%mod
ans=solve(n,0,1)%mod
print(ans)
``` | output | 1 | 64,235 | 12 | 128,471 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the easy version of the problem. The only difference between the easy version and the hard version is the constraints on n. You can only make hacks if both versions are solved.
A permutation of 1, 2, …, n is a sequence of n integers, where each integer from 1 to n appears exactly once. For example, [2,3,1,4] is a permutation of 1, 2, 3, 4, but [1,4,2,2] isn't because 2 appears twice in it.
Recall that the number of inversions in a permutation a_1, a_2, …, a_n is the number of pairs of indices (i, j) such that i < j and a_i > a_j.
Let p and q be two permutations of 1, 2, …, n. Find the number of permutation pairs (p,q) that satisfy the following conditions:
* p is lexicographically smaller than q.
* the number of inversions in p is greater than the number of inversions in q.
Print the number of such pairs modulo mod. Note that mod may not be a prime.
Input
The only line contains two integers n and mod (1≤ n≤ 50, 1≤ mod≤ 10^9).
Output
Print one integer, which is the answer modulo mod.
Example
Input
4 403458273
Output
17
Note
The following are all valid pairs (p,q) when n=4.
* p=[1,3,4,2], q=[2,1,3,4],
* p=[1,4,2,3], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,4,3],
* p=[1,4,3,2], q=[2,3,1,4],
* p=[1,4,3,2], q=[3,1,2,4],
* p=[2,3,4,1], q=[3,1,2,4],
* p=[2,4,1,3], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,4,2],
* p=[2,4,3,1], q=[3,2,1,4],
* p=[2,4,3,1], q=[4,1,2,3],
* p=[3,2,4,1], q=[4,1,2,3],
* p=[3,4,1,2], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,3,2],
* p=[3,4,2,1], q=[4,2,1,3]. | instruction | 0 | 64,236 | 12 | 128,472 |
Tags: combinatorics, dp, fft, math
Correct Solution:
```
import sys
input = sys.stdin.readline
def make_tree(n):
i = 2
while True:
if i >= n * 2:
tree = [0] * i
break
else:
i *= 2
return tree
def update(i, x):
i += len(tree) // 2
tree[i] = x
i //= 2
while True:
if i == 0:
break
tree[i] = tree[2 * i] + tree[2 * i + 1]
i //= 2
return
def get_sum(s, t):
s += len(tree) // 2
t += len(tree) // 2
ans = 0
while True:
if s > t:
break
if s % 2 == 0:
s //= 2
else:
ans += tree[s]
s = (s + 1) // 2
if t % 2 == 1:
t //= 2
else:
ans += tree[t]
t = (t - 1) // 2
return ans
def prime_factorize(n):
ans = []
for i in range(2, int(n ** (1 / 2)) + 1):
while True:
if n % i:
break
ans.append(i)
n //= i
if n == 1:
break
if not n == 1:
ans.append(n)
return ans
def euler_func(n):
p = set(prime_factorize(n))
x = n
for i in p:
x *= (i - 1)
x //= i
return x
def f(a, b):
ans = 1
for i in range(a + 1, b + 1):
ans *= i
ans %= mod
return ans
n, mod = map(int, input().split())
x = euler_func(mod)
l = n + 5
fact = [1] * (l + 1)
for i in range(1, l + 1):
fact[i] = i * fact[i - 1] % mod
if n <= 3:
ans = 0
else:
dp = [0] * 2000
dp[0], dp[1], dp[2], dp[3] = 1, 2, 2, 1
tree = make_tree(2005)
for i in range(4):
update(i, dp[i])
m = 3
ans = 0
for i in range(n - 3):
dp0 = list(dp)
ans0 = 0
for j in range(i + 3):
for k in range(1, m + 2):
ans0 += get_sum(j + k + 1, 2004) * dp0[k - 1] % mod
ans0 %= mod
dp[j + k] += dp0[k - 1]
dp[j + k] %= mod
update(j + k, dp[j + k])
m += i + 3
ans += f(i + 4, n) * ans0 % mod
ans %= mod
print(ans)
``` | output | 1 | 64,236 | 12 | 128,473 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the easy version of the problem. The only difference between the easy version and the hard version is the constraints on n. You can only make hacks if both versions are solved.
A permutation of 1, 2, …, n is a sequence of n integers, where each integer from 1 to n appears exactly once. For example, [2,3,1,4] is a permutation of 1, 2, 3, 4, but [1,4,2,2] isn't because 2 appears twice in it.
Recall that the number of inversions in a permutation a_1, a_2, …, a_n is the number of pairs of indices (i, j) such that i < j and a_i > a_j.
Let p and q be two permutations of 1, 2, …, n. Find the number of permutation pairs (p,q) that satisfy the following conditions:
* p is lexicographically smaller than q.
* the number of inversions in p is greater than the number of inversions in q.
Print the number of such pairs modulo mod. Note that mod may not be a prime.
Input
The only line contains two integers n and mod (1≤ n≤ 50, 1≤ mod≤ 10^9).
Output
Print one integer, which is the answer modulo mod.
Example
Input
4 403458273
Output
17
Note
The following are all valid pairs (p,q) when n=4.
* p=[1,3,4,2], q=[2,1,3,4],
* p=[1,4,2,3], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,4,3],
* p=[1,4,3,2], q=[2,3,1,4],
* p=[1,4,3,2], q=[3,1,2,4],
* p=[2,3,4,1], q=[3,1,2,4],
* p=[2,4,1,3], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,4,2],
* p=[2,4,3,1], q=[3,2,1,4],
* p=[2,4,3,1], q=[4,1,2,3],
* p=[3,2,4,1], q=[4,1,2,3],
* p=[3,4,1,2], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,3,2],
* p=[3,4,2,1], q=[4,2,1,3]. | instruction | 0 | 64,237 | 12 | 128,474 |
Tags: combinatorics, dp, fft, math
Correct Solution:
```
def solve():
n, mod = map(int, input().split());m = n*(n-1)//2;dp = [[0]*(n*(n-1)+1) for i in range(n+1)];dp1 = [[0]*(n*(n-1)+1) for i in range(n+1)];dp[1][m] = 1
for i in range(2, n+1):
for x in range(m-(i-1)*(i-2)//2, m+(i-1)*(i-2)//2+1):
for d in range(-i+1, i):dp[i][x+d] = (dp[i][x+d]+dp[i-1][x]*(i-abs(d))) % mod
for i in range(2, n+1):
for x in range(m-(i-1)*(i-2)//2, m+(i-1)*(i-2)//2+1):dp1[i][x] = dp1[i-1][x] * i % mod
for x in range(m-(i-1)*(i-2)//2, m+(i-1)*(i-2)//2+1):
for d in range(1, i):dp1[i][x-d] = (dp1[i][x-d]+dp[i-1][x]*(i-d)) % mod
return sum(dp1[-1][m+1:]) % mod
import sys;input = lambda: sys.stdin.readline().rstrip();print(solve())
``` | output | 1 | 64,237 | 12 | 128,475 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the easy version of the problem. The only difference between the easy version and the hard version is the constraints on n. You can only make hacks if both versions are solved.
A permutation of 1, 2, …, n is a sequence of n integers, where each integer from 1 to n appears exactly once. For example, [2,3,1,4] is a permutation of 1, 2, 3, 4, but [1,4,2,2] isn't because 2 appears twice in it.
Recall that the number of inversions in a permutation a_1, a_2, …, a_n is the number of pairs of indices (i, j) such that i < j and a_i > a_j.
Let p and q be two permutations of 1, 2, …, n. Find the number of permutation pairs (p,q) that satisfy the following conditions:
* p is lexicographically smaller than q.
* the number of inversions in p is greater than the number of inversions in q.
Print the number of such pairs modulo mod. Note that mod may not be a prime.
Input
The only line contains two integers n and mod (1≤ n≤ 50, 1≤ mod≤ 10^9).
Output
Print one integer, which is the answer modulo mod.
Example
Input
4 403458273
Output
17
Note
The following are all valid pairs (p,q) when n=4.
* p=[1,3,4,2], q=[2,1,3,4],
* p=[1,4,2,3], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,4,3],
* p=[1,4,3,2], q=[2,3,1,4],
* p=[1,4,3,2], q=[3,1,2,4],
* p=[2,3,4,1], q=[3,1,2,4],
* p=[2,4,1,3], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,4,2],
* p=[2,4,3,1], q=[3,2,1,4],
* p=[2,4,3,1], q=[4,1,2,3],
* p=[3,2,4,1], q=[4,1,2,3],
* p=[3,4,1,2], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,3,2],
* p=[3,4,2,1], q=[4,2,1,3]. | instruction | 0 | 64,238 | 12 | 128,476 |
Tags: combinatorics, dp, fft, math
Correct Solution:
```
import sys
sys.stderr = sys.stdout
def egcd(a, b):
r0 = a
r1 = b
s0 = 1
s1 = 0
t0 = 0
t1 = 1
while r1:
q = r0 // r1
r0, r1 = r1, r0 - q*r1
s0, s1 = s1, s0 - q*s1
t0, t1 = t1, t0 - q*t1
return r0, s0
# def comb(n0, M):
# C = [[None] * (i+1) for i in range(n0+1)]
# C[0][0] = 1
# C[1][0] = C[1][1] = 1
# for n in range(2, n0+1):
# Cp = C[n-1]
# Cn = C[n]
# Cn[0] = Cn[n] = 1
# for i in range(1, n):
# Cn[i] = (Cp[i] + Cp[i-1]) % M
# return C
def tf(n, M):
C = [0] * (n+1)
C[n] = 1
for k in reversed(range(n)):
C[k] = (C[k+1] * (k+1)) % M
if not C[k]:
break
return C
def app(n, M):
K = [[[1]]]
for i in range(n-1):
Ki = K[i]
ni = len(Ki)
Ki_ = [[0] * (i+2) for _ in range(ni + i + 1)]
K.append(Ki_)
for j, Kij in enumerate(Ki):
for k, v in enumerate(Kij):
for h in range(i+1):
Ki_[j+h][k] += v
Ki_[j+h][k] %= M
Ki_[j + i + 1][i+1] += v
Ki_[j + i + 1][i+1] %= M
# C = comb(n, M)[n]
C = tf(n, M)
s = 0
for i in range(1, n):
Ki = K[i]
ni = len(Ki)
mi = len(Ki[0])
Si = [[None] * mi for _ in range(ni)]
for j in range(ni):
Si[j][mi-1] = Ki[j][mi-1]
for k in reversed(range(mi-1)):
Si[j][k] = (Ki[j][k] + Si[j][k+1]) % M
for j in range(1, ni):
for k in range(mi):
Si[j][k] += Si[j-1][k]
Si[j][k] %= M
# log("i", i, "Ki", Ki, "Si", Si)
si = 0
for j in range(1, ni):
for k in range(mi-1):
si += (Ki[j][k] * Si[j-1][k+1]) % M
si %= M
# log(" si", si)
c = C[i+1]
# log(" n", n, "k", i+1, "c", c)
si *= c
si %= M
s += si
s %= M
return s
def main():
n, m = readinti()
print(app(n, m))
##########
def readint():
return int(input())
def readinti():
return map(int, input().split())
def readintt():
return tuple(readinti())
def readintl():
return list(readinti())
def readinttl(k):
return [readintt() for _ in range(k)]
def readintll(k):
return [readintl() for _ in range(k)]
def log(*args, **kwargs):
print(*args, **kwargs, file=sys.__stderr__)
if __name__ == '__main__':
main()
``` | output | 1 | 64,238 | 12 | 128,477 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the easy version of the problem. The only difference between the easy version and the hard version is the constraints on n. You can only make hacks if both versions are solved.
A permutation of 1, 2, …, n is a sequence of n integers, where each integer from 1 to n appears exactly once. For example, [2,3,1,4] is a permutation of 1, 2, 3, 4, but [1,4,2,2] isn't because 2 appears twice in it.
Recall that the number of inversions in a permutation a_1, a_2, …, a_n is the number of pairs of indices (i, j) such that i < j and a_i > a_j.
Let p and q be two permutations of 1, 2, …, n. Find the number of permutation pairs (p,q) that satisfy the following conditions:
* p is lexicographically smaller than q.
* the number of inversions in p is greater than the number of inversions in q.
Print the number of such pairs modulo mod. Note that mod may not be a prime.
Input
The only line contains two integers n and mod (1≤ n≤ 50, 1≤ mod≤ 10^9).
Output
Print one integer, which is the answer modulo mod.
Example
Input
4 403458273
Output
17
Note
The following are all valid pairs (p,q) when n=4.
* p=[1,3,4,2], q=[2,1,3,4],
* p=[1,4,2,3], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,4,3],
* p=[1,4,3,2], q=[2,3,1,4],
* p=[1,4,3,2], q=[3,1,2,4],
* p=[2,3,4,1], q=[3,1,2,4],
* p=[2,4,1,3], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,4,2],
* p=[2,4,3,1], q=[3,2,1,4],
* p=[2,4,3,1], q=[4,1,2,3],
* p=[3,2,4,1], q=[4,1,2,3],
* p=[3,4,1,2], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,3,2],
* p=[3,4,2,1], q=[4,2,1,3].
Submitted Solution:
```
import sys
input = sys.stdin.readline
def make_tree(n):
i = 2
while True:
if i >= n * 2:
tree = [0] * i
break
else:
i *= 2
return tree
def update(i, x):
i += len(tree) // 2
tree[i] = x
i //= 2
while True:
if i == 0:
break
tree[i] = tree[2 * i] + tree[2 * i + 1]
i //= 2
return
def get_sum(s, t):
s += len(tree) // 2
t += len(tree) // 2
ans = 0
while True:
if s > t:
break
if s % 2 == 0:
s //= 2
else:
ans += tree[s]
s = (s + 1) // 2
if t % 2 == 1:
t //= 2
else:
ans += tree[t]
t = (t - 1) // 2
return ans
n, mod = map(int, input().split())
l = n + 5
fact = [1] * (l + 1)
for i in range(1, l + 1):
fact[i] = i * fact[i - 1] % mod
if n <= 3:
ans = 0
else:
dp = [0] * 2000
dp[0], dp[1], dp[2], dp[3] = 1, 2, 2, 1
tree = make_tree(2005)
for i in range(4):
update(i, dp[i])
m = 3
ans = 0
for i in range(n - 3):
dp0 = list(dp)
ans0 = 0
for j in range(i + 3):
for k in range(1, m + 2):
ans0 += get_sum(j + k + 1, 2004) * dp0[k - 1] % mod
ans0 %= mod
dp[j + k] += dp0[k - 1]
dp[j + k] %= mod
update(j + k, dp[j + k])
m += i + 3
ans += fact[n] * pow(fact[i + 4], mod - 2, mod) * ans0 % mod
ans %= mod
print(ans)
``` | instruction | 0 | 64,239 | 12 | 128,478 |
No | output | 1 | 64,239 | 12 | 128,479 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the easy version of the problem. The only difference between the easy version and the hard version is the constraints on n. You can only make hacks if both versions are solved.
A permutation of 1, 2, …, n is a sequence of n integers, where each integer from 1 to n appears exactly once. For example, [2,3,1,4] is a permutation of 1, 2, 3, 4, but [1,4,2,2] isn't because 2 appears twice in it.
Recall that the number of inversions in a permutation a_1, a_2, …, a_n is the number of pairs of indices (i, j) such that i < j and a_i > a_j.
Let p and q be two permutations of 1, 2, …, n. Find the number of permutation pairs (p,q) that satisfy the following conditions:
* p is lexicographically smaller than q.
* the number of inversions in p is greater than the number of inversions in q.
Print the number of such pairs modulo mod. Note that mod may not be a prime.
Input
The only line contains two integers n and mod (1≤ n≤ 50, 1≤ mod≤ 10^9).
Output
Print one integer, which is the answer modulo mod.
Example
Input
4 403458273
Output
17
Note
The following are all valid pairs (p,q) when n=4.
* p=[1,3,4,2], q=[2,1,3,4],
* p=[1,4,2,3], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,4,3],
* p=[1,4,3,2], q=[2,3,1,4],
* p=[1,4,3,2], q=[3,1,2,4],
* p=[2,3,4,1], q=[3,1,2,4],
* p=[2,4,1,3], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,4,2],
* p=[2,4,3,1], q=[3,2,1,4],
* p=[2,4,3,1], q=[4,1,2,3],
* p=[3,2,4,1], q=[4,1,2,3],
* p=[3,4,1,2], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,3,2],
* p=[3,4,2,1], q=[4,2,1,3].
Submitted Solution:
```
import sys
input = sys.stdin.readline
def make_tree(n):
i = 2
while True:
if i >= n * 2:
tree = [0] * i
break
else:
i *= 2
return tree
def update(i, x):
i += len(tree) // 2
tree[i] = x
i //= 2
while True:
if i == 0:
break
tree[i] = tree[2 * i] + tree[2 * i + 1]
i //= 2
return
def get_sum(s, t):
s += len(tree) // 2
t += len(tree) // 2
ans = 0
while True:
if s > t:
break
if s % 2 == 0:
s //= 2
else:
ans += tree[s]
s = (s + 1) // 2
if t % 2 == 1:
t //= 2
else:
ans += tree[t]
t = (t - 1) // 2
return ans
n, mod = map(int, input().split())
if n <= 3:
ans = 0
else:
dp = [0] * 2500
dp[0], dp[1], dp[2], dp[3] = 1, 2, 2, 1
tree = make_tree(2505)
for i in range(4):
update(i, dp[i])
m = 3
ans = 0
for i in range(n - 3):
dp0 = list(dp)
for j in range(i + 3):
for k in range(1, m + 2):
ans += get_sum(j + k + 1, 2504) * dp0[k - 1] % mod
ans %= mod
dp[j + k] += dp0[k - 1]
dp[j + k] %= mod
update(j + k, dp[j + k])
m += i + 3
print(ans)
``` | instruction | 0 | 64,240 | 12 | 128,480 |
No | output | 1 | 64,240 | 12 | 128,481 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the easy version of the problem. The only difference between the easy version and the hard version is the constraints on n. You can only make hacks if both versions are solved.
A permutation of 1, 2, …, n is a sequence of n integers, where each integer from 1 to n appears exactly once. For example, [2,3,1,4] is a permutation of 1, 2, 3, 4, but [1,4,2,2] isn't because 2 appears twice in it.
Recall that the number of inversions in a permutation a_1, a_2, …, a_n is the number of pairs of indices (i, j) such that i < j and a_i > a_j.
Let p and q be two permutations of 1, 2, …, n. Find the number of permutation pairs (p,q) that satisfy the following conditions:
* p is lexicographically smaller than q.
* the number of inversions in p is greater than the number of inversions in q.
Print the number of such pairs modulo mod. Note that mod may not be a prime.
Input
The only line contains two integers n and mod (1≤ n≤ 50, 1≤ mod≤ 10^9).
Output
Print one integer, which is the answer modulo mod.
Example
Input
4 403458273
Output
17
Note
The following are all valid pairs (p,q) when n=4.
* p=[1,3,4,2], q=[2,1,3,4],
* p=[1,4,2,3], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,4,3],
* p=[1,4,3,2], q=[2,3,1,4],
* p=[1,4,3,2], q=[3,1,2,4],
* p=[2,3,4,1], q=[3,1,2,4],
* p=[2,4,1,3], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,4,2],
* p=[2,4,3,1], q=[3,2,1,4],
* p=[2,4,3,1], q=[4,1,2,3],
* p=[3,2,4,1], q=[4,1,2,3],
* p=[3,4,1,2], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,3,2],
* p=[3,4,2,1], q=[4,2,1,3].
Submitted Solution:
```
def divisors(M):
d=[]
i=1
while M>=i**2:
if M%i==0:
d.append(i)
if i**2!=M:
d.append(M//i)
i=i+1
return d
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def eratosthenes(n):
res=[0 for i in range(n+1)]
prime=set([])
for i in range(2,n+1):
if not res[i]:
prime.add(i)
for j in range(1,n//i+1):
res[i*j]=1
return prime
def factorization(n):
res=[]
for p in prime:
if n%p==0:
while n%p==0:
n//=p
res.append(p)
if n!=1:
res.append(n)
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def ind(b,n):
res=0
while n%b==0:
res+=1
n//=b
return res
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 3, 5, 7, 11, 13, 17]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
from math import gcd
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(n):
res = [1]
prime = primeFactor(n)
for p in prime:
newres = []
for d in res:
for j in range(prime[p]+1):
newres.append(d*p**j)
res = newres
res.sort()
return res
def xorfactorial(num):
if num==0:
return 0
elif num==1:
return 1
elif num==2:
return 3
elif num==3:
return 0
else:
x=baseorder(num)
return (2**x)*((num-2**x+1)%2)+function(num-2**x)
def xorconv(n,X,Y):
if n==0:
res=[(X[0]*Y[0])%mod]
return res
x=[X[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
z=[X[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
res1=xorconv(n-1,x,y)
res2=xorconv(n-1,z,w)
former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
former=list(map(lambda x:x%mod,former))
latter=list(map(lambda x:x%mod,latter))
return former+latter
def merge_sort(A,B):
pos_A,pos_B = 0,0
n,m = len(A),len(B)
res = []
while pos_A < n and pos_B < m:
a,b = A[pos_A],B[pos_B]
if a < b:
res.append(a)
pos_A += 1
else:
res.append(b)
pos_B += 1
res += A[pos_A:]
res += B[pos_B:]
return res
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self.group = N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
stack = [x]
while self._parent[stack[-1]]!=stack[-1]:
stack.append(self._parent[stack[-1]])
for v in stack:
self._parent[v] = stack[-1]
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
self.group -= 1
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
class WeightedUnionFind():
def __init__(self,N):
self.parent = [i for i in range(N)]
self.size = [1 for i in range(N)]
self.val = [0 for i in range(N)]
self.flag = True
self.edge = [[] for i in range(N)]
def dfs(self,v,pv):
stack = [(v,pv)]
new_parent = self.parent[pv]
while stack:
v,pv = stack.pop()
self.parent[v] = new_parent
for nv,w in self.edge[v]:
if nv!=pv:
self.val[nv] = self.val[v] + w
stack.append((nv,v))
def unite(self,x,y,w):
if not self.flag:
return
if self.parent[x]==self.parent[y]:
self.flag = (self.val[x] - self.val[y] == w)
return
if self.size[self.parent[x]]>self.size[self.parent[y]]:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[x] += self.size[y]
self.val[y] = self.val[x] - w
self.dfs(y,x)
else:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[y] += self.size[x]
self.val[x] = self.val[y] + w
self.dfs(x,y)
class Dijkstra():
class Edge():
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
self.G = [[] for i in range(V)]
self._E = 0
self._V = V
@property
def E(self):
return self._E
@property
def V(self):
return self._V
def add_edge(self, _from, _to, _cost):
self.G[_from].append(self.Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
import heapq
que = []
d = [10**15] * self.V
d[s] = 0
heapq.heappush(que, (0, s))
while len(que) != 0:
cost, v = heapq.heappop(que)
if d[v] < cost: continue
for i in range(len(self.G[v])):
e = self.G[v][i]
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
#Z[i]:length of the longest list starting from S[i] which is also a prefix of S
#O(|S|)
def Z_algorithm(s):
N = len(s)
Z_alg = [0]*N
Z_alg[0] = N
i = 1
j = 0
while i < N:
while i+j < N and s[j] == s[i+j]:
j += 1
Z_alg[i] = j
if j == 0:
i += 1
continue
k = 1
while i+k < N and k + Z_alg[k]<j:
Z_alg[i+k] = Z_alg[k]
k += 1
i += k
j -= k
return Z_alg
class BIT():
def __init__(self,n,mod=0):
self.BIT = [0]*(n+1)
self.num = n
self.mod = mod
def query(self,idx):
res_sum = 0
mod = self.mod
while idx > 0:
res_sum += self.BIT[idx]
if mod:
res_sum %= mod
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
mod = self.mod
while idx <= self.num:
self.BIT[idx] += x
if mod:
self.BIT[idx] %= mod
idx += idx&(-idx)
return
class dancinglink():
def __init__(self,n,debug=False):
self.n = n
self.debug = debug
self._left = [i-1 for i in range(n)]
self._right = [i+1 for i in range(n)]
self.exist = [True for i in range(n)]
def pop(self,k):
if self.debug:
assert self.exist[k]
L = self._left[k]
R = self._right[k]
if L!=-1:
if R!=self.n:
self._right[L],self._left[R] = R,L
else:
self._right[L] = self.n
elif R!=self.n:
self._left[R] = -1
self.exist[k] = False
def left(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._left[res]
if res==-1:
break
k -= 1
return res
def right(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._right[res]
if res==self.n:
break
k -= 1
return res
class SparseTable():
def __init__(self,A,merge_func,ide_ele):
N=len(A)
n=N.bit_length()
self.table=[[ide_ele for i in range(n)] for i in range(N)]
self.merge_func=merge_func
for i in range(N):
self.table[i][0]=A[i]
for j in range(1,n):
for i in range(0,N-2**j+1):
f=self.table[i][j-1]
s=self.table[i+2**(j-1)][j-1]
self.table[i][j]=self.merge_func(f,s)
def query(self,s,t):
b=t-s+1
m=b.bit_length()-1
return self.merge_func(self.table[s][m],self.table[t-2**m+1][m])
class BinaryTrie:
class node:
def __init__(self,val):
self.left = None
self.right = None
self.max = val
def __init__(self):
self.root = self.node(-10**15)
def append(self,key,val):
pos = self.root
for i in range(29,-1,-1):
pos.max = max(pos.max,val)
if key>>i & 1:
if pos.right is None:
pos.right = self.node(val)
pos = pos.right
else:
pos = pos.right
else:
if pos.left is None:
pos.left = self.node(val)
pos = pos.left
else:
pos = pos.left
pos.max = max(pos.max,val)
def search(self,M,xor):
res = -10**15
pos = self.root
for i in range(29,-1,-1):
if pos is None:
break
if M>>i & 1:
if xor>>i & 1:
if pos.right:
res = max(res,pos.right.max)
pos = pos.left
else:
if pos.left:
res = max(res,pos.left.max)
pos = pos.right
else:
if xor>>i & 1:
pos = pos.right
else:
pos = pos.left
if pos:
res = max(res,pos.max)
return res
def solveequation(edge,ans,n,m):
#edge=[[to,dire,id]...]
x=[0]*m
used=[False]*n
for v in range(n):
if used[v]:
continue
y = dfs(v)
if y!=0:
return False
return x
def dfs(v):
used[v]=True
r=ans[v]
for to,dire,id in edge[v]:
if used[to]:
continue
y=dfs(to)
if dire==-1:
x[id]=y
else:
x[id]=-y
r+=y
return r
class SegmentTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
self.size = n
for i in range(n):
self.tree[self.num + i] = init_val[i]
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
if r==self.size:
r = self.num
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def bisect_l(self,l,r,x):
l += self.num
r += self.num
Lmin = -1
Rmin = -1
while l<r:
if l & 1:
if self.tree[l] <= x and Lmin==-1:
Lmin = l
l += 1
if r & 1:
if self.tree[r-1] <=x:
Rmin = r-1
l >>= 1
r >>= 1
if Lmin != -1:
pos = Lmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
elif Rmin != -1:
pos = Rmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
else:
return -1
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log
input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())
N,mod = mi()
COMB = [[0 for j in range(N+1)] for i in range(N+1)]
COMB[0][0] = 1
for i in range(1,N+1):
COMB[i][0] = 1
for j in range(1,i+1):
COMB[i][j] = COMB[i-1][j] + COMB[i-1][j-1]
COMB[i][j] %= mod
dp = [[0 for j in range(N*(N-1)//2+1)] for i in range(N+1)]
dp[1][0] = 1
for i in range(2,N+1):
for k in range(N*(N-1)//2+1):
if not dp[i-1][k]:
continue
dp[i][k] += dp[i-1][k]
dp[i][k] %= mod
if k+i <= N*(N-1)//2:
dp[i][k+i] -= dp[i-1][k]
dp[i][k+i] %= mod
for k in range(1,N*(N-1)//2+1):
dp[i][k] += dp[i][k-1]
dp[i][k] %= mod
imos = [[dp[i][j] for j in range(N*(N-1)//2+1)] for i in range(N+1)]
for i in range(1,N+1):
for j in range(1,N*(N-1)//2+1):
imos[i][j] += imos[i][j-1]
imos[i][j] %= mod
res = 0
for i in range(1,N):
cnt = N - i
inverse = [0 for inv in range(-(N-i+1),0)]
for j in range(1,N-i+1):
for k in range(j+1,N-i+2):
inv = j-k
inverse[inv] += 1
inverse[inv] %= mod
for inv in range(-(N-i+1),0):
for ip in range(cnt*(cnt-1)//2+1):
if ip+inv <= 0:
continue
R = ip+inv-1
res += (COMB[N][i-1] * dp[cnt][ip] % mod) * (imos[cnt][R] * inverse[inv] % mod)
res %= mod
#for iq in range(cnt*(cnt-1)//2+1):
#if ip-iq+inverse > 0:
#res += COMB[N][i-1] * dp[cnt][ip] * dp[cnt][iq]
#res %= mod
print(res)
``` | instruction | 0 | 64,241 | 12 | 128,482 |
No | output | 1 | 64,241 | 12 | 128,483 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the easy version of the problem. The only difference between the easy version and the hard version is the constraints on n. You can only make hacks if both versions are solved.
A permutation of 1, 2, …, n is a sequence of n integers, where each integer from 1 to n appears exactly once. For example, [2,3,1,4] is a permutation of 1, 2, 3, 4, but [1,4,2,2] isn't because 2 appears twice in it.
Recall that the number of inversions in a permutation a_1, a_2, …, a_n is the number of pairs of indices (i, j) such that i < j and a_i > a_j.
Let p and q be two permutations of 1, 2, …, n. Find the number of permutation pairs (p,q) that satisfy the following conditions:
* p is lexicographically smaller than q.
* the number of inversions in p is greater than the number of inversions in q.
Print the number of such pairs modulo mod. Note that mod may not be a prime.
Input
The only line contains two integers n and mod (1≤ n≤ 50, 1≤ mod≤ 10^9).
Output
Print one integer, which is the answer modulo mod.
Example
Input
4 403458273
Output
17
Note
The following are all valid pairs (p,q) when n=4.
* p=[1,3,4,2], q=[2,1,3,4],
* p=[1,4,2,3], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,4,3],
* p=[1,4,3,2], q=[2,3,1,4],
* p=[1,4,3,2], q=[3,1,2,4],
* p=[2,3,4,1], q=[3,1,2,4],
* p=[2,4,1,3], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,4,2],
* p=[2,4,3,1], q=[3,2,1,4],
* p=[2,4,3,1], q=[4,1,2,3],
* p=[3,2,4,1], q=[4,1,2,3],
* p=[3,4,1,2], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,3,2],
* p=[3,4,2,1], q=[4,2,1,3].
Submitted Solution:
```
import sys
sys.stderr = sys.stdout
def egcd(a, b):
r0 = a
r1 = b
s0 = 1
s1 = 0
t0 = 0
t1 = 1
while r1:
q = r0 // r1
r0, r1 = r1, r0 - q*r1
s0, s1 = s1, s0 - q*s1
t0, t1 = t1, t0 - q*t1
return r0, s0
def app(n, M):
K = [[[1]]]
for i in range(n-1):
Ki = K[i]
ni = len(Ki)
Ki_ = [[0] * (i+2) for _ in range(ni + i + 1)]
K.append(Ki_)
for j, Kij in enumerate(Ki):
for k, v in enumerate(Kij):
for h in range(i+1):
Ki_[j+h][k] += v
Ki_[j+h][k] %= M
Ki_[j + i + 1][i+1] += v
Ki_[j + i + 1][i+1] %= M
c = n
s = 0
for i in range(1, n):
Ki = K[i]
ni = len(Ki)
mi = len(Ki[0])
Si = [[None] * mi for _ in range(ni)]
for j in range(ni):
Si[j][mi-1] = Ki[j][mi-1]
for k in reversed(range(mi-1)):
Si[j][k] = (Ki[j][k] + Si[j][k+1]) % M
for j in range(1, ni):
for k in range(mi):
Si[j][k] += Si[j-1][k]
Si[j][k] %= M
# log("i", i, "Ki", Ki, "Si", Si)
si = 0
for j in range(1, ni):
for k in range(mi-1):
si += (Ki[j][k] * Si[j-1][k+1]) % M
si %= M
# log(" si", si)
# log(" n", n, "i+1", i+1, "c", c)
x, y = egcd(i+1, M)
c = (c * y) % M
# log(" x", x, "y", y)
# assert c % x == 0
c = (c // x) % M
c = (c * (n - i)) % M
# log(" c", c)
si *= c
si %= M
s += si
s %= M
return s
def main():
n, m = readinti()
print(app(n, m))
##########
def readint():
return int(input())
def readinti():
return map(int, input().split())
def readintt():
return tuple(readinti())
def readintl():
return list(readinti())
def readinttl(k):
return [readintt() for _ in range(k)]
def readintll(k):
return [readintl() for _ in range(k)]
def log(*args, **kwargs):
print(*args, **kwargs, file=sys.__stderr__)
if __name__ == '__main__':
main()
``` | instruction | 0 | 64,242 | 12 | 128,484 |
No | output | 1 | 64,242 | 12 | 128,485 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1 | instruction | 0 | 64,272 | 12 | 128,544 |
Tags: implementation
Correct Solution:
```
mat = [input().split(), input().split(), input().split(), input().split(), input().split()]
m = 2
for x, a in enumerate(mat):
if "1" in a:
for y, b in enumerate(a):
if b == "1":
print(abs(x - m) + abs(y - m))
``` | output | 1 | 64,272 | 12 | 128,545 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1 | instruction | 0 | 64,273 | 12 | 128,546 |
Tags: implementation
Correct Solution:
```
i=j=2
arr=[]
for _ in range(5):
arr.append(list(map(int,input().rstrip().split())))
flag=False
for x in range(0,5):
for y in range(0,5):
if arr[x][y]==1:
flag=True
break
if flag is True:
break
print(abs(x-i)+abs(y-j))
``` | output | 1 | 64,273 | 12 | 128,547 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1 | instruction | 0 | 64,275 | 12 | 128,550 |
Tags: implementation
Correct Solution:
```
for i in range(5):
ls=list(map(int,input().split()))
if 1 in ls:
print(abs(ls.index(1)-2)+abs(i-2))
``` | output | 1 | 64,275 | 12 | 128,551 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1 | instruction | 0 | 64,276 | 12 | 128,552 |
Tags: implementation
Correct Solution:
```
a1,a2 = 0, 0
for i in range(5):
l = list(map(int,input().split()))
if 1 in l:
a1 = i+1
a2 = l.index(1)+1
print(abs(3-a1)+abs(3-a2))
``` | output | 1 | 64,276 | 12 | 128,553 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1 | instruction | 0 | 64,277 | 12 | 128,554 |
Tags: implementation
Correct Solution:
```
c=0
pos=0
for i in range(0,5):
if pos!=0:
break
c=c+1
list1=list(map(int,input().split()))
for i in range(0,len(list1)):
if list1[i]==1:
pos=i+1
break
print(abs(3-c)+abs(3-pos))
``` | output | 1 | 64,277 | 12 | 128,555 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1 | instruction | 0 | 64,278 | 12 | 128,556 |
Tags: implementation
Correct Solution:
```
for i in range(5):
l = str(input())
if '1' in l:
y=i+1
l=l.split()
z=l.index('1')
z=z+1
print(abs(3-y)+abs(3-z))
``` | output | 1 | 64,278 | 12 | 128,557 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1. | instruction | 0 | 64,414 | 12 | 128,828 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
b = list(map(int,input().split()))
print(abs(b[0])+ sum([abs(b[i]-b[i-1]) for i in range(1,n)]))
# Made By Mostafa_Khaled
``` | output | 1 | 64,414 | 12 | 128,829 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1. | instruction | 0 | 64,415 | 12 | 128,830 |
Tags: greedy, implementation
Correct Solution:
```
def array(bs):
s = 0
k = 0
for b in bs:
s += abs(b-k)
k = b
return s
if __name__ == '__main__':
n = int(input())
bs = tuple(map(int, input().split()))
print(array(bs))
``` | output | 1 | 64,415 | 12 | 128,831 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1. | instruction | 0 | 64,416 | 12 | 128,832 |
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
value=0
ans=0
b=list(map(int,input().split()))
i=0
while(i<n):
if value==b[i]:
i+=1
else:
ans+=abs(value-b[i])
value=b[i]
i+=1
print(ans)
``` | output | 1 | 64,416 | 12 | 128,833 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1. | instruction | 0 | 64,417 | 12 | 128,834 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
arr = list(map(int, input().split()))
count = 0
num = 0
for x in arr:
if num != x:
if num > x:
sub = abs(num-x)
count += sub
num -= sub
if num < x:
add = abs(num-x)
count += add
num += add
print(count)
``` | output | 1 | 64,417 | 12 | 128,835 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1. | instruction | 0 | 64,418 | 12 | 128,836 |
Tags: greedy, implementation
Correct Solution:
```
def vilbur(lst):
a = [0] + lst
count = 0
for i in range(len(a) - 1):
count += abs(a[i + 1] - a[i])
return count
n = int(input())
b = [int(j) for j in input().split()]
print(vilbur(b))
``` | output | 1 | 64,418 | 12 | 128,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1. | instruction | 0 | 64,419 | 12 | 128,838 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
ans = 0
for i in range(n):
if i > 0:
ans += abs(a[i]-a[i-1])
else:
ans += abs(a[i])
print(ans)
``` | output | 1 | 64,419 | 12 | 128,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1. | instruction | 0 | 64,420 | 12 | 128,840 |
Tags: greedy, implementation
Correct Solution:
```
input()
ans = int(0)
curr = int(0)
for x in input().split():
x = int(x)
ans += abs(curr - x)
curr = x
print(ans)
``` | output | 1 | 64,420 | 12 | 128,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1. | instruction | 0 | 64,421 | 12 | 128,842 |
Tags: greedy, implementation
Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
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 main():
n = I()
a = LI()
r = abs(a[0])
for i in range(1,n):
r += abs(a[i] - a[i-1])
return r
print(main())
``` | output | 1 | 64,421 | 12 | 128,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1.
Submitted Solution:
```
if __name__ == "__main__":
n = int( input() )
b = [ int(x) for x in input().split() ]
res = abs(b[0])
for i in range(1,n):
res += abs( b[i] - b[i-1] )
print( res )
``` | instruction | 0 | 64,422 | 12 | 128,844 |
Yes | output | 1 | 64,422 | 12 | 128,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1.
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
t=0
for i in range(n):
if(i==0):
t=t+abs(l[i])
else:
t=t+abs(l[i]-l[i-1])
print(t)
``` | instruction | 0 | 64,423 | 12 | 128,846 |
Yes | output | 1 | 64,423 | 12 | 128,847 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1.
Submitted Solution:
```
input()
A = [0] + list(map(int, input().split()))
print(sum(abs(a - b) for a, b in zip(A, A[1:])))
``` | instruction | 0 | 64,424 | 12 | 128,848 |
Yes | output | 1 | 64,424 | 12 | 128,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1.
Submitted Solution:
```
n=int(input())
x=list(map(int,input().split()))
c=0
t=0
for i in x:
c+=abs(t-i)
t=i
print(c)
``` | instruction | 0 | 64,425 | 12 | 128,850 |
Yes | output | 1 | 64,425 | 12 | 128,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1.
Submitted Solution:
```
n = int(input())
b = [int(x) for x in input().split()]
count = b[0]
for i in range(1, n):
count += abs(b[i]-b[i-1])
print(count)
``` | instruction | 0 | 64,426 | 12 | 128,852 |
No | output | 1 | 64,426 | 12 | 128,853 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1.
Submitted Solution:
```
n=int(input())
r=[int(j) for j in input().split()]
q=0
t=True
ee=max(r)
for j in range(1,n):
if t==True:
if r[j]>r[j-1]:
q=q+1
else:
if r[j]<r[j-1]:
q=q+1
t=False
else:
if r[j]<r[j-1]:
q=q+1
else:
if r[j]>r[j-1]:
q=q+1
t=True
if q==0:
print(ee)
else:
if ee>q+1:
print(ee-(q+1)+ee)
else:
print(q+1)
``` | instruction | 0 | 64,427 | 12 | 128,854 |
No | output | 1 | 64,427 | 12 | 128,855 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1.
Submitted Solution:
```
n = int(input())
l = list(map(int, input().split()))
count = l[0]
for i in range(n - 1):
c = abs(l[i] - l[i + 1])
count += c
print(count)
``` | instruction | 0 | 64,428 | 12 | 128,856 |
No | output | 1 | 64,428 | 12 | 128,857 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1.
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
a=max(l)
b=l.count(a)
print(a+b-1)
``` | instruction | 0 | 64,429 | 12 | 128,858 |
No | output | 1 | 64,429 | 12 | 128,859 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day, ZS the Coder wrote down an array of integers a with elements a1, a2, ..., an.
A subarray of the array a is a sequence al, al + 1, ..., ar for some integers (l, r) such that 1 ≤ l ≤ r ≤ n. ZS the Coder thinks that a subarray of a is beautiful if the bitwise xor of all the elements in the subarray is at least k.
Help ZS the Coder find the number of beautiful subarrays of a!
Input
The first line contains two integers n and k (1 ≤ n ≤ 106, 1 ≤ k ≤ 109) — the number of elements in the array a and the value of the parameter k.
The second line contains n integers ai (0 ≤ ai ≤ 109) — the elements of the array a.
Output
Print the only integer c — the number of beautiful subarrays of the array a.
Examples
Input
3 1
1 2 3
Output
5
Input
3 2
1 2 3
Output
3
Input
3 3
1 2 3
Output
2
Submitted Solution:
```
import sys
import math
import itertools as it
import operator as op
import fractions as fr
n,k = map(int, sys.stdin.readline().split())
A = list(map(int, sys.stdin.readline().split()))
Ap = [0 for _ in range(n)]
r = len(list(filter(lambda e: e >= k, A)))
print(A)
for i in range(1,n):
App,Ap = Ap, A
A = [0 for _ in range(n)]
for j in range(i,n):
A[j] = Ap[j-1] ^ Ap[j] ^ App[j-1]
r += len(list(filter(lambda e: e >= k, A)))
print(A)
print(r)
``` | instruction | 0 | 64,462 | 12 | 128,924 |
No | output | 1 | 64,462 | 12 | 128,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day, ZS the Coder wrote down an array of integers a with elements a1, a2, ..., an.
A subarray of the array a is a sequence al, al + 1, ..., ar for some integers (l, r) such that 1 ≤ l ≤ r ≤ n. ZS the Coder thinks that a subarray of a is beautiful if the bitwise xor of all the elements in the subarray is at least k.
Help ZS the Coder find the number of beautiful subarrays of a!
Input
The first line contains two integers n and k (1 ≤ n ≤ 106, 1 ≤ k ≤ 109) — the number of elements in the array a and the value of the parameter k.
The second line contains n integers ai (0 ≤ ai ≤ 109) — the elements of the array a.
Output
Print the only integer c — the number of beautiful subarrays of the array a.
Examples
Input
3 1
1 2 3
Output
5
Input
3 2
1 2 3
Output
3
Input
3 3
1 2 3
Output
2
Submitted Solution:
```
class Trie(object):
def __init__(self):
self.size = [0, 0]
self.child = [None, None]
def add(self, bit: int, d: int):
node = self
digit = 1 << d
while digit > 1:
b = (1 if bit & digit else 0)
if not node.child[b]:
node.child[b] = Trie()
node.size[b] += 1
node = node.child[b]
digit >>= 1
node.size[bit & 1] += 1
if __name__ == '__main__':
import sys
n, k = map(int, sys.stdin.buffer.readline().decode('utf-8').split())
a = list(map(int, sys.stdin.buffer.readline().decode('utf-8').split()))
trie = Trie()
trie.add(0, 29)
acc, ans = 0, 0
for x in a:
node = trie
acc ^= x
digit = 1 << 29
mask, req = 0, 0
while digit and node:
mask |= digit
if ((acc ^ req) & mask | digit) >= k:
ans += node.size[0 if (acc & digit) else 1]
node = node.child[1 if (acc & digit) else 0]
req |= (acc & digit)
else:
node = node.child[1 if (acc & digit) else 0]
req |= (acc & digit) ^ digit
digit >>= 1
trie.add(acc, 29)
print(ans)
``` | instruction | 0 | 64,463 | 12 | 128,926 |
No | output | 1 | 64,463 | 12 | 128,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day, ZS the Coder wrote down an array of integers a with elements a1, a2, ..., an.
A subarray of the array a is a sequence al, al + 1, ..., ar for some integers (l, r) such that 1 ≤ l ≤ r ≤ n. ZS the Coder thinks that a subarray of a is beautiful if the bitwise xor of all the elements in the subarray is at least k.
Help ZS the Coder find the number of beautiful subarrays of a!
Input
The first line contains two integers n and k (1 ≤ n ≤ 106, 1 ≤ k ≤ 109) — the number of elements in the array a and the value of the parameter k.
The second line contains n integers ai (0 ≤ ai ≤ 109) — the elements of the array a.
Output
Print the only integer c — the number of beautiful subarrays of the array a.
Examples
Input
3 1
1 2 3
Output
5
Input
3 2
1 2 3
Output
3
Input
3 3
1 2 3
Output
2
Submitted Solution:
```
import sys
import math
import itertools as it
import operator as op
import fractions as fr
n,k = map(int, sys.stdin.readline().split())
A = list(map(int, sys.stdin.readline().split()))
Ap = [0 for _ in range(n)]
r = len(list(filter(lambda e: e >= k, A)))
for i in range(1,n):
App,Ap = Ap, A
A = [0 for _ in range(n)]
for j in range(i,n):
A[i] = Ap[i-1] ^ Ap[i] ^ App[i-1]
r += len(list(filter(lambda e: e >= k, A)))
print(r)
``` | instruction | 0 | 64,464 | 12 | 128,928 |
No | output | 1 | 64,464 | 12 | 128,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day, ZS the Coder wrote down an array of integers a with elements a1, a2, ..., an.
A subarray of the array a is a sequence al, al + 1, ..., ar for some integers (l, r) such that 1 ≤ l ≤ r ≤ n. ZS the Coder thinks that a subarray of a is beautiful if the bitwise xor of all the elements in the subarray is at least k.
Help ZS the Coder find the number of beautiful subarrays of a!
Input
The first line contains two integers n and k (1 ≤ n ≤ 106, 1 ≤ k ≤ 109) — the number of elements in the array a and the value of the parameter k.
The second line contains n integers ai (0 ≤ ai ≤ 109) — the elements of the array a.
Output
Print the only integer c — the number of beautiful subarrays of the array a.
Examples
Input
3 1
1 2 3
Output
5
Input
3 2
1 2 3
Output
3
Input
3 3
1 2 3
Output
2
Submitted Solution:
```
def sort(a,p,r):
if(p==r):
return [a[p]]
elif(r>p):
q,a=partition(a,p,r)
return sort(a,p,q-1)+[a[q]]+sort(a,q+1,r)
def partition(a,p,r):
c=a[r]
j=p-1
for i in range(p,r):
if(a[i]<=c):
j=j+1
a[j],a[i]=a[i],a[j]
a[j+1],a[r]=a[r],a[j+1]
return j+1,a
def find(k,e,f,g,h):
l=[]
r=[]
for i in range(len(e)):
r.append(e[i])
for i in range(len(g)):
r.append(r[len(e)-1] ^ g[i])
for i in range(len(h)):
l.append(h[i])
x=h[0]
for i in range(len(f)):
l.insert(0,x ^ f[len(f)-i-1])
rt=0
#print(l[len(e):len(l)])
for i in range(len(e),len(r)):
if(r[i]>=k):
rt=rt+1
#print(r[0:len(f)])
lt=0
for i in range(1,len(f)):
if(l[i]>=k):
lt=lt+1
s=0
for i in range(len(g)):
for j in range(len(f)):
if(g[i]^f[j]>=k):
s=s+1
return s,r,l
"""
a=sort(sl,0,len(sl)-1)
b=sort(su,0,len(su)-1)
i=j=0
s=None
while(i<len(a) and j<len(b)):
if(a[i]+b[j]>=k):
s=[i,j]
break
if(i==len(a)-1):
i=i+1
elif(j==len(b)-1):
j=j+1
elif(a[i]<=b[j]):
i=i+1
else:
j=j+1
if(s==None):
return 0
else:
return (len(a)-s[0])*(len(b)-s[1])
"""
def subarray(a,p,r,k):
if(p==r):
if(a[p]>=k):
return 1,[a[p]],[a[p]]
else:
return 0,[a[p]],[a[p]]
q=int((p+r)/2)
l,e,f=subarray(a,p,q,k)
m,g,h=subarray(a,q+1,r,k)
x,j,t=find(k,e,f,g,h)
return l+m+x,j,t
#print(0 ^ 0)
#u=[1,2,3,4]
#print(u[1:3])
x=input().split()
y=input().split()
x=[int(n) for n in x]
y=[int(n) for n in y]
#print(find([1,2],0,1,1,[1],[1],[2],[2]))
print(subarray(y,0,len(y)-1,x[1]))
#print(1 ^ 2 ^ 3)
``` | instruction | 0 | 64,465 | 12 | 128,930 |
No | output | 1 | 64,465 | 12 | 128,931 |
Provide a correct Python 3 solution for this coding contest problem.
You are given integers N, K, and an integer sequence A of length M.
An integer sequence where each element is between 1 and K (inclusive) is said to be colorful when there exists a contiguous subsequence of length K of the sequence that contains one occurrence of each integer between 1 and K (inclusive).
For every colorful integer sequence of length N, count the number of the contiguous subsequences of that sequence which coincide with A, then find the sum of all the counts. Here, the answer can be extremely large, so find the sum modulo 10^9+7.
Constraints
* 1 \leq N \leq 25000
* 1 \leq K \leq 400
* 1 \leq M \leq N
* 1 \leq A_i \leq K
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K M
A_1 A_2 ... A_M
Output
For every colorful integer sequence of length N, count the number of the contiguous subsequences of that sequence which coincide with A, then print the sum of all the counts modulo 10^9+7.
Examples
Input
3 2 1
1
Output
9
Input
4 2 2
1 2
Output
12
Input
7 4 5
1 2 3 1 2
Output
17
Input
5 4 3
1 1 1
Output
0
Input
10 3 5
1 1 2 3 3
Output
1458
Input
25000 400 4
3 7 31 127
Output
923966268
Input
9954 310 12
267 193 278 294 6 63 86 166 157 193 168 43
Output
979180369 | instruction | 0 | 64,655 | 12 | 129,310 |
"Correct Solution:
```
MOD = 10 ** 9 + 7
n, k, m = map(int, input().split())
a = list(map(int, input().split()))
def include_perm(a):
for i in range(m - k + 1):
seen = [False] * (k + 1)
for j in range(i, i + k):
if seen[a[j]]:
break
seen[a[j]] = True
else:
return True
return False
def unique_len(a):
seen = [False] * (k+1)
ans = 0
for ai in a:
if seen[ai]:
break
seen[ai] = True
ans += 1
return ans
if unique_len(a) < m:
dp_fw = [[0] * k for _ in range(n-m+1)]
dp_bw = [[0] * k for _ in range(n-m+1)]
if not include_perm(a):
dp_fw[0][unique_len(reversed(a))] = 1
dp_bw[0][unique_len(a)] = 1
for i in range(n-m):
for j in range(k):
dp_fw[i+1][j] = dp_fw[i][j]
dp_bw[i+1][j] = dp_bw[i][j]
for j in range(k-2, 0, -1):
dp_fw[i+1][j] += dp_fw[i+1][j+1]
dp_fw[i+1][j] %= MOD
dp_bw[i+1][j] += dp_bw[i+1][j+1]
dp_bw[i+1][j] %= MOD
for j in range(k-1):
dp_fw[i+1][j+1] += dp_fw[i][j] * (k-j)
dp_fw[i+1][j] %= MOD
dp_bw[i+1][j+1] += dp_bw[i][j] * (k-j)
dp_bw[i+1][j] %= MOD
ans = 0
tot = pow(k, n-m, MOD)
for i in range(n-m+1):
lcnt = i
rcnt = n - m - i
t = tot - sum(dp_fw[rcnt]) * sum(dp_bw[lcnt])
ans = (ans + t) % MOD
print(ans)
else:
dp = [[0] * k for _ in range(n+1)]
dp2 = [[0] * k for _ in range(n+1)]
dp[0][0] = 1
for i in range(n):
for j in range(1, k):
dp[i+1][j] = dp[i][j]
dp2[i+1][j] = dp2[i][j]
for j in range(k-2, 0, -1):
dp[i+1][j] += dp[i+1][j+1]
dp[i+1][j] %= MOD
dp2[i+1][j] += dp2[i+1][j+1]
dp2[i+1][j] %= MOD
for j in range(k-1):
dp[i+1][j+1] += dp[i][j] * (k-j)
dp[i+1][j+1] %= MOD
dp2[i+1][j+1] += dp2[i][j] * (k-j)
dp2[i+1][j+1] %= MOD
for j in range(m, k):
dp2[i+1][j] += dp[i+1][j]
dp2[i+1][j] %= MOD
f = 1
for i in range(m):
f = f * (k - i) % MOD
t = sum(dp2[n]) * pow(f, MOD-2, MOD) % MOD
ans = ((n-m+1) * pow(k, n-m, MOD) - t) % MOD
print(ans)
``` | output | 1 | 64,655 | 12 | 129,311 |
Provide a correct Python 3 solution for this coding contest problem.
When you enter 8 numbers from 0 to 9, write a program that outputs the difference between the largest integer and the smallest integer that can sort the 8 numbers. The number that can be sorted may start from 0, such as 00135569.
Input
Given multiple datasets. The number of datasets n (n ≤ 50) is given on the first line. Then n rows of data are given. Each data is a sequence of 8 numbers (0 to 9 numbers).
Output
For each dataset, output the difference between the largest and smallest integers that can be rearranged in the entered numbers on one line.
Example
Input
2
65539010
65539010
Output
96417531
96417531 | instruction | 0 | 64,722 | 12 | 129,444 |
"Correct Solution:
```
n=int(input())
for _ in range(n):
c=[i for i in input()]
Max=int("".join(sorted(c,reverse=True)))
Min=int("".join(sorted(c)))
print(Max-Min)
``` | output | 1 | 64,722 | 12 | 129,445 |
Provide a correct Python 3 solution for this coding contest problem.
When you enter 8 numbers from 0 to 9, write a program that outputs the difference between the largest integer and the smallest integer that can sort the 8 numbers. The number that can be sorted may start from 0, such as 00135569.
Input
Given multiple datasets. The number of datasets n (n ≤ 50) is given on the first line. Then n rows of data are given. Each data is a sequence of 8 numbers (0 to 9 numbers).
Output
For each dataset, output the difference between the largest and smallest integers that can be rearranged in the entered numbers on one line.
Example
Input
2
65539010
65539010
Output
96417531
96417531 | instruction | 0 | 64,723 | 12 | 129,446 |
"Correct Solution:
```
n = int(input())
for i in range(n):
s = input()
minv = ''.join(sorted(s))
maxv = ''.join(sorted(s, reverse=1))
print(int(maxv) - int(minv))
``` | output | 1 | 64,723 | 12 | 129,447 |
Provide a correct Python 3 solution for this coding contest problem.
When you enter 8 numbers from 0 to 9, write a program that outputs the difference between the largest integer and the smallest integer that can sort the 8 numbers. The number that can be sorted may start from 0, such as 00135569.
Input
Given multiple datasets. The number of datasets n (n ≤ 50) is given on the first line. Then n rows of data are given. Each data is a sequence of 8 numbers (0 to 9 numbers).
Output
For each dataset, output the difference between the largest and smallest integers that can be rearranged in the entered numbers on one line.
Example
Input
2
65539010
65539010
Output
96417531
96417531 | instruction | 0 | 64,724 | 12 | 129,448 |
"Correct Solution:
```
n = int(input())
for _ in range(n):
s = list(input())
print(int("".join(sorted(s,reverse=True))) - int("".join(sorted(s))))
``` | output | 1 | 64,724 | 12 | 129,449 |
Provide a correct Python 3 solution for this coding contest problem.
When you enter 8 numbers from 0 to 9, write a program that outputs the difference between the largest integer and the smallest integer that can sort the 8 numbers. The number that can be sorted may start from 0, such as 00135569.
Input
Given multiple datasets. The number of datasets n (n ≤ 50) is given on the first line. Then n rows of data are given. Each data is a sequence of 8 numbers (0 to 9 numbers).
Output
For each dataset, output the difference between the largest and smallest integers that can be rearranged in the entered numbers on one line.
Example
Input
2
65539010
65539010
Output
96417531
96417531 | instruction | 0 | 64,725 | 12 | 129,450 |
"Correct Solution:
```
def join_num(arr):
result = 0
for i in range(len(arr)):
result += arr[i] * 10**(7-i)
return result
n = int(input())
x = [0] * n
for i in range(n):
x[i] = str(input())
for i in range(n):
d = []
for c in x[i]:
d.append(int(c))
d.sort()
a = join_num(d)
d.reverse()
b = join_num(d)
print(b-a)
``` | output | 1 | 64,725 | 12 | 129,451 |
Provide a correct Python 3 solution for this coding contest problem.
When you enter 8 numbers from 0 to 9, write a program that outputs the difference between the largest integer and the smallest integer that can sort the 8 numbers. The number that can be sorted may start from 0, such as 00135569.
Input
Given multiple datasets. The number of datasets n (n ≤ 50) is given on the first line. Then n rows of data are given. Each data is a sequence of 8 numbers (0 to 9 numbers).
Output
For each dataset, output the difference between the largest and smallest integers that can be rearranged in the entered numbers on one line.
Example
Input
2
65539010
65539010
Output
96417531
96417531 | instruction | 0 | 64,726 | 12 | 129,452 |
"Correct Solution:
```
n=int(input())
for i in range(n):
A=[]
string=input()
for j in string:
A.append(j)
A.sort(reverse=True)
Max="".join(A)
A.sort()
Min="".join(A)
Min=int(Min)
Max=int(Max)
print(Max-Min)
``` | output | 1 | 64,726 | 12 | 129,453 |
Provide a correct Python 3 solution for this coding contest problem.
When you enter 8 numbers from 0 to 9, write a program that outputs the difference between the largest integer and the smallest integer that can sort the 8 numbers. The number that can be sorted may start from 0, such as 00135569.
Input
Given multiple datasets. The number of datasets n (n ≤ 50) is given on the first line. Then n rows of data are given. Each data is a sequence of 8 numbers (0 to 9 numbers).
Output
For each dataset, output the difference between the largest and smallest integers that can be rearranged in the entered numbers on one line.
Example
Input
2
65539010
65539010
Output
96417531
96417531 | instruction | 0 | 64,727 | 12 | 129,454 |
"Correct Solution:
```
m=int(input())
while m:
n,m=''.join(sorted(input())),m-1
print(int(n[::-1]) - int(n))
``` | output | 1 | 64,727 | 12 | 129,455 |
Provide a correct Python 3 solution for this coding contest problem.
When you enter 8 numbers from 0 to 9, write a program that outputs the difference between the largest integer and the smallest integer that can sort the 8 numbers. The number that can be sorted may start from 0, such as 00135569.
Input
Given multiple datasets. The number of datasets n (n ≤ 50) is given on the first line. Then n rows of data are given. Each data is a sequence of 8 numbers (0 to 9 numbers).
Output
For each dataset, output the difference between the largest and smallest integers that can be rearranged in the entered numbers on one line.
Example
Input
2
65539010
65539010
Output
96417531
96417531 | instruction | 0 | 64,728 | 12 | 129,456 |
"Correct Solution:
```
diff=lambda l:int("".join(map(str,sorted(l,reverse=True))))-int("".join(map(str,sorted(l))))
[print(diff(input())) for i in range(int(input()))]
``` | output | 1 | 64,728 | 12 | 129,457 |
Provide a correct Python 3 solution for this coding contest problem.
When you enter 8 numbers from 0 to 9, write a program that outputs the difference between the largest integer and the smallest integer that can sort the 8 numbers. The number that can be sorted may start from 0, such as 00135569.
Input
Given multiple datasets. The number of datasets n (n ≤ 50) is given on the first line. Then n rows of data are given. Each data is a sequence of 8 numbers (0 to 9 numbers).
Output
For each dataset, output the difference between the largest and smallest integers that can be rearranged in the entered numbers on one line.
Example
Input
2
65539010
65539010
Output
96417531
96417531 | instruction | 0 | 64,729 | 12 | 129,458 |
"Correct Solution:
```
for i in range(int(input())):
num = list(input())
num.sort()
min = int(''.join(num))
num.reverse()
max = int(''.join(num))
print(max-min)
``` | output | 1 | 64,729 | 12 | 129,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When you enter 8 numbers from 0 to 9, write a program that outputs the difference between the largest integer and the smallest integer that can sort the 8 numbers. The number that can be sorted may start from 0, such as 00135569.
Input
Given multiple datasets. The number of datasets n (n ≤ 50) is given on the first line. Then n rows of data are given. Each data is a sequence of 8 numbers (0 to 9 numbers).
Output
For each dataset, output the difference between the largest and smallest integers that can be rearranged in the entered numbers on one line.
Example
Input
2
65539010
65539010
Output
96417531
96417531
Submitted Solution:
```
def toValue(arr):
s = 0
l = len(arr) - 1
i = 0
while l >= 0:
s += int(arr[i]) * pow(10,l)
i += 1
l -= 1
return s
n = int(input())
for i in range(0,n):
s = input()
max = []
for j in s:
max.append(j)
max = sorted(max,reverse=True)
min = sorted(max)
print(toValue(max) - toValue(min))
``` | instruction | 0 | 64,730 | 12 | 129,460 |
Yes | output | 1 | 64,730 | 12 | 129,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When you enter 8 numbers from 0 to 9, write a program that outputs the difference between the largest integer and the smallest integer that can sort the 8 numbers. The number that can be sorted may start from 0, such as 00135569.
Input
Given multiple datasets. The number of datasets n (n ≤ 50) is given on the first line. Then n rows of data are given. Each data is a sequence of 8 numbers (0 to 9 numbers).
Output
For each dataset, output the difference between the largest and smallest integers that can be rearranged in the entered numbers on one line.
Example
Input
2
65539010
65539010
Output
96417531
96417531
Submitted Solution:
```
n = int(input())
for _ in range(n):
data = list(input())
data.sort(reverse=True)
max = int(''.join(d for d in data))
data.sort()
min = int(''.join(d for d in data))
print(max - min)
``` | instruction | 0 | 64,732 | 12 | 129,464 |
Yes | output | 1 | 64,732 | 12 | 129,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When you enter 8 numbers from 0 to 9, write a program that outputs the difference between the largest integer and the smallest integer that can sort the 8 numbers. The number that can be sorted may start from 0, such as 00135569.
Input
Given multiple datasets. The number of datasets n (n ≤ 50) is given on the first line. Then n rows of data are given. Each data is a sequence of 8 numbers (0 to 9 numbers).
Output
For each dataset, output the difference between the largest and smallest integers that can be rearranged in the entered numbers on one line.
Example
Input
2
65539010
65539010
Output
96417531
96417531
Submitted Solution:
```
n=int(input())
for i in range(n):
nmax=[]
nmin=[]
for ii in str(input()):
nmax.append(ii)
nmin.append(ii)
nmax.sort(reverse=True)
nmin.sort()
ans=int("".join(nmax))-int("".join(nmin))
print(ans)
``` | instruction | 0 | 64,733 | 12 | 129,466 |
Yes | output | 1 | 64,733 | 12 | 129,467 |
Provide a correct Python 3 solution for this coding contest problem.
Counting sort can be used for sorting elements in an array which each of the n input elements is an integer in the range 0 to k. The idea of counting sort is to determine, for each input element x, the number of elements less than x as C[x]. This information can be used to place element x directly into its position in the output array B. This scheme must be modified to handle the situation in which several elements have the same value. Please see the following pseudocode for the detail:
Counting-Sort(A, B, k)
1 for i = 0 to k
2 do C[i] = 0
3 for j = 1 to length[A]
4 do C[A[j]] = C[A[j]]+1
5 /* C[i] now contains the number of elements equal to i */
6 for i = 1 to k
7 do C[i] = C[i] + C[i-1]
8 /* C[i] now contains the number of elements less than or equal to i */
9 for j = length[A] downto 1
10 do B[C[A[j]]] = A[j]
11 C[A[j]] = C[A[j]]-1
Write a program which sorts elements of given array ascending order based on the counting sort.
Constraints
* 1 ≤ n ≤ 2,000,000
* 0 ≤ A[i] ≤ 10,000
Input
The first line of the input includes an integer n, the number of elements in the sequence.
In the second line, n elements of the sequence are given separated by spaces characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character.
Example
Input
7
2 5 1 3 2 3 0
Output
0 1 2 2 3 3 5 | instruction | 0 | 64,793 | 12 | 129,586 |
"Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
k = max(a) + 1
b = [0 for i in range(n)]
c = [0 for i in range(k)]
for j in range(n):
c[a[j]] += 1
for i in range(1, k):
c[i] += c[i-1]
for j in range(n-1, -1, -1):
b[c[a[j]] - 1] = a[j]
c[a[j]] -= 1
print(*b)
``` | output | 1 | 64,793 | 12 | 129,587 |
Provide a correct Python 3 solution for this coding contest problem.
Counting sort can be used for sorting elements in an array which each of the n input elements is an integer in the range 0 to k. The idea of counting sort is to determine, for each input element x, the number of elements less than x as C[x]. This information can be used to place element x directly into its position in the output array B. This scheme must be modified to handle the situation in which several elements have the same value. Please see the following pseudocode for the detail:
Counting-Sort(A, B, k)
1 for i = 0 to k
2 do C[i] = 0
3 for j = 1 to length[A]
4 do C[A[j]] = C[A[j]]+1
5 /* C[i] now contains the number of elements equal to i */
6 for i = 1 to k
7 do C[i] = C[i] + C[i-1]
8 /* C[i] now contains the number of elements less than or equal to i */
9 for j = length[A] downto 1
10 do B[C[A[j]]] = A[j]
11 C[A[j]] = C[A[j]]-1
Write a program which sorts elements of given array ascending order based on the counting sort.
Constraints
* 1 ≤ n ≤ 2,000,000
* 0 ≤ A[i] ≤ 10,000
Input
The first line of the input includes an integer n, the number of elements in the sequence.
In the second line, n elements of the sequence are given separated by spaces characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character.
Example
Input
7
2 5 1 3 2 3 0
Output
0 1 2 2 3 3 5 | instruction | 0 | 64,794 | 12 | 129,588 |
"Correct Solution:
```
if __name__ == '__main__':
n = int(input())
A = list(map(int, input().split()))
B = [0] * n
C = [0] * 10001
for i in A:
C[i] += 1
for i in range(1, len(C)):
C[i] += C[i - 1]
for i in A:
B[C[i] - 1] = i
C[i] -= 1
print(' '.join(map(str, B)))
``` | output | 1 | 64,794 | 12 | 129,589 |
Provide a correct Python 3 solution for this coding contest problem.
Counting sort can be used for sorting elements in an array which each of the n input elements is an integer in the range 0 to k. The idea of counting sort is to determine, for each input element x, the number of elements less than x as C[x]. This information can be used to place element x directly into its position in the output array B. This scheme must be modified to handle the situation in which several elements have the same value. Please see the following pseudocode for the detail:
Counting-Sort(A, B, k)
1 for i = 0 to k
2 do C[i] = 0
3 for j = 1 to length[A]
4 do C[A[j]] = C[A[j]]+1
5 /* C[i] now contains the number of elements equal to i */
6 for i = 1 to k
7 do C[i] = C[i] + C[i-1]
8 /* C[i] now contains the number of elements less than or equal to i */
9 for j = length[A] downto 1
10 do B[C[A[j]]] = A[j]
11 C[A[j]] = C[A[j]]-1
Write a program which sorts elements of given array ascending order based on the counting sort.
Constraints
* 1 ≤ n ≤ 2,000,000
* 0 ≤ A[i] ≤ 10,000
Input
The first line of the input includes an integer n, the number of elements in the sequence.
In the second line, n elements of the sequence are given separated by spaces characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character.
Example
Input
7
2 5 1 3 2 3 0
Output
0 1 2 2 3 3 5 | instruction | 0 | 64,795 | 12 | 129,590 |
"Correct Solution:
```
def countingsort(a, n):
c = [0]*10001
for i in range(n):
c[a[i]] += 1
for j in range(1, 10001):
c[j] += c[j - 1]
b = [0]*(n+1)
for k in range(n, 0, -1):
b[c[a[k-1]]] = a[k-1]
c[a[k-1]] -= 1
return b[1:]
n = int(input())
a = list(map(int, input().split()))
print(*countingsort(a, n))
``` | output | 1 | 64,795 | 12 | 129,591 |
Provide a correct Python 3 solution for this coding contest problem.
Counting sort can be used for sorting elements in an array which each of the n input elements is an integer in the range 0 to k. The idea of counting sort is to determine, for each input element x, the number of elements less than x as C[x]. This information can be used to place element x directly into its position in the output array B. This scheme must be modified to handle the situation in which several elements have the same value. Please see the following pseudocode for the detail:
Counting-Sort(A, B, k)
1 for i = 0 to k
2 do C[i] = 0
3 for j = 1 to length[A]
4 do C[A[j]] = C[A[j]]+1
5 /* C[i] now contains the number of elements equal to i */
6 for i = 1 to k
7 do C[i] = C[i] + C[i-1]
8 /* C[i] now contains the number of elements less than or equal to i */
9 for j = length[A] downto 1
10 do B[C[A[j]]] = A[j]
11 C[A[j]] = C[A[j]]-1
Write a program which sorts elements of given array ascending order based on the counting sort.
Constraints
* 1 ≤ n ≤ 2,000,000
* 0 ≤ A[i] ≤ 10,000
Input
The first line of the input includes an integer n, the number of elements in the sequence.
In the second line, n elements of the sequence are given separated by spaces characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character.
Example
Input
7
2 5 1 3 2 3 0
Output
0 1 2 2 3 3 5 | instruction | 0 | 64,796 | 12 | 129,592 |
"Correct Solution:
```
def counting_sort(A, B, k):
C=[0 for i in range(k)]
for j in range(n):
C[A[j]] += 1
for i in range(1,k):
C[i] = C[i] + C[i-1]
for j in range(n-1,-1, -1):
B[C[A[j]]-1] = A[j]
C[A[j]] -= 1
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
B=[-1 for i in range(n)]
counting_sort(A,B,max(A)+1)
print(*B)
``` | output | 1 | 64,796 | 12 | 129,593 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.