message stringlengths 2 48.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 318 108k | cluster float64 8 8 | __index_level_0__ int64 636 217k |
|---|---|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
There are N squares arranged in a row from left to right. The height of the i-th square from the left is H_i.
For each square, you will perform either of the following operations once:
* Decrease the height of the square by 1.
* Do nothing.
Determine if it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq H_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
H_1 H_2 ... H_N
Output
If it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right, print `Yes`; otherwise, print `No`.
Examples
Input
5
1 2 1 1 3
Output
Yes
Input
4
1 3 2 1
Output
No
Input
5
1 2 3 4 5
Output
Yes
Input
1
1000000000
Output
Yes | instruction | 0 | 78,913 | 8 | 157,826 |
"Correct Solution:
```
n=int(input())
h=list(map(int,input().split()))
c=1
max_h=0
for i in h:
if max_h>=i+2:
c=0
max_h=max(max_h,i)
print('Yes' if c==1 else 'No')
``` | output | 1 | 78,913 | 8 | 157,827 |
Provide a correct Python 3 solution for this coding contest problem.
There are N squares arranged in a row from left to right. The height of the i-th square from the left is H_i.
For each square, you will perform either of the following operations once:
* Decrease the height of the square by 1.
* Do nothing.
Determine if it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq H_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
H_1 H_2 ... H_N
Output
If it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right, print `Yes`; otherwise, print `No`.
Examples
Input
5
1 2 1 1 3
Output
Yes
Input
4
1 3 2 1
Output
No
Input
5
1 2 3 4 5
Output
Yes
Input
1
1000000000
Output
Yes | instruction | 0 | 78,914 | 8 | 157,828 |
"Correct Solution:
```
N = int(input())
H = list(map(int,input().split()))
for i in range(N-1,0,-1):
if H[i] < H[i-1] :
H[i-1] -= 1
if sorted(H) != H:
print('No')
else:
print('Yes')
``` | output | 1 | 78,914 | 8 | 157,829 |
Provide a correct Python 3 solution for this coding contest problem.
There are N squares arranged in a row from left to right. The height of the i-th square from the left is H_i.
For each square, you will perform either of the following operations once:
* Decrease the height of the square by 1.
* Do nothing.
Determine if it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq H_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
H_1 H_2 ... H_N
Output
If it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right, print `Yes`; otherwise, print `No`.
Examples
Input
5
1 2 1 1 3
Output
Yes
Input
4
1 3 2 1
Output
No
Input
5
1 2 3 4 5
Output
Yes
Input
1
1000000000
Output
Yes | instruction | 0 | 78,915 | 8 | 157,830 |
"Correct Solution:
```
n=int(input())
a=list(map(int, input().split()))
ans='Yes'
now=a[0]-1
for i in a:
if now>i:
ans='No'
now=max(now, i-1)
print(ans)
``` | output | 1 | 78,915 | 8 | 157,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row from left to right. The height of the i-th square from the left is H_i.
For each square, you will perform either of the following operations once:
* Decrease the height of the square by 1.
* Do nothing.
Determine if it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq H_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
H_1 H_2 ... H_N
Output
If it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right, print `Yes`; otherwise, print `No`.
Examples
Input
5
1 2 1 1 3
Output
Yes
Input
4
1 3 2 1
Output
No
Input
5
1 2 3 4 5
Output
Yes
Input
1
1000000000
Output
Yes
Submitted Solution:
```
n=int(input())
h=list(map(int,input().split()))
f=h[0]
for i in range(1,n):
if f > h[i]:
print('No')
exit()
f=max(h[i]-1,f)
print('Yes')
``` | instruction | 0 | 78,916 | 8 | 157,832 |
Yes | output | 1 | 78,916 | 8 | 157,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row from left to right. The height of the i-th square from the left is H_i.
For each square, you will perform either of the following operations once:
* Decrease the height of the square by 1.
* Do nothing.
Determine if it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq H_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
H_1 H_2 ... H_N
Output
If it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right, print `Yes`; otherwise, print `No`.
Examples
Input
5
1 2 1 1 3
Output
Yes
Input
4
1 3 2 1
Output
No
Input
5
1 2 3 4 5
Output
Yes
Input
1
1000000000
Output
Yes
Submitted Solution:
```
N = int(input())
A = list(map(int,input().split()))
for i in range(1, N):
if A[i] > A[i-1]:
A[i] -= 1
if A[i] - A[i-1] < 0:
print("No")
exit()
print("Yes")
``` | instruction | 0 | 78,917 | 8 | 157,834 |
Yes | output | 1 | 78,917 | 8 | 157,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row from left to right. The height of the i-th square from the left is H_i.
For each square, you will perform either of the following operations once:
* Decrease the height of the square by 1.
* Do nothing.
Determine if it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq H_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
H_1 H_2 ... H_N
Output
If it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right, print `Yes`; otherwise, print `No`.
Examples
Input
5
1 2 1 1 3
Output
Yes
Input
4
1 3 2 1
Output
No
Input
5
1 2 3 4 5
Output
Yes
Input
1
1000000000
Output
Yes
Submitted Solution:
```
n=int(input())
h=list(map(int,input().split()))
for i in range(n-1):
if h[i+1] > h[i]:
h[i+1] -= 1
elif h[i+1] < h[i]:
print('No')
exit(0)
print('Yes')
``` | instruction | 0 | 78,918 | 8 | 157,836 |
Yes | output | 1 | 78,918 | 8 | 157,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row from left to right. The height of the i-th square from the left is H_i.
For each square, you will perform either of the following operations once:
* Decrease the height of the square by 1.
* Do nothing.
Determine if it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq H_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
H_1 H_2 ... H_N
Output
If it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right, print `Yes`; otherwise, print `No`.
Examples
Input
5
1 2 1 1 3
Output
Yes
Input
4
1 3 2 1
Output
No
Input
5
1 2 3 4 5
Output
Yes
Input
1
1000000000
Output
Yes
Submitted Solution:
```
n = int(input())
h = [int(i) for i in input().split()]
f = True
m = 0
for i in range(n):
m = max(m, h[i])
if m - 1 > h[i]:
f = False
print('Yes' if f else 'No')
``` | instruction | 0 | 78,919 | 8 | 157,838 |
Yes | output | 1 | 78,919 | 8 | 157,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row from left to right. The height of the i-th square from the left is H_i.
For each square, you will perform either of the following operations once:
* Decrease the height of the square by 1.
* Do nothing.
Determine if it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq H_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
H_1 H_2 ... H_N
Output
If it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right, print `Yes`; otherwise, print `No`.
Examples
Input
5
1 2 1 1 3
Output
Yes
Input
4
1 3 2 1
Output
No
Input
5
1 2 3 4 5
Output
Yes
Input
1
1000000000
Output
Yes
Submitted Solution:
```
import sys
N = int(input())
H = list(map(int,input().split()))
for i in range(N-1):
if not (H[i+1]-H[i]==0 or H[i+1]-H[i]==1):
print('No')
sys.exit()
print('Yes')
``` | instruction | 0 | 78,920 | 8 | 157,840 |
No | output | 1 | 78,920 | 8 | 157,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row from left to right. The height of the i-th square from the left is H_i.
For each square, you will perform either of the following operations once:
* Decrease the height of the square by 1.
* Do nothing.
Determine if it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq H_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
H_1 H_2 ... H_N
Output
If it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right, print `Yes`; otherwise, print `No`.
Examples
Input
5
1 2 1 1 3
Output
Yes
Input
4
1 3 2 1
Output
No
Input
5
1 2 3 4 5
Output
Yes
Input
1
1000000000
Output
Yes
Submitted Solution:
```
N = int(input())
H = list(map(int,input().split()))
lists = [0]
cnt = 0
for i in range(1,N):
lists.append(H[i] - H[i-1])
for i in range(len(lists)-1):
if lists[i] < 0:
if lists[i+1] < 0:
print("No")
exit()
print("Yes")
``` | instruction | 0 | 78,921 | 8 | 157,842 |
No | output | 1 | 78,921 | 8 | 157,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row from left to right. The height of the i-th square from the left is H_i.
For each square, you will perform either of the following operations once:
* Decrease the height of the square by 1.
* Do nothing.
Determine if it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq H_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
H_1 H_2 ... H_N
Output
If it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right, print `Yes`; otherwise, print `No`.
Examples
Input
5
1 2 1 1 3
Output
Yes
Input
4
1 3 2 1
Output
No
Input
5
1 2 3 4 5
Output
Yes
Input
1
1000000000
Output
Yes
Submitted Solution:
```
import numpy as np
n = int(input())
h = np.array([int(i) for i in input().split()])
if n == 1:
print('Yes')
elif n == 2:
if h[0] <= h[1]:
print('Yes')
elif h[0] - h[1] == 1:
print('Yes')
else:
print('No')
else:
df = np.diff(h)
df_idx = np.where(df == -1)
if np.any(df < -1):
print('No')
elif np.any(np.diff(df_idx) == 1):
print('No')
else:
print('Yes')
``` | instruction | 0 | 78,922 | 8 | 157,844 |
No | output | 1 | 78,922 | 8 | 157,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row from left to right. The height of the i-th square from the left is H_i.
For each square, you will perform either of the following operations once:
* Decrease the height of the square by 1.
* Do nothing.
Determine if it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq H_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
H_1 H_2 ... H_N
Output
If it is possible to perform the operations so that the heights of the squares are non-decreasing from left to right, print `Yes`; otherwise, print `No`.
Examples
Input
5
1 2 1 1 3
Output
Yes
Input
4
1 3 2 1
Output
No
Input
5
1 2 3 4 5
Output
Yes
Input
1
1000000000
Output
Yes
Submitted Solution:
```
n = int(input())
H = list(map(int, input().split()))
f = 0
if n == 1:
f = 0
elif n == 2:
if abs(H[0] - H[1]) <= 1:
f = 0
else:
f = 1
else:
H[0] -= 1
for i in range(n-2):
if H[i+2] - H[i+1] < 0:
H[i+1] -= 1
if H[i] > H[i+1] or H[i+2] - H[i+1] < 0:
f = 1
break
if f == 0:
print("Yes")
else:
print("No")
``` | instruction | 0 | 78,923 | 8 | 157,846 |
No | output | 1 | 78,923 | 8 | 157,847 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor has fallen in love with Tanya. Now Igor wants to show his feelings and write a number on the fence opposite to Tanya's house. Igor thinks that the larger the number is, the more chance to win Tanya's heart he has.
Unfortunately, Igor could only get v liters of paint. He did the math and concluded that digit d requires ad liters of paint. Besides, Igor heard that Tanya doesn't like zeroes. That's why Igor won't use them in his number.
Help Igor find the maximum number he can write on the fence.
Input
The first line contains a positive integer v (0 ≤ v ≤ 106). The second line contains nine positive integers a1, a2, ..., a9 (1 ≤ ai ≤ 105).
Output
Print the maximum number Igor can write on the fence. If he has too little paint for any digit (so, he cannot write anything), print -1.
Examples
Input
5
5 4 3 2 1 2 3 4 5
Output
55555
Input
2
9 11 1 12 5 8 9 10 6
Output
33
Input
0
1 1 1 1 1 1 1 1 1
Output
-1
Submitted Solution:
```
import sys
input = sys.stdin.buffer.readline
def I(): return(list(map(int,input().split())))
def sieve(n):
a=[1]*n
for i in range(2,n):
if a[i]:
for j in range(i*i,n,i):
a[j]=0
return a
# for __ in range(int(input())):
v=int(input())
a = I()
# idxs = list(range(9))
# idxs.sort(key =lambda x: a[x])
mina= min(a)
l = v//mina
if l==0:
print(-1)
else:
for i in reversed(range(9)):
if a[i]==mina:
break
left = v - l*mina
m = i+1
currans = [i+1]*l
# print(currans,left,sum(a))
for i in range(l):
for j in reversed(range(m+1,10)):
if left>= a[j-1]-mina:
left-=(a[j-1]-mina)
currans[i]=j
break
print("".join([str(i) for i in currans]))
``` | instruction | 0 | 79,458 | 8 | 158,916 |
Yes | output | 1 | 79,458 | 8 | 158,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor has fallen in love with Tanya. Now Igor wants to show his feelings and write a number on the fence opposite to Tanya's house. Igor thinks that the larger the number is, the more chance to win Tanya's heart he has.
Unfortunately, Igor could only get v liters of paint. He did the math and concluded that digit d requires ad liters of paint. Besides, Igor heard that Tanya doesn't like zeroes. That's why Igor won't use them in his number.
Help Igor find the maximum number he can write on the fence.
Input
The first line contains a positive integer v (0 ≤ v ≤ 106). The second line contains nine positive integers a1, a2, ..., a9 (1 ≤ ai ≤ 105).
Output
Print the maximum number Igor can write on the fence. If he has too little paint for any digit (so, he cannot write anything), print -1.
Examples
Input
5
5 4 3 2 1 2 3 4 5
Output
55555
Input
2
9 11 1 12 5 8 9 10 6
Output
33
Input
0
1 1 1 1 1 1 1 1 1
Output
-1
Submitted Solution:
```
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
# import numpy as np
starttime = time.time()
# import numpy as np
mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def L(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
try:
sys.setrecursionlimit(int(pow(10,6)))
sys.stdin = open("input.txt", "r")
# sys.stdout = open("../output.txt", "w")
except:
pass
n=int(input())
a=list(map(int,input().split()))
m=a[0]
d=1
for i in range(9):
if a[i]<=m:
m=a[i]
d=i+1
if m>n:
print(-1)
exit()
ans=list(str(d)*(n//m))
rem=n-m*(n//m)
for i in range(len(ans)):
if rem<=0:
break
for j in range(8,d-1,-1):
if a[j]-a[d-1]<=rem:
ans[i]=str(j+1)
rem-=a[j]-a[d-1]
break
print(''.join(ans))
endtime = time.time()
# print(f"Runtime of the program is {endtime - starttime}")
``` | instruction | 0 | 79,459 | 8 | 158,918 |
Yes | output | 1 | 79,459 | 8 | 158,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor has fallen in love with Tanya. Now Igor wants to show his feelings and write a number on the fence opposite to Tanya's house. Igor thinks that the larger the number is, the more chance to win Tanya's heart he has.
Unfortunately, Igor could only get v liters of paint. He did the math and concluded that digit d requires ad liters of paint. Besides, Igor heard that Tanya doesn't like zeroes. That's why Igor won't use them in his number.
Help Igor find the maximum number he can write on the fence.
Input
The first line contains a positive integer v (0 ≤ v ≤ 106). The second line contains nine positive integers a1, a2, ..., a9 (1 ≤ ai ≤ 105).
Output
Print the maximum number Igor can write on the fence. If he has too little paint for any digit (so, he cannot write anything), print -1.
Examples
Input
5
5 4 3 2 1 2 3 4 5
Output
55555
Input
2
9 11 1 12 5 8 9 10 6
Output
33
Input
0
1 1 1 1 1 1 1 1 1
Output
-1
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = a
min_el = min(a)
minIndex = a.index(min(a))
for i in range(minIndex + 1, 9):
if (a[i] == min_el):
minIndex = i
#a.sort()
c = int(n / min_el)
k = n - c * min_el
for i in range(9):
a[i] -= min_el
T = [0 for i in range(9)]
for i in range(9):
if (a[8 - i] == 0):
T[i] = c
break
T[i] = int(k / a[8 - i])
c -= T[i]
k -= T[i] * a[8 - i]
if (c < 1):
print(-1)
else:
for i in range(9):
for j in range(T[i]):
print(9 - i, end = '')
``` | instruction | 0 | 79,460 | 8 | 158,920 |
Yes | output | 1 | 79,460 | 8 | 158,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor has fallen in love with Tanya. Now Igor wants to show his feelings and write a number on the fence opposite to Tanya's house. Igor thinks that the larger the number is, the more chance to win Tanya's heart he has.
Unfortunately, Igor could only get v liters of paint. He did the math and concluded that digit d requires ad liters of paint. Besides, Igor heard that Tanya doesn't like zeroes. That's why Igor won't use them in his number.
Help Igor find the maximum number he can write on the fence.
Input
The first line contains a positive integer v (0 ≤ v ≤ 106). The second line contains nine positive integers a1, a2, ..., a9 (1 ≤ ai ≤ 105).
Output
Print the maximum number Igor can write on the fence. If he has too little paint for any digit (so, he cannot write anything), print -1.
Examples
Input
5
5 4 3 2 1 2 3 4 5
Output
55555
Input
2
9 11 1 12 5 8 9 10 6
Output
33
Input
0
1 1 1 1 1 1 1 1 1
Output
-1
Submitted Solution:
```
#! /usr/bin/env python3
'''
Author: krishna
Created: Sat Sep 22 07:59:59 2018 IST
USAGE:
b.py
Description:
'''
def main():
'''The Main'''
v = int(input())
w = list(map(int, input().rstrip().split()))
cost = dict(zip(range(1, 10), w))
tsoc = dict(zip(w, range(1, 10)))
minCost = min(tsoc.keys())
if minCost > v:
print(-1)
return
l = int(v/minCost)
ans = [tsoc[minCost]] * l
v -= (l * minCost)
for i in range(len(ans)):
for n in reversed(range(ans[i] + 1, 10)):
d = cost[n] - cost[ans[i]]
if v >= d:
ans[i] = n
v -= d
break
print("".join(map(str, ans)))
return
if __name__ == '__main__':
main()
``` | instruction | 0 | 79,461 | 8 | 158,922 |
Yes | output | 1 | 79,461 | 8 | 158,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor has fallen in love with Tanya. Now Igor wants to show his feelings and write a number on the fence opposite to Tanya's house. Igor thinks that the larger the number is, the more chance to win Tanya's heart he has.
Unfortunately, Igor could only get v liters of paint. He did the math and concluded that digit d requires ad liters of paint. Besides, Igor heard that Tanya doesn't like zeroes. That's why Igor won't use them in his number.
Help Igor find the maximum number he can write on the fence.
Input
The first line contains a positive integer v (0 ≤ v ≤ 106). The second line contains nine positive integers a1, a2, ..., a9 (1 ≤ ai ≤ 105).
Output
Print the maximum number Igor can write on the fence. If he has too little paint for any digit (so, he cannot write anything), print -1.
Examples
Input
5
5 4 3 2 1 2 3 4 5
Output
55555
Input
2
9 11 1 12 5 8 9 10 6
Output
33
Input
0
1 1 1 1 1 1 1 1 1
Output
-1
Submitted Solution:
```
def colour_the_fence():
n = int(input())
litre_list = list(map(int, str(input()).split()))
paint_dict = {}
diff_list = []
for i in range(1, 10):
if litre_list[i-1] > n:
continue
paint_dict[litre_list[i-1]] = i
# print(paint_dict)
min_litre = min(litre_list)
for key in paint_dict.keys():
diff_list.append(key - min_litre)
if min_litre > n:
print(-1)
else:
x = divmod(n, min_litre)
# x[0] is quotient and x[1] is remainder
remaining_litres = x[1]
largest_num = int(x[0]*str(paint_dict[min_litre]))
if remaining_litres == 0:
print(largest_num)
else:
while remaining_litres > 0:
print("Hi ", largest_num)
largest_num = int((str(largest_num))[1:])
if remaining_litres in paint_dict.keys():
largest_num = int(str(largest_num) + str(paint_dict[remaining_litres]))
else:
max_value = find_max(diff_list, remaining_litres)
remaining_litres -= max_value
largest_num = int(str(largest_num) + str(paint_dict[max_value + min_litre]))
print("Rem ", remaining_litres)
if remaining_litres < 0:
largest_num = largest_num//10
print(int(''.join(sorted(str(largest_num), reverse=True))))
def find_max(given_list, limit):
max_value = -1
for i in range(len(given_list)):
if given_list[i] <= limit:
if given_list[i] > max_value:
max_value = given_list[i]
return max_value
if __name__ == '__main__':
colour_the_fence()
``` | instruction | 0 | 79,462 | 8 | 158,924 |
No | output | 1 | 79,462 | 8 | 158,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor has fallen in love with Tanya. Now Igor wants to show his feelings and write a number on the fence opposite to Tanya's house. Igor thinks that the larger the number is, the more chance to win Tanya's heart he has.
Unfortunately, Igor could only get v liters of paint. He did the math and concluded that digit d requires ad liters of paint. Besides, Igor heard that Tanya doesn't like zeroes. That's why Igor won't use them in his number.
Help Igor find the maximum number he can write on the fence.
Input
The first line contains a positive integer v (0 ≤ v ≤ 106). The second line contains nine positive integers a1, a2, ..., a9 (1 ≤ ai ≤ 105).
Output
Print the maximum number Igor can write on the fence. If he has too little paint for any digit (so, he cannot write anything), print -1.
Examples
Input
5
5 4 3 2 1 2 3 4 5
Output
55555
Input
2
9 11 1 12 5 8 9 10 6
Output
33
Input
0
1 1 1 1 1 1 1 1 1
Output
-1
Submitted Solution:
```
def mi():
return map(int, input().split())
v = int(input())
a = list(mi())
cur = [(a.index(min(a))+1)]*(v//min(a))
l = v%min(a)
c = a.index(min(a))+1
if v%min(a):
for i in range(1, min(a)+v%min(a)+1):
if i in a and a.index(i)+1>c:
c = a.index(i)+1
if c not in cur:
cur[0] = c
if not len(cur):
print (-1)
else:
print (*cur, sep='')
``` | instruction | 0 | 79,463 | 8 | 158,926 |
No | output | 1 | 79,463 | 8 | 158,927 |
Provide a correct Python 3 solution for this coding contest problem.
There is a data which provides heights (in meter) of mountains. The data is only for ten mountains.
Write a program which prints heights of the top three mountains in descending order.
Constraints
0 ≤ height of mountain (integer) ≤ 10,000
Input
Height of mountain 1
Height of mountain 2
Height of mountain 3
.
.
Height of mountain 10
Output
Height of the 1st mountain
Height of the 2nd mountain
Height of the 3rd mountain
Examples
Input
1819
2003
876
2840
1723
1673
3776
2848
1592
922
Output
3776
2848
2840
Input
100
200
300
400
500
600
700
800
900
900
Output
900
900
800 | instruction | 0 | 79,822 | 8 | 159,644 |
"Correct Solution:
```
x = []
for i in range(10):
x.append(int(input()))
x.sort()
for i in reversed(range(7,10)):
print(x[i])
``` | output | 1 | 79,822 | 8 | 159,645 |
Provide a correct Python 3 solution for this coding contest problem.
There is a data which provides heights (in meter) of mountains. The data is only for ten mountains.
Write a program which prints heights of the top three mountains in descending order.
Constraints
0 ≤ height of mountain (integer) ≤ 10,000
Input
Height of mountain 1
Height of mountain 2
Height of mountain 3
.
.
Height of mountain 10
Output
Height of the 1st mountain
Height of the 2nd mountain
Height of the 3rd mountain
Examples
Input
1819
2003
876
2840
1723
1673
3776
2848
1592
922
Output
3776
2848
2840
Input
100
200
300
400
500
600
700
800
900
900
Output
900
900
800 | instruction | 0 | 79,825 | 8 | 159,650 |
"Correct Solution:
```
num = [int(input()) for i in range(10)]
num.sort(reverse=True)
for i in range(3):
print(num[i])
``` | output | 1 | 79,825 | 8 | 159,651 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0 | instruction | 0 | 80,422 | 8 | 160,844 |
Tags: brute force
Correct Solution:
```
n = int(input())
x = [n] * 4 ** 9
a = list(map(int,input().split()))
for i in range(n):
x[a[i] - min(i,n - i - 1)] -= 1
print(min(x[1 : 7 ** 6]))
``` | output | 1 | 80,422 | 8 | 160,845 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0 | instruction | 0 | 80,423 | 8 | 160,846 |
Tags: brute force
Correct Solution:
```
read = lambda: map(int, input().split())
n = int(input())
a = list(read())
b = [0] * n
for i in range(n // 2):
b[i] = b[n - i - 1] = i + 1
if n % 2: b[n // 2] = n // 2 + 1
from collections import Counter
c = Counter()
for i in range(n):
if a[i] >= b[i]: c[a[i] - b[i]] += 1
ans = n - max(c.values())
print(ans)
``` | output | 1 | 80,423 | 8 | 160,847 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0 | instruction | 0 | 80,424 | 8 | 160,848 |
Tags: brute force
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
if n==1:
print(0)
else:
d={}
if n%2==0:
x=[i+1 for i in range(n//2)]
i=x[-1]
while i>=1:
x.append(i)
i=i-1
else:
x=[i+1 for i in range(n//2)]
x.append(n//2+1)
i=x[-2]
while i>=1:
x.append(i)
i=i-1
for i in range(n):
if l[i]-x[i]>=0:
d[l[i]-x[i]]=d.get(l[i]-x[i],0)+1
m,x=0,0
for i in d:
if d[i]>=m:
m=d[i]
x=i
ll=[]
for i in range(n//2+n%2):
ll.append(i+1+x)
ans=0
for i in range(n//2+n%2):
if l[i]!=ll[i]:
ans=ans+1
l[i]=ll[i]
i=0
j=n-1
while i<=j:
if l[i]!=l[j]:
ans=ans+1
i=i+1
j=j-1
print(ans)
``` | output | 1 | 80,424 | 8 | 160,849 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0 | instruction | 0 | 80,425 | 8 | 160,850 |
Tags: brute force
Correct Solution:
```
n = int(input())
a = [0] * 100005
l = list(map(int, input().split()))
for i in range(n):
a[l[i] - min(i, n - i - 1)] += 1
print(n - max(a[1::]))
``` | output | 1 | 80,425 | 8 | 160,851 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0 | instruction | 0 | 80,426 | 8 | 160,852 |
Tags: brute force
Correct Solution:
```
import math
n=int(input())
a= list(map(int, input().split()))
x=[n]*100001
for i in range(n):
x[a[i]-min(n-i-1,i)]-=1
print (min(x[1:]))
``` | output | 1 | 80,426 | 8 | 160,853 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0 | instruction | 0 | 80,427 | 8 | 160,854 |
Tags: brute force
Correct Solution:
```
n=int(input())
arr=[int(x) for x in input().split()]
i=0;j=n-1
d=0
while i<j:
arr[i]-=d
arr[j]-=d
d+=1
i+=1
j-=1
if i==j:
arr[i]-=d
dict={}
for item in arr:
if item not in dict:
dict[item]=1
else:
dict[item]+=1
m=0
for key,val in dict.items():
if key>0:m=max(m,val)
print(n-m)
``` | output | 1 | 80,427 | 8 | 160,855 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0 | instruction | 0 | 80,428 | 8 | 160,856 |
Tags: brute force
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
d=[n]*(100001)
for i in range(n):
d[l[i]-min(n-i-1,i)]-=1
print(min(d[1:]))
``` | output | 1 | 80,428 | 8 | 160,857 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0 | instruction | 0 | 80,429 | 8 | 160,858 |
Tags: brute force
Correct Solution:
```
n=int(input());
x=[n]*4**9;
a=list(map(int,input().split()))
for i in range(n):
x[a[i]-min(i,n-i-1)]-=1
print(min(x[1:7**6]))
``` | output | 1 | 80,429 | 8 | 160,859 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0
Submitted Solution:
```
import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n = int(input())
a = list(map(int, input().split()))
up = sorted([x - min(l, r) for l, r, x in zip(range(1, n + 1), range(n, 0, -1), a)], reverse=True)
down_count = 0
zero_count = 0
while up and up[-1] <= 0:
if up[-1] == 0:
zero_count += 1
else:
down_count += 1
up.pop()
ans = n - zero_count
for i in range(1, 10**5 + 1):
down_count += zero_count
zero_count = 0
while up and up[-1] == i:
up.pop()
zero_count += 1
ans = min(ans, n - zero_count)
print(ans)
``` | instruction | 0 | 80,430 | 8 | 160,860 |
Yes | output | 1 | 80,430 | 8 | 160,861 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0
Submitted Solution:
```
n = int(input())
b = []
a = []
for i in range(100005):
b.append(0)
a.append(0)
s = input()
a +=list(map(int, s.strip().split()))
mid = (n+1)//2
for i in range(1,mid+1):
if a[i]-i >=0 :
b[a[i]-i]+=1
for i in range(mid+1,n+1):
if a[i]-(n-i+1)>=0:
b[a[i]-(n-i+1)]+=1
ans = 0
for i in b:
ans = max(ans,i)
print(n-ans)
``` | instruction | 0 | 80,431 | 8 | 160,862 |
Yes | output | 1 | 80,431 | 8 | 160,863 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
indices=[0]*(10**5+1)
if len(a)%2==0:
for i in range(len(a)):
if i<len(a)/2:
num=a[i]-i
if num>0:
indices[num]+=1
else:
num=a[i]-((len(a)-1)-i)
if num>0:
indices[num]+=1
resp=n-max(indices)
print(resp)
else:
for i in range(len(a)):
if i<len(a)//2:
num=a[i]-i
if num>0:
indices[num]+=1
else:
num=a[i]-((len(a)-1)-i)
if num>0:
indices[num]+=1
resp=n-max(indices)
print(resp)
``` | instruction | 0 | 80,432 | 8 | 160,864 |
Yes | output | 1 | 80,432 | 8 | 160,865 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0
Submitted Solution:
```
from collections import defaultdict as dd
n = int(input())
a = list(map(int, input().split()))
count = dd(lambda: 0)
for i in range(n//2):
count[a[i]-i] += 1
count[a[n-i-1] - i] += 1
#print(i, a[i]-i, a[n-i-1]-i)
#print([count[k] for k in count.keys()])
if n%2: count[a[n//2]-n//2] += 1
print(n - max([count[k] for k in count.keys() if k > 0]))
``` | instruction | 0 | 80,433 | 8 | 160,866 |
Yes | output | 1 | 80,433 | 8 | 160,867 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0
Submitted Solution:
```
import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n = int(input())
a = list(map(int, input().split()))
up = sorted([x - min(l, r) for l, r, x in zip(range(1, n + 1), range(n, 0, -1), a)], reverse=True)
down_sum, down_count = 0, 0
while up and up[-1] <= 0:
down_sum -= up.pop()
down_count += 1
up_sum = sum(up)
up_count = len(up)
ans = down_sum + up_sum
for i in range(1, 10**5 + 1):
down_sum += down_count
up_sum -= up_count
while up and up[-1] == i:
up.pop()
up_count -= 1
down_count += 1
ans = min(ans, down_sum + up_sum)
print(ans)
``` | instruction | 0 | 80,434 | 8 | 160,868 |
No | output | 1 | 80,434 | 8 | 160,869 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0
Submitted Solution:
```
n = int(input())
l = list(map(int,input().split()))
NumList = []
ll = []
if (n%2==0):
k=0
for i in range(0,n//2):
ll.append(k)
k+=1
k-=1
for i in range(n//2,n):
ll.append(k)
k-=1
for i in range(0,n):
NumList.append(l[i]-ll[i])
else:
k = 0
for i in range(0,n//2+1):
ll.append(k)
k+=1
k-=2
for i in range(n//2+1,n):
ll.append(k)
k-=1
for i in range(0,n):
NumList.append(l[i]-ll[i])
# print(NumList)
NumList = sorted(NumList)
cnt = 1
ans = n-1
MaxCnt = 0
for i in range(0,len(NumList)-1):
if NumList[i] == NumList[i+1] and NumList[i]>=1:
cnt +=1
else:
cnt = 1
if (MaxCnt<cnt):
MaxCnt = cnt
# print(l)
# print(ll)
ans = n - MaxCnt
print(ans)
``` | instruction | 0 | 80,435 | 8 | 160,870 |
No | output | 1 | 80,435 | 8 | 160,871 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0
Submitted Solution:
```
p=int(input(""))
ch=input("")
L=list(map(int,ch.split(" ")))
j=0
while j < (len(L)/2):
if L[j]==L[p-j-1]:
if j+1 < len(L)/2 :
if L[j+1]-L[j]!=1 :
print('1')
break
j=j+1
else :
print('1')
break
if j==len(L)//2 +p %2 :
print('0')
``` | instruction | 0 | 80,436 | 8 | 160,872 |
No | output | 1 | 80,436 | 8 | 160,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On Bertown's main street n trees are growing, the tree number i has the height of ai meters (1 ≤ i ≤ n). By the arrival of the President of Berland these trees were decided to be changed so that their heights formed a beautiful sequence. This means that the heights of trees on ends (the 1st one and the n-th one) should be equal to each other, the heights of the 2-nd and the (n - 1)-th tree must also be equal to each other, at that the height of the 2-nd tree should be larger than the height of the first tree by 1, and so on. In other words, the heights of the trees, standing at equal distance from the edge (of one end of the sequence) must be equal to each other, and with the increasing of the distance from the edge by 1 the tree height must also increase by 1. For example, the sequences "2 3 4 5 5 4 3 2" and "1 2 3 2 1" are beautiful, and '1 3 3 1" and "1 2 3 1" are not.
Changing the height of a tree is a very expensive operation, using advanced technologies invented by Berland scientists. In one operation you can choose any tree and change its height to any number, either increase or decrease. Note that even after the change the height should remain a positive integer, i. e, it can't be less than or equal to zero. Identify the smallest number of changes of the trees' height needed for the sequence of their heights to become beautiful.
Input
The first line contains integer n (1 ≤ n ≤ 105) which is the number of trees. The second line contains integers ai (1 ≤ ai ≤ 105) which are the heights of the trees.
Output
Print a single number which is the minimal number of trees whose heights will have to be changed for the sequence to become beautiful.
Examples
Input
3
2 2 2
Output
1
Input
4
1 2 2 1
Output
0
Submitted Solution:
```
p=int(input(""))
ch=input("")
L=list(map(int,ch.split(" ")))
j=0
nb=0
while j < (len(L)/2)+p%2:
if L[j]==L[p-j-1]:
if j+1 < len(L)/2 :
if L[j+1]-L[j]!=1 :
nb=nb+1
else :
nb=nb+1
j=j+1
print(nb)
``` | instruction | 0 | 80,437 | 8 | 160,874 |
No | output | 1 | 80,437 | 8 | 160,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728 | instruction | 0 | 81,093 | 8 | 162,186 |
Tags: combinatorics
Correct Solution:
```
n,k=map(int,input().split())
M=10**9+7
print(k**~-k*pow(n-k,n-k,M)%M)
``` | output | 1 | 81,093 | 8 | 162,187 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728 | instruction | 0 | 81,094 | 8 | 162,188 |
Tags: combinatorics
Correct Solution:
```
import sys,math,heapq,copy
from collections import defaultdict,deque
from bisect import bisect_left,bisect_right
from functools import cmp_to_key
from itertools import permutations,combinations,combinations_with_replacement
# sys.setrecursionlimit(10**6)
# sys.stdin=open('Input.txt','r')
# sys.stdout=open('Output.txt','w')
mod=1000000007
# Reading Single Input
def get_int(): return int(sys.stdin.readline().strip())
def get_str(): return sys.stdin.readline().strip()
def get_float(): return float(sys.stdin.readline().strip())
# Reading Multiple Inputs
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_strs(): return map(str, sys.stdin.readline().strip().split())
def get_floats(): return map(float, sys.stdin.readline().strip().split())
# Reading List Of Inputs
def list_ints(): return list(map(int, sys.stdin.readline().strip().split()))
def list_strs(): return list(map(str, sys.stdin.readline().strip().split()))
def list_floats(): return list(map(float, sys.stdin.readline().strip().split()))
# ------------------------------------------------------------------------------------- #
n,k=get_ints()
print((pow(k,k-1,mod)*pow(n-k,n-k,mod))%mod)
``` | output | 1 | 81,094 | 8 | 162,189 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728 | instruction | 0 | 81,096 | 8 | 162,192 |
Tags: combinatorics
Correct Solution:
```
n, k = map(int, input().split())
m = 1000000007
print((pow(k, k - 1, m) * pow(n - k, n - k, m)) % m)
``` | output | 1 | 81,096 | 8 | 162,193 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728 | instruction | 0 | 81,097 | 8 | 162,194 |
Tags: combinatorics
Correct Solution:
```
n, k = list(map(int, input().split()))
MOD = int(1e9 + 7)
lim = k
total = list(range(lim))
ans = 0
def dfs(lst, reach, curr):
reach[curr] = -2
nxt = lst[curr]
if nxt == 0:
reach[curr] = 1
return
if reach[nxt] == -2:
reach[curr] = 0
return
if reach[nxt] == -1:
dfs(lst, reach, nxt)
reach[curr] = reach[nxt]
def check(lst):
global ans
reach = [-1 for _ in total]
for i in total:
if reach[i] == -1:
dfs(lst, reach, i)
if not reach[i]:
return
ans += 1
def answer(curr, sofar):
if curr >= lim:
check(sofar)
return
for choose in total:
if curr == choose and curr > 1:
continue
sofar[curr] = choose
answer(curr + 1, sofar)
answer(0, [0 for _ in total])
cnt = n - k
for _ in range(cnt):
ans *= cnt
ans %= MOD
print(ans)
``` | output | 1 | 81,097 | 8 | 162,195 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728
Submitted Solution:
```
mod=10**9+7
def power(x, a):
if(a==0):
return(1)
z=power(x, a//2)
z=(z*z)%mod
if(a%2):
z=(z*x)%mod
return(z)
[n, k]=list(map(int, input().split()))
print((power(n-k, n-k)*power(k, k-1))%mod)
``` | instruction | 0 | 81,100 | 8 | 162,200 |
Yes | output | 1 | 81,100 | 8 | 162,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728
Submitted Solution:
```
inp = input().split(' ')
n = int(inp[0])
k = int(inp[1])
print((k**(k-1)*(n-k)**(n-k)) % 1000000007)
``` | instruction | 0 | 81,101 | 8 | 162,202 |
Yes | output | 1 | 81,101 | 8 | 162,203 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728
Submitted Solution:
```
n, k = map(int, input().split())
d = 1000000007
print(pow(k, k - 1, d) * pow(n - k, n - k, d) % d)
``` | instruction | 0 | 81,102 | 8 | 162,204 |
Yes | output | 1 | 81,102 | 8 | 162,205 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728
Submitted Solution:
```
n,k=map(int,input().split());n-=k;print(k**~-k*n**n%(10**9+7))
``` | instruction | 0 | 81,103 | 8 | 162,206 |
Yes | output | 1 | 81,103 | 8 | 162,207 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728
Submitted Solution:
```
n, k = map(int, input().split())
m=10**9+7
print(pow(k,k,m)*pow(n-k,n-k,m)%m)
``` | instruction | 0 | 81,104 | 8 | 162,208 |
No | output | 1 | 81,104 | 8 | 162,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728
Submitted Solution:
```
n, k = map(int, input().split())
mod = 1000000007
print(pow(k, k-1, mod) * pow(n-k, n-k, mod))
``` | instruction | 0 | 81,105 | 8 | 162,210 |
No | output | 1 | 81,105 | 8 | 162,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728
Submitted Solution:
```
n, k = map(int, input().split())
def f(a, b):
if b == 0: return 1
s, c = 0, b * a
for i in range(1, b + 1):
s += c * f(i, b - i)
c = (a * c * (b - i)) // (i + 1)
return s
print(k * f(1, k - 1) * (n - k) ** (n - k))
``` | instruction | 0 | 81,106 | 8 | 162,212 |
No | output | 1 | 81,106 | 8 | 162,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728
Submitted Solution:
```
import sys,math,heapq,copy
from collections import defaultdict,deque
from bisect import bisect_left,bisect_right
from functools import cmp_to_key
from itertools import permutations,combinations,combinations_with_replacement
# sys.setrecursionlimit(10**6)
# sys.stdin=open('Input.txt','r')
# sys.stdout=open('Output.txt','w')
mod=1000000007
# Reading Single Input
def get_int(): return int(sys.stdin.readline().strip())
def get_str(): return sys.stdin.readline().strip()
def get_float(): return float(sys.stdin.readline().strip())
# Reading Multiple Inputs
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_strs(): return map(str, sys.stdin.readline().strip().split())
def get_floats(): return map(float, sys.stdin.readline().strip().split())
# Reading List Of Inputs
def list_ints(): return list(map(int, sys.stdin.readline().strip().split()))
def list_strs(): return list(map(str, sys.stdin.readline().strip().split()))
def list_floats(): return list(map(float, sys.stdin.readline().strip().split()))
# ------------------------------------------------------------------------------------- #
n,k=get_ints()
print(pow(k,k-1)*pow(n-k,n-k))
``` | instruction | 0 | 81,107 | 8 | 162,214 |
No | output | 1 | 81,107 | 8 | 162,215 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5. | instruction | 0 | 81,170 | 8 | 162,340 |
Tags: implementation, math
Correct Solution:
```
import math
a, b = list(map(int, input().split()))
r = math.ceil(a/2)
flag = 0
for i in range(r, a+1):
if i % b == 0:
flag = 1
break
if flag == 1:
print(i)
else:
print(-1)
``` | output | 1 | 81,170 | 8 | 162,341 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5. | instruction | 0 | 81,171 | 8 | 162,342 |
Tags: implementation, math
Correct Solution:
```
"""
x + 2y = n
x + y : m
x = n - 2y
n - y : m
"""
import math
n, m = map(int, input().split())
my_min = n
for k in range(1, math.ceil(n / m)):
y = n - m * k
x = m * k - y
if x >= 0 and y >= 0:
if x + y < my_min:
my_min = x + y
if my_min % m != 0:
print(-1)
else:
print(my_min)
``` | output | 1 | 81,171 | 8 | 162,343 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dreamoon wants to climb up a stair of n steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer m.
What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?
Input
The single line contains two space separated integers n, m (0 < n ≤ 10000, 1 < m ≤ 10).
Output
Print a single integer — the minimal number of moves being a multiple of m. If there is no way he can climb satisfying condition print - 1 instead.
Examples
Input
10 2
Output
6
Input
3 5
Output
-1
Note
For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.
For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5. | instruction | 0 | 81,172 | 8 | 162,344 |
Tags: implementation, math
Correct Solution:
```
from math import ceil
I = lambda :map(int,input().split())
n,m = I()
if m > n:
print(-1)
exit()
if m == n:
print(m)
exit()
Move = range(ceil(n/2),n+1)
for i in Move:
if i%m==0:
print(i)
exit()
print(-1)
``` | output | 1 | 81,172 | 8 | 162,345 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.