Search is not available for this dataset
name stringlengths 2 112 | description stringlengths 29 13k | source int64 1 7 | difficulty int64 0 25 | solution stringlengths 7 983k | language stringclasses 4 values |
|---|---|---|---|---|---|
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, k;
const int sz = 1e6;
long long a[sz];
int main() {
cin >> n >> a[0];
for (int i = 1; i < n; i++) cin >> a[i], a[i] += a[i - 1];
int t, x, l = 0, h = n - 1, mid, res;
cin >> t;
while (t--) {
res = l = 0;
h = n - 1;
cin >> x;
while (l <= h) {
mid = (l + h) / 2;
if (a[mid] < x)
l = mid + 1;
else {
res = mid + 1;
h = mid - 1;
}
}
cout << res << '\n';
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
cin >> m;
vector<long long int> b(m);
for (long long int i = 0; i < m; i++) cin >> b[i];
vector<long long int> c(n);
c[0] = a[0];
for (long long int i = 1; i < n; i++) c[i] = c[i - 1] + a[i];
vector<long long int>::iterator x;
for (long long int i = 0; i < m; i++) {
x = lower_bound(c.begin(), c.end(), b[i]);
cout << x - c.begin() + 1 << " ";
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const int MAX = 2003;
class pile {
public:
long long first, last;
pile() { first = last = 0; }
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m, q, A;
cin >> n;
pile a[n + 1];
for (int i = 1; i <= n; ++i) {
cin >> A;
a[i].first = a[i - 1].last + 1;
a[i].last = a[i - 1].last + A;
}
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> q;
long long lo = 1, hi = n, mid;
while (1) {
mid = (lo + hi) / 2;
if (q > a[mid].last)
lo = mid + 1;
else if (q < a[mid].first)
hi = mid - 1;
else
break;
}
cout << mid << '\n';
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigDecimal;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author Rafael Regis
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastReader in = new FastReader(inputStream);
FastWriter out = new FastWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
}
class TaskB {
public void solve(int testNumber, FastReader in, FastWriter out) {
int n = in.nextInt();
int[] an = in.nextIntArray(n);
int[] bn = new int[n];
int acc = an[0] + 1;
bn[0] = 1;
for (int i = 1; i < n; i++) {
bn[i] = acc;
acc += an[i];
}
int m = in.nextInt();
for (int i = 0; i < m; i++) {
int a = in.nextInt();
int index = Arrays.binarySearch(bn, a) + 1;
if (index < 0) index = -index;
out.println(index);
}
}
}
class FastReader {
private BufferedReader reader;
private StringTokenizer tokenizer;
public FastReader(InputStream stream) {
this.reader = new BufferedReader(new InputStreamReader(stream));
this.tokenizer = new StringTokenizer("");
}
public String next() {
return ensureTokens() ? tokenizer.nextToken() : null;
}
private boolean ensureTokens() {
while(!tokenizer.hasMoreTokens()){
try{
tokenizer = new StringTokenizer(reader.readLine());
} catch (Exception e){
return false;
}
}
return true;
}
public int nextInt() {
return Integer.parseInt(next());
}
public int[] nextIntArray(int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++) {
array[i] = nextInt();
}
return array;
}
}
class FastWriter {
private final PrintWriter printWriter;
public FastWriter(OutputStream stream) {
printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(stream)));
}
public FastWriter(Writer writer) {
printWriter = new PrintWriter(writer);
}
public void close() {
printWriter.close();
}
public void println(int element) {
printWriter.println(element);
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import bisect
n=int(input())
s=input()
s=s.split()
t=[1]
for i in range(n):
t.append(t[i]+int(s[i]))
t=sorted(t)
q=int(input())
a=input()
a=a.split()
for i in range(q):
p=bisect.bisect_left(t,int(a[i]))
if (int(a[i])==t[p]):
print(p+1)
else:
print(p)
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import bisect
N = int(input())
A = list(map(int, input().split()))
M = int(input())
Q = list(map(int, input().split()))
now = 0
R = []
for a in A:
right = now + a
R.append(right)
now = right
for q in Q:
ind = bisect.bisect_left(R, q)
print(ind + 1)
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | length=input()
a=[]
last=0
summation=[]
def kanu(query):
low=0
high=length-1
middle=(high-low)/2
while low!=high and high-low!=1:
if(query==summation[middle]):
return middle+1
elif(query>summation[middle]):
low=middle
elif(query<summation[middle]):
high=middle
middle=low+(high-low)/2
if low==high:
if query<summation[low]:
return low
else:
low+1
else:
if query<=summation[low]:
return low+1
else:
return high+1
size=map(int,raw_input().split())
for i in range(length):
summation.append(size[i]+last)
last=summation[i]
n=input()
query=map(int,raw_input().split())
for i in range(n):
ans=kanu(query[i])
print ans
| PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | nPiles = input()
nWormPile = input().split(' ')
nJuicyWorm = input()
labelJuicy = input().split(' ')
iWorms = []
idxPile = 0
for i in range(int(nPiles)):
idxPile += 1
for j in range(int(nWormPile[i])):
iWorms.append(idxPile)
for i in range(int(nJuicyWorm)):
print(iWorms[int(labelJuicy[i])-1]) | PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Zad474B {
public static void main(String[] args) {
// TODO Auto-generated method stub
FastReader sc = new FastReader();
int n = sc.nextInt();
StringBuilder answer = new StringBuilder();
int[] aLastCherv = new int[n+1];
for(int i = 1;i<=n;i++) {
aLastCherv[i]=aLastCherv[i-1]+sc.nextInt();
}
int m = sc.nextInt();
for(int i = 0;i<m;i++) {
int t = sc.nextInt();
int k = 0;
for(int j = n/2;j>=1;j/=2) {
while(j+k<n && aLastCherv[j+k]<t) k+=j;
}
answer.append(k+1+"\n");
}
System.out.print(answer);
}
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | //package CodeforcesRoundN271;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class B {
private static BufferedReader in;
private static StringTokenizer st;
public static void main(String[] args) throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
in = new BufferedReader(isr);
st = new StringTokenizer("");
int n = nextInt();
int []a=new int[n+1];
int []c=new int[3000000];
int x=1, y=0;
for (int i=1; i<=n; i++) {
a[i]= nextInt();
y+=a[i];
for (int j=x; j<=y; j++) {
c[j]=i;
}
x=y+1;
}
int m= nextInt();
for (int i=1; i<=m; i++) {
int x1 = nextInt();
System.out.println(c[x1]);
}
}
private static int nextInt() throws NumberFormatException, IOException {
return Integer.parseInt(next());
}
private static String next() throws IOException {
while(!st.hasMoreElements()){
st = new StringTokenizer(in.readLine());
}
return st.nextToken();
}
} | JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | def binary_search(arr, key, start, end):
mid = start + (end-start)/2
if start > end:
return mid + 1
if arr[mid] == key:
return mid
elif arr[mid] > key:
return binary_search(arr, key, start=start, end = mid-1)
else:
return binary_search(arr, key, start=mid+1, end=end)
number_piles = input()
piles = map(int, raw_input().split())
cum_sum = [_ for _ in piles]
for i in range(1, len(piles)):
cum_sum[i] += cum_sum[i-1]
num_queries = input()
queries = map(int, raw_input().split())
for i in queries:
print binary_search(cum_sum, i, 0, number_piles) + 1
| PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | def binary(aim, start, end):
mid = (start + end) // 2
if a[mid] == aim:
return mid
if start >= end:
return end
if a[mid] > aim:
return binary(aim, start, mid - 1)
else:
return binary(aim, mid + 1, end)
inp = lambda : [*map(int, input().split())]
n = int(input())
a = inp()
for i in range(1, n):
a[i] += a[i - 1]
a = [0] + a + [10 ** 6 + 1]
m = int(input())
for i in inp():
position = binary(i, 0, n + 1)
if a[position - 1] < i <= a[position]:
print(position)
continue
if a[position] < i <= a[position + 1]:
print(position + 1)
continue | PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | '''def find_indx(x) :
low=0
up=n-1
smaller=False
greater=False
while low<=up :
m=(low+up)/2
if x>s[m] :
if smaller==True :
return m+1
low=m+1
greater=True
elif x<s[m] :
if greater==True :
return m-1
up=m-1
smaller=True
else :
return m+1
return 1'''
n=int(input())
a=map(int,raw_input().split())
m=int(input())
ans=[0]
for i in xrange(n) :
num=a[i]
while num>0 :
ans.append(i+1)
num-=1
worms=map(int,raw_input().split())
for w in worms :
print ans[w]
| PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.util.Scanner;
import java.io.PrintWriter;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int n = sc.nextInt();
int[] which = new int[1000001];
int last = 0;
for (int i = 0; i < n; i++) {
int x = sc.nextInt();
while (x --> 0) {
which[++last] = i + 1;
}
}
int q = sc.nextInt();
while (q --> 0) {
int x = sc.nextInt();
pw.println(which[x]);
}
pw.close();
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m, x, a[100006], Ans[1000006];
inline void in(int &x) {
char c;
while (!isdigit((c = getchar())) && c ^ '-')
;
bool f = (c == '-');
if (f) (c = getchar());
for (x = 0; isdigit(c); (c = getchar())) x = x * 10 - 48 + c;
if (f) x = -x;
}
int main() {
in(n);
for (int i = 1; i <= n; ++i) in(a[i]), a[i] += a[i - 1];
for (int i = 1; i <= n; ++i)
for (int j = a[i - 1] + 1; j <= a[i]; ++j) Ans[j] = i;
in(m);
for (int i = 1; i <= m; ++i) in(x), printf("%d\n", Ans[x]);
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | n = int(input())
piles = [int(x) for x in input().split()]
worms = int(input())
labels = [int(x) for x in input().split()]
L = []
k = 1
for x in range(len(piles)):
L.extend([k]*piles[x])
k += 1
for l in labels:
print(L[l-1])
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int N = 1000009;
int n, a[N] = {}, k = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
for (int j = k; j < k + x; j++) a[j] = i;
k += x;
}
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
printf("%d\n", a[x - 1] + 1);
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import sys
def bin_search(plist, nu):
lo = 0
hi = len(plist) - 1
prober = ((lo + hi) / 2)
prev_prober = -1
while prober != prev_prober:
prev_prober = prober
if nu < plist[prober]:
hi = prober
elif nu > plist[prober]:
lo = prober
else:
return prober
prober = (lo + hi) / 2
return prober
num_piles = int(sys.stdin.readline())
pile_ids = [int(x) for x in sys.stdin.readline().strip().split()]
ctr = 0
acc = [0]
for x in pile_ids:
ctr += x
acc.append(ctr)
num_queries = int(sys.stdin.readline())
queries = [int(x) - 1 for x in sys.stdin.readline().strip().split()]
for x in queries:
print bin_search(acc, x) + 1
| PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | n=int(input())
w=list(map(int,input().split()))
m=int(input())
q=list(map(int,input().split()))
pre=[w[0]]
for i in range(1,n):
pre.append(pre[i-1]+w[i])
for i in q:
left=0
right=n-1
ans=0
while(left<=right):
mid=left+(right-left)//2
if(pre[mid]>=i):
ans=mid
right=mid-1
else:
left=mid+1
print(ans+1)
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.io.*;
import java.util.*;
/**
* Created by radoslav on 12/7/2014.
*/
public class B implements Runnable{
class TaskB{
int n;
int[] a;
int m;
int[] q;
int[] map = new int[1000000];
TaskB(int n,int[] a, int m, int[] q){
this.n = n;
this.a= a;
this.m = m;
this.q = q;
}
private int search(int x, int[] S){
int left=0;
int right=n-1;
for(int iter=0;iter<100;iter++){
int mid = (left+right)/2;
if(S[mid] >= x){
right = mid;
}else{
left=mid;
}
}
//System.out.println(left + " " + right);
return right;
}
public List<Integer> solve(){
List<Integer> answer = new ArrayList();
int[] S = new int[n];
S[0]= a[0];
for(int i=1;i<n;i++){
S[i]=S[i-1] + a[i];
}
for(int i=0;i<q.length;i++){
answer.add(search(q[i],S));
}
return answer;
}
}
public int readInt() throws Exception {
return Integer.parseInt(readword());
}
public double readDouble() throws Exception {
return Double.parseDouble(readword());
}
public long readLong() throws Exception {
return Long.parseLong(readword());
}
public void run() {
try {
in = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
int n = readInt();
int[] a = new int[n];
for(int i=0;i<n;i++){
a[i]= readInt();
}
int m = readInt();
int[] q = new int[m];
for(int i=0;i<m;i++){
q[i] = readInt();
}
List<Integer> ans = new TaskB(n,a,m,q).solve();
for(Integer r : ans){
out.println(r+1);
}
out.close();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
private BufferedReader in;
public String readword() throws IOException {
StringBuilder b = new StringBuilder();
int c;
c = in.read();
while (c >= 0 && c <= ' ')
c = in.read();
if (c < 0)
return "";
while (c > ' ') {
b.append((char) c);
c = in.read();
}
return b.toString();
}
public static void main(String[] args) throws Exception {
new Thread(new B()).start();
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int upper(vector<int>& vec, int a) {
vector<int>::iterator uppers;
uppers = std::upper_bound(vec.begin(), vec.end(), a);
return uppers - vec.begin();
}
int main() {
int n;
cin >> n;
vector<int> vec;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
vec.push_back(a - 1);
}
vector<int> vec2;
int m = 0;
for (int i = 0; i < n; i++) {
m = m + 1;
vec2.push_back(m);
m = m + vec[i];
vec2.push_back(m);
}
int w;
cin >> w;
vector<int> vec3;
while (w--) {
int a;
cin >> a;
vec3.push_back(a);
}
for (int i = 0; i < vec3.size(); i++) {
int u = upper(vec2, vec3[i]) + 1;
cout << u / 2 << "\n";
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | from bisect import bisect_left
n1=int(input())
a=[int(i) for i in input().split()]
n2=int(input())
c1=[int(i) for i in input().split()]
c=[]
c12=0
k12=0
lb=0
ub=n1
mid=(lb+ub)/2
for i in range(n1):
c12+=a[i]
c.append(c12)
#print(c)
for i in range(n2):
b=c1[i]
if b<c[0]:
print(1)
else:
k12=bisect_left(c, b)
print(k12+1)
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import bisect
def solve(d, x):
return bisect.bisect_left(d, x)+1
n = int(raw_input())
a = map(int, raw_input().split())
m = int(raw_input())
q = map(int, raw_input().split())
d = [a[0]]
for i in range(1, len(a)):
d.append(d[i-1]+a[i])
for x in q:
print solve(d, x) | PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | n = int(input())
a = [int(i) for i in input().split()]
m = int(input())
q = [int(i) for i in input().split()]
worm = []
for i in range(n):
for j in range(a[i]):
worm.append(i+1)
for i in range(m):
print(worm[q[i]-1])
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
int b[1000010];
int main() {
int n, m, i, j, k;
int a;
while (~scanf("%d", &n)) {
j = 1;
for (i = 1; i <= n; i++) {
scanf("%d", &a);
while (a--) b[j++] = i;
}
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d", &k);
printf("%d\n", b[k]);
}
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import bisect
n=int(input())
l=[int(i) for i in input().split()]
m=int(input())
a=[int(i) for i in input().split()]
sum=0
k=0
for i in range(n):
sum+=l[i]
l[i]=sum
#print(l)
for i in range(m):
x=bisect.bisect_left(l,a[i])
print(x+1)
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | L=[]
input()
r=1
for k in input().split():
L+=[r]*int(k)
r+=1
input()
for j in input().split():
print(L[int(j)-1])
# Made By Mostafa_Khaled | PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int bi_search(int a[], int n, int x) {
int fst = 0, lst = n - 1, mid;
while (fst <= lst) {
mid = (fst + lst) / 2;
if (a[mid] == x) return (mid + 1);
if (a[mid] > x)
lst = mid - 1;
else
fst = mid + 1;
}
return fst + 1;
}
void solve() {
int n;
cin >> n;
int a[n];
cin >> a[0];
for (int i = 1; i < n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
int q;
cin >> q;
int b[q];
for (int i = 0; i < q; i++) cin >> b[i];
for (int i = 0; i < q; i++) {
int r = b[i];
int ans = bi_search(a, n, r);
cout << ans << endl;
}
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int bs(int b1, int b2, int temp, int n, int a[]) {
int mid = (b1 + b2) / 2;
if (mid == 0) {
return 1;
} else if (temp <= a[mid]) {
if (temp > a[mid - 1])
return mid + 1;
else
return bs(b1, mid, temp, n, a);
} else {
return bs(mid + 1, b2, temp, n, a);
}
}
int main() {
long int n;
cin >> n;
int a[n];
long int s = 0;
cin >> a[0];
for (long int i = 1; i < n; i++) {
cin >> s;
a[i] = a[i - 1] + s;
}
long m;
cin >> m;
long int temp;
for (long int i = 0; i < m; i++) {
cin >> temp;
cout << bs(0, n - 1, temp, n, a);
cout << endl;
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
int main() {
int n, i, a[1000000], k, j = 1;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &k);
while (k--) {
a[j] = i + 1;
j++;
}
}
int m;
scanf("%d", &m);
while (m--) {
int g;
scanf("%d", &g);
printf("%d\n", a[g]);
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long long a[1000001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long x;
a[0] = 0;
map<long long, long long> m;
for (int i = 1; i <= n; i++) {
cin >> x;
a[i] = x + a[i - 1];
}
long long j = 1;
for (long long i = 1; i <= a[n]; i++) {
if (i > a[j]) j++;
m[i] = j;
}
long long b;
cin >> b;
while (b--) {
long long c;
cin >> c;
cout << m[c] << endl;
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int arr[(int)1e5 + 1];
int q[(int)1e5 + 1];
int sol[(int)1e5 + 1];
int main() {
int n, m;
cin >> n;
cin >> arr[0];
for (int i = 1; i < n; i++) {
int x;
cin >> x;
arr[i] = arr[i - 1] + x;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> q[i];
}
for (int i = 0; i < m; i++) {
int lo = 0, hi = n - 1, res = -1;
while (lo <= hi) {
int md = (hi + lo) >> 1;
if (arr[md] >= q[i] && q[i] >= arr[md - 1]) {
hi = md - 1;
res = md;
} else if (arr[md] >= q[i])
hi = md - 1;
else
lo = md + 1;
}
sol[i] = res + 1;
}
for (int i = 0; i < m; i++) {
cout << sol[i] << endl;
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | def f():
n=int(input())
A=list(map(int,input().split()))
m=int(input())
B=list(map(int,input().split()))
A_2=[0]*len(A)
A_2[0]=A[0]
for i in range(1,len(A)):
A_2[i]=A_2[i-1]+A[i]
for i in range(len(B)):
left = -1
right = len(A)-1
while right > left + 1:
middle = (left + right) // 2
if A_2[middle] >= B[i]:
right = middle
else:
left = middle
print(right+1)
f()
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int q[n], m, sum = 0;
q[0] = 0;
for (long long int i = 1; i <= n; i++) {
cin >> m;
q[i] = q[i - 1] + m;
sum += m;
}
long long int arr[sum + 1], index = 1;
for (long long int i = 1; i <= sum; i++) {
if (i > q[index]) index++;
arr[i] = index;
}
long long int r;
cin >> r;
while (r--) {
long long int s;
cin >> s;
cout << arr[s] << endl;
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.util.Scanner;
public class P474B {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int p[]= new int[n];
int sum=1;
for(int i = 0 ; i<n ; i++)
{p[i]=in.nextInt(); sum+=p[i];}
int a[]= new int[sum];
int pile=1;
int j=1;
int r=0;
for(int i=1; i<=n; i++)
{
for(int y=1; y<=p[r]; y++)
{a[j]=pile; j++;}
pile++;
r++;
}
int t = in.nextInt();
for(int u= 1; u<=t;u++)
{int l = in.nextInt();
System.out.println(a[l]);
}
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | /**
* Created by mohammad on 8/27/16.
*/
import java.util.*;
public class Problem474B {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] worms = new int[n];
worms[0] = sc.nextInt();
for (int i = 1; i < n; i++)
worms[i] = worms[i-1] + sc.nextInt();
int m = sc.nextInt();
int[] juicy = new int[m];
for (int i = 0; i < m; i++)
juicy[i] = sc.nextInt();
int[] result = new int[m];
sc.close();
for (int i = 0; i < m ;i++)
result[i] = binarySearch(worms, juicy[i], 0, n-1);
for (int i = 0; i < m; i++)
System.out.println(result[i]);
}
public static int binarySearch(int[] worms, int e, int begin, int end){
int mid = 0, left = begin, right = end;
for (int i = 0; i < 200; i++){
mid = (left + right) >> 1;
if (e > worms[mid])
left = mid;
else
right = mid;
}
if (e > worms[mid])
mid++;
return mid + 1;
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.util.*;
import java.io.*;
public class Main{
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer st = new StringTokenizer("");
public static int nextInt(){
try{
if(! st.hasMoreTokens()){
st = new StringTokenizer(br.readLine());
}
}catch(IOException e){}
return Integer.parseInt(st.nextToken());
}
public static void main(String... args){
int n = nextInt();
int arr[] = new int[n];
arr[0] = nextInt();
for(int i=1;i<n;i++){
arr[i] = nextInt()+arr[i-1];
}
int m = nextInt();
while(m-->0){
System.out.println(search(arr,nextInt(),0,n-1)+1);
}
}
public static int search(int[] data,int key,int start,int end){
if(start == end) return start;
if(key > data[(start+end)/2]){
return search(data,key,(start+end)/2+1,end);
}else{
return search(data,key,start,(start+end)/2);
}
}
} | JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long n, m, temp, p, q;
int main() {
cin >> n;
long a[n];
for (int i = 0; i < n; i++) {
cin >> p;
temp += p;
a[i] = temp;
}
cin >> m;
long b[m];
for (int i = 0; i < m; i++) {
cin >> p;
q = lower_bound(a, a + n, p) - a;
b[i] = q + 1;
}
for (int i = 0; i < m; i++) {
cout << b[i] << endl;
}
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | n=int(input())
a=list(map(int,input().split()))
m=int(input())
q=list(map(int,input().split()))
li=[0]
cur=1
s=0
for i in range(1,sum(a)+1):
if i>s+a[cur-1]:
s+=a[cur-1]
cur+=1
li.append(cur)
for i in q:
print(li[i])
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | l=[]
n=input()
a=map(int,raw_input().split(' '))
for i in range(n):
l+=[i+1]*a[i]
m=input()
q=map(int,raw_input().split(' '))
for i in q:
print l[i-1]
| PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int num[100007];
int main() {
vector<pair<int, int> > data;
int curr = 0;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num[i];
data.push_back(make_pair(curr + 1, curr + num[i]));
curr = curr + num[i];
}
int m;
cin >> m;
int x;
for (int i = 0; i < m; i++) {
cin >> x;
int s = 0, e = n - 1;
int ans;
while (s <= e) {
int mid = s + (e - s) / 2;
if (x >= data[mid].first && x <= data[mid].second) {
ans = mid + 1;
break;
} else if (x >= data[mid].first && x >= data[mid].second) {
s = mid + 1;
} else
e = mid - 1;
}
cout << ans << endl;
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | from bisect import bisect_left
n = int(input())
n1 = input().split()
lista = []
valor = 0
for e in n1:
valor += int(e)
lista.append(valor)
m = int(input())
m1 = input().split()
for e in m1:
print(bisect_left(lista, int(e)) + 1) | PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int n;
cin >> n;
int inp, prev = 1;
int *table = (int *)malloc(sizeof(int) * 1000001);
for (long long i = 0; i < n; i++) {
cin >> inp;
for (int j = prev; j <= prev + inp + 1; j++) {
table[j] = i + 1;
}
prev += inp;
}
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> inp;
cout << table[inp] << "\n";
}
free(table);
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author Asus
*/
import java.util.Scanner;
public class Chervi {
static int[] ans;
public static void main(String args[]) {
int sum = 0;
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = in.nextInt();
sum += arr[i];
}
int[] array = new int[sum + 1];
int i = 0;
int j = 1;
while (i < n) {
for (int k = 1; k <= arr[i]; k++) {
array[j] = i + 1;
j++;
}
i++;
}
int m = in.nextInt();
ans = new int[m];
for (int k = 0; k < m; k++) {
ans[k] = array[in.nextInt()];
}
for (Integer k : ans) {
System.out.println(k);
}
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
long long location = 1;
long long a_aux;
int array[n][2];
for (int i = 0; i < n; i++) {
scanf("%d", &a_aux);
array[i][0] = location;
array[i][1] = a_aux + location - 1;
location += a_aux;
}
int m, start, end, mid;
scanf("%d", &m);
location = 0;
int nasli = n;
for (int i = 0; i < m; i++) {
scanf("%d", &location);
mid = (nasli / 2);
start = 0;
end = nasli - 1;
while (true) {
if (location >= array[mid][0] && location <= array[mid][1]) {
printf("%d\n", mid + 1);
break;
} else if (location > array[mid][1]) {
start = mid;
} else {
end = mid;
}
if ((start + end) % 2 == 0) {
mid = (start + end) / 2;
} else if ((start + end) / 2 == mid) {
mid = (start + end + 1) / 2;
} else {
mid = (start + end - 1) / 2;
}
}
}
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | n = int(input())
a = input().split()
k = 1
c = []
for elim in a:
for i in range(int(elim)):
c.append(k)
k += 1
m = int(input())
b =input().split()
for elim in b:
print(c[int(elim)-1]) | PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 |
n=int(input())
a=list(map(int,input().split()))
for i in range(1,n):
a[i]=a[i]+a[i-1]
c=(a[n-1]+1)*[0]
c[0]=1
for i in range(n):
c[a[i]]=1
for i in range(1,len(c)):
c[i]=c[i]+c[i-1]
m=int(input())
w=list(map(int,input().split()))
for i in w:
print(c[i-1])
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.util.Scanner;
public class RENAMETHISBITCH {
public static void main(String[] args) {
try (Scanner sc = new Scanner(System.in)) {
int[] worms = new int[1000001];
int start = 0;
int n = sc.nextInt();
for (int i = 1; i <= n; i++) {
int pile = sc.nextInt();
for (int j = start + 1; j <= start + pile; j++) {
worms[j] = i;
}
start += pile;
}
int m = sc.nextInt();
for (int i = 0; i < m; i++) {
System.out.println(worms[sc.nextInt()]);
}
}
catch (Exception e) {
e.printStackTrace();
}
}
} | JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | num_piles = int(input())
worm_piles = list(map(int, input().split()))
num_juicy_worms = int(input())
juicy_worm_labels = list(map(int, input().split()))
bins = [] # ith num is min for the bin
running_sum = 1
for i in range(1, num_piles + 1):
if i == 1:
bins.append(running_sum)
running_sum += worm_piles[i - 1]
else:
bins.append(running_sum)
running_sum += worm_piles[i - 1]
# Output the bin the juicy worms are in
last_bin_idx = num_piles - 1
for juicy_worm_label in juicy_worm_labels:
if juicy_worm_label >= bins[last_bin_idx]: # don't need to do binary search since it's last
print(last_bin_idx + 1)
continue
mn = 0
mx = last_bin_idx
while mn <= mx:
mid_idx = (mn + mx) // 2
if bins[mid_idx] <= juicy_worm_label < bins[mid_idx + 1]:
print(mid_idx + 1)
break
if juicy_worm_label > bins[mid_idx]: # want to check greater vals
mn = mid_idx + 1 #if mn != mid_idx else mn + 1
else: # want to check lower vals
mx = mid_idx - 1 #if mx != mid_idx else mx - 1
# print('worm label: {}, mn: {}, mx: {}'.format(juicy_worm_label, mn, mx))
# for i in range(num_piles):
# if juicy_worm_label >= bins[last_bin_idx]:
# print(last_bin_idx + 1)
# break
# elif bins[i] <= juicy_worm_label < bins[i + 1]:
# print(i + 1)
# break
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author programajor
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
static class TaskB {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int n = in.nextInt();
int[] sum = new int[n];
int cummulative = 0;
for (int i = 0; i < n; i++) {
cummulative += in.nextInt();
sum[i] = cummulative;
}
int m = in.nextInt();
StringBuilder builder = new StringBuilder();
for (int i = 0; i < m; i++) {
int num = in.nextInt();
builder.append(search(sum, num) + "\n");
}
out.print(builder.toString());
}
private int search(int[] sum, int num) {
int ans = -1;
int left = 0;
int right = sum.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (sum[mid] == num) {
return mid + 1;
} else if (sum[mid] > num) {
ans = mid + 1;
right = mid - 1;
} else {
left = mid + 1;
}
}
return ans;
}
}
static class InputReader {
private BufferedReader reader;
private StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | def binarysearch(a,m,n):
i=0
l=n-1
while(i<=l):
mid=(i+l)//2
if a[mid]==m:
return mid
#print(mid,'mid')
if m>=a[mid] and m<=a[mid+1]:
return mid+1
elif m>a[mid]:
i=mid+1
#print('i',i)
else:
l=mid-1
#print('l',l)
n=int(input())
s=0
a=[1]
for i in input().split():
s=s+int(i)
a.append(s)
#print(a)
m=int(input())
b=[int(i) for i in input().split()]
for i in range(m):
if b[i]==1:
print(1)
else:
print(binarysearch(a,b[i],n)) | PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | n=int(input())
piles=list(map(int,input().split()))
m=int(input())
num=list(map(int,input().split()))
num2=sorted(num)
cnt=piles[0]
seq=1
dic={}
while num2:
if num2[0]<=cnt:
dic[num2[0]]=seq
del num2[0]
else:
cnt+=piles[seq]
seq+=1
for i in range(m):
print(dic[num[i]])
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | t = input
p = print
r = range
n, a = int(t()), list(map(int, t().split()))
m, b = int(t()), list(map(int, t().split()))
f = [0]
for i in range(n):
f += [i + 1] * a[i]
for x in b:
p(f[x])
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner ();
StringBuffer ans = new StringBuffer();
while (sc.hasNext()) {
int n = sc.nextInt();
long arr[] = new long[n+1];
arr[1]=sc.nextInt();
for (int i = 2; i < arr.length; i++) {
arr[i]=sc.nextInt()+arr[i-1];
}
int m = sc.nextInt();
for (int i = 0; i < m; i++) {
int ser = sc.nextInt();
//System.out.println(ser);
int top = arr.length-1 ;
int down = 0;
int mid = 0;
while (down<=top) {
mid = (top+down)/2;
if(arr[mid]<ser){
down = mid+1;
}else if (arr[mid]>ser) {
top=mid-1;
}else {
break;
}
}
if (arr[mid]<ser) {
ans.append((mid+1)+"\n");
}else {
ans.append(mid+"\n");
}
}
}
System.out.println(ans.toString());
}
static class Scanner implements Iterator<String> {
BufferedReader buffer;
StringTokenizer tok;
public Scanner() {
buffer = new BufferedReader(new InputStreamReader(System.in));
}
public boolean hasNext() {
while (tok == null || !tok.hasMoreElements()) {
try {
tok = new StringTokenizer(buffer.readLine());
} catch (Exception e) {
return false;
}
}
return true;
}
public String next() {
if (hasNext()) {
return tok.nextToken();
}
return null;
}
public void remove() {
return;
}
int nextInt() {
return Integer.parseInt(next());
}
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import bisect
input()
a = [0]
for x in map(int, input().split()):
a.append(a[-1] + x)
input()
for x in map(int, input().split()):
print(bisect.bisect_left(a, x)) | PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | //package com.company;
import java.io.*;
import java.util.*;
public class Main {
static long TIME_START, TIME_END;
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
// Scanner sc = new Scanner(new FileInputStream("Test.in"));
PrintWriter pw = new PrintWriter(System.out);
// PrintWriter pw = new PrintWriter(new FileOutputStream("Test.out"));
// PrintWriter pw = new PrintWriter(new FileOutputStream("Test.in"));
Runtime runtime = Runtime.getRuntime();
long usedMemoryBefore = runtime.totalMemory() - runtime.freeMemory();
TIME_START = System.currentTimeMillis();
Task t = new Task();
t.solve(sc, pw);
TIME_END = System.currentTimeMillis();
long usedMemoryAfter = runtime.totalMemory() - runtime.freeMemory();
pw.close();
// System.out.println("Memory increased:" + (usedMemoryAfter-usedMemoryBefore) / 1000000 );
// System.out.println("Time used: " + (TIME_END - TIME_START) + ".");
}
public static class Task {
public void solve(Scanner sc, PrintWriter pw) throws IOException {
int n = sc.nextInt();
int[] a = new int[n];
int total = 0;
for (int i = 0; i < n; i++) {
a[i] = sc.nextInt();
total += a[i];
}
int[] worms = new int[total];
int idx = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < a[i]; j++) {
worms[idx] = i;
idx++;
}
}
int m = sc.nextInt();
for (int i = 0; i < m; i++) {
int q = sc.nextInt() - 1;
pw.println(worms[q] + 1);
}
}
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s){ br = new BufferedReader(new InputStreamReader(s));}
public Scanner(FileReader s) throws FileNotFoundException {br = new BufferedReader(s);}
public String next() throws IOException
{
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {return Integer.parseInt(next());}
public long nextLong() throws IOException {return Long.parseLong(next());}
public String nextLine() throws IOException {return br.readLine();}
public double nextDouble() throws IOException { return Double.parseDouble(next()); }
public boolean ready() throws IOException {return br.ready();}
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 |
import java.math.BigInteger;
import java.sql.Array;
import java.util.*;
import java.lang.*;
import java.util.Arrays;
public class geek {
public static void main(String[] args) {
try {
Scanner s = new Scanner(System.in);
StringBuffer sb=new StringBuffer();
int n=s.nextInt();
int a[]=new int[n];
for(int i=0;i<n;i++){
a[i]=s.nextInt();
}
TreeSet<Integer> t=new TreeSet<>();
t.add(a[0]);
Map<Integer,Integer> mp=new HashMap<>();
mp.put(a[0],0);
for(int i=1;i<n;i++){
a[i]=a[i-1]+a[i];
t.add(a[i]);
mp.put(a[i],i);
//System.out.println(a[i]);
}
int m=s.nextInt();
int b[]=new int[m];
int c[]=new int[m];
for(int i=0;i<m;i++){
b[i]=s.nextInt();
c[i]=t.ceiling(b[i]);
sb.append((mp.get(c[i])+1)+"\n");
}
System.out.println(sb);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
} | JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | n = int(input())
arr, res = [], 1
for i in list(map(int, input().split())):
arr += [res] * i
res += 1
m = int(input())
for j in list(map(int, input().split())):
print(arr[j-1])
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | ar=[0]
n=input()
p=list(map(int,raw_input().split()))
n=len(p)
for i in range(0,n):
for j in range(0,p[i]):
ar.append(i+1)
n=input()
an=map(int,raw_input().split())
for i in range(0,len(an)):
print ar[an[i]]
| PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | # from sys import stdout
from bisect import bisect_left as bs
from math import log as lg
log = lambda *x: print(*x)
def cin(*fn, def_fn=str):
i,r = 0,[]
if fn: def_fn=fn[0]
for c in input().split(' '):
r+=[(fn[i] if len(fn)>i else def_fn) (c)]
i+=1
return r
####################################################
n, = cin(int)
a = cin(int)
m, = cin(int)
q = cin(int)
ra = [1]
for i in range(n-1):
ra += [ra[-1] + a[i]]
c,loc = 0,{1: 1}
for i in range(2,ra[-1]+1):
c += (c != n-1) and (i >= ra[c+1])
loc[i] = c+1
for i in q: log(loc.setdefault(i, n))
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | n=int(input())
N=[int(i) for i in input().split()]
k=1
d={}
for i in range(n):
for j in range(N[i]):
d[k]=i+1
k+=1
m=int(input())
M=[int(i) for i in input().split()]
for i in range(m):
print(d[M[i]])
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.util.Map;
import java.util.Scanner;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.TreeMap;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author bitver
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
Scanner in = new Scanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
}
class TaskB {
public void solve(int testNumber, Scanner in, PrintWriter out) {
TreeMap<Integer, Integer> treeMap = new TreeMap<Integer, Integer>();
int groups = in.nextInt();
int upper = 0;
for (int i = 1; i <= groups; i++){
upper+= in.nextInt();
treeMap.put(upper, i);
}
int m = in.nextInt();
while( m-- > 0) {
int a = in.nextInt();
Map.Entry<Integer, Integer> entry = treeMap.ceilingEntry(a);
out.print(entry.getValue() + " ");
}
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 |
import java.util.Scanner;
public class worms2 {
public static void main(String[] args) {
int n,m,q;
int lo,hi,mid;
Scanner s = new Scanner(System.in);
n=s.nextInt();
int[]sum=new int[n];
sum[0]=s.nextInt();
for (int i=1;i<n;i++){
sum[i]=sum[i-1]+s.nextInt();
}
m=s.nextInt();
for (int a=0;a<m;a++){
q=s.nextInt();
lo=0;hi=n-1;
while (lo<=hi){
mid=(lo+hi)/2;
if (q<=sum[mid]){
if (mid>0 && q>=sum[mid-1]+1){
System.out.println(mid+1);
break;
}
else if (mid==0){
System.out.println(mid+1);
break;
}
else hi=mid-1;
}
else lo=mid+1;
}
}
}
} | JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | n = int(input())
a = list(map(int, input().split()))
m = int(input())
q = list(map(int, input().split()))
sums = [a[0], ]
for x in range(1, n):
sums.append(sums[-1] + a[x])
sq = sorted(q)
d = dict()
start=0
for y in sq:
for x in range(start, n - 1):
# print (x,y)
if sums[x] >=y:
d[y] = x + 1
# print(x+1)
start =x
break
elif sums[x] < y <= sums[x + 1]:
# print(x+2)
d[y] = x + 2
start = x
break
for aaa in q:
print(d[aaa])
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
/**
*
* @author FZ
*/
public class Rnd271B {
Scanner in = new Scanner(System.in);
private Rnd271B() throws IOException {
int n = in.nextInt();
int[] num = ns(n);
int[] acc = new int[n];
acc[0] = num[0];
for(int i = 1; i < n; i++)
acc[i] = num[i] + acc[i - 1];
int m = in.nextInt();
int[] query = ns(m);
for(int i = 0; i < m; i++) {
int res = searchInsert(acc, query[i]);
outln(res + 1);
}
}
public int searchInsert(int[] A, int target) {
int len = A.length;
int beg = 0;
int end = len - 1;
while(beg <= end) {
if(beg == end) {
if(target <= A[beg])
return beg;
else if(target > A[beg])
return beg + 1;
}
if(beg == end - 1) {
if(target <= A[beg])
return beg;
else if(target <= A[end])
return end;
else
return end + 1;
}
int mid = beg + (end - beg) / 2;
if(A[mid] == target)
return mid;
else if(target < A[mid])
end = mid - 1;
else
beg = mid + 1;
}
return -1;
}
private int[] ns(int n) {
int[] a = new int[n];
for(int i = 0; i < n; i++) {
a[i] = in.nextInt();
}
return a;
}
private static void outln(Object x) {
System.out.println(x);
}
private static void out(Object x) {
System.out.print(x);
}
public static void main(String[] args) throws IOException {
new Rnd271B();
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.Comparator;
import java.io.OutputStream;
import java.util.RandomAccess;
import java.io.PrintWriter;
import java.util.Random;
import java.util.AbstractList;
import java.io.Writer;
import java.util.Map;
import java.util.List;
import java.io.IOException;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.AbstractSet;
import java.util.Iterator;
import java.util.Set;
import java.util.AbstractMap;
import java.util.NoSuchElementException;
import java.math.BigInteger;
import java.util.Collections;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author Nguyen Trung Hieu - vuondenthanhcong11@gmail.com
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
}
class TaskB {
public void solve(int testNumber, InputReader in, OutputWriter out) {
int count = in.readInt();
int[] piles = IOUtils.readIntArray(in, count);
int sum = (int)ArrayUtils.sumArray(piles);
int[] order = new int[sum];
int curOrder = 1;
int idx = 0;
for (int i = 0; i < count; i++) {
for (int j = 0; j < piles[i]; j++) {
order[idx++] = curOrder;
}
curOrder++;
}
int query = in.readInt();
for (int i = 0; i < query; i++) {
out.printLine(order[in.readInt() - 1]);
}
}
}
class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int readInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(Object...objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
writer.print(' ');
writer.print(objects[i]);
}
}
public void printLine(Object...objects) {
print(objects);
writer.println();
}
public void close() {
writer.close();
}
}
class IOUtils {
public static int[] readIntArray(InputReader in, int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++)
array[i] = in.readInt();
return array;
}
}
class ArrayUtils {
public static long sumArray(int[] array) {
long result = 0;
for (int element : array)
result += element;
return result;
}
/*Them boi Nguyen Trung Hieu*/
//update 24/8/2013
}
abstract class IntCollection {
public abstract IntIterator iterator();
public abstract int size();
}
interface IntIterator {
public int value() throws NoSuchElementException;
/*
* @throws NoSuchElementException only if iterator already invalid
*/
public void advance() throws NoSuchElementException;
public boolean isValid();
}
interface IntComparator {
public static final IntComparator DEFAULT = new IntComparator() {
public int compare(int first, int second) {
if (first < second)
return -1;
if (first > second)
return 1;
return 0;
}
};
public int compare(int first, int second);
}
abstract class IntList extends IntCollection implements Comparable<IntList> {
private static final int INSERTION_THRESHOLD = 8;
public abstract int get(int index);
public abstract void set(int index, int value);
public IntIterator iterator() {
return new IntIterator() {
private int size = size();
private int index = 0;
public int value() throws NoSuchElementException {
if (!isValid())
throw new NoSuchElementException();
return get(index);
}
public void advance() throws NoSuchElementException {
if (!isValid())
throw new NoSuchElementException();
index++;
}
public boolean isValid() {
return index < size;
}
};
}
private void swap(int first, int second) {
if (first == second)
return;
int temp = get(first);
set(first, get(second));
set(second, temp);
}
public IntSortedList inPlaceSort(IntComparator comparator) {
quickSort(0, size() - 1, size(), comparator);
return new IntSortedArray(this, comparator);
}
private void quickSort(int from, int to, int remaining, IntComparator comparator) {
if (to - from < INSERTION_THRESHOLD) {
insertionSort(from, to, comparator);
return;
}
if (remaining == 0) {
heapSort(from, to, comparator);
return;
}
remaining >>= 1;
int pivotIndex = (from + to) >> 1;
int pivot = get(pivotIndex);
swap(pivotIndex, to);
int storeIndex = from;
int equalIndex = to;
for (int i = from; i < equalIndex; i++) {
int value = comparator.compare(get(i), pivot);
if (value < 0)
swap(storeIndex++, i);
else if (value == 0)
swap(--equalIndex, i--);
}
quickSort(from, storeIndex - 1, remaining, comparator);
for (int i = equalIndex; i <= to; i++)
swap(storeIndex++, i);
quickSort(storeIndex, to, remaining, comparator);
}
private void heapSort(int from, int to, IntComparator comparator) {
for (int i = (to + from - 1) >> 1; i >= from; i--)
siftDown(i, to, comparator, from);
for (int i = to; i > from; i--) {
swap(from, i);
siftDown(from, i - 1, comparator, from);
}
}
private void siftDown(int start, int end, IntComparator comparator, int delta) {
int value = get(start);
while (true) {
int child = ((start - delta) << 1) + 1 + delta;
if (child > end)
return;
int childValue = get(child);
if (child + 1 <= end) {
int otherValue = get(child + 1);
if (comparator.compare(otherValue, childValue) > 0) {
child++;
childValue = otherValue;
}
}
if (comparator.compare(value, childValue) >= 0)
return;
swap(start, child);
start = child;
}
}
private void insertionSort(int from, int to, IntComparator comparator) {
for (int i = from + 1; i <= to; i++) {
int value = get(i);
for (int j = i - 1; j >= from; j--) {
if (comparator.compare(get(j), value) <= 0)
break;
swap(j, j + 1);
}
}
}
public int hashCode() {
int hashCode = 1;
for (IntIterator i = iterator(); i.isValid(); i.advance())
hashCode = 31 * hashCode + i.value();
return hashCode;
}
public boolean equals(Object obj) {
if (!(obj instanceof IntList))
return false;
IntList list = (IntList)obj;
if (list.size() != size())
return false;
IntIterator i = iterator();
IntIterator j = list.iterator();
while (i.isValid()) {
if (i.value() != j.value())
return false;
i.advance();
j.advance();
}
return true;
}
public int compareTo(IntList o) {
IntIterator i = iterator();
IntIterator j = o.iterator();
while (true) {
if (i.isValid()) {
if (j.isValid()) {
if (i.value() != j.value()) {
if (i.value() < j.value())
return -1;
else
return 1;
}
} else
return 1;
} else {
if (j.isValid())
return -1;
else
return 0;
}
i.advance();
j.advance();
}
}
public IntSortedList sort(IntComparator comparator) {
return new IntArray(this).inPlaceSort(comparator);
}
}
abstract class IntSortedList extends IntList {
protected final IntComparator comparator;
protected IntSortedList(IntComparator comparator) {
this.comparator = comparator;
}
public void set(int index, int value) {
throw new UnsupportedOperationException();
}
public IntSortedList inPlaceSort(IntComparator comparator) {
if (comparator == this.comparator)
return this;
throw new UnsupportedOperationException();
}
public IntSortedList sort(IntComparator comparator) {
if (comparator == this.comparator)
return this;
return super.sort(comparator);
}
protected void ensureSorted() {
int size = size();
if (size == 0)
return;
int last = get(0);
for (int i = 1; i < size; i++) {
int current = get(i);
if (comparator.compare(last, current) > 0)
throw new IllegalArgumentException();
last = current;
}
}
}
class IntArray extends IntList {
private final int[] array;
public IntArray(int[] array) {
this.array = array;
}
public IntArray(IntCollection collection) {
array = new int[collection.size()];
int i = 0;
for (IntIterator iterator = collection.iterator(); iterator.isValid(); iterator.advance())
array[i++] = iterator.value();
}
public int get(int index) {
return array[index];
}
public void set(int index, int value) {
array[index] = value;
}
public int size() {
return array.length;
}
}
class IntSortedArray extends IntSortedList {
private final int[] array;
public IntSortedArray(int[] array) {
this(array, IntComparator.DEFAULT);
}
public IntSortedArray(IntCollection collection) {
this(collection, IntComparator.DEFAULT);
}
public IntSortedArray(int[] array, IntComparator comparator) {
super(comparator);
this.array = array;
ensureSorted();
}
public IntSortedArray(IntCollection collection, IntComparator comparator) {
super(comparator);
array = new int[collection.size()];
int i = 0;
for (IntIterator iterator = collection.iterator(); iterator.isValid(); iterator.advance())
array[i++] = iterator.value();
ensureSorted();
}
public int get(int index) {
return array[index];
}
public int size() {
return array.length;
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.List;
import java.util.Collections;
import java.util.Map;
import java.util.HashMap;
import java.util.Comparator;
import java.util.stream.IntStream;
import java.util.ArrayDeque;
import java.util.Set;
import java.util.HashSet;
public class Solution {
private static FastScanner fs=new FastScanner();
private static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) {
int n = fs.nextInt();
int a[] = fs.readArray(n);
int m = fs.nextInt();
int b[] = new int [m];
int c[] = new int [m];
for(int i=0;i<m;i++)
{
int num = fs.nextInt();
b[i] = num;
c[i] = num;
}
Map<Integer,Integer> map = new HashMap<>();
Arrays.sort(c);
long sum =0;
int ans =0;
int k =0;
for(int i=0;i<n;i++)
{
sum+=a[i];
while(k<m && c[k]<=sum)
{
ans = i+1;
map.put(c[k],ans);
k++;
}
}
for(int i=0;i<m;i++)
{
System.out.println(map.get(b[i]));
}
}
static final Random random=new Random();
static void ruffleSort(int [] a) {
int n=a.length;//shuffle, then sort
for (int i=0; i<n; i++) {
int oi=random.nextInt(n); int temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static class FastScanner {
private int MOD = Integer.MAX_VALUE;
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
int [] sort(int [] arr)
{
List<Integer> list = new ArrayList<>();
for(int i : arr) list.add(i);
Collections.sort(list);
int res[] = new int[arr.length];
for(int i=0;i<arr.length;i++) res[i] = list.get(i);
return res;
}
void debug(int a)
{
System.out.println("This is var "+a);
}
long powermod(long a, long b)
{
long ans = 1;
while (b>0)
{
if ((b & 1)==1) ans = (ans * a) % MOD;
b = b / 2;
a = (a * a) % MOD;
}
return ans;
}
long gcd(long a, long b)
{
if (b == 0) return a;
return gcd(b, a % b);
}
long lcm(long a, long b)
{
return (a / gcd(a, b)) * b;
}
}
} | JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | def binarySearch(value, xList):
low=0
high=len(xList)
while low!=high:
mid=(low+high)//2
if xList[mid]<=value:
low=mid+1
else:
high=mid
return low
n=int(input())
tmp=list(map(int,input().split()))
k=int(input())
ask=list(map(int,input().split()))
for i in range(1,len(tmp)):
tmp[i]+=tmp[i-1]
for i in range(len(tmp)):
tmp[i]+=1
for item in ask:
x=binarySearch(item,tmp)
print (x+1) | PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import sys
n = int(sys.stdin.readline())
a = map(int, sys.stdin.readline().split())
m = int(sys.stdin.readline())
q = map(int, sys.stdin.readline().split())
def bin_find(arr, x):
position_begin = 0
position_end = len(arr) - 1
while position_begin != position_end:
position = (position_end + position_begin) / 2
if x < arr[position]:
position_end = position
if x > arr[position]:
position_begin = position + 1
if x == arr[position]:
return position
return position_begin
b = [0] * n
b[0] = a[0]
for i in range(1, n):
b[i] = b[i - 1] + a[i]
for i in q:
print bin_find(b, i) + 1
| PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.io.*;
public class Worms{
public static void main(String[] args)throws IOException{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(in.readLine());
String[] temp = in.readLine().split(" ");
long[] a = new long[n];
long[][] list = new long[n][2];
long start;
long end = 0;
for(int i = 0; i < n; i++){
a[i] = Long.parseLong(temp[i]);
start = end + 1;
end += a[i];
list[i][0] = start;
list[i][1] = end;
}
int m = Integer.parseInt(in.readLine());
temp = in.readLine().split(" ");
long[] q = new long[m];
for(int i = 0; i < m; i++){
q[i] = Long.parseLong(temp[i]);
int l = 0;
int h = n-1;
int mid = (l+h)/2;
while(l<=h){
mid = (l+h)/2;
if(list[mid][0] <= q[i] && list[mid][1] >= q[i]){
System.out.println(mid+1);
break;
}
else if(list[mid][1] < q[i]){
l = mid + 1;
}
else{
h = mid - 1;
}
}
}
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;
public class Dia3 {
public static void problemaH() {
Scanner sc = new Scanner(System.in);
int pilas = sc.nextInt();
int[] contenedores = new int[pilas];
for (int i = 0; i < pilas; i++) {
contenedores[i] = sc.nextInt();
}
int jugosos = sc.nextInt();
int[] etiquetas = new int[jugosos];
for (int i = 0; i < jugosos; i++) {
etiquetas[i] = sc.nextInt();
}
int[] arreglo = new int[pilas];
int acum = 0;
for (int i = 0; i < contenedores.length; i++) {
acum += contenedores[i];
arreglo[i] = acum;
}
for (int i = 0; i < etiquetas.length; i++) {
int index = Arrays.binarySearch(arreglo, etiquetas[i]);
if( index >= 0 && arreglo[index] == etiquetas[i] ) {
System.out.println(index + 1);
}else {
while(index > 1 && arreglo[index] == arreglo[index-1]) {
index = index -1;
}
System.out.println(Math.abs(index));
}
}
}
public static void main(String[] args) {
problemaH();
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | n,a,m,q=int(input()),list(map(int,input().split())),int(input()),list(map(int,input().split()))
l,f,j=[0],[],0
for i in range(n) :
l.append(l[i]+a[i])
for i in range(pow(10,6)) :
if j==len(l) :
break
if l[j]==i :
j+=1
f.append(j)
for i in q :
print(f[i-1])
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 |
import java.util.Scanner;
public class aaa {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner k = new Scanner(System.in);
int m = k.nextInt();
int[] a = new int[m];
int[] comulative = new int[m];
a[0] = k.nextInt();
comulative[0] = a[0];
for (int i = 1; i < a.length; i++) {
a[i] = k.nextInt();
comulative[i] = a[i];
comulative[i] += comulative[i - 1];
}
int n = k.nextInt();
for (int i = 0; i < n; i++) {
int beg = k.nextInt();
int low = 0;
int end = comulative.length - 1;
while (end > low) {
int mid = low + (end - low) / 2;
if (comulative[mid]>beg) {
end=mid;
}
else if(comulative[mid]<beg){
low=mid+1;
}
else {
low=mid;
break;
}
}
System.out.println(low+1);
}
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
int arr[1100000];
using namespace std;
int main() {
memset(arr, 0, sizeof arr);
int n;
cin >> n;
int x = 1, pre = 1;
for (int i = 1; i <= n; i++) {
int c;
cin >> c;
arr[x] = i;
x += c;
}
x = arr[1];
for (int i = 1; i <= 1000000; i++) {
if (!arr[i])
arr[i] = x;
else
x = arr[i];
}
int q;
cin >> q;
while (q--) {
cin >> x;
cout << arr[x] << endl;
}
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.util.Scanner;
public class Source {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[] a = new int[n];
int total = 0;
for (int i = 0; i < n; i++) {
a[i] = scan.nextInt();
total += a[i];
}
int[] b = new int[total];
int w1 = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < a[i]; j++) {
b[j + w1] = i + 1;
}
w1 += a[i];
}
int m = scan.nextInt();
int q;
for (int j = 0; j < m; j++) {
q = scan.nextInt();
System.out.println(b[q - 1]);
}
}
}
| JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int dp[1000000];
int main() {
int n;
cin >> n;
int arr[n];
int sum = 0;
int count = 1;
int k;
for (int i = 0; i < n; i++) cin >> k, sum += k, dp[i + 1] = sum;
int q;
cin >> q;
while (q--) {
int left = 0, right = n;
int a;
cin >> a;
while (left <= right) {
int mid = (left + right) / 2;
if (dp[mid] < a)
left = mid + 1;
else
right = mid - 1;
}
cout << left << "\n";
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> arr(n);
cin >> arr[0];
for (int i = 1; i < n; ++i) {
cin >> arr[i];
arr[i] += arr[i - 1];
}
sort(arr.begin(), arr.end());
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int a;
cin >> a;
cout << lower_bound(arr.begin(), arr.end(), a) - arr.begin() + 1 << endl;
}
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | def binary_search(arr, low, high, target):
while low < high:
mid = low + int((high - low)/2)
if arr[mid] >= target:
high = mid
else:
low = mid + 1
return low + 1
def main():
n = int(input())
arr = [int(x) for x in input().split()]
m = int(input())
qrr = [int(x) for x in input().split()]
frr = []
count = 0
for i in arr:
count += i
frr.append(count)
for q in qrr:
print(binary_search(frr, 0, len(arr) - 1, q))
if __name__ == '__main__':
main()
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import atexit
import io
import sys
buff = io.BytesIO()
sys.stdout = buff
@atexit.register
def write():
sys.__stdout__.write(buff.getvalue())
def binsearch(arr,elem):
first=0
last=len(arr)-1
while first<=last:
mid=(first+last)//2
if elem>arr[mid-1] and elem<=arr[mid]:
break
elif arr[mid]>elem:
last=mid-1
else:
first=mid+1
return mid
n=int(input())
l= list(map(int,raw_input().split()))
m=int(input())
l1= list(map(int,raw_input().split()))
m=[0]
x=0
for t in l:
x+=t
m.append(x)
for t in l1:
j=binsearch(m,t)
print (j)
| PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import java.util.*;
public class A
{
public static void main(String ar[])
{
Scanner s=new Scanner(System.in);
int n=s.nextInt();
int a[]=new int[n];
a[0]=s.nextInt();
for(int i=1;i<n;i++)
a[i]=a[i-1]+s.nextInt();
int m=s.nextInt();
for(int i=0;i<m;i++)
{
int b=s.nextInt();
int x=Arrays.binarySearch(a,b);
if(x>=0)
System.out.println(x+1);
else
{ x=-1*x;
System.out.println(x);
}
}
}
} | JAVA |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import bisect
n=int(input())
l=[int(i) for i in input().split()]
m=int(input())
k=[int(i) for i in input().split()]
psa=[]
s=0
for i in range(len(l)):
s+=l[i]
psa.append(s)
for i in k:
t=bisect.bisect_left(psa,i)
print(t+1)
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #!/usr/bin/env python3
import atexit
import io
import sys
import bisect
_I_B = sys.stdin.read().splitlines()
input = iter(_I_B).__next__
_O_B = io.StringIO()
sys.stdout = _O_B
@atexit.register
def write():
sys.__stdout__.write(_O_B.getvalue())
def main():
n=int(input())
a=list(map(int,input().split()))
for i in range(1,n):
a[i]+=a[i-1]
a=[0]+a
m=int(input())
q=list(map(int,input().split()))
# print(a)
for i in q:
print(bisect.bisect_left(a,i))
if __name__=='__main__':
main() | PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long long int a[1000001];
int main() {
long long int n;
cin >> n;
int _count = 1;
for (int i = 0; i < n; i++) {
long long int x;
cin >> x;
for (int j = 0; j < x; j++) {
a[_count++] = i;
}
}
long long int x;
cin >> x;
while (x--) {
long long int m;
cin >> m;
cout << a[m] + 1 << endl;
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | def binary_search(data, n, value):
mid = n // 2
low = 0
high = n - 1
while True:
if value <= data[mid] and value > data[mid - 1]:
return mid
if value > data[mid]:
low = mid + 1
else:
high = mid - 1
mid = (high + low) // 2
n = int(input())
data = list(map(int, input().split()))
summ_arr = []
summ = 0
summ_arr.append(0)
m = int(input())
data_2 = []
data_2 = list(map(int, input().split()))
index = 1
for i in range(m):
while data_2[i] > summ:
summ += data[index - 1]
summ_arr.append(summ)
index += 1
print(binary_search(summ_arr, index, data_2[i])) | PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import bisect
n=input()
a=[int(x) for x in input().split()]
m=input()
q=[int(x) for x in input().split()]
for i in range(1,len(a)):
a[i]+=a[i-1]
for x in q:
print(bisect.bisect_left(a,x)+1) | PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #474B-Worms
n=int(input())
alist=[int(x) for x in input().split(' ')]
for i in range(1,n):
alist[i]+=alist[i-1]
m=int(input())
qlist=[int(x) for x in input().split(' ')]
for i in range(m):
min0=0
max0=n-1
q=qlist[i]
if q <= alist[0]:
print(1)
else:
while max0-min0 > 1:
mid=(max0+min0)//2
if q < alist[mid]:
max0=mid
elif q == alist[mid]:
break
else:
min0=mid
if q == alist[mid]:
print(mid+1)
else:
print(max0+1)
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | from bisect import bisect
n = int(raw_input())
a = map(int, raw_input().split())
b = [1]
c = 1
for i in a:
c += i
b.append(c)
raw_input()
for i in map(int, raw_input().split()):
print bisect(b, i) | PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
int n;
cin >> n;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
int m;
cin >> m;
vector<long long int> b(m);
for (long long int i = 0; i < m; i++) cin >> b[i];
vector<long long int> c(n);
c[0] = a[0];
for (long long int i = 1; i < n; i++) {
c[i] = c[i - 1] + a[i];
}
for (long long int i = 0; i < m; i++) {
if (binary_search((c).begin(), (c).end(), b[i])) {
cout << lower_bound((c).begin(), (c).end(), b[i]) - c.begin() + 1
<< '\n';
} else {
cout << upper_bound((c).begin(), (c).end(), b[i]) - c.begin() + 1
<< '\n';
}
}
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | N=[0 for i in range(1000001)]
n=int(input())
L=list(map(int,input().split()))
j=0
for i in L:
N[i+j]=1
j=i+j
P=[N[0]]
for i in range(1,1000001):
P.append(P[i-1]+N[i])
k=int(input())
M=list(map(int,input().split()))
for i in range(k):
print(P[M[i]-1]+1) | PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<vector<int> > quest(100006, vector<int>(2));
int n, i, a[100006], m, num, ans[100006], j = 0, sum = 0;
cin >> n;
for (i = 0; i < n; ++i) cin >> a[i];
cin >> m;
for (i = 0; i < m; ++i) {
cin >> num;
quest[i][0] = num;
quest[i][1] = i;
}
sort(quest.begin(), quest.begin() + m);
for (i = 0; i < m; ++i) {
if (sum < quest[i][0]) {
--i;
sum += a[j];
++j;
} else {
ans[quest[i][1]] = j;
}
}
for (i = 0; i < m; ++i) cout << ans[i] << endl;
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | def binary_search(alist, item, n):
first = 0
last = n - 1
found = False
while first <= last and not found:
midpoint = (first + last)//2
#print "First = " + str(first) + " | " + "Mid = " + str(midpoint) + " | " + "Last = " + str(last) + " | Search: " + str(item)
if alist[midpoint] == item:
found = True
return midpoint + 1
else:
if item < alist[midpoint]:
last = midpoint-1
else:
first = midpoint+1
if first == midpoint and midpoint == last:
return first + 2
else:
if item < alist[first]:
return first + 1
else:
return first + 2
return found
n = int(raw_input()) # Number of piles
a = map(int, raw_input().split())
m = int(raw_input()) # Numbers of juici worms
q = map(int, raw_input().split())
index_array = range(n)
acumulate_a = list()
for i in index_array: # Poblate acumulate array
if i == 0:
acumulate_a.append(a[i])
else:
acumulate_a.append(a[i] + acumulate_a[-1])
for i in q:
print binary_search(acumulate_a, i, n)
| PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 |
get_int = lambda: map(int, input().split())
heaps_quantity = get_int()
heap_capacity = get_int()
worms_quantity = get_int()
worm_number = get_int()
a = 0
cnt = 0
h = []
for i in heap_capacity:
a += i
cnt += 1
for j in range(a - i, a):
h.append(cnt)
for i in worm_number:
print(h[i-1])
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100050], m, q, in = 0;
map<int, int> b;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) a[i] += a[i - 1];
for (int i = 0; i < a[n - 1] + 1; ++i) {
if (i > a[in]) ++in;
b[i] = in + 1;
}
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> q;
cout << b[q] << endl;
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | import bisect
n = int(raw_input())
a= map(int,raw_input().split())
m=int(raw_input())
q= map(int,raw_input().split())
accu=0
for i in xrange(n):
accu+=a[i]
a[i]=accu
# for qi in q:
# print bisect.bisect_left(a,qi)+1
def busquedaBinaria(a,inicio,fin,elemento):
centro=(inicio+fin)/2
if inicio==fin:
return inicio
if elemento<a[centro]:
return busquedaBinaria(a,inicio,centro,elemento)
elif elemento>a[centro]:
return busquedaBinaria(a,centro+1,fin,elemento)
else:
return centro
for qi in q:
print busquedaBinaria(a,0,len(a),qi)+1 | PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 |
li=[]
m=int(input())
a=1
for i in input().split():
li+=[a]*int(i)
a+=1
n=int(input())
for j in input().split():
print(li[int(j)-1])
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
int arr[n];
for (int &i : arr) cin >> i;
for (long long int i = (1); i < (n); i++) {
arr[i] += arr[i - 1];
}
int q;
cin >> q;
while (q--) {
int x;
cin >> x;
int ans = lower_bound(arr, arr + n, x) - arr;
cout << ans + 1 << "\n";
}
return 0;
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
pair<int, int> a[100005];
int n, q, x = 1, b[100005], h;
int find(int k) {
int l = 0, r = n - 1;
while (l <= r) {
h++;
int m = (l + r) / 2;
if ((a[m].first == k) || (a[m].second == k) ||
(a[m].first < k && a[m].second > k))
return m;
if (a[m].first > k)
r = m - 1;
else
l = m + 1;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> b[i];
a[i].first = x;
a[i].second = x + b[i] - 1;
x += b[i];
}
for (cin >> q; q--;) {
cin >> x;
cout << find(x) + 1 << endl;
}
}
| CPP |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | input = raw_input
n = int( input() )
a = [int(x) for x in input().split()]
m = int( input() )
q = [int(x) for x in input().split()]
for i in xrange( 1, n ):
a[i] = a[i-1] + a[i]
def fnd(a,z):
lo = 0
hi = n
while lo < hi:
mid = (hi + lo) // 2
if z > a[mid]:
lo = mid + 1
else:
hi = mid
return lo
for z in q:
print( fnd(a,z) + 1 ) | PYTHON |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | n = int(input())
arr = list(map(int, input().split()))
q = int(input())
qrs = list(map(int, input().split()))
for i in range(1, len(arr)):
arr[i] = arr[i] + arr[i - 1]
for qr in qrs:
left = 0
right = len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == qr or left == right == mid:
print(mid + 1)
break
elif arr[mid] < qr:
left = mid + 1
else:
right = mid
| PYTHON3 |
474_B. Worms | It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m, a[100000], k, l, r, c, i;
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> a[0];
for (i = 1; i < n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
cin >> m;
while (m--) {
cin >> k;
l = 0;
r = n - 1;
while (l < r) {
c = (l + r) / 2;
if (k == a[c]) {
l = c;
r = l;
} else if (k < a[c])
r = c;
else
l = c + 1;
}
cout << l + 1 << endl;
}
return 0;
}
| CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.