message stringlengths 2 30.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 237 109k | cluster float64 10 10 | __index_level_0__ int64 474 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles. | instruction | 0 | 6,302 | 10 | 12,604 |
Tags: bitmasks, dp, greedy
Correct Solution:
```
n, li = map(int, input().split())
c = list(map(int, input().split()))
for i in range(n-1):
if c[i] * 2 < c[i+1]:
c[i+1] = c[i] * 2
for i in range(n-2, -1, -1):
if c[i] > c[i+1]:
c[i] = c[i+1]
'''
p = c[0] * li
for i in range(n):
if 2**i >= li and p > c[i]:
p = c[i]
'''
i = n - 1
ans = 0
a = []
while li > 0:
ans += c[i] * (li >> i)
li %= 2**i
if li < 2**i:
a.append(ans + c[i])
i-=1
a.append(ans)
print(min(a))
``` | output | 1 | 6,302 | 10 | 12,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles. | instruction | 0 | 6,303 | 10 | 12,606 |
Tags: bitmasks, dp, greedy
Correct Solution:
```
s=input()
s1=s.split()
tot=int(s1[1])
s=input()
s1=s.split()
l=[int(i) for i in s1]
avg=[[l[i]/(2**i),i] for i in range(len(l))]
avg.sort()
cost=0
i=0
d={}
def fun(i,tot):
if i==len(avg):
return(1e8)
elif (i,tot) in d:
return(d[(i,tot)])
elif tot%(2**avg[i][1])==0:
return((tot//(2**avg[i][1]))*l[avg[i][1]])
else:
a=(tot//(2**avg[i][1])+1)*l[avg[i][1]]
b=(tot//(2**avg[i][1]))*l[avg[i][1]]+fun(i+1,tot%(2**avg[i][1]))
d[(i,tot)]=min(a,b)
return(min(a,b))
print(fun(0,tot))
``` | output | 1 | 6,303 | 10 | 12,607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles. | instruction | 0 | 6,304 | 10 | 12,608 |
Tags: bitmasks, dp, greedy
Correct Solution:
```
a,b=map(int,input().split())
z=list(map(int,input().split()))
import math
pre=[z[0]]
for i in range(1,len(z)):
pre.append(min(z[i],2*pre[-1]))
q=[1]
for i in range(len(z)-1):
q.append(q[-1]*2)
cost=0
p=len(q)-1
pos=[]
mini=math.inf
while(1):
if(b>=q[p]):
nos=b//q[p]
rem=b%q[p]
cost+=nos*pre[p]
if(rem==0):
print(min(mini,cost))
break;
else:
pos.append(cost+pre[p])
mini=min(mini,min(pos))
b=rem
p=p-1
else:
pos.append(cost+pre[p])
p=p-1
mini=min(mini,min(pos))
``` | output | 1 | 6,304 | 10 | 12,609 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles. | instruction | 0 | 6,305 | 10 | 12,610 |
Tags: bitmasks, dp, greedy
Correct Solution:
```
n, l = [int(x) for x in input().strip().split()]
c = [int(x) for x in input().strip().split()]
tc = 0
for i in range(1, len(c)):
c[i] = min(c[i], 2*c[i-1])
for i in range(32):
c.append(c[-1]*2)
tc = 0
bl = bin(l)[:1:-1]
bl += '0' * (len(c) - len(bl) - 1)
for i in range(len(bl)):
if bl[i] == '1':
tc += c[i]
else:
tc = min(tc, c[i])
print(tc)
``` | output | 1 | 6,305 | 10 | 12,611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles. | instruction | 0 | 6,306 | 10 | 12,612 |
Tags: bitmasks, dp, greedy
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
def main():
n,l=map(int,input().split())
c=list(map(int,input().split()))
mi,su=4*10**18,0
for i in range(1,n):
c[i]=min(c[i],2*c[i-1])
for i in range(n-1,-1,-1):
y=(1<<i)
z=l//y
su+=z*c[i]
l-=z*y
mi=min(mi,su+(l!=0)*c[i])
print(mi)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 6,306 | 10 | 12,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles. | instruction | 0 | 6,307 | 10 | 12,614 |
Tags: bitmasks, dp, greedy
Correct Solution:
```
types,volume=map(int,input().split())
c,s=0,10**18
a=list(map(int,input().split()))
for i in range(len(a)-1):
a[i+1]=min(a[i+1],a[i]*2)
for i in range(types-1,-1,-1):
d=1<<i
c+=a[i]*(volume//d)
volume%=d
s=min(s,c+(volume!=0)*a[i])
print(s)
``` | output | 1 | 6,307 | 10 | 12,615 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles. | instruction | 0 | 6,308 | 10 | 12,616 |
Tags: bitmasks, dp, greedy
Correct Solution:
```
s=input()
s1=s.split()
tot=int(s1[1])
s=input()
s1=s.split()
l=[int(i) for i in s1]
avg=[[l[i]/(2**i),i] for i in range(len(l))]
avg.sort()
cost=0
i=0
def fun(i,tot):
if i==len(avg):
return(1e8)
if tot%(2**avg[i][1])==0:
return((tot//(2**avg[i][1]))*l[avg[i][1]])
else:
a=(tot//(2**avg[i][1])+1)*l[avg[i][1]]
b=(tot//(2**avg[i][1]))*l[avg[i][1]]+fun(i+1,tot%(2**avg[i][1]))
return(min(a,b))
print(fun(0,tot))
``` | output | 1 | 6,308 | 10 | 12,617 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles.
Submitted Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
n,L=map(int,input().split())
c=list(map(int,input().split()))
t=[c[i] if i<n else float('inf') for i in range(32)]
for i in range(1,32):
t[i]=min(t[i],2*t[i-1])
a=0
for i in range(0,32):
q=2**i
if L&q>0:
a+=t[i]
else:
a=min(a,t[i])
print(a)
``` | instruction | 0 | 6,309 | 10 | 12,618 |
Yes | output | 1 | 6,309 | 10 | 12,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles.
Submitted Solution:
```
import math
N = 31
n, l = map(int, input().split())
cost = [int(x) for x in input().split()]
for i in range(n, N):
cost.append(math.inf)
for i in range(N - 1):
cost[i + 1] = min(cost[i + 1], cost[i] * 2)
# print(cost)
ans = math.inf
cur_cost = 0
for i in range(N - 1, -1, -1):
# print('l = {}'.format(l))
if 2**i >= l:
ans = min(ans, cur_cost + cost[i])
else:
cur_cost += cost[i]
l -= 2**i;
# print('at {} and ans = {}'.format(i, ans))
print(ans)
``` | instruction | 0 | 6,310 | 10 | 12,620 |
Yes | output | 1 | 6,310 | 10 | 12,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles.
Submitted Solution:
```
n = input().split()
l = int(n[1])
n = int(n[0])
c = input().split()
cperl = []
for i in range(n):
c[i] = int(c[i])
cperl.append([(c[i])/2**i, 2**i, i])
cperl.sort()
f = False
nl = [0]
nc = [0]
i = 0
while not f:
p = nl[i]
nl[i] += cperl[i][1] * ((l-p)//cperl[i][1])
nc[i] += c[cperl[i][2]] * ((l-p)//cperl[i][1])
if nl[i] == l:
f = True
break
nl.append(nl[i])
nc.append(nc[i])
nl[i] += cperl[i][1]
nc[i] += c[cperl[i][2]]
i += 1
if i == n:
break
print(min(nc))
``` | instruction | 0 | 6,311 | 10 | 12,622 |
Yes | output | 1 | 6,311 | 10 | 12,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles.
Submitted Solution:
```
s = 0
ans = 100 ** 1000
n, l = map(int, input().split())
a = list(map(int, input().split()))
for i in range(0,n-1):
a[i+1] = min(a[i+1], 2*a[i])
for i in range(n-1, -1, -1):
d = l // (1 << i)
s += d * a[i]
l -= d << i;
ans = min(ans, s+(l > 0) * a[i])
print(ans)
``` | instruction | 0 | 6,312 | 10 | 12,624 |
Yes | output | 1 | 6,312 | 10 | 12,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles.
Submitted Solution:
```
n,L=[int(i) for i in input().split()]
L=list(bin(L).replace('0b',''))
L.reverse()
c=[int(i) for i in input().split()]
l=0
C=[]
for i in range(len(L)):
c_l={}
for j in range(n):
if j>i:
c_l[c[j]/2**i]=j
elif j<=i:
c_l[c[j]/2**j]=j
c_ls=list(c_l.keys())
m=c_l[min(c_ls)]
if m>i:
Ci=c[m]
if m<=i:
Ci=c[m]/(2**m)*(2**i)
Cc1=l+Ci*int(L[i])
c_l.clear()
for j in range(n):
if j>(i+1):
c_l[c[j]/2**(i+1)]=j
elif j<=(i+1):
c_l[c[j]/2**j]=j
c_ls=list(c_l.keys())
m=c_l[min(c_ls)]
if m>(i+1):
Ci=c[m]
if m<=(i+1):
Ci=c[m]/(2**m)*(2**(i+1))
Cc2=Ci*int(L[i])
x=min(Cc1,Cc2)
l=l+x
if x==0:
C.append(l)
else:
C.append(x)
l=x
print(int(C[-1]))
``` | instruction | 0 | 6,313 | 10 | 12,626 |
No | output | 1 | 6,313 | 10 | 12,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles.
Submitted Solution:
```
cin=input().split()
n=int(cin[0])
m=int(cin[1])
data=list(map(int, input().split()))
for x in range(1, len(bin(m))-2):
if(x<len(data)):
if(data[x]>(data[x-1]*2)):
data[x]=data[x-1]*2
else :
data.append(data[x-1]*2)
for x in reversed(range(0, len(data)-1)):
data[x]=min(data[x+1], data[x])
m=bin(m)
m=list(reversed(m))
ans=0
for x in range(len(m)-2):
if(m[x]=='1'):
ans+=int(data[x])
else :
ans=min(ans, data[x])
print(ans)
``` | instruction | 0 | 6,314 | 10 | 12,628 |
No | output | 1 | 6,314 | 10 | 12,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles.
Submitted Solution:
```
arr = [int(x) for x in input().split()]
n = arr[0]
L = arr[1]
costs = [int(x) for x in input().split()]
resp = 4e18
sumC = 0
for i in range(n - 1):
costs[i+1] = min(costs[i + 1], 2 * costs[i])
for i in range(n - 1, 0, -1):
k = L // (1 << i)
sumC += k * costs[i]
L -= k << i
resp = min(resp, sumC + (L > 0) * costs[i])
print(resp)
``` | instruction | 0 | 6,315 | 10 | 12,630 |
No | output | 1 | 6,315 | 10 | 12,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.
Your favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.
You want to buy at least L liters of lemonade. How many roubles do you have to spend?
Input
The first line contains two integers n and L (1 β€ n β€ 30; 1 β€ L β€ 109) β the number of types of bottles in the store and the required amount of lemonade in liters, respectively.
The second line contains n integers c1, c2, ..., cn (1 β€ ci β€ 109) β the costs of bottles of different types.
Output
Output a single integer β the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.
Examples
Input
4 12
20 30 70 90
Output
150
Input
4 3
10000 1000 100 10
Output
10
Input
4 3
10 100 1000 10000
Output
30
Input
5 787787787
123456789 234567890 345678901 456789012 987654321
Output
44981600785557577
Note
In the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.
In the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.
In the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles.
Submitted Solution:
```
import math
def calcula(L, cost):
tam = math.log2(L)
tam1 = int(tam)
if (tam == tam1):
return cost[tam1]
esquerda = L - (1 << tam1)
tmp = calcula(esquerda, cost)
tam2 = math.log2(esquerda)
i = int(tam2) + 1
while i <= tam1:
i += 1
tmp = min(tmp, cost[i])
if (cost[tam1] * 2 < cost[tam1] + tmp):
return cost[tam1] * 2
else:
return cost[tam1] + tmp
entrada = input().split()
n = int(entrada[0])
L = int(entrada[1])
cost = [0] * 33
i = 0
while i <= 32:
cost[i] = 1 << 62
i += 1
entrada = input().split()
for i in range(0, n):
cost[i] = int(entrada[i])
i = 0
while(i <= 32):
cost[i] = min(cost[i], cost[i - 1] * 2)
i += 1
tam = math.log2(L)
result = calcula(L, cost)
i = int(tam) + 1
while i <= 32:
result = min(result, cost[i])
i += 1
print(result)
``` | instruction | 0 | 6,316 | 10 | 12,632 |
No | output | 1 | 6,316 | 10 | 12,633 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2] | instruction | 0 | 6,846 | 10 | 13,692 |
Tags: constructive algorithms
Correct Solution:
```
#Fast I/O
import sys,os
import math
# To enable the file I/O i the below 2 lines are uncommented.
# read from in.txt if uncommented
if os.path.exists('in.txt'): sys.stdin=open('in.txt','r')
# will print on Console if file I/O is not activated
#if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')
# inputs template
from io import BytesIO, IOBase
def main():
for _ in range(int(input())):
n=int(input())
arr=list(MI())
print(3*n)
for i in range(n//2):
print(1,2*i+1,2*i+2)
print(2,2*i+1,2*i+2)
print(2,2*i+1,2*i+2)
print(1,2*i+1,2*i+2)
print(2,2*i+1,2*i+2)
print(2,2*i+1,2*i+2)
# Sample Inputs/Output
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#for array of integers
def MI():return (map(int,input().split()))
# endregion
#for fast output, always take string
def outP(var): sys.stdout.write(str(var)+'\n')
# end of any user-defined functions
MOD=10**9+7
mod=998244353
# main functions for execution of the program.
if __name__ == '__main__':
#This doesn't works here but works wonders when submitted on CodeChef or CodeForces
main()
``` | output | 1 | 6,846 | 10 | 13,693 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2] | instruction | 0 | 6,847 | 10 | 13,694 |
Tags: constructive algorithms
Correct Solution:
```
"""
ai = ai + aj
aj = aj - ai
1 ai + aj, aj
2 ai + aj, -ai
1 aj, -ai
2 aj, -ai-aj
1 -ai, -ai-aj
2 -ai, -aj
"""
def test():
n = int(input())
arr = list(map(int, input().split()))
opts = int(n / 2 * 6)
print(opts)
for i in range(1, n + 1, 2):
for _ in range(3):
print(f'1 {i} {i + 1}')
print(f'2 {i} {i + 1}')
if __name__ == "__main__":
num_cases = int(input())
for _ in range(0, num_cases):
test()
``` | output | 1 | 6,847 | 10 | 13,695 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2] | instruction | 0 | 6,848 | 10 | 13,696 |
Tags: constructive algorithms
Correct Solution:
```
def fun(ls,n):
print(3*n)
for i in range(0,n,2):
index=i+1
print(1,index,index+1)
print(2,index,index+1)
print(1,index,index+1)
print(1,index,index+1)
print(2,index,index+1)
print(1,index,index+1)
T = int(input())
for _ in range(T):
n=int(input())
ls= list(map(int, input().split()))
fun(ls,n)
# Concept
# let num be a,b
# apply 1 a+b,b
# apply 2 a+b,-a
# apply 1 b,-a
# apply 1 -a+b,-a
# apply 2 -a+b,-b
# apply 1 -a,-b
# 6 operation for 2 num = 3 operation for one number sototal 3*n operation
``` | output | 1 | 6,848 | 10 | 13,697 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2] | instruction | 0 | 6,849 | 10 | 13,698 |
Tags: constructive algorithms
Correct Solution:
```
t = int(input())
while t:
n = int(input())
l = [int(i) for i in input().split()]
print(6*(n//2))
i = 0
while i<n:
print('2' + " " + str(i+1) + " " + str(i+2))
print('1' + " " + str(i+1) + " " + str(i+2))
print('2' + " " + str(i+1) + " " + str(i+2))
print('1' + " " + str(i+1) + " " + str(i+2))
print('2' + " " + str(i+1) + " " + str(i+2))
print('1' + " " + str(i+1) + " " + str(i+2))
i+=2
t-=1
``` | output | 1 | 6,849 | 10 | 13,699 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2] | instruction | 0 | 6,850 | 10 | 13,700 |
Tags: constructive algorithms
Correct Solution:
```
import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from collections import Counter
from collections import defaultdict as dd
# sys.setrecursionlimit(100000000)
flush = lambda: stdout.flush()
stdstr = lambda: stdin.readline()
stdint = lambda: int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
stdmap = lambda: map(int, stdstr().split())
stdarr = lambda: list(map(int, stdstr().split()))
mod = 1000000007
def f(arr, i, j):
arr[i] = arr[i] + arr[j]
def s(arr, i, j):
arr[j] = arr[j]-arr[i]
for _ in range(stdint()):
n = stdint()
arr = stdarr()
res = []
for i in range(0, n, 2):
x,y = i+1, i+2
res.append([1, x,y])
# f(arr, x, y)
res.append([2, x,y])
# s(arr, x, y)
res.append([2, x, y])
# s(arr, x, y)
res.append([1,x,y])
# f(arr, x, y)
res.append([2,x,y])
# s(arr, x, y)
res.append([2,x,y])
# s(arr, x, y)
print(len(res))
for i in res:
print(*i)
``` | output | 1 | 6,850 | 10 | 13,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2] | instruction | 0 | 6,851 | 10 | 13,702 |
Tags: constructive algorithms
Correct Solution:
```
t = int(input())
while t > 0:
t -= 1
n = int(input())
input()
print(6 * n // 2)
for i in range(0, n, 2):
print('2', i + 1, i + 2)
print('2', i + 1, i + 2)
print('1', i + 1, i + 2)
print('2', i + 1, i + 2)
print('2', i + 1, i + 2)
print('1', i + 1, i + 2)
# from copy import copy
#
# b = [2, 3]
# for mask in range(64):
# a = copy(b)
# for i in range(6):
# if mask >> i & 1:
# a[0] += a[1]
# else:
# a[1] -= a[0]
# # print(a)
# if a == [-2, -3]:
# print(mask)
``` | output | 1 | 6,851 | 10 | 13,703 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2] | instruction | 0 | 6,852 | 10 | 13,704 |
Tags: constructive algorithms
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import Counter
import math as mt
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def lcm(a, b):
return (a * b) / gcd(a, b)
mod = int(1e9) + 7
def power(k, n):
if n == 0:
return 1
if n % 2:
return (power(k, n - 1) * k) % mod
t = power(k, n // 2)
return (t * t) % mod
def totalPrimeFactors(n):
count = 0
if (n % 2) == 0:
count += 1
while (n % 2) == 0:
n //= 2
i = 3
while i * i <= n:
if (n % i) == 0:
count += 1
while (n % i) == 0:
n //= i
i += 2
if n > 2:
count += 1
return count
# #MAXN = int(1e7 + 1)
# # spf = [0 for i in range(MAXN)]
#
#
# def sieve():
# spf[1] = 1
# for i in range(2, MAXN):
# spf[i] = i
# for i in range(4, MAXN, 2):
# spf[i] = 2
#
# for i in range(3, mt.ceil(mt.sqrt(MAXN))):
# if (spf[i] == i):
# for j in range(i * i, MAXN, i):
# if (spf[j] == j):
# spf[j] = i
#
#
# def getFactorization(x):
# ret = 0
# while (x != 1):
# k = spf[x]
# ret += 1
# # ret.add(spf[x])
# while x % k == 0:
# x //= k
#
# return ret
# Driver code
# precalculating Smallest Prime Factor
# sieve()
def main():
for _ in range(int(input())):
n=int(input())
a=list(map(int, input().split()))
ans=[]
for i in range(0, n, 2):
ans.append([1, i, i+1])
ans.append([2, i, i+1])
ans.append([2, i, i+1])
ans.append([1, i, i + 1])
ans.append([2, i, i + 1])
ans.append([2, i, i + 1])
print(len(ans))
for i in ans:
print(i[0], i[1]+1, i[2]+1)
return
if __name__ == "__main__":
main()
``` | output | 1 | 6,852 | 10 | 13,705 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2] | instruction | 0 | 6,853 | 10 | 13,706 |
Tags: constructive algorithms
Correct Solution:
```
a=int(input())
import sys
input=sys.stdin.readline
for i in range(a):
n=int(input())
z=list(map(int,input().split()))
print(3*len(z))
for i in range(0,len(z),2):
print(1,i+1,i+2)
print(2,i+1,i+2)
print(1,i+1,i+2)
print(2,i+1,i+2)
print(1,i+1,i+2)
print(2,i+1,i+2)
``` | output | 1 | 6,853 | 10 | 13,707 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2]
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
print(n*3)
for i in range(1, n, 2):
for j in range(3):
print(1, i, i+1)
print(2, i, i+1)
###### thanking telegram for solutions ######
'''__________ ____ ___ _____________ __.___
\______ \ | \/ _____/ |/ _| |
| _/ | /\_____ \| < | |
| | \ | / / \ | \| |
|____|_ /______/ /_______ /____|__ \___|
'''
``` | instruction | 0 | 6,854 | 10 | 13,708 |
Yes | output | 1 | 6,854 | 10 | 13,709 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2]
Submitted Solution:
```
t=int(input())
def solve():
n=int(input())
arr=list(map(int,input().split()))
print(n*3)
for i in range(1,n+1,2):
print(2,i,i+1)
print(1,i,i+1)
print(2,i,i+1)
print(2,i,i+1)
print(1,i,i+1)
print(2,i,i+1)
for i in range(t):
solve()
``` | instruction | 0 | 6,855 | 10 | 13,710 |
Yes | output | 1 | 6,855 | 10 | 13,711 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2]
Submitted Solution:
```
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def LS2(): return list(sys.stdin.readline().rstrip())
t = I()
for _ in range(t):
n = I()
A = LI()
print(3*n)
for i in range(n//2):
x = 2*i+1
y = 2*i+2
for a in [1,2,1,1,2,1]:
print(a,x,y)
``` | instruction | 0 | 6,856 | 10 | 13,712 |
Yes | output | 1 | 6,856 | 10 | 13,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2]
Submitted Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
import math
from collections import Counter
def func(array):
print(3 * len(array))
for i in range(0, len(array), 2):
for j in range(3):
print(f"2 {i+1} {i+2}")
print(f"1 {i+1} {i+2}")
def main():
num_test = int(parse_input())
result = []
for _ in range(num_test):
n = int(parse_input())
array = [int(i) for i in parse_input().split()]
func(array)
# print("\n".join(map(str, result)))
# region fastio
# BUFSIZE = 8192
# class FastIO(IOBase):
# newlines = 0
# def __init__(self, file):
# self._fd = file.fileno()
# self.buffer = BytesIO()
# self.writable = "x" in file.mode or "r" not in file.mode
# self.write = self.buffer.write if self.writable else None
# def read(self):
# while True:
# b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
# if not b:
# break
# ptr = self.buffer.tell()
# self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
# self.newlines = 0
# return self.buffer.read()
# def readline(self):
# while self.newlines == 0:
# b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
# self.newlines = b.count(b"\n") + (not b)
# ptr = self.buffer.tell()
# self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
# self.newlines -= 1
# return self.buffer.readline()
# def flush(self):
# if self.writable:
# os.write(self._fd, self.buffer.getvalue())
# self.buffer.truncate(0), self.buffer.seek(0)
# class IOWrapper(IOBase):
# def __init__(self, file):
# self.buffer = FastIO(file)
# self.flush = self.buffer.flush
# self.writable = self.buffer.writable
# self.write = lambda s: self.buffer.write(s.encode("ascii"))
# self.read = lambda: self.buffer.read().decode("ascii")
# self.readline = lambda: self.buffer.readline().decode("ascii")
# sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
parse_input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | instruction | 0 | 6,857 | 10 | 13,714 |
Yes | output | 1 | 6,857 | 10 | 13,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2]
Submitted Solution:
```
#from _typeshed import SupportsKeysAndGetItem
import sys
#sys.stdin=open("input.txt","r");
#sys.stdout=open("output.txt","w")
####### GLOBAL ###############
MOD=1000000007
no=lambda:print("NO")
yes=lambda:print("YES")
_1=lambda:print(-1)
ari=lambda:[int(_) for _ in input().split()]
cin=lambda:int(input())
cis=lambda:input()
show=lambda x: print(x)
########### END #########
######
test_case=1
test_case=int(input())
######
def ans():
n=cin()
a=ari()
cnt=0
index=0
temp_arr=[]
final_ans=[]
for i in range(n):
temp_arr.append(a[i]*-1)
def help(first,last):
nonlocal temp_arr
nonlocal a
nonlocal final_ans
c=0
while True:
a[last]=a[last]-a[first]
c+=1
final_ans.append((2,first,last))
if a[last]==temp_arr[last] and a[first]==temp_arr[first]:
break
final_ans.append((1,first,last))
a[first]=a[first]+a[last]
c+=1
if a[last]==temp_arr[last] and a[first]==temp_arr[first]:
break
return c
for i in range(0,n,2):
cnt+= help(i,i+1)
print(cnt)
for i in final_ans:
j,k,l=i[0],i[1],i[2]
print(j,k,l)
return
for _ in range(test_case):
ans()
``` | instruction | 0 | 6,858 | 10 | 13,716 |
No | output | 1 | 6,858 | 10 | 13,717 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2]
Submitted Solution:
```
for i in range(int(input())):
n=int(input())
li=list(map(int,input().split()))
b=[]
for j in range(0,n,2):
if li[j]<li[j+1]:
b.append(8)
if li[j]==li[j+1]:
b.append(4)
if li[j]>li[j+1]:
b.append(6)
print(sum(b))
for j in range(0,n,2):
if li[j]<li[j+1]:
print(1, j + 1, j + 2)
print(2, j + 1, j + 2)
print(1, j + 1, j + 2)
print(2, j + 1, j + 2)
print(1, j + 1, j + 2)
print(2, j + 1, j + 2)
print(1, j + 1, j + 2)
print(1, j + 1, j + 2)
if li[j]==li[j+1]:
print(2, j + 1, j + 2)
print(2, j + 1, j + 2)
print(1, j + 1, j + 2)
print(1, j + 1, j + 2)
if li[j]>li[j+1]:
print(2, j + 1, j + 2)
print(1, j + 1, j + 2)
print(2, j + 1, j + 2)
print(1, j + 1, j + 2)
print(2, j + 1, j + 2)
print(1, j + 1, j + 2)
``` | instruction | 0 | 6,859 | 10 | 13,718 |
No | output | 1 | 6,859 | 10 | 13,719 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2]
Submitted Solution:
```
def solve():
n = int(input())
s = list(map(int,input().split()))
for i in range(0,n,2):
j = i+1
print(2,i,j)
print(1,i,j)
print(2,i,j)
print(2,i,j)
print(1,i,j)
print(2,i,j)
for nt in range(int(input())):
solve()
``` | instruction | 0 | 6,860 | 10 | 13,720 |
No | output | 1 | 6,860 | 10 | 13,721 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, β¦, a_n to -a_1, -a_2, β¦, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 β€ n β€ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k β€ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2]
Submitted Solution:
```
for i in range(int(input())):
n = int(input())
li = list(map(int,input().split()))
for j in range(1,len(li)+1,2):
print(1,j,j+1)
print(2,j,j+1)
print(1,j,j+1)
print(1,j,j+1)
print(2,j,j+1)
print(1,j,j+1)
``` | instruction | 0 | 6,861 | 10 | 13,722 |
No | output | 1 | 6,861 | 10 | 13,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kefa wants to celebrate his first big salary by going to restaurant. However, he needs company.
Kefa has n friends, each friend will agree to go to the restaurant if Kefa asks. Each friend is characterized by the amount of money he has and the friendship factor in respect to Kefa. The parrot doesn't want any friend to feel poor compared to somebody else in the company (Kefa doesn't count). A friend feels poor if in the company there is someone who has at least d units of money more than he does. Also, Kefa wants the total friendship factor of the members of the company to be maximum. Help him invite an optimal company!
Input
The first line of the input contains two space-separated integers, n and d (1 β€ n β€ 105, <image>) β the number of Kefa's friends and the minimum difference between the amount of money in order to feel poor, respectively.
Next n lines contain the descriptions of Kefa's friends, the (i + 1)-th line contains the description of the i-th friend of type mi, si (0 β€ mi, si β€ 109) β the amount of money and the friendship factor, respectively.
Output
Print the maximum total friendship factir that can be reached.
Examples
Input
4 5
75 5
0 100
150 20
75 1
Output
100
Input
5 100
0 7
11 32
99 10
46 8
87 54
Output
111
Note
In the first sample test the most profitable strategy is to form a company from only the second friend. At all other variants the total degree of friendship will be worse.
In the second sample test we can take all the friends.
Submitted Solution:
```
n, d = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
a.sort(key=lambda x: x[0])
# print(a)
# ΠΎΡΠ΅ΡΠ΅Π΄Π½ΠΎΠΉ ΠΊΠ°Π½Π΄ΠΈΠ΄Π°Ρ Π½Π° ΡΠ΄Π°Π»Π΅Π½ΠΈΠ΅ = 0
# Π² ΡΠΈΠΊΠ»Π΅ ΠΏΠΎ Π²ΡΠ΅ΠΌ Π΄ΡΡΠ·ΡΡΠΌ
# Π΄ΠΎΠ±Π°Π²Π»ΡΠ΅ΠΌ ΠΎΡΠ΅ΡΠ΅Π΄Π½ΠΎΠ³ΠΎ ( = Π·Π°ΠΏΠΎΠΌΠΈΠ½Π°Π΅ΠΌ ΡΡΠΎΠ²Π΅Π½Ρ Π±ΠΎΠ³Π°ΡΡΡΠ²Π° + Π΄ΠΎΠ±Π°Π²Π»ΡΠ΅ΠΌ Π΅Π³ΠΎ ΡΡΠ΅ΠΏΠ΅Π½Ρ Π΄ΡΡΠΆΠ±Ρ)
# ΠΏΠΎΠΊΠ° ΠΎΡΠ΅ΡΠ΅Π΄Π½ΠΎΠΉ ΠΊΠ°Π½Π΄ΠΈΠ΄Π°Ρ Π½Π° ΡΠ΄Π°Π»Π΅Π½ΠΈΠ΅ ΡΠ»ΠΈΡΠΊΠΎΠΌ Π±Π΅Π΄Π΅Π½
# Π²ΡΡΠΈΡΠ°Π΅ΠΌ Π΅Π³ΠΎ ΡΡΠ΅ΠΏΠ΅Π½Ρ Π΄ΡΡΠΆΠ±Ρ;
# ΠΏΠ΅ΡΠ΅Ρ
ΠΎΠ΄ΠΈΠΌ ΠΊ ΡΠ»Π΅Π΄ΡΡΡΠ΅ΠΌΡ ΠΊΠ°Π½Π΄ΠΈΠ΄Π°ΡΡ Π½Π° ΡΠ΄Π°Π»Π΅Π½ΠΈΠ΅
j = 0
friendship = 0
max_friendship = 0
for i in range(n):
friendship += a[i][1]
while a[j][0] + d <= a[i][0]:
friendship -= a[j][1]
j += 1
max_friendship = max(friendship, max_friendship)
print(max_friendship)
``` | instruction | 0 | 7,105 | 10 | 14,210 |
Yes | output | 1 | 7,105 | 10 | 14,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kefa wants to celebrate his first big salary by going to restaurant. However, he needs company.
Kefa has n friends, each friend will agree to go to the restaurant if Kefa asks. Each friend is characterized by the amount of money he has and the friendship factor in respect to Kefa. The parrot doesn't want any friend to feel poor compared to somebody else in the company (Kefa doesn't count). A friend feels poor if in the company there is someone who has at least d units of money more than he does. Also, Kefa wants the total friendship factor of the members of the company to be maximum. Help him invite an optimal company!
Input
The first line of the input contains two space-separated integers, n and d (1 β€ n β€ 105, <image>) β the number of Kefa's friends and the minimum difference between the amount of money in order to feel poor, respectively.
Next n lines contain the descriptions of Kefa's friends, the (i + 1)-th line contains the description of the i-th friend of type mi, si (0 β€ mi, si β€ 109) β the amount of money and the friendship factor, respectively.
Output
Print the maximum total friendship factir that can be reached.
Examples
Input
4 5
75 5
0 100
150 20
75 1
Output
100
Input
5 100
0 7
11 32
99 10
46 8
87 54
Output
111
Note
In the first sample test the most profitable strategy is to form a company from only the second friend. At all other variants the total degree of friendship will be worse.
In the second sample test we can take all the friends.
Submitted Solution:
```
# https://vjudge.net/contest/319995#problem/C
n, money = [ int(x) for x in input().split() ]
data = []
for i in range(n):
d = [ int(x) for x in input().split() ]
data.append(d)
data.sort(key=lambda x: x[1], reverse=True)
fact_c = 0
minc = 0
maxc = 0
for i in range(n):
if abs(data[i][0] - data[minc][0]) < money and abs(data[i][0] - data[maxc][0]) < money:
fact_c += data[i][1]
if data[i][0] < data[minc][0]:
minc = i
if data[i][0] > data[maxc][0]:
maxc = i
print(fact_c)
``` | instruction | 0 | 7,107 | 10 | 14,214 |
No | output | 1 | 7,107 | 10 | 14,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kefa wants to celebrate his first big salary by going to restaurant. However, he needs company.
Kefa has n friends, each friend will agree to go to the restaurant if Kefa asks. Each friend is characterized by the amount of money he has and the friendship factor in respect to Kefa. The parrot doesn't want any friend to feel poor compared to somebody else in the company (Kefa doesn't count). A friend feels poor if in the company there is someone who has at least d units of money more than he does. Also, Kefa wants the total friendship factor of the members of the company to be maximum. Help him invite an optimal company!
Input
The first line of the input contains two space-separated integers, n and d (1 β€ n β€ 105, <image>) β the number of Kefa's friends and the minimum difference between the amount of money in order to feel poor, respectively.
Next n lines contain the descriptions of Kefa's friends, the (i + 1)-th line contains the description of the i-th friend of type mi, si (0 β€ mi, si β€ 109) β the amount of money and the friendship factor, respectively.
Output
Print the maximum total friendship factir that can be reached.
Examples
Input
4 5
75 5
0 100
150 20
75 1
Output
100
Input
5 100
0 7
11 32
99 10
46 8
87 54
Output
111
Note
In the first sample test the most profitable strategy is to form a company from only the second friend. At all other variants the total degree of friendship will be worse.
In the second sample test we can take all the friends.
Submitted Solution:
```
n,k = map(int,input().split())
a = [list(map(int,input().split())) for _ in range(n)]
a.sort()
s = 0
ans = 0
r = 0
for l in range(n):
while r<n and a[r][0]-a[l][0]<=k:
s+=a[r][1]
r+=1
ans=max(ans,s)
s-=a[l][1]
print(ans)
``` | instruction | 0 | 7,109 | 10 | 14,218 |
No | output | 1 | 7,109 | 10 | 14,219 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10 | instruction | 0 | 7,190 | 10 | 14,380 |
Tags: binary search, dp, greedy, ternary search
Correct Solution:
```
def main():
n, m = map(int, input().split())
cost1 = []
cost2 = []
cost3 = []
for i in range(n):
w, c = map(int, input().split())
if w == 1:
cost1.append(c)
elif w == 2:
cost2.append(c)
else:
cost3.append(c)
cost1 = sorted(cost1)[::-1]
cost2 = sorted(cost2)[::-1]
cost3 = sorted(cost3)[::-1]
cost3_prefix = [0]
for c in cost3:
cost3_prefix.append(cost3_prefix[-1] + c)
dp = [(0, 0, 0)] * (m + 1)
dp[0] = (0, 0, 0)
for i in range(0, m):
cost, n1, n2 = dp[i]
if i + 1 <= m and n1 < len(cost1):
new_cost = cost + cost1[n1]
if dp[i + 1][0] < new_cost:
dp[i + 1] = (new_cost, n1 + 1, n2)
if i + 2 <= m and n2 < len(cost2):
new_cost = cost + cost2[n2]
if dp[i + 2][0] < new_cost:
dp[i + 2] = (new_cost, n1, n2 + 1)
if n1 == len(cost1) and n2 == len(cost2):
break
dp_prefix = [0]
for x in dp[1:]:
dp_prefix.append(max(dp_prefix[-1], x[0]))
ans = 0
for k in range(len(cost3) + 1):
l = m - 3 * k
if l < 0:
continue
new_ans = cost3_prefix[k] + dp_prefix[l]
ans = max(new_ans, ans)
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 7,190 | 10 | 14,381 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10 | instruction | 0 | 7,191 | 10 | 14,382 |
Tags: binary search, dp, greedy, ternary search
Correct Solution:
```
import sys
from itertools import accumulate
n, m = map(int, sys.stdin.buffer.readline().decode('utf-8').split())
items = [[], [], [], []]
for w, c in (map(int, line.decode('utf-8').split()) for line in sys.stdin.buffer):
items[w].append(c)
for i in range(1, 4):
items[i].sort(reverse=True)
n_w1, n_w2 = len(items[1]), len(items[2])
dp = [0]*(m+3)
dp_w1, dp_w2 = [0]*(m+3), [0]*(m+3)
for i in range(m+1):
if i > 0 and dp[i-1] > dp[i]:
dp[i] = dp[i-1]
dp_w1[i], dp_w2[i] = dp_w1[i-1], dp_w2[i-1]
if dp_w1[i] < n_w1 and dp[i+1] < dp[i] + items[1][dp_w1[i]]:
dp[i+1] = dp[i] + items[1][dp_w1[i]]
dp_w1[i+1] = dp_w1[i] + 1
dp_w2[i+1] = dp_w2[i]
if dp_w2[i] < n_w2 and dp[i+2] < dp[i] + items[2][dp_w2[i]]:
dp[i+2] = dp[i] + items[2][dp_w2[i]]
dp_w1[i+2] = dp_w1[i]
dp_w2[i+2] = dp_w2[i] + 1
items[3] = [0] + list(accumulate(items[3]))
ans = 0
for i in range(len(items[3])):
if i*3 > m:
break
ans = max(ans, items[3][i] + dp[m - i*3])
print(ans)
``` | output | 1 | 7,191 | 10 | 14,383 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10 | instruction | 0 | 7,192 | 10 | 14,384 |
Tags: binary search, dp, greedy, ternary search
Correct Solution:
```
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
dp = [0]*(m + 1)
used = [[0]*2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max(pf[k] + dp[m - 3*k] for k in range(min(len(pf),m // 3 + 1)))
print(ans)
if __name__ == '__main__':
solve()
``` | output | 1 | 7,192 | 10 | 14,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10 | instruction | 0 | 7,193 | 10 | 14,386 |
Tags: binary search, dp, greedy, ternary search
Correct Solution:
```
n,m = map(int,input().split())
a = [[],[],[]]
for _ in range(n):
x,y = map(int,input().split())
a[x-1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0,a_length[0]-1,2):
a_one_even.append(a[0][i]+a[0][i+1])
for i in range(1,a_length[0]-1,2):
a_one_odd.append(a[0][i]+a[0][i+1])
data_even = sorted(a_one_even+a[1],reverse=True)
data_odd = sorted(a_one_odd+a[1],reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1]+x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1]+x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1]+x)
ans = 0
#print(data_sum_odd,data_sum_even,data_sum_three)
for k in range(a_length[2]+1):
if m-3*k < 0:break
now1,now2 = data_sum_three[k],data_sum_three[k]
if (m-3*k)%2== 0:
now1 += data_sum_even[min((m-3*k)//2,len(data_sum_even)-1)]
if a_length[0] > 0 and m-3*k > 0:
now2 += a[0][0]
if (m-3*k)//2 >= 1:
now2 += data_sum_odd[min((m-3*k)//2-1,len(data_sum_odd)-1)]
else:
now1 += data_sum_even[min((m-3*k)//2,len(data_sum_even)-1)]
if a_length[0] > 0 and m-3*k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m-3*k-1)//2,len(data_sum_odd)-1)]
ans = max(ans,now1,now2)
print(ans)
``` | output | 1 | 7,193 | 10 | 14,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10 | instruction | 0 | 7,194 | 10 | 14,388 |
Tags: binary search, dp, greedy, ternary search
Correct Solution:
```
def f():
n, m = map(int, input().split())
l = list(tuple(map(int, input().split())) for _ in range(n))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = [0] * 4, 0
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = [r], (None, [], [], [])
for w, c in l[i:]:
tail[w].append(c)
for w in 1, 2, 3:
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else: # m == 2
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
if __name__ == '__main__':
main()
``` | output | 1 | 7,194 | 10 | 14,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10 | instruction | 0 | 7,195 | 10 | 14,390 |
Tags: binary search, dp, greedy, ternary search
Correct Solution:
```
#Bhargey Mehta (Sophomore)
#DA-IICT, Gandhinagar
import sys, math, queue, bisect
#sys.stdin = open("input.txt", "r")
MOD = 10**9+7
sys.setrecursionlimit(1000000)
n, m = map(int, input().split())
c1, c2, c3 = [0], [0], [0]
for _ in range(n):
x, y = map(int, input().split())
if x == 3:
c3.append(y)
elif x == 2:
c2.append(y)
else:
c1.append(y)
c1.sort(reverse=True)
c2.sort(reverse=True)
c3.sort(reverse=True)
dp = [None for i in range(m+1)]
dp[0] = (0, 0, 0)
dp[1] = (c1[0], 1, 0)
for i in range(2, m+1):
if dp[i-1][1] == len(c1):
x1 = (dp[i-1][0], dp[i-1][1], dp[i-1][2])
else:
x1 = (dp[i-1][0]+c1[dp[i-1][1]], dp[i-1][1]+1, dp[i-1][2])
if dp[i-2][2] == len(c2):
x2 = (dp[i-2][0], dp[i-2][1], dp[i-2][2])
else:
x2 = (dp[i-2][0]+c2[dp[i-2][2]], dp[i-2][1], dp[i-2][2]+1)
if x1[0] > x2[0]:
dp[i] = x1
else:
dp[i] = x2
ans = 0
cost3 = 0
for i in range(len(c3)):
cost3 += c3[i-1]
cap = m - 3*i
if cap < 0: break
ans = max(ans, cost3+dp[cap][0])
print(ans)
``` | output | 1 | 7,195 | 10 | 14,391 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10 | instruction | 0 | 7,196 | 10 | 14,392 |
Tags: binary search, dp, greedy, ternary search
Correct Solution:
```
#!/usr/bin/env python3
[n, m] = map(int, input().strip().split())
wc = [[] for _ in range(4)] # w[0] unused
for _ in range(n):
w, c = map(int, input().strip().split())
wc[w].append(c)
for i in range(1, 4):
wc[i].sort(reverse=True)
iwc = [[0 for _ in range(len(wc[i]) + 1)] for i in range(4)]
for i in range(4):
for j in range(len(wc[i])):
iwc[i][j + 1] = iwc[i][j] + wc[i][j]
n1 = len(wc[1])
n2 = len(wc[2])
n3 = len(wc[3])
c12 = [(0, 0, 0) for _ in range(m + 1)]
for w in range(len(c12) - 1):
c, q1, q2 = c12[w]
c12[w + 1] = max(c12[w + 1], c12[w])
if q1 < n1:
c12[w + 1] = max(c12[w + 1], (iwc[1][q1 + 1] + iwc[2][q2], q1 + 1, q2))
if q2 < n2 and w + 2 < len(c12):
c12[w + 2] = max(c12[w + 2], (iwc[1][q1] + iwc[2][q2 + 1], q1, q2 + 1))
cmax = 0
for i in range(n3 + 1):
if 3 * i > m:
break
cmax = max(cmax, iwc[3][i] + c12[m - 3 * i][0])
print(cmax)
``` | output | 1 | 7,196 | 10 | 14,393 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10 | instruction | 0 | 7,197 | 10 | 14,394 |
Tags: binary search, dp, greedy, ternary search
Correct Solution:
```
import sys
n, m = map(int, input().split())
w1 = []
w2 = []
w3 = [10**10]
for w, c in (map(int, l.split()) for l in sys.stdin):
if w == 1:
w1.append(c)
elif w == 2:
w2.append(c)
else:
w3.append(c)
w1.sort(reverse=True)
w2.sort(reverse=True)
w3.sort(reverse=True)
w3[0] = 0
w1_size, w2_size = len(w1), len(w2)
dp = [(0, 0, 0) for _ in range(m+3)]
for i in range(m):
dp[i+1] = max(dp[i+1], dp[i])
if dp[i][1] < w1_size:
dp[i+1] = max(dp[i+1], (dp[i][0]+w1[dp[i][1]], dp[i][1]+1, dp[i][2]))
if dp[i][2] < w2_size:
dp[i+2] = max(dp[i+2], (dp[i][0]+w2[dp[i][2]], dp[i][1], dp[i][2]+1))
ans = 0
w3_c = 0
for i in range(len(w3)):
if i*3 > m:
continue
w3_c += w3[i]
ans = max(ans, w3_c + dp[m-i*3][0])
print(ans)
``` | output | 1 | 7,197 | 10 | 14,395 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
import sys
import bisect
from bisect import bisect_left as lb
input_=lambda: sys.stdin.readline().strip("\r\n")
from math import log
from math import gcd
from math import atan2,acos
from random import randint
sa=lambda :input_()
sb=lambda:int(input_())
sc=lambda:input_().split()
sd=lambda:list(map(int,input_().split()))
sflo=lambda:list(map(float,input_().split()))
se=lambda:float(input_())
sf=lambda:list(input_())
flsh=lambda: sys.stdout.flush()
#sys.setrecursionlimit(10**6)
mod=10**9+7
mod1=998244353
gp=[]
cost=[]
dp=[]
mx=[]
ans1=[]
ans2=[]
special=[]
specnode=[]
a=0
kthpar=[]
def dfs(root,par):
if par!=-1:
dp[root]=dp[par]+1
for i in range(1,20):
if kthpar[root][i-1]!=-1:
kthpar[root][i]=kthpar[kthpar[root][i-1]][i-1]
for child in gp[root]:
if child==par:continue
kthpar[child][0]=root
dfs(child,root)
ans=0
b=[]
def hnbhai(tc):
n,m=sd()
dp=[(0,0,0) for i in range(m+3)]
gp=[[] for i in range(4)]
for i in range(n):
w,c=sd()
gp[w].append(c)
gp[1].sort(reverse=True)
gp[2].sort(reverse=True)
gp[3].sort(reverse=True)
for i in range(0,m+1):
one=dp[i][1]
two=dp[i][2]
if one<len(gp[1]):
if dp[i+1][0]<dp[i][0]+gp[1][one]:
dp[i+1]=(dp[i][0]+gp[1][one],one+1,two)
if two<len(gp[2]):
dp[i+2]=(dp[i][0]+gp[2][two],one,two+1)
for i in range(1,m+1):
dp[i]=max(dp[i-1],dp[i])
#print(dp)
ans=dp[m][0]
tot=0
for i in range(len(gp[3])+1):
if 3*i<=m:
ans=max(dp[m-3*(i)][0]+tot,ans)
if i<len(gp[3]):
tot+=gp[3][i]
print(ans)
for _ in range(1):
hnbhai(_+1)
``` | instruction | 0 | 7,198 | 10 | 14,396 |
Yes | output | 1 | 7,198 | 10 | 14,397 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
n, m = map(int, input().split())
d = [[] for i in range(3)]
res_odd = 0
res_even = 0
for i in range(n):
t1, t2 = map(int, input().split())
d[t1 - 1].append(t2)
d[0].sort()
d[2].sort(reverse=True)
c = d[1].copy()
if d[0]:
i = len(d[0]) - 2
while i >= 1:
c.append(d[0][i] + d[0][i - 1])
i -= 2
c.sort(reverse=True)
pref = [0 for i in range(len(c) + 1)]
pref[0] = 0
for i in range(1, len(c) + 1):
pref[i] = pref[i - 1] + c[i - 1]
p = 0
for i in range(min(len(d[2]), (m - 1) // 3) + 1):
if i != 0:
p += d[2][i - 1]
res_odd = max(res_odd, d[0][-1] + p + pref[min(max(m - i * 3 - 1, 0) // 2, len(pref) - 1)])
i = len(d[0]) - 1
while i >= 1:
d[1].append(d[0][i] + d[0][i - 1])
i -= 2
d[1].sort(reverse=True)
pref = [0 for i in range(len(d[1]) + 1)]
pref[0] = 0
for i in range(1, len(d[1]) + 1):
pref[i] = pref[i - 1] + d[1][i - 1]
p = 0
for i in range(min(len(d[2]), m // 3) + 1):
if i != 0:
p += d[2][i - 1]
res_even = max(res_even, p + pref[min(max(m - i * 3, 0) // 2, len(pref) - 1)])
print(max(res_odd, res_even))
``` | instruction | 0 | 7,199 | 10 | 14,398 |
Yes | output | 1 | 7,199 | 10 | 14,399 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight+1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1]/x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const):
sum += weights[i]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum-3)
for weight in range(sum, down-1, -1):
ans[weight] = max(ans[weight], ans[weight-weights[i]]+value[i])
sol = max(sol, ans[weight])
return sol
if __name__ == '__main__':
N, M = map(int, input().split())
assert(N <= 10**5 and M <= 3*(10**5)), 'Out of range'
weights = []
value = []
for i in range(N):
x, y = map(int, input().split())
assert(x >= 1 and x <= 3), 'Out of range'
assert(y >= 1 and y <= 10**9), 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
``` | instruction | 0 | 7,200 | 10 | 14,400 |
Yes | output | 1 | 7,200 | 10 | 14,401 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
n, m = list(map(int, input().split()))
a = [[], [], []]
for i in range(n):
w, c = list(map(int, input().split()))
a[w-1].append(c)
p = [[0], [0], [0]]
for i in range(3):
a[i].sort(reverse=True)
for x in a[i]:
p[i].append(p[i][-1] + x)
ans = 0
for i in range(min(m//3, len(a[2])) + 1):
w = m - i * 3
if len(a[1]) * 2 + len(a[0]) <= w:
ans = max(ans, p[2][i] + p[1][len(a[1])] + p[0][len(a[0])])
continue
if not len(a[0]):
ans = max(ans, p[2][i] + p[1][min(w//2, len(a[1]))])
continue
if 2 + 2 == 4:
x = min(len(a[0]), w)
y = (w - x) // 2
ans = max(ans, p[2][i] + p[1][y] + p[0][x])
lo = max((w - len(a[0]) + 1) // 2 + 1, 1)
hi = min(len(a[1]), w // 2)
while lo <= hi:
mi = (lo + hi) // 2
if a[1][mi - 1] - (p[0][w-mi*2+2] - p[0][w-mi*2]) > 0:
lo = mi + 1
else:
hi = mi - 1
ans = max(ans, p[2][i] + p[1][hi] + p[0][w-hi*2])
print(ans)
``` | instruction | 0 | 7,201 | 10 | 14,402 |
Yes | output | 1 | 7,201 | 10 | 14,403 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
a = [int(x) for x in input().split()]
n = a[0]
m = a[1]
dp = [0]*(m+1)
ws = [[0,0,0],[0,0],[0]]
for p in range(n):
a = [int(x) for x in input().split()]
w = a[0]
c = a[1]
ws[w-1].append(c)
ws[0] = sorted(ws[0])[::-1]
ws[1] = sorted(ws[1])[::-1]
ws[2] = sorted(ws[2])[::-1]
if m == 1:
print ((ws[0][0]))
exit(0)
if m == 2:
print( max(ws[0][0] + ws[0][1], ws[1][0]))
exit(0)
if m == 3:
print (max(ws[0][0] + ws[0][1] + ws[0][2], ws[0][0] + ws[1][0], ws[2][0]))
exit(0)
dp[1] = (ws[0][0], [1,0,0])
if ws[0][0]+ws[0][1] <= ws[1][0]:
dp[2] = (ws[1][0], [0,1,0])
else:
dp[2] = (ws[0][0]+ws[0][1], [2,0,0])
if ws[2][0] == max(ws[0][0] + ws[0][1] + ws[0][2], ws[0][0] + ws[1][0], ws[2][0]):
dp[3] = (ws[2][0], [0,0,1])
elif ws[0][0] + ws[1][0] == max(ws[0][0] + ws[0][1] + ws[0][2], ws[0][0] + ws[1][0], ws[2][0]):
dp[3] = (ws[0][0]+ws[1][0], [1,1,0])
else:
dp[3] = (ws[0][0] + ws[0][1] + ws[0][2], [3,0,0])
#s1 = sum(ws[0]) + sum(ws[1]) + sum(ws[2])
#if s1 <= m:
# print(s1)
# exit(0)
for i in range(4, m+1):
# print (i, dp)
if dp[i-3] != 0 and len(ws[2]) > dp[i-3][1][2]:
c1 = dp[i-3][0] + ws[2][dp[i-3][1][2]]
z1 = c1-dp[i-3][0]
else:
z1 = 0
c1 = 0
if dp[i-2] != 0 and len(ws[1]) > dp[i-2][1][1]:
c2 = dp[i-2][0] + ws[1][dp[i-2][1][1]]
z2 = c2-dp[i-2][0]
else:
c2 = 0
z2 = 0
if dp[i-1] != 0 and len(ws[0]) > dp[i-1][1][0]:
c3 = dp[i-1][0] + ws[0][dp[i-1][1][0]]
z3 = c3-dp[i-1][0]
else:
c3 = 0
z3 = 0
z = [z1, z2, z3]
if c1 == max(c1, c2, c3) and c1 != 0:
tmp = [x for x in dp[i-3][1]]
tmp[2] += 1
dp[i] = (c1, tmp)
elif c2 == max(c1, c2, c3) and c2 != 0:
tmp = [x for x in dp[i-2][1]]
tmp[1] += 1
dp[i] = (c2, tmp)
elif c3 == max(c1, c2, c3) and c3 != 0:
tmp = [x for x in dp[i-1][1]]
tmp[0] += 1
dp[i] = (c3, tmp)
elif sum(z) == 0:
if (dp[i-1][0] == 24804061302924):
print ("24804061310402")
else:
print (dp[i-1][0])
exit(0)
if (dp[m][0] == 24804061302924):
print ("24804061310402")
else:
print (dp[m][0])
``` | instruction | 0 | 7,202 | 10 | 14,404 |
No | output | 1 | 7,202 | 10 | 14,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
w[wi - 1].append(ci)
w[0].sort(reverse=True)
w[1].sort(reverse=True)
w[2].sort(reverse=True)
m0 = len(w[0])
m1 = len(w[1])
m2 = len(w[2])
dp = [0] * (m + 1)
used = [[0]*3 for i in range(m + 1)]
if m0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0, 0]
else:
pass
if m == 1:
print(dp[1])
return
if m0 > 1:
dp[2] = dp[1] + w[0][1]
used[2] = [2, 0, 0]
else:
dp[2] = dp[1]
used[2] = used[1][:]
if m1 > 0 and w[1][0] > dp[2]:
dp[2] = w[1][0]
used[2] = [0, 1, 0]
if m == 2:
print(dp[2])
return
for i in range(3, m + 1):
if used[i - 1][0] < m0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
if used[i - 2][1] < m1 and dp[i - 2] + w[1][used[i - 2][1]] > dp[i]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
if used[i - 3][2] < m2 and dp[i - 3] + w[2][used[i - 3][2]] > dp[i]:
dp[i] = dp[i - 3] + w[2][used[i - 3][2]]
used[i] = used[i - 3][:]
used[i][2] += 1
ans = dp[m]
print(ans)
if __name__ == '__main__':
solve()
``` | instruction | 0 | 7,203 | 10 | 14,406 |
No | output | 1 | 7,203 | 10 | 14,407 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
import sys
n, m = map(int, input().split())
w1 = [10**10]
w2 = [10**10]
w3 = [10**10]
for w, c in (map(int, l.split()) for l in sys.stdin):
if w == 1:
w1.append(c)
elif w == 2:
w2.append(c)
else:
w3.append(c)
w1.sort(reverse=True)
w1[0] = 0
for i in range(len(w1)-1):
w1[i+1] += w1[i]
w2.sort(reverse=True)
w2[0] = 0
for i in range(len(w2)-1):
w2[i+1] += w2[i]
w3.sort(reverse=True)
w3[0] = 0
for i in range(len(w3)-1):
w3[i+1] += w3[i]
w1_size, w2_size = len(w1)-1, len(w2)-1
ans = 0
for c3 in range(len(w3)):
if c3*3 > m:
break
if c3*3 == m:
ans = max(ans, w3[c3])
break
W = m - c3*3
l, r = 0, min(W//2, w2_size)
while r-l > 1:
ml, mr = l+(r-l+2)//3, r-(r-l+2)//3
c1 = w2[ml] + w1[min(W-ml*2, w1_size)]
c2 = w2[mr] + w1[min(W-mr*2, w1_size)]
if c1 > c2:
r = mr
else:
l = ml
ans = max(ans,
w3[c3] + w2[l]+w1[min(W-l*2, w1_size)],
w3[c3] + w2[r]+w1[min(W-r*2, w1_size)]
)
print(ans)
``` | instruction | 0 | 7,204 | 10 | 14,408 |
No | output | 1 | 7,204 | 10 | 14,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 β€ n β€ 100000, 1 β€ m β€ 300000) β the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 β€ wi β€ 3, 1 β€ ci β€ 109) β the weight and the cost of ith souvenir.
Output
Print one number β maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
m0 = len(w[0])
m1 = len(w[1])
m2 = len(w[2])
# print(w)
dp = [0] * (m + 1)
used = [[0]*3 for i in range(m + 1)]
for i in range(1, m + 1):
tmp = 0
tmp_u = []
if used[i - 1][0] < m0:
tmp = dp[i - 1] + w[0][used[i - 1][0]]
tmp_u = used[i - 1][:]
tmp_u[0] += 1
else:
tmp = dp[i - 1]
tmp_u = used[i - 1][:]
if i - 2 < 0:
dp[i] = tmp
used[i] = tmp_u[:]
continue
if used[i - 2][1] < m1 and tmp < dp[i - 2] + w[1][used[i - 2][1]]:
tmp = dp[i - 2] + w[1][used[i - 2][1]]
tmp_u = used[i - 2][:]
used[i][1] += 1
if i - 3 < 0:
dp[i] = tmp
used[i] = tmp_u[:]
continue
if used[i - 3][2] < m2 and tmp < dp[i - 3] + w[2][used[i - 3][2]]:
tmp = dp[i - 3] + w[2][used[i - 3][2]]
tmp_u = used[i - 3][:]
used[i][2] += 1
dp[i] = tmp
used[i] = tmp_u[:]
# print(dp)
# print(used)
ans = dp[m]
print(ans)
if __name__ == '__main__':
solve()
``` | instruction | 0 | 7,205 | 10 | 14,410 |
No | output | 1 | 7,205 | 10 | 14,411 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.