solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
int X[] = {-1, -1, -1, 0, 1, 1, 1, 0};
int Y[] = {-1, 0, +1, 1, 1, 0, -1, -1};
long long pas[1005][1005];
int main() {
pas[0][0] = 1;
for (int i = 1; i <= 1000; i++) {
pas[i][0] = pas[i][i] = 1;
for (int j = 1; j < i; j++) {
pas[i][j] = pas[i - 1][j] + pas[i - 1][j - 1];
pas[i][j] %= 1000000007;
}
}
int n;
int tot = 0;
long long ans = 1;
read(n);
for (int i = 0; i < n; i++) {
int a;
read(a);
a--;
ans = (ans * pas[tot + a][a]) % 1000000007;
a++;
tot += a;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
import sys
import math
import collections
from pprint import pprint
mod = 1000000007
def vector(size, val=0):
vec = [val for i in range(size)]
return vec
def matrix(rowNum, colNum, val=0):
mat = []
for i in range(rowNum):
collumn = [val for j in range(colNum)]
mat.append(collumn)
return mat
def pascle(lim):
p = matrix(lim, lim)
for i in range(lim):
p[i][i] = p[i][0] = 1
for i in range(1, lim):
for j in range(1, lim):
p[i][j] = (p[i - 1][j - 1] + p[i - 1][j]) % mod
return p
p = pascle(1005)
n = int(input())
a = [0] + [int(input()) for i in range(n)]
s = 0
ans = 1
for i in range(1, n + 1):
ans = (ans * p[s + a[i] - 1][a[i] - 1]) % mod
s += a[i]
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7, Base = 998244353;
const long long N = 1e3 + 7;
const long long INF = 1LL * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 7LL;
const double pie = acos(-1.0);
long long Fact[N], k, a[N], n, Ans;
void extended_euclid(long long a, long long b, long long *x, long long *y) {
if (b == 0) {
*x = 1;
*y = 0;
return;
}
long long x1, y1;
extended_euclid(b, a % b, &x1, &y1);
*x = y1;
*y = x1 - ((a / b) * y1);
}
long long inverse_mod(long long C) {
long long x, y;
extended_euclid(MOD, C, &x, &y);
return ((y % MOD) + MOD) % MOD;
}
long long mod_expo(long long A, long long B) {
if (B == 0) return 1;
long long x = mod_expo(A, B / 2);
x %= MOD;
x = (x * x) % MOD;
if (B % 2 == 1) {
x = (x * (A % MOD)) % MOD;
}
return x;
}
long long ncr(long long n, long long r) {
r = ((Fact[r] % MOD) * (Fact[n - r] % MOD)) % MOD;
return ((Fact[n] % MOD) * (inverse_mod(r) % MOD)) % MOD;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
Fact[0] = 1;
for (long long i = 1; i < N; ++i) Fact[i] = (i * Fact[i - 1]) % MOD;
cin >> k;
Ans = 1;
for (long long i = 1; i <= k; ++i) {
cin >> a[i];
n += a[i];
Ans = Ans * ncr(n - 1, a[i] - 1) % MOD;
}
cout << Ans << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int D = 1e9 + 7;
long long k, A[1002], F[1002], c[1002][1002], d[1002][1002];
int main() {
cin >> k;
for (int i = 1; i <= k; ++i) scanf("%d", &A[i]);
for (int i = 1; i <= 1000; ++i) d[0][i] = 1, c[0][i] = 1;
for (int i = 1; i <= 1000; ++i)
for (int j = 1; j <= 1000; ++j) {
if (j == 1)
c[i][j] = 1;
else
c[i][j] = d[i][j - 1];
d[i][j] = (d[i - 1][j] + c[i][j]) % D;
}
long long so = A[1];
F[1] = 1;
for (int i = 2; i <= 1000; ++i) {
F[i] = (F[i - 1] * c[A[i] - 1][so + 1]) % D;
so += A[i];
}
cout << F[k];
fclose(stdin);
fclose(stdout);
}
| 9 | CPP |
fac = [1] * 1001
for i in range(1, 1001):
fac[i] = fac[i - 1] * i
k = int(input())
tmp = 0
res = 1
for i in range(k):
tmp2 = int(input())
res *= (fac[tmp2 + tmp - 1] // fac[tmp2 - 1] // fac[tmp]) % (10 ** 9 + 7)
tmp += tmp2
print(res % (10 ** 9 + 7)) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long quick_mod(long long a, long long b) {
long long ans = 1;
a %= 1000000007;
while (b) {
if (b % 2 != 0) {
ans = ans * a % 1000000007;
b--;
}
b /= 2;
a = a * a % 1000000007;
}
return ans;
}
long long judge(long long n, long long m) {
if (m > n) return 0;
long long ans = 1;
for (long long i = 1; i <= m; i++) {
long long a = (n + i - m) % 1000000007;
long long b = i % 1000000007;
ans = ans * (a * quick_mod(b, 1000000007 - 2) % 1000000007) % 1000000007;
}
return ans;
}
long long work(long long n, long long m) {
if (m == 0) return 1;
return judge(n % 1000000007, m % 1000000007) *
work(n / 1000000007, m / 1000000007) % 1000000007;
}
int main() {
long long m, n, i, j, k, ans = 1, a[10005], t = 0, count;
while (cin >> m) {
for (i = 1; i <= m; i++) cin >> a[i];
ans = 1;
long long sum = a[1];
for (i = 2; i <= m; i++) {
sum += a[i];
ans = (ans * work(sum - 1, a[i] - 1)) % 1000000007;
}
cout << ans % 1000000007 << endl;
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7FFFFFFF;
const int MOD = 1000000000 + 7;
const double EPS = 1e-10;
const double PI = 2 * acos(0.0);
const int maxn = 1000 + 66;
int cnt[maxn];
bool prime[maxn];
long long primelist[maxn], prime_len;
void GetPrime() {
memset(prime, true, sizeof(prime));
prime_len = 0;
long long i;
for (i = 2; i <= maxn; i++) {
if (prime[i]) primelist[prime_len++] = i;
long long j;
for (j = 0; j < prime_len; j++) {
if (i * primelist[j] > maxn) break;
prime[i * primelist[j]] = false;
if (i % primelist[j] == 0) break;
}
}
}
long long mult_mod(long long a, long long b, long long mod) {
a %= mod;
b %= mod;
long long ans = 0;
long long temp = a;
while (b) {
if (b & 1) {
ans += temp;
if (ans > mod) ans -= mod;
}
temp <<= 1;
if (temp > mod) temp -= mod;
b >>= 1;
}
return ans;
}
long long pow_mod(long long a, long long n, long long mod) {
long long ans = 1;
long long temp = a % mod;
while (n) {
if (n & 1) ans = mult_mod(ans, temp, mod);
temp = mult_mod(temp, temp, mod);
n >>= 1;
}
return ans;
}
long long Work(long long n, long long p) {
long long ans = 0;
while (n) {
ans += n / p;
n /= p;
}
return ans;
}
long long GetComMod(long long n, long long m, long long p) {
long long ans = 1;
for (long long i = 0; i < prime_len && primelist[i] <= n; i++) {
long long x = Work(n, primelist[i]);
long long y = Work(n - m, primelist[i]);
long long z = Work(m, primelist[i]);
x -= (y + z);
ans *= pow_mod(primelist[i], x, p);
ans %= p;
}
return ans;
}
int main() {
GetPrime();
int k;
cin >> k;
for (int i = 1; i <= k; i++) cin >> cnt[i];
long long res = 1, tempsum = cnt[1];
for (int i = 2; i <= k; i++) {
res = (res % MOD * GetComMod(tempsum + cnt[i] - 1, cnt[i] - 1, MOD)) % MOD;
tempsum += cnt[i];
}
cout << res << endl;
return 0;
}
| 9 | CPP |
__author__ = 'taras-sereda'
from pprint import pprint as pp
n = int(input())
maxn = 1010
mod = 1000000007
coef = [[0 for i in range(maxn)]for i in range(maxn)]
for i in range(maxn):
coef[i][0] = 1
for j in range(1, maxn):
coef[i][j] = (coef[i-1][j] + coef[i-1][j-1]) % mod
colors = [int(input()) for i in range(n)]
res = 1
total = 0
for i in range(n):
res = (res*coef[total+colors[i]-1][colors[i]-1]) % mod
total += colors[i]
print(res)
| 9 | PYTHON3 |
import sys
input=sys.stdin.readline
p=(10**9)+7
pri=p
fac=[1 for i in range((10**6)+1)]
for i in range(2,len(fac)):
fac[i]=(fac[i-1]*(i%pri))%pri
def modi(x):
return (pow(x,p-2,p))%p;
def ncr(n,r):
x=(fac[n]*((modi(fac[r])%p)*(modi(fac[n-r])%p))%p)%p
return x;
a=int(input())
ans=[0 for i in range(a+1)]
for i in range(a):
s=int(input())
ans[i+1]=s
pref=[0]
for i in range(1,a+1):
pref.append(pref[-1]+ans[i])
total=1
for i in range(2,len(ans)):
spaces=pref[i-1]+1
items=ans[i]-1
x=ncr(spaces+items-1,spaces-1)
x%=pri
total=(total*x)%pri
print(total)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
const int mod = 1000 * 1000 * 1000 + 7;
const int inf = 1000 * 1000 * 1000 * 2;
const int rad = 400;
int c[maxn][maxn];
inline void pre() {
for (int i = 0; i < maxn; ++i) c[0][i] = 1, c[1][i] = i, c[i][i] = 1;
for (int j = 2; j < maxn; ++j)
for (int i = 2; i < j; ++i) c[i][j] = (c[i - 1][j - 1] + c[i][j - 1]) % mod;
}
int main() {
ios_base::sync_with_stdio(false);
pre();
int k;
cin >> k;
int x;
cin >> x;
long long ans = 1;
for (int i = 2; i <= k; ++i) {
int y;
cin >> y;
ans *= c[x][x + y - 1];
ans %= mod;
x += y;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long C[1015][1015];
long long k;
long long sum = 0;
long long a[1015];
void init() {
for (int i = 0; i <= 1010; ++i) {
for (int j = 0; j <= i; ++j) {
C[i][j] = (i && j) ? (C[i - 1][j] + C[i - 1][j - 1]) % mod : 1;
}
}
}
int main() {
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> a[i];
sum += a[i];
}
init();
long long ans = 1;
for (int i = k; i >= 1; i--) {
ans = ans * C[sum - 1][a[i] - 1] % mod;
sum -= a[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
if (k == 0) {
cout << 1;
} else {
vector<long long> c(k, 0);
for (int i = 0; i < k; i++) cin >> c[i];
long long tot = accumulate((c).begin(), (c).end(), 0);
vector<vector<long long> > coeffs(tot, vector<long long>(tot, 0));
for (int i = 0; i < tot; i++) coeffs[i][0] = 1, coeffs[i][i] = 1;
for (int i = 1; i < tot; i++) {
for (int j = 1; j < i; j++) {
coeffs[i][j] = (coeffs[i - 1][j] + coeffs[i - 1][j - 1]) % 1000000007;
}
}
vector<long long> d(k, 0);
d[0] = c[0];
for (int i = 1; i < k; i++) {
d[i] = d[i - 1] + c[i];
}
int soln = 1;
for (int i = 0; i < (c).size(); i++) {
soln = (soln * coeffs[d[i] - 1][c[i] - 1]) % 1000000007;
}
cout << soln;
}
}
| 9 | CPP |
#include <bits/stdc++.h>
long long int *f;
long long int pow(long long int a, long long int b) {
long long int x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > 1000000007) x %= 1000000007;
}
y = (y * y);
if (y > 1000000007) y %= 1000000007;
b /= 2;
}
return x;
}
long long int InverseEuler(long long int n) { return pow(n, 1000000007 - 2); }
long long int SmallC(long long int n, long long int r) {
return (f[n] * ((InverseEuler(f[r]) * InverseEuler(f[n - r])) % 1000000007)) %
1000000007;
}
long long int Lucas(long long int n, long long int m) {
if (n == 0 && m == 0) return 1;
long long int ni = n % 1000000007;
long long int mi = m % 1000000007;
if (mi > ni) return 0;
return Lucas(n / 1000000007, m / 1000000007) * SmallC(ni, mi);
}
long long int C(long long int n, long long int r) {
if (r == 0)
return 1;
else
return Lucas(n, r);
}
int main() {
long long int k, *a, i, n;
long long int ans;
scanf("%I64d", &k);
f = (long long int *)malloc(sizeof(long long int) * (1000 + 1));
f[0] = f[1] = 1;
for (i = 2; i < 1000 + 1; i++) f[i] = (f[i - 1] * i) % 1000000007;
a = (long long int *)malloc(sizeof(long long int) * k);
n = 0;
for (i = 0; i < k; i++) {
scanf("%I64d", &a[i]);
n += a[i];
}
ans = 1;
for (i = k - 1; i >= 0; i--) {
ans = (ans * C(n - 1, a[i] - 1)) % 1000000007;
n -= a[i];
}
printf("%I64d", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long ncr[1001][1001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int i, j, x, n, tot = 0, ans, k;
cin >> k;
long long int in[k + 1];
for (i = 1; i <= k; i++) {
cin >> in[i];
}
ncr[1][1] = 1;
ncr[1][0] = 1;
for (i = 0; i <= 1000; i++) {
ncr[i][0] = 1;
for (j = 1; j <= i; j++)
ncr[i][j] = (ncr[i - 1][j - 1] + ncr[i - 1][j]) % 1000000007;
}
ans = 1;
tot = in[1];
for (i = 2; i <= k; i++) {
tot += in[i];
x = tot - 1;
ans = (ans * ncr[x][in[i] - 1]) % 1000000007;
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> memo(1001, vector<long long>(1001, -1));
long long cnk(long long n, long long k) {
if (memo[n][k] == -1) {
if (n < k)
memo[n][k] = 0;
else if (n == k)
memo[n][k] = 1;
else if (k == 0)
memo[n][k] = 1;
else {
memo[n][k] = cnk(n - 1, k) + cnk(n - 1, k - 1);
memo[n][k] %= 1000000007;
}
}
return memo[n][k];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int k, sum = 0, a;
cin >> k;
long long ans = 1;
for (int i = 0; i < k; ++i) {
cin >> a;
ans *= cnk(sum + a - 1, a - 1);
ans %= 1000000007;
sum += a;
}
cout << ans << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int mod_inv(long long base) {
long long result = 1, exp = MOD - 2;
while (exp) {
if (exp & 1) result = (result * base) % MOD;
exp >>= 1;
base = (base * base) % MOD;
}
return result;
}
int fact(int a) {
long long f = 1;
for (int i = 2; i <= a; i++) f = (f * i) % MOD;
return f;
}
int comb(int a, int b) {
long long comb_res = 1;
int x = max(a, b - a);
for (int i = b; i > x; i--) comb_res = (comb_res * i) % MOD;
return (comb_res * (mod_inv(fact(b - x)) % MOD)) % MOD;
}
int c[1001], t[1001];
int main() {
int i, k;
long long res = 1;
cin >> k;
for (i = 1; i <= k; i++) {
cin >> c[i];
t[i] = t[i - 1] + c[i];
}
for (i = 2; i <= k; i++) {
res *= comb(c[i] - 1, t[i] - 1);
res %= MOD;
}
cout << res << endl;
}
| 9 | CPP |
from sys import stdin,stdout
from collections import defaultdict
import math
#stdin = open('input.txt','r')
mod = 10**9+7
I = stdin.readline
P = stdout.write
k = int(I())
tot = 0
ans = 1
for i in range(k):
now = int(I())
ans*=math.factorial(tot+now-1)//math.factorial(tot)//math.factorial(now-1)
tot+=now
ans%=mod
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
ll modpow(ll x, ll p, ll mod) {
ll res = 1LL;
for (; p; p >>= 1, (x *= x) %= mod)
if (p & 1) (res *= x) %= mod;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int k;
cin >> k;
constexpr ll mod = 1e9 + 7, maxsum = 1000;
vector<ll> f(maxsum + 1, 1), inv(maxsum + 1, 1LL);
for (int x = 1; x <= maxsum; ++x) {
f[x] = x * f[x - 1] % mod;
inv[x] = modpow(f[x], mod - 2, mod);
}
ll sum = 0LL, res = 1LL;
for (int j = 0; j < k; ++j) {
ll ct;
cin >> ct;
res = ((res * f[sum + ct - 1] % mod) * inv[sum] % mod) * inv[ct - 1] % mod;
sum += ct;
}
cout << res << '\n';
exit(0);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int fact[1010], invfact[1010];
long long int powmod(long long int base, long long int expo) {
if (expo == 0)
return 1;
else if (expo & 1)
return base * powmod(base, expo - 1) % 1000000007;
else {
long long int root = powmod(base, expo >> 1);
return (root * root) % 1000000007;
}
}
long long int inverse(long long int x) { return powmod(x, 1000000007 - 2); }
void init(long long int n) {
long long int i;
fact[0] = 1;
for (i = 1; i <= n; i++) fact[i] = (i * fact[i - 1]) % 1000000007;
invfact[n] = inverse(fact[n]);
for (i = n; i > 0; i--) invfact[i - 1] = (i * invfact[i]) % 1000000007;
}
long long int nCr(long long int n, long long int r) {
if (r > n || r < 0) return 0;
return ((fact[n] * invfact[r] % 1000000007) * invfact[n - r]) % 1000000007;
}
int main() {
long long int n, k, i, sum = 0;
init(1005);
cin >> k;
long long int ans = 1;
long long int p;
long long int arr[1005];
for (i = 0; i < k; i++) {
cin >> arr[i];
sum += arr[i];
}
for (i = k - 1; i >= 0; i--) {
p = arr[i] - 1;
ans = (ans * nCr(sum - 1, p)) % 1000000007;
sum -= arr[i];
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MAX = 1000;
long long k;
long long sum;
long long buf[MAX + 1];
long long e[MAX + 1][MAX + 1];
long long res;
int main(int argc, char const *argv[]) {
cin >> k;
for (int i = 0; i < MAX + 1; ++i) {
e[i][0] = 1;
}
for (int i = 1; i < MAX + 1; ++i) {
for (int j = 1; j < MAX + 1; ++j) {
e[i][j] = (e[i - 1][j - 1] + e[i - 1][j]) % INF;
}
}
res = 1;
for (int i = 0; i < k; ++i) {
int c;
cin >> c;
sum += c;
res = (res * e[sum - 1][c - 1]) % INF;
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int m = 1e9 + 7;
int c[1012][1012];
long long int n, k, t, res = 1, all;
int main() {
for (int i = 0; i < 1012; i++) c[0][i] = 1;
for (int i = 1; i < 1012; i++) {
c[i][0] = 1, c[i][i] = 1;
for (int j = 1; j < i; j++) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % m;
}
cin >> k;
while (k--) {
cin >> t;
all += t;
res = ((long long int)c[all - 1][t - 1] * res) % m;
}
cout << res << endl;
return 0;
}
| 9 | CPP |
numeroColores=int(input())
listaNumColores=[]
for i in range (0, numeroColores):
listaNumColores.append(int(input()))
conclusion= 1
anterior= listaNumColores[0]
for i, numeroColores in enumerate(listaNumColores[1:]):
#for i in range(0,numeroColores-1):
anterior+= 1
#reset
conteo1= 1
conteo2= 1
for j in range(numeroColores - 1):
conclusion= conclusion* anterior
anterior+= 1
conteo1= conteo1* conteo2
conteo2+= 1
conclusion= conclusion// conteo1
if conclusion> 1000000007:
#Aplicar modulo
conclusion = conclusion% 1000000007
print(conclusion) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxk = 1e3 + 7;
const int p = 1000000007;
int k;
int c[maxk];
long long dp[maxk];
int cnt;
long long n, m;
long long quick_mod(long long a, long long b) {
long long ans = 1;
a %= p;
while (b) {
if (b & 1) {
ans = ans * a % p;
b--;
}
b >>= 1;
a = a * a % p;
}
return ans;
}
long long C(long long n, long long m) {
if (m > n) return 0;
long long ans = 1;
for (int i = 1; i <= m; i++) {
long long a = (n + i - m) % p;
long long b = i % p;
ans = ans * (a * quick_mod(b, p - 2) % p) % p;
}
return ans;
}
long long Lucas(long long n, long long m) {
if (m == 0) return 1;
return C(n % p, m % p) * Lucas(n / p, m / p) % p;
}
long long fun(long long x) {
long long ans = 0;
for (int i = 0; i < x - 1; i++) {
long long t = Lucas(x - 2, i);
long long y = Lucas(cnt + 1, i + 1);
ans = (ans % p + (t % p * y % p) % p) % p;
}
if (!ans) return 1ll;
return ans;
}
void solve() {
dp[0] = 1;
cnt = c[0];
for (int i = 1; i < k; i++) {
dp[i] = dp[i - 1] * fun(c[i]) % p;
cnt += c[i];
}
cout << dp[k - 1] << endl;
}
int main() {
cin >> k;
for (int i = 0; i < k; i++) {
cin >> c[i];
}
solve();
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long C[1001][1001];
void PreCalc() {
C[0][0] = 1;
for (int i = 1; i < 1001; ++i) {
C[i][0] = 1;
for (int j = 1; j <= i; ++j) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
}
int main() {
PreCalc();
int k;
scanf("%d", &k);
int n = 0;
vector<int> c(k);
for (int i = 0; i < k; ++i) {
scanf("%d", &c[i]);
n += c[i];
}
long long ans = 1;
for (int i = k - 1; i >= 0; --i) {
ans *= C[n - 1][c[i] - 1];
ans %= mod;
n -= c[i];
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int C[1010][1010];
int main() {
std::ios::sync_with_stdio(false);
for (int i = 0; i < 1005; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] >= 1000000007) C[i][j] %= 1000000007;
}
}
long long int ans = 1, total = 0, n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
ans = (ans * C[total + a[i] - 1][a[i] - 1]) % 1000000007;
total += a[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long n;
long long f[1005];
long long sum;
long long C[1005][1005];
void init() {
for (int i = 0; i <= 1000; i++) {
for (int j = 0; j <= i; j++) {
if (i == 0 || i == j)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
return;
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> f[i];
sum += f[i];
}
init();
long long ans = 1;
for (int i = n; i > 0; i--) {
ans *= C[sum - 1][f[i] - 1];
sum -= f[i];
ans %= mod;
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long C[1005][1005];
int sum[1005];
long long Sech(int n, int m) {
if (n == 1) return 1;
return C[m - 1][sum[n] - 1] * Sech(n - 1, m - sum[n]) % 1000000007;
}
int main(void) {
int m, n, i, j;
for (i = 0; i <= 1002; i++) C[i][0] = 1;
for (i = 1; i <= 1002; i++) {
for (j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 1000000007;
}
m = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &sum[i]);
m += sum[i];
}
printf("%lld\n", Sech(n, m));
return 0;
}
| 9 | CPP |
from sys import stdin,stdout
from collections import Counter
nmbr = lambda: int(stdin.readline())
lst = lambda: list(map(int,stdin.readline().split()))
M=10**9+7
fact=[1]
for i in range(1,1005):
fact+=[(fact[-1]*i)%M]
def ncr(n,r):
num=fact[n]
den=(fact[r]*fact[n-r])%M
ans=(num*pow(den,M-2,M))%M
return ans
for _ in range(1):#nmbr()):
n=nmbr()
a=[nmbr() for _ in range(n)]
dp=[0]*(1+n)
dp[1]=1
spaces=0
sm=a[0]
for i in range(2,n+1):
spaces=sm+a[i-1]-1
dp[i]=(dp[i-1]*(ncr(spaces,a[i-1]-1)))%M
sm+=a[i-1]
print(dp[n]%M) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int MAXN = 1003;
int C[MAXN][MAXN];
void build() {
C[0][0] = 1;
for (int i = 1; i < MAXN; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] >= MOD) C[i][j] -= MOD;
}
}
}
int main() {
build();
int n, ans = 1, cnt = 0;
int a;
cin >> n;
while (n-- > 0) {
scanf("%d", &a);
ans = (long long)ans * C[cnt + a - 1][cnt] % MOD;
cnt += a;
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int col[1000001], dp[1000001], fact[1000001], ifact[1000001],
sum[1000001];
long long int bpow(long long int x, long long int n) {
long long int ans = 1;
while (n > 0) {
if (n & 1) ans *= x;
x *= x;
ans %= 1000000007;
x %= 1000000007;
n /= 2;
}
return ans;
}
void pre_calc(long long int N) {
fact[0] = ifact[0] = 1;
for (long long int i = 1; i <= N; ++i) {
fact[i] = (fact[i - 1] * i) % 1000000007;
ifact[i] = bpow(fact[i], 1000000007 - 2);
}
}
long long int ncr(int n, int r) {
if (r < 0 or n < r) return 0;
long long int ans = fact[n];
ans = (ans * ifact[r]) % 1000000007;
ans = (ans * ifact[n - r]) % 1000000007;
return ans;
}
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
pre_calc(1000000);
long long int i, j, k;
cin >> k;
for (i = 1; i <= k; i++) {
cin >> col[i];
sum[i] = sum[i - 1] + col[i];
}
dp[1] = 1;
for (i = 2; i <= k; i++) {
dp[i] = dp[i - 1] * ncr(sum[i] - 1, sum[i - 1]);
dp[i] %= 1000000007;
}
cout << dp[k];
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int k;
int dp[1002][1002];
int f(int pos, int sisa) {
if (sisa < 0) return 0;
if (pos == 0) return (sisa == 0);
if (dp[pos][sisa] != -1) return dp[pos][sisa];
return dp[pos][sisa] = (f(pos - 1, sisa) + f(pos, sisa - 1)) % 1000000007;
}
int main() {
scanf("%d", &k);
int c;
long long ans = 1;
int now = 1;
memset(dp, -1, sizeof dp);
for (int i = 0; i < k; i++) {
scanf("%d", &c);
ans *= f(now, c - 1);
ans %= 1000000007;
now += c;
}
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
const int INF = (1 << 29);
const double EPS = 0.0000000001;
const double Pi = acos(-1.0);
const long long p = 1000000007;
int k, a[maxn];
long long s[maxn];
long long qpow(long long n, long long k) {
long long res = 1;
while (k) {
if (k & 1) res = (res % p * (n % p)) % p;
n = (n % p) * (n % p) % p;
k >>= 1;
}
return res;
}
long long C(long long n, long long k) {
if (n < k) return 0;
long long res = 1;
for (int(i) = (1); (i) <= (k); (i)++) {
long long a = (n - k + i) % p;
long long b = i % p;
res = (res * (a * qpow(b, p - 2) % p)) % p;
}
return res % p;
}
long long lucas(long long n, long long k) {
if (k == 0) return 1;
return (C(n % p, k % p) % p) * (lucas(n / p, k / p) % p) % p;
}
long long f(long long n, long long m) { return lucas(n + m, n); }
int main() {
while (cin >> k) {
s[0] = 0;
for (int(i) = (1); (i) <= (k); (i)++)
scanf("%d", &(a[i])), s[i] = s[i - 1] + a[i];
long long ans = 1;
for (int(i) = (1); (i) <= (k - 1); (i)++) {
ans = ans * (f(a[i + 1] - 1, s[i]) % p) % p;
}
cout << ans % p << endl;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int k, n, c[1001];
long long gt[1001], igt[1001], kq = 1;
long long moe(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) return moe((a * a) % 1000000007, b / 2);
return (a * moe((a * a) % 1000000007, b / 2)) % 1000000007;
}
void init() {
gt[0] = 1;
for (int i = 1; i <= 1000; ++i) gt[i] = (gt[i - 1] * i) % 1000000007;
igt[1000] = moe(gt[1000], 1000000007 - 2);
for (int i = 999; i >= 0; --i) {
igt[i] = (igt[i + 1] * (i + 1)) % 1000000007;
}
}
void nhap() {
scanf("%d", &k);
for (int i = 1; i <= k; ++i) {
scanf("%d", &c[i]);
}
}
long long nCk(int a, int b) {
return ((gt[a] * igt[b]) % 1000000007 * igt[a - b]) % 1000000007;
}
void process() {
n = c[1];
for (int i = 2; i <= k; ++i) {
kq = (kq * nCk(n + c[i] - 1, c[i] - 1)) % 1000000007;
n += c[i];
}
cout << kq;
}
int main() {
init();
nhap();
process();
return 0;
}
| 9 | CPP |
from functools import reduce
from operator import mul
mod = 10 ** 9 + 7
k = int(input())
cs = [int(input()) for _ in range(k)]
cumcs = cs[:]
for i in range(1, len(cs)):
cumcs[i] += cumcs[i - 1]
def C(n, k):
num = reduce(mul, range(n, n - k, -1), 1)
denom = reduce(mul, range(k, 0, -1), 1)
return (num // denom) % mod
res = 1
for cum, c in zip(cumcs, cs):
res = (res * C(cum - 1, c - 1)) % mod
print(res)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long k, c[1000 + 7], ncr[2000 + 7][2000 + 7];
int main(void) {
ncr[0][0] = 1;
for (int i = 1; i <= 2000; i++) {
ncr[i][0] = 1;
for (int j = 1; j < i; j++) {
ncr[i][j] = (ncr[i - 1][j - 1] + ncr[i - 1][j]) % 1000000007;
}
ncr[i][i] = 1;
}
cin >> k;
for (int i = 0; i < k; i++) cin >> c[i];
long long res = 1;
int cnt = c[0];
for (int i = 1; i < k; i++) {
if (c[i] != 1) res *= ncr[cnt + c[i] - 1][c[i] - 1];
res %= 1000000007;
cnt += c[i];
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
long long triangle[2005][2005];
void makeTriangle() {
long long i, j;
triangle[0][0] = 1;
for (i = 1; i < 2005; i++) {
triangle[i][0] = 1;
for (j = 1; j <= i; j++) {
triangle[i][j] = (triangle[i - 1][j - 1] + triangle[i - 1][j]) % M;
}
}
}
long long CC(long long n, long long r) { return triangle[n][r]; }
int main() {
makeTriangle();
long long k, i, nw, t, ans = 1;
cin >> k;
vector<long long> c(k);
for (i = 0; i < k; i++) {
cin >> c[i];
}
if (k == 1) {
cout << 1;
return 0;
}
t = c[0];
for (i = 1; i < k; i++) {
nw = c[i] - 1;
t += nw;
if (nw) ans = (ans * CC(t, nw)) % M;
t++;
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long m = 1002, n, r, s = 0, i, j, p = 1, a[1010][1010];
int main() {
for (i = 1; i < m; i++)
for (j = 2, a[i][1] = 1; j <= i; j++)
(a[i][j] += a[i - 1][j] + a[i - 1][j - 1]) %= 1000000007;
for (cin >> n, i = 0; i < n; i++)
cin >> r, s += r, (p *= a[s][r]) %= 1000000007;
cout << p << endl;
return 0;
}
| 9 | CPP |
def fact(n):
r = 1
for i in range(1, n + 1):
r *= i
return r
n = int(input())
c = [int(input()) for i in range(n)]
r = 1
u = c[0] - 1
d = 0
for i in range(1, n):
u += c[i]
d += c[i-1]
r *= fact(u) // fact(d) // fact(c[i] - 1)
print(r % 1000000007) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, y, l, r;
double a, b, c, d, q;
vector<int> V;
vector<vector<int> > D;
string s, k, z;
long long res = 0;
double eps = 0.000000001;
const int INF = 1000000007;
const int MAXNUM = 1005;
long long arr[MAXNUM][MAXNUM] = {0};
int main() {
arr[0][0] = 1;
for (int i = 1; i < MAXNUM; i++) {
arr[i][0] = 1;
for (int j = 1; j <= i; j++) {
arr[i][j] = (arr[i - 1][j] + arr[i - 1][j - 1]) % INF;
}
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> m;
V.push_back(m);
}
m = 0;
res = 1;
for (int i = 0; i < n; i++) {
res = (res * arr[m + V[i] - 1][V[i] - 1]) % INF;
m += V[i];
}
cout << res % INF << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long k;
long long c[1010];
long long s[1010];
long long ncr[1000][1000];
void init() {
ncr[0][0] = 1;
for (long long i = 1; i < 1000; i++)
for (long long j = 0; j <= i; j++) {
ncr[i][j] = ncr[i - 1][j];
if (j > 0) ncr[i][j] = ((ncr[i][j] + ncr[i - 1][j - 1]) % 1000000007);
}
}
int main() {
ios_base::sync_with_stdio(false);
init();
cin >> k;
for (int i = 0; i < k; i++) cin >> c[i];
s[0] = c[0];
for (int i = 1; i < k; i++) s[i] = s[i - 1] + c[i];
long long q = 1;
for (int i = 1; i < k; i++) {
q = (q * ncr[s[i] - 1][c[i] - 1]) % 1000000007;
}
cout << q;
return 0;
}
| 9 | CPP |
#! /usr/bin/env python3
k = int(input())
c = [int(input()) for _ in range(k)]
MOD = (10 ** 9 + 7)
def fact(x):
prod = 1
for i in range(1, x + 1):
prod *= i
return prod
def C(n, k):
prod = 1
for i in range(n - k + 1, n + 1):
prod *= i
return (prod // fact(k)) % MOD
prod = 1
c_sum = -1
for c_i in c:
c_sum += c_i
prod *= C(c_sum, c_i - 1)
prod %= MOD
print(prod)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int c[1009];
int k;
long long fact[1009];
long long mpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (1LL * res * a) % 1000000007;
b = b / 2;
a = (1LL * a * a) % 1000000007;
}
return res;
}
long long nCr(int a, int b) {
return (((fact[a] * mpow(fact[b], 1000000007 - 2)) % 1000000007) *
mpow(fact[a - b], 1000000007 - 2)) %
1000000007;
}
int main() {
cin >> k;
for (int i = 0; i < k; i++) cin >> c[i];
fact[0] = 1;
for (int i = 1; i <= 1000; i++) {
fact[i] = (1LL * fact[i - 1] * i) % 1000000007;
}
long long res = 1;
long long sum = c[0];
for (int i = 1; i < k; i++) {
sum += c[i];
long long temp = nCr(sum - 1, c[i] - 1);
res = (1LL * res * temp) % 1000000007;
}
res = res % 1000000007;
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T min(T a, T b, T c, T d) {
return min(a, min(b, min(c, d)));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
T max(T a, T b, T c, T d) {
return max(a, max(b, max(c, d)));
}
bool cmp(const int& a, const int& b) { return a > b; }
int a[5007];
long long f[5007];
inline long long power(long long n, long long k) {
if (k == 0LL) return 1LL;
long long tmp = power(n, k / 2LL) % 1000000007LL;
if (k % 2) return (((tmp * tmp) % 1000000007LL) * n) % 1000000007LL;
return (tmp * tmp) % 1000000007LL;
}
inline long long com(int n, int k) {
return (
f[n] *
(power(((long long)f[k] * f[n - k]) % 1000000007LL, 1000000007LL - 2) %
1000000007LL) %
1000000007LL);
}
int main() {
int n;
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i]);
f[0] = 1LL;
for (int i = (1); i <= (2000); ++i) f[i] = (f[i - 1] * i) % 1000000007LL;
int sum = 0;
long long ans = 1LL;
for (int i = (1); i <= (n); ++i) {
sum += a[i];
ans *= com(sum - 1, a[i] - 1) % 1000000007LL;
ans %= 1000000007LL;
}
printf("%lld\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
long long jc[1000010], c[1010];
long long poww(long long a, long long b) {
long long ans = 1;
while (b) {
if (b % 2) ans = ans * a % 1000000007;
b = b >> 1;
a = a * a % 1000000007;
}
return ans;
}
int main(void) {
int i;
long long ans = 1, tot = 0, k;
jc[0] = 1;
for (i = 1; i < 1000010; i++) jc[i] = jc[i - 1] * i % 1000000007;
scanf("%I64d", &k);
for (i = 0; i < k; i++) {
scanf("%I64d", &c[i]);
tot += c[i];
}
for (i = k - 1; i >= 0; i--) {
ans = ans *
(jc[tot - 1] *
(poww(jc[c[i] - 1] * jc[tot - c[i]] % 1000000007, 1000000007 - 2) %
1000000007) %
1000000007) %
1000000007;
tot -= c[i];
}
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
from math import factorial
n,ans,s = int(input()),1,0
for i in range(n) :
a = int(input())
ans=(ans*factorial(s+a-1)//factorial(s)//factorial(a-1))%1000000007
s+=a
print(ans)
#copied...
# Made By Mostafa_Khaled | 9 | PYTHON3 |
pt = []
for i in range(1000):
pt.append([0] * (i + 1))
pt[i][0] = pt[i][i] = 1
for j in range(1, i):
pt[i][j] = pt[i - 1][j - 1] + pt[i - 1][j]
k, s, v = int(input()), int(input()), 1
for i in range(1, k):
c = int(input())
v = v * pt[s + c - 1][c - 1] % 1000000007
s += c
print(v) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int c[1005];
long long int tri[2005][2005];
int main() {
int k;
for (int i = 0; i < 2001; ++i) {
tri[i][i] = tri[i][0] = 1;
for (int j = 1; j < i; ++j) {
tri[i][j] = (tri[i - 1][j - 1] + tri[i - 1][j]) % mod;
}
}
while (cin >> k) {
for (int i = 0; i < k; ++i) {
cin >> c[i];
}
long long int sum = 1;
int tot = c[0];
for (int i = 1; i < k; ++i) {
tot += c[i];
sum = (sum * tri[tot - 1][c[i] - 1]) % mod;
}
cout << sum << "\n";
}
return 0;
}
| 9 | CPP |
k = int(input())
res, mod, last = 1, 10**9 + 7, int(input())
comb = [[0]*1001 for _ in range(1001)]
comb[0][0] = 1
for i in range(1, 1001):
comb[i][0] = 1
for j in range(1, i+1):
comb[i][j] = (comb[i-1][j] + comb[i-1][j-1]) % mod
for _ in range(k-1):
to_place = int(input())
res = (res * comb[last+to_place-1][to_place-1]) % mod
last += to_place
print(res)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long C[1010][1010];
long long input[1010];
void build() {
int i, j;
for (i = 0; i <= 1000; i++) C[i][0] = 1;
for (i = 0; i <= 1000; i++) C[i][i] = 1;
for (i = 2; i <= 1000; i++)
for (j = 1; j < i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007L;
}
int main() {
build();
int i, j, k;
while (scanf("%d", &k) != EOF) {
long long sum = 0;
long long ans = 1;
for (i = 0; i < k; i++) scanf("%I64d", &input[i]);
for (i = 0; i < k; i++) {
ans = (ans * C[sum + input[i] - 1][input[i] - 1]) % 1000000007L;
sum += input[i];
}
printf("%I64d\n", ans);
}
return 0;
}
| 9 | CPP |
k = int(input())
h = []
for i in range(k):
h.append(int(input()))
ffs = [1]
def f(n):
if n < len(ffs):
return ffs[n]
v = n * f(n-1)
ffs.append(v)
return v
def c(k, n):
return f(n) // (f(k) * f(n-k))
def cc(k, n):
return c(n-1, n + k-1)
def solve(h):
if len(h) == 1:
return 1
hh = h[:-1]
hh_len = sum(hh)
return solve(hh) * cc(h[-1] -1, hh_len + 1)
r = 1
for i in range(len(h)):
r *= cc(h[i] -1, sum(h[:i]) + 1)
print(r % 1000000007)
| 9 | PYTHON3 |
def g(): return int(input())
def ncr(n,r):
if 2*r > n:
r = n-r
a = 1
for i in range(r):
a = a * (n-i) // (i+1)
return a
k = g()
ans = 1
n2 = g()
for i in range(k-1):
n1 = n2
n2 += g()
ans = ans * ncr(n2-1,n1) % 1000000007
print(ans)
| 9 | PYTHON3 |
kk = 1
f = [0] * 1001
f[0] = 1
for i in range(1, 1001):
kk *= i
kk %= (10**9+7)
f[i] = pow(kk, 10**9+5, 10**9+7)
def c(n, k):
prod = 1
for i in range(n-k+1, n+1):
prod *= i
prod %= (10**9+7)
prod = (prod*f[k])%(10**9+7)
return prod
l = []
m = []
a = 1
s = 0
for i in range(int(input())):
x = int(input())
s += x
l.append(s-1)
m.append(x-1)
ans = 1
for i in range(len(l)):
ans = (ans*c(l[i], m[i]))%(10**9+7)
print(ans)
| 9 | PYTHON3 |
s = int(input())
MOD = int(1e9 + 7)
comb = [[1] + [0 for i in range(1000)] for j in range(1001)]
for i in range(1,1001):
for j in range(1,i+1):
comb[i][j] = (comb[i-1][j] + comb[i-1][j-1]) % MOD
res = 1
sums = 0
for i in range(s):
x = int(input())
res = (res * comb[sums + x - 1][x - 1]) % MOD
sums += x
print(res)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline long long int fast_input(void) {
char t;
long long int x = 0;
long long int neg = 0;
t = getchar();
while ((t < 48 || t > 57) && t != '-') t = getchar();
if (t == '-') {
neg = 1;
t = getchar();
}
while (t >= 48 && t <= 57) {
x = (x << 3) + (x << 1) + t - 48;
t = getchar();
}
if (neg) x = -x;
return x;
}
inline void fast_output(long long int x) {
char a[20];
long long int i = 0, j;
a[0] = '0';
if (x < 0) {
putchar('-');
x = -x;
}
if (x == 0) putchar('0');
while (x) {
a[i++] = x % 10 + 48;
x /= 10;
}
for (j = i - 1; j >= 0; j--) {
putchar(a[j]);
}
putchar('\n');
}
long long int power(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b % 2) ans = ans * a;
b /= 2;
a *= a;
if (a > 1000000007) a %= 1000000007;
if (ans > 1000000007) ans %= 1000000007;
}
return ans;
}
long long int k, c[1001], i, ans, fac[1000005], invfac[1000005], sum, bot;
int main() {
k = fast_input();
fac[0] = 1, invfac[0] = 1;
sum = 0;
for (i = 0; i < k; i++) {
c[i] = fast_input();
sum += c[i];
}
for (i = 1; i <= sum; i++) {
fac[i] = fac[i - 1] * i;
if (fac[i] > 1000000007) fac[i] %= 1000000007;
invfac[i] = invfac[i - 1] * power(i, 1000000007 - 2);
if (invfac[i] > 1000000007) invfac[i] %= 1000000007;
}
ans = fac[sum];
ans *= invfac[c[0]];
ans %= 1000000007;
bot = c[0];
for (i = 1; i < k; i++) {
ans = ans * invfac[c[i]];
if (ans > 1000000007) ans %= 1000000007;
bot += c[i];
ans *= c[i];
if (ans > 1000000007) ans %= 1000000007;
ans = ans * invfac[bot];
if (ans > 1000000007) ans %= 1000000007;
ans = ans * fac[bot - 1];
if (ans > 1000000007) ans %= 1000000007;
}
fast_output(ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int k, A[1005], choose[1005][1005];
int solve(int pos, int cnt) {
if (pos == 1) return 1;
return ((long long)solve(pos - 1, cnt - A[pos]) *
choose[cnt - 1][A[pos] - 1]) %
mod;
}
int main() {
scanf("%d", &k);
int s = 0;
for (int i = 1; i <= k; i++) {
scanf("%d", &A[i]);
s += A[i];
}
for (int i = 0; i <= 1001; i++) {
choose[i][0] = 1;
}
for (int i = 1; i <= 1001; i++) {
for (int j = 1; j <= 1001; j++) {
choose[i][j] = (choose[i - 1][j] + choose[i - 1][j - 1]) % mod;
}
}
printf("%d\n", solve(k, s));
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007, pas[1005][1005];
class TaskC {
public:
void solve(istream& in, ostream& out) {
for (int i = 0; i < 1005; i++) pas[i][0] = pas[i][i] = 1;
for (int i = 2; i < 1005; i++)
for (int j = 1; j < i; j++) {
pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
pas[i][j] %= mod;
}
int k;
in >> k;
long long ans = 1;
vector<long long> c(k), psum(k);
for (int i = 0; i < k; ++i) in >> c[i];
partial_sum(c.begin(), c.end(), psum.begin());
for (int i = k - 1; i > 0; i--) {
ans *= pas[psum[i] - 1][c[i] - 1];
ans %= mod;
}
out << ans;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
TaskC solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MO = 1e9 + 7;
long long c[1010][1010], i, j, n, ans = 1, a[1010];
int main() {
cin >> n;
for (i = 0; i <= 1005; i++) {
c[i][0] = 1;
c[i][i] = 1;
for (j = 1; j <= i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MO;
}
long long sum = 0;
for (i = 1; i <= n; i++) {
scanf("%ld", &a[i]);
ans = ans * c[sum + a[i] - 1][a[i] - 1] % MO;
sum += a[i];
}
cout << ans;
return 0;
}
| 9 | CPP |
# Python3 function to
# calculate nCr % p
def ncr(n, r, p):
# initialize numerator
# and denominator
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
k=int(input())
p=10**9+7
ans=1
total=0
for i in range(k):
c=int(input())
ans*=ncr(total+c-1,total,p)
ans%=p
total+=c
print(ans) | 9 | PYTHON3 |
'''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineering College
'''
from os import path
from io import BytesIO, IOBase
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,Counter,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input().rstrip()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('0')
file = 1
def ceil(a,b):
return (a+b-1)//b
def solve():
# for _ in range(ii()):
N = 10001
invfact = [0]*N
fact = [1]*N
for i in range(1,N):
fact[i] = (fact[i-1]*i)%mod
invfact[-1] = pow(fact[-1],mod-2,mod)
for i in range(N-2,-1,-1):
invfact[i] = ((i+1)*invfact[i+1])%mod
def nCr(x,y):
if y > x:
return 0
ans = (invfact[x-y]*invfact[y])%mod
ans *= fact[x]
ans %= mod
return ans
k = ii()
ans = 1
cnt = ii()
for i in range(1,k):
x = ii()
cnt += (x-1)
ans *= nCr(cnt,x-1)
ans %= mod
cnt += 1
print(ans)
if __name__ =="__main__":
if(file):
if path.exists('tmp/input.txt'):
sys.stdin=open('tmp/input.txt', 'r')
sys.stdout=open('tmp/output.txt','w')
else:
input=sys.stdin.readline
solve()
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long dp[1005][1005];
int main() {
ios::sync_with_stdio(false);
for (long long i = 0; i < 1001; i++) dp[i][0] = 1;
for (long long i = 1; i < 1001; i++)
for (long long j = 1; j < i + 1; j++)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % 1000000007;
long long n, ans = 1;
cin >> n;
long long a;
cin >> a;
for (long long i = 2; i < n + 1; i++) {
long long x;
cin >> x;
ans = (ans * dp[a + x - 1][x - 1]) % 1000000007;
a += x;
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, len;
long long MOD = 1000000007ll;
long long a[1111], d[1111], cache[1111][1111];
long long C(long long x, long long y) {
if (x == y) return 1;
if (y == 1) return x;
if (y <= 0) return 1;
long long &ret = cache[x][y];
if (~ret) return ret;
return ret = (C(x - 1, y) + C(x - 1, y - 1)) % MOD;
}
int main() {
memset(cache, -1, sizeof(cache));
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
d[1] = 1;
len = a[1];
for (int i = 2; i <= n; i++) {
d[i] = (d[i - 1] * C(len + a[i] - 1ll, a[i] - 1ll)) % MOD;
len += a[i];
}
cout << d[n];
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long comb[1001][1001];
int col[1001];
int k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
comb[0][0] = 1;
;
for (int i = 1; i <= 1000; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 or j == i)
comb[i][j] = 1;
else
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % 1000000007;
}
}
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> col[i];
}
long long cnt = 0;
long long ans = 1;
for (int i = 1; i <= k; i++) {
ans = (ans * comb[cnt + col[i] - 1][col[i] - 1]) % 1000000007;
cnt += col[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int c[1005];
int sum[1005];
long long dp[1005];
const int Mod = 1e9 + 7;
int Pow(long long x, int y) {
if (y == 0) {
return 1;
} else if (y == 1) {
return x;
}
if (y % 2 == 0) {
return Pow(x * x % Mod, y / 2) % Mod;
} else {
return Pow(x * x % Mod, y / 2) % Mod * x % Mod;
}
}
int inv(int x) { return Pow(x, Mod - 2) % Mod; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
sum[i] = sum[i - 1] + c[i];
}
dp[1] = 1;
for (int i = 2; i <= n; i++) {
int b = sum[i - 1] + c[i] - 1;
int a = c[i] - 1;
dp[i] = dp[i - 1];
for (int j = 1; j <= a; j++) {
dp[i] = (dp[i] * (b - j + 1)) % Mod;
dp[i] = (dp[i] * inv(j)) % Mod;
}
}
printf("%I64d", dp[n]);
return 0;
}
| 9 | CPP |
from math import factorial as f
n=int(input())
d=0
out=1
for i in range(n) :
m=int(input())
out=out*f(d+m-1)//f(d)//f(m-1)%1000000007
d+=m
print(out)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long fr[1005];
long long comb[1005][1005];
int main() {
for (long long i = 0; i < 1005; i++) {
comb[i][0] = 1;
}
for (long long i = 0; i < 1005; i++) {
comb[i][1] = i;
}
for (long long i = 2; i < 1005; i++) {
for (long long j = 2; j < 1005; j++) {
comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % 1000000007;
}
}
long long k;
scanf("%lld", &k);
long long n = 0;
for (long long i = 0; i < k; i++) {
long long in;
scanf("%lld", &in);
fr[i] = in;
n += in;
}
long long ans = 1;
long long curr;
for (long long i = k - 1; i >= 0; i--) {
n--;
curr = comb[n][fr[i] - 1];
n -= (fr[i] - 1);
ans = (ans * curr) % 1000000007;
}
printf("%lld\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
int k, cur_balls, balls;
long long int pre_ans, ans;
long long int table[1005][1005];
void C() {
memset(table, 0, sizeof(table));
for (int i = 0; i <= 1000; i++) {
table[i][0] = 1;
table[i][1] = i;
}
for (int i = 2; i <= 1000; i++) {
for (int j = 2; j <= i; j++) {
table[i][j] = table[i - 1][j] + table[i - 1][j - 1];
table[i][j] %= MOD;
}
}
}
int main(void) {
C();
while (1 == scanf("%d", &k)) {
pre_ans = 1;
scanf("%d", &balls);
if (k == 1) ans = 1;
for (int i = 1; i < k; i++) {
scanf("%d", &cur_balls);
ans = (pre_ans * table[balls + (cur_balls - 1)][balls]) % MOD;
pre_ans = ans;
balls += cur_balls;
}
printf("%lld\n", ans);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long c[1005];
long long best[1005];
long long f_exp(long long n, long long exp) {
n %= MOD;
if (exp > 1) {
if (exp & 1) {
return (n * f_exp(n, exp - 1)) % MOD;
} else {
return f_exp(n * n, exp >> 1) % MOD;
}
}
return !exp ? 1LL : n;
}
long long inv_mod(long long n) { return f_exp(n, MOD - 2); }
long long mult(initializer_list<long long> l) {
long long ans = 1;
for (auto each : l) {
ans = (ans * each) % MOD;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
long long fat[1005];
fat[0] = fat[1] = 1LL;
for (long long i = 2; i <= 1000; i++) {
fat[i] = (fat[i - 1] * i) % MOD;
}
int K;
cin >> K;
for (int i = 1; i <= K; i++) {
cin >> c[i];
}
best[1] = 1;
long long total = c[1];
for (int i = 2; i <= K; i++) {
total += c[i];
best[i] = mult({best[i - 1], fat[total - 1], inv_mod(fat[c[i] - 1]),
inv_mod(fat[(total - 1) - (c[i] - 1)])});
}
cout << best[K] << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
int a[k + 1];
for (int i = 0; i < k; i++) cin >> a[i];
long long int comb[1005][1005];
comb[0][0] = 1;
for (int i = 1; i < 1005; i++) {
comb[i][0] = 1;
for (int j = 1; j <= i; j++) {
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % 1000000007;
}
}
long long sum = 0, ans = 1;
for (int i = 0; i < k; i++) {
ans = (ans * comb[sum + a[i] - 1][a[i] - 1]) % 1000000007;
sum += a[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
from sys import stdin
from collections import deque
mod = 10**9 + 7
import sys
# sys.setrecursionlimit(10**6)
from queue import PriorityQueue
# def rl():
# return [int(w) for w in stdin.readline().split()]
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt,factorial,gcd,log2,inf,ceil
# map(int,input().split())
# # l = list(map(int,input().split()))
# from itertools import permutations
import heapq
# input = lambda: sys.stdin.readline().rstrip()
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
from itertools import permutations
from math import factorial as f
def ncr(x, y):
return f(x) // (f(y) * f(x - y))
n = int(input())
ans = 1
sm = 0
for _ in range(n):
x = int(input())
ans = (ans*ncr(sm+x-1,x-1))%mod
sm+=x
print(ans) | 9 | PYTHON3 |
s = int(input())
MOD = 1000000007
MAXN = 1000
dp = [[1] + [0 for i in range(MAXN)] for j in range(MAXN + 1)]
for i in range(1, MAXN + 1):
for j in range(1, i + 1):
dp[i][j] = (dp[i-1][j] + dp[i-1][j-1]) % MOD
ans = 1
acum = 0
for i in range(s):
x = int(input())
ans = (ans * dp[acum + x - 1][x - 1]) % MOD
acum += x
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30, MOD = 1000000007;
const long double eps = 1e-9;
int c[2000];
long long f[1000002], fobr[1000002], inv[1000002];
long long cnk[2000][2000];
int s[1005];
long long ans[1005];
int main() {
cnk[1][0] = cnk[1][1] = 1;
for (int i = 0; i < (int)1005; i++) cnk[i][0] = 1;
for (int n = 2; n < 1005; n++) {
for (int k = 1; k <= n; k++)
cnk[n][k] = (cnk[n - 1][k - 1] + cnk[n - 1][k]) % MOD;
}
int k;
cin >> k;
for (int i = 0; i < (int)k; i++) scanf("%d", &c[i]);
s[0] = c[0];
for (int i = 0; i < (int)k - 1; i++) s[i + 1] = s[i] + c[i + 1];
ans[0] = 1;
for (int i = 0; i < (int)k - 1; i++)
ans[i + 1] = (ans[i] * cnk[s[i + 1] - 1][c[i + 1] - 1]) % MOD;
cout << ans[k - 1];
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
const int MOD = 1E9 + 7;
const int N = 1E3 + 5;
int k;
int c[N];
long long sum, dp[N], a[N][N];
void solve() {
a[1][1] = 1;
a[2][1] = 1;
a[2][2] = 2;
a[2][3] = 1;
for (int i = 3; i < N - 3; i++) {
for (int j = 1; j <= i + 1; j++) {
a[i][j] = (a[i - 1][j] + a[i - 1][j - 1]) % MOD;
}
}
}
int main() {
cin >> k;
memset(a, 0, sizeof(a));
solve();
for (int i = 0; i < k; i++) scanf("%d", &c[i]);
memset(dp, 0, sizeof(dp));
dp[0] = 1;
sum = c[0] - 1;
for (int i = 1; i < k; i++) {
sum = (sum + c[i]);
dp[i] = (dp[i - 1] * a[sum][c[i]]) % MOD;
}
cout << dp[k - 1] % MOD << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
const long long MOD = 1000000007;
long long C[MAXN][MAXN];
int a[MAXN];
void db() {
C[0][0] = 1;
C[1][0] = 1;
C[1][1] = 1;
for (int i = 2; i < MAXN; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
C[i][j] %= MOD;
}
}
}
int main() {
int k;
db();
while (~scanf("%d", &k)) {
long long sum = 0;
for (int i = 1; i <= k; i++) {
scanf("%d", a + i);
sum += a[i];
}
long long ans = 1;
for (int i = k; i >= 1; i--) {
ans *= C[sum - 1][a[i] - 1];
ans %= MOD;
sum -= a[i];
}
printf("%I64d\n", ans);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
long long mod = 1000000007;
using namespace std;
long long a[1005], b[1005], c[1005][1005];
long long k;
void init() {
c[0][0] = 1;
for (int i = 1; i <= 1000; i++) {
for (int j = 0; j <= 1000; j++) {
if (!j)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
}
int main() {
init();
scanf("%I64d", &k);
for (long long i = 1; i <= k; i++) {
scanf("%I64d", &a[i]);
b[i] = b[i - 1] + a[i];
}
long long ans = 1;
for (int i = k; i >= 1; i--) ans = (ans * c[b[i] - 1][a[i] - 1]) % mod;
printf("%I64d", ans);
return 0;
}
| 9 | CPP |
k=int(input())
mod=10**9+7
f=[0]*(10**6+1)
f[0]=f[1]=1
for i in range(2,10**6+1):
f[i]=(f[i-1]*i)%mod
def comb(n,r):
return (f[n]*pow(f[r],mod-2,mod)*pow(f[n-r],mod-2,mod))%mod
ans=1
cc=int(input())
for i in range(1,k):
c=int(input())
cc+=c
ans*=comb(cc-1,c-1)
ans%=mod
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 5;
const int MOD = 1e9 + 7;
const int INF = 2e9;
int arr[MAXN];
long long C[MAXN][MAXN];
void precalc() {
C[1][1] = 1;
for (int i = 2; i <= 1000; i++)
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
}
long long bin_mult(long long A, long long B, long long md) {
long long RES = 0;
while (B) {
if (B & 1) RES = (RES + A) % md;
A = (A + A) % md;
B >>= 1;
}
return RES;
}
int main() {
precalc();
int N = 0;
long long RES = 1;
scanf("%i", &N);
for (int i = 1; i <= N; i++) scanf("%i", &arr[i]);
long long prevI = arr[1];
for (int i = 2; i <= N; i++) {
RES = bin_mult(RES, C[arr[i] + prevI][arr[i]], MOD);
prevI += arr[i];
}
printf("%I64d", RES);
return 0;
}
| 9 | CPP |
mod = 10**9+7
k = int(input())
maxi = 1001
arr = []
for i in range(k):
arr.append(int(input()))
C = [[0 for i in range(maxi)] for i in range(maxi)]
for i in range(maxi):
for j in range(i+1):
if i == j:
C[i][j] = 1
else:
C[i][j] = C[i-1][j-1] + C[i-1][j]
ans = 1
tot = arr[0]
for i in arr[1:]:
tot += i
ans = ans*(C[tot-1][i-1])%mod
print(ans%mod) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long nck[1005][1005];
long long m(long long a) {
return ((a % 1000000007) + 1000000007) % 1000000007;
}
long long ncr(long long n, long long r) {
if (r > n) return 0ll;
if (n == r || r == 0) return 1ll;
if (nck[n][r] != 0) return nck[n][r];
return nck[n][r] = m(ncr(n - 1, r) + ncr(n - 1, r - 1));
}
int main() {
int k;
scanf("%d", &k);
vector<int> a(k);
for (int &i : a) scanf("%d", &i);
vector<long long> dp(1005);
dp[1] = 1;
long long sm = a[0];
for (int i = 2; i <= k; i++) {
sm += a[i - 1];
dp[i] = m(dp[i - 1] * ncr(sm - 1, a[i - 1] - 1));
}
printf("%lld\n", dp[k]);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
long long c[1100][1100];
int main() {
int n, x;
cin >> n;
cin >> x;
long long ans = 1, sum = x;
c[1][1] = c[1][0] = 1;
for (int i = 2; i <= 1000; i++)
for (int j = 0; j <= i; j++) {
if (j == 0) c[i][j] = 1;
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
c[i][j] %= Mod;
}
for (int i = 1; i < n; i++) {
cin >> x;
long long res = c[sum + x - 1][sum];
ans *= res;
ans %= Mod;
sum += x;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
n = int(input())
a = [0]
s = [0]
md = 1000000007
for i in range(n) :
x = int(input())
a.append(x)
s.append(s[len(s)-1]+x)
def factor(x) :
total = 1
for i in range(2,x+1) : total*=i
return total
ans = 1
for i in range(2,n+1) :
ans*=factor(s[i-1]+a[i]-1)//factor(s[i-1])//factor(a[i]-1)
ans%=md
print(ans)
| 9 | PYTHON3 |
MOD = 1000000007
MAX_BALLS = 1000
def initFactors():
factors = [1]
for i in range(1, MAX_BALLS + 1):
last_fact = factors[-1]
factors.append(last_fact * i)
return factors
n_colors = int(input())
factors = initFactors()
balls = []
for i in range(n_colors):
balls.append(int(input()))
res = 1
l = balls[0]
for i in range(1, n_colors):
res *= ((factors[l + balls[i] - 1] // (factors[l] * factors[balls[i] - 1])) % MOD)
l += balls[i]
print(res % MOD) | 9 | PYTHON3 |
n = int(input())
balls = []
for i in range (n):
balls.append(int(input()))
ans = 1
urns = balls[0] + 1
def theorem(n, k): # n urns k balls
ret = 1
for i in range(1, k+1):
ret = ret * (n+k-i)
for i in range(1, k+1):
ret = ret // i
return ret
for i in range (1, n):
ans *= theorem(urns, balls[i]-1) % 1000000007
urns += balls[i]
print (ans % 1000000007)
| 9 | PYTHON3 |
MOD = int(1e9+7)
def nCr(n, r):
if 2 * r > n:
r = n - r
res = 1
for i in range(r):
res = res * (n-i) // (i+1)
return res
k = int(input())
n2 = int(input())
res = 1
for i in range(k-1):
n1 = n2
n2 += int(input())
res = res * nCr(n2 - 1, n1) % MOD
print(res)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long int dp[2000][2000];
int arr[10010];
int main() {
int i, j, k;
cin >> k;
for (i = 0; i < k; ++i) cin >> arr[i];
for (i = 0; i < 2000; ++i) {
dp[i][0] = dp[i][i] = 1;
for (j = 1; j < i; ++j)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % 1000000007;
}
int tot = 0;
long long int ans = 1;
for (i = 0; i < k; ++i) {
ans = (ans * dp[tot + arr[i] - 1][arr[i] - 1]) % 1000000007;
tot += arr[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
# coding=utf-8
def com(lo, hi):
loo = 1
for i in range(1, lo + 1):
loo *= i
hii = 1
for i in range(hi, hi - lo, -1):
hii *= i
return hii // loo
n = int(input())
data = [int(input()) for i in range(n)]
ans = 1
total = sum(data)
for i in range(len(data) - 1, -1, -1):
ans *= com(data[i] - 1, total - 1)
total -= data[i]
print(ans if ans < 1000000007 else ans % 1000000007)
| 9 | PYTHON3 |
MOD = 1000000007
k = int(input())
c = [int(input()) for i in range(k)]
total_c = sum(c)
comb = [[0]*(max(c)+1) for i in range(total_c+1)]
comb[0][0] = 1
for i in range(1,len(comb)):
comb[i][0] = 1
for j in range(1,len(comb[0])):
comb[i][j] = comb[i-1][j-1] + comb[i-1][j]
comb[i][j] %= MOD
w = [0]*(total_c+1)
w[0] = 1
for color in range(k):
new_w = [0]*len(w)
for n in range(len(new_w)):
new_w[n] = w[n]
for i in range(c[color]):
if n-i-1 < 0: break
new_w[n] += comb[n-1][i]*w[n-i-1]
new_w[n] %= MOD
w = new_w
print(w[total_c]) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long c[1001][1001];
for (long long i = 0; i < 1001; i++) {
for (long long j = 0; j < i + 1; j++) {
if (i == 0 || j == 0)
c[i][j] = 1;
else
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
c[i][j] %= 1000000007;
}
}
long long k;
cin >> k;
long long r[k];
long long s = 0;
for (long long i = 0; i < k; i++) {
cin >> r[i];
s += r[i];
}
long long ans = 1;
for (long long i = k - 1; i >= 0; i--) {
ans = ans * c[s - 1][r[i] - 1];
ans %= 1000000007;
s -= r[i];
}
cout << ans % 1000000007;
}
| 9 | CPP |
n = 1000
mod = 10**9 + 7
pascal = [[1]]
for r in range(1, n+1):
previous_row = pascal[-1]
row = [1]
for c in range(1, r):
row.append((previous_row[c-1] + previous_row[c]) % mod)
row.append(1)
pascal.append(row)
k = int(input())
length = int(input())
product = 1
for i in range(1, k):
curr = int(input())
product *= pascal[length + curr - 1][length]
product %= mod
length += curr
print(product)
| 9 | PYTHON3 |
from math import factorial
n = int(input())
ans = 1
s = 0
for i in range(n) :
a = int(input())
ans*=factorial(s+a-1)//factorial(s)//factorial(a-1)
ans%=1000000007
s+=a
print(ans)
| 9 | PYTHON3 |
ans, col, mod = 1, 0, 1000000007
C = [[1 if i <= j else 0 for i in range(1001)] for j in range(1001)]
for i in range(1, 1001):
for j in range(1, i + 1):
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod
for _ in range(int(input())):
a = int(input())
ans *= C[col + a - 1][col]
ans %= mod
col += a
print(ans)
| 9 | PYTHON3 |
from math import exp
def pfold (arr):
return arr[0] * pfold (arr[1:]) if arr else 1
def pscan (x, arr):
arr = (pscan (x * arr[-1], arr[:-1]) if arr else [])
arr.append(x)
return arr
def P(n, r):
return pfold(range(n, n-r, -1))
def F(n):
return P(n, n)
#return reduce(op.mul, range(n, 0, -1), 1)
def C(n, r):
if (r > n): return 0
r = min(r, n-r)
return P(n, r)//F(r)
def AC(a, b):
return C(a+b-1, b-1)
def CCC(n, k):
return AC(n, k)/F(k)
def Cat(n):
return C(2*n,n+1)/n
def Cat2(n):
return
def dot(a,b):
return sum(i*j for i, j in zip(a,b))
def Catray(n):
arr = [1]
for i in range(1,n):
arr = arr + [dot(arr,arr[::-1])]
return arr
# binomial distribution:
# with an event E which has probability p of occuring every try,
# what is the chance of E occuring exactly k times from n tries
def Bd (n, p, k):
return C(n,k)*p**k*(1-p)**(n-k)
# evaluate the sum of the binomial distribution in the range [0, k]
def BdS (n, p, k):
return sum(Bd(n, p, i) for i in range(k+1))
def Normal (mu, sigma, k):
return 0
# exponential distribution
def Ed (p, k):
return (1-p)*p**(k-1)
def EdS (p, k):
return 1 - p**k
def Pd (x, k):
return x**k/F(k) * exp(-x)
def PdS (x, k):
return (sum(pscan (1, [x/i for i in range (k, 0, -1)]))) * exp(-x)
#def PPP(n, k, m):
def nTermsSumToXInRangeAToB(n, x, a, b): # a <= b
x -= a*n
b -= a
if x < 0 or x > b*n:
return 0
else:
return nTermsUnderASumToX(n, x, b+1, 0)
def nTermsUnderASumToX(n, x, a, b):
if x < 0:
return 0
else:
return AC(x,n) - (n-b)*nTermsUnderASumToX(n, x-a, a, b+1)
def f(n, x, a, b):
return nTermsSumToXInRangeAToB(n, x, a, b)
M = 10**9+7
k = int(input())
v = 1
n = 0
for _ in range(k):
c = int(input())
v *= C(n+c-1,c-1)
v %= M
n+= c
print(v)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if ((a == 0) || (b == 0)) return a + b;
return gcd(b, a % b);
}
long long pow_mod(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long dp[1010], arr[2010], way = 1, fact[1010], ifact[1010];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long K, i, j, ans, opop;
fact[0] = 1;
for (i = 1; i <= 1002; i++) {
fact[i] = ((fact[i - 1] * i) % 1000000007);
}
ifact[1002] = pow_mod(fact[1002], 1000000007 - 2);
for (i = 1001; i >= 0; i--) {
ifact[i] = ((ifact[i + 1] * (i + 1)) % 1000000007);
}
cin >> K;
for (i = 1; i <= K; i++) {
cin >> arr[i];
}
ans = arr[1];
for (i = 2; i <= K; i++) {
ans += arr[i];
ans--;
opop = ((fact[ans] *
((ifact[arr[i] - 1] * ifact[ans - arr[i] + 1]) % 1000000007)) %
1000000007);
way = ((way * opop) % 1000000007);
ans++;
}
cout << way;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int k, c[1010];
long long dp[1010][1010];
long long calc(int id, int ball) {
if (id == 1)
return 1;
else if (ball == 0)
return 1;
long long& ans = dp[id][ball];
if (ans == -1)
ans = (calc(id - 1, ball) % MOD + calc(id, ball - 1) % MOD) % MOD;
return ans;
}
int main(void) {
cin >> k;
for (int i = 0; i < k; i++) {
cin >> c[i];
}
memset(dp, -1, sizeof(dp));
long long ans = 1;
int ball = 1;
for (int i = 0; i < k; i++) {
ans *= calc(ball, c[i] - 1);
ans %= MOD;
ball += c[i];
}
cout << ans << "\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int MOD = 1000000007;
int dp[1001][1001];
int main() {
int k;
cin >> k;
int balls[1000];
int n = 0;
for (int i = 0; i < k; i++) {
cin >> balls[i];
n += balls[i];
}
long long l = 1;
for (int i = 0; i <= n; i++) {
dp[i][0] = 1;
dp[i][i] = 1;
for (int j = 1; j <= i; j++) {
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % MOD;
}
}
long long ans = 1;
int cur = balls[0];
for (int i = 1; i < k; i++) {
cur += balls[i];
ans = ((ans % MOD) * (dp[cur - 1][balls[i] - 1]) % MOD) % MOD;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007, pas[1005][1005];
class TaskC {
public:
void solve(istream& in, ostream& out) {
for (int i = 0; i < 1005; i++)
for (int j = 0; j < 1005; j++) pas[0][j] = pas[i][j] = 1;
for (int i = 2; i < 1005; i++)
for (int j = 1; j < i; j++) {
pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
pas[i][j] %= mod;
}
int k;
in >> k;
long long ans = 1;
vector<long long> c(k), psum(k);
for (int i = 0; i < k; ++i) in >> c[i];
partial_sum(c.begin(), c.end(), psum.begin());
for (int i = k - 1; i > 0; i--) {
ans *= pas[psum[i] - 1][c[i] - 1];
ans %= mod;
}
out << ans;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
TaskC solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long k;
vector<long long> c;
vector<long long> tot;
long long dp[1002][1002];
long long C[1002][1002];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> k;
c.resize(k + 1);
tot.resize(k + 1, 0);
tot[0] = 0;
c[0] = 0;
for (int i = 1; i <= k; i++) {
cin >> c[i];
tot[i] = tot[i - 1] + c[i];
}
for (int i = 0; i < 1001; i++) C[0][i] = 0;
C[0][0] = 1;
for (int i = 1; i <= 1001; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0) {
C[i][j] = 1;
continue;
}
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007;
}
}
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
for (int i = 1; i <= k; i++) {
for (int j = tot[k] - (k - i); j >= tot[i]; j--) {
int voids = j - tot[i - 1];
for (int l = j - 1; l >= tot[i - 1]; l--) {
dp[i][j] =
(dp[i][j] + dp[i - 1][l] * (C[voids - 1][c[i] - 1])) % 1000000007;
}
}
}
cout << dp[k][tot[k]] << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int INF = -10000000;
const double pi = acos(-1.0);
int a[1010];
int c[1010][1010];
void init() {
for (int i = 0; i < 1010; i++) c[i][0] = 1;
for (int i = 1; i < 1010; i++) {
for (int j = 1; j <= i; j++) {
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
c[i][j] %= 1000000007;
}
}
}
int main() {
init();
int k, s;
while (scanf("%d", &k) != EOF) {
s = 0;
for (int i = 0; i < k; i++) {
scanf("%d", a + i);
s += a[i];
}
long long ans = 1;
for (int i = k - 1; i > 0; i--) {
ans *= (long long)c[s - 1][a[i] - 1];
ans %= 1000000007;
s -= a[i];
}
printf("%d\n", ans);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a[1005], num[1005];
long long poww(long long n, long long m) {
long long b = 1;
while (m > 0) {
if (m & 1) b = (b * n) % 1000000007;
m >>= 1;
n = (n * n) % 1000000007;
}
return b;
}
long long solve(int n, int m) {
return ((num[n] % 1000000007) *
(poww((num[m] * num[n - m]) % 1000000007, 1000000007 - 2)) %
1000000007) %
1000000007;
}
int main() {
num[0] = 1;
num[1] = 1;
for (int i = 2; i <= 1005 - 5; i++) {
num[i] = (num[i - 1] * i) % 1000000007;
}
long long m, n = 0;
scanf("%I64d", &m);
for (int i = 1; i <= m; i++) {
scanf("%I64d", &a[i]);
n += a[i];
}
long long answer = 1;
for (int i = m; i >= 1; i--) {
answer = (answer * solve(n - 1, a[i] - 1)) % 1000000007;
n -= a[i];
}
printf("%I64d\n", answer);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int c[1005];
int sum[1005];
long long dp[1005];
int C[1005][1005];
const int Mod = 1e9 + 7;
void pre_C() {
C[1][0] = C[1][1] = 1;
for (int i = 2; i <= 1000; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0) {
C[i][0] = 1;
} else if (j == 1) {
C[i][1] = i % Mod;
} else {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
C[i][j] %= Mod;
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
sum[i] = sum[i - 1] + c[i];
}
pre_C();
dp[1] = 1ll;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] * C[sum[i - 1] + c[i] - 1][c[i] - 1];
dp[i] %= Mod;
}
printf("%I64d", dp[n]);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool isvowel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'A' ||
c == 'E' || c == 'I' || c == 'O' || c == 'U')
return true;
return false;
}
bool prime[5000001];
int spf[5000001];
vector<int> primes;
void sieve() {
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= 5000000; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= 5000000; i += p) {
prime[i] = false;
if (spf[i] == 0) spf[i] = p;
}
}
}
for (int p = 2; p <= 5000000; p++)
if (prime[p]) primes.push_back(p);
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int fast_exp(long long int x, long long int n) {
long long int ans = 1;
while (n) {
if (n & 1) ans *= x;
n = n >> 1;
x = x * x;
}
return ans;
}
long long int mod_exp(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int pre_sum[2000005];
vector<int> adj[2000005];
long long int dp[2000005];
void solve() {
dp[0] = 1;
for (long long int i = 1; i <= 1000; i++) {
dp[i] = (dp[i - 1] * i) % 1000000007;
}
long long int k, n;
cin >> k;
long long int ans = 1, sum = 0;
while (k--) {
cin >> n;
sum += n;
long long int x = dp[n - 1];
long long int y = dp[sum - 1];
long long int xinv = mod_exp(x, 1000000007 - 2, 1000000007);
long long int res = (y * xinv) % 1000000007;
x = dp[sum - 1 - (n - 1)];
xinv = mod_exp(x, 1000000007 - 2, 1000000007);
res = (res * xinv) % 1000000007;
ans = (ans * res) % 1000000007;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
solve();
cout << '\n';
}
}
| 9 | CPP |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.