input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
print(("Even" if eval(input().replace(" ","*"))%2==0 else "Odd"))
|
a,b=list(map(int,input().split()))
if a*b%2==0:
print("Even")
else:
print("Odd")
|
p03455
|
a,b = list(map(int,input().split()))
if (a * b) % 2 == 1:
print("Odd")
else:
print("Even")
|
a,b = list(map(int,input().split()))
if a*b % 2 == 1:
print("Odd")
else:
print("Even")
|
p03455
|
a,b=list(map(int,input().split()))
if a*b%2:
print('Odd')
else:
print('Even')
|
a,b=list(map(int,input().split()))
if a*b%2==0:
print('Even')
else:
print('Odd')
|
p03455
|
a,b = input().split()
if (int(a)*int(b))%2==0:
print("Even")
else:
print("Odd")
|
a,b = list(map(int,input().split()))
print(("Even" if a*b%2==0 else "Odd"))
|
p03455
|
a,b = list(map(int,input().split()))
print(("Even" if a*b%2==0 else "Odd"))
|
a,b=list(map(int,input().split()))
print(("Odd" if a*b%2 else "Even"))
|
p03455
|
a, b = list(map(int, input().split()))
if a%2 == 0 or b%2 == 0:
print("Even")
else:
print("Odd")
|
a, b = list(map(int, input().split()))
if (a*b)%2 == 0:
print("Even")
else:
print("Odd")
|
p03455
|
x, y = list(map(int, input().split()))
if x * y % 2:
print('Odd')
else:
print('Even')
|
a, b = list(map(int, input().split()))
if (a*b)%2 == 0:
print("Even")
else:
print("Odd")
|
p03455
|
a,b=list(map(int,input().split()))
def evenodd(a,b):
if a*b%2==1:
return "Odd"
else:
return"Even"
print((evenodd(a,b)))
|
a,b=list(map(int,input().split()))
if a*b%2==1:
print('Odd')
else:
print('Even')
|
p03455
|
a,b = list(map(int, input().split()))
c = a * b
if c % 2 == 0:
print("Even")
else:
print("Odd")
|
a, b = list(map(int, input().split()))
if (a*b % 2) == 0:
print("Even")
else:
print("Odd")
|
p03455
|
# -*- coding: utf-8 -*-
# スペース区切りの整数の入力
a, b = list(map(int, input().split()))
c = a * b
if c % 2 == 0:
print("Even")
else:
print("Odd")
|
i = list(map(int, input().split()))
j = i[0] * i[1]
if j % 2 == 0:
print("Even")
else:
print("Odd")
|
p03455
|
a,b = list(map(int,input().split()))
if (a*b) % 2 == 0:
print('Even')
else:
print('Odd')
|
a,b = list(map(int,input().split()))
if a*b%2==0:
print('Even')
else:
print('Odd')
|
p03455
|
[a, b] = list(map(int, input().split()))
if a * b % 2 == 0:
print("Even")
else:
print("Odd")
|
a, b = list(map(int, input().split()))
if a * b % 2 == 0:
print("Even")
else:
print("Odd")
|
p03455
|
a, b = list(map(int, input().split()))
print(("Even" if a * b % 2 == 0 else "Odd"))
|
a, b = list(map(int, input().split(' ')))
print(("Even" if a % 2 == 0 or b % 2 == 0 else "Odd"))
|
p03455
|
a, b = list(map(int, input().split()))
if a * b % 2 == 0:
print("Even")
else:
print("Odd")
|
a, b = list(map(int, input().split()))
print(('Even' if a*b % 2 == 0 else 'Odd'))
|
p03455
|
for _ in range(10**7*5):None
a,b=list(map(int,input().split()))
print(('EOvdedn'[a*b%2::2]))
|
print(('EOvdedn'[eval(input().replace(*' *'))%2::2]))
|
p03455
|
a, b = list(map(int, input().split()))
if (a*b) % 2:
print("Odd")
else:
print("Even")
|
x = input().split()
a =int(x[0])
b =int(x[1])
if (a*b) % 2:
print("Odd")
else:
print("Even")
|
p03455
|
x = input().split()
a =int(x[0])
b =int(x[1])
if (a*b) % 2:
print("Odd")
else:
print("Even")
|
x = input().split()
y = int(x[0])*int(x[1])
if y % 2:
print("Odd")
else:
print("Even")
|
p03455
|
x = input().split()
y = int(x[0])*int(x[1])
if y%2 == 1:
print("Odd")
else:
print("Even")
|
a,b = list(map(int,input().split()))
if a*b%2:
print("Odd")
else:
print("Even")
|
p03455
|
a,b = list(map(int,input().split()))
if (a*b)%2 != 0:
print("Odd")
else:
print("Even")
|
a, b = list(map(int, input().split()))
num = a*b
if num % 2==0:
print("Even")
else:
print("Odd")
|
p03455
|
a, b = list(map(int, input().split()))
if (a*b)%2:
print("Odd")
else:
print("Even")
|
a, b = list(map(int, input().split()))
if (a*b)%2 == 1:
print("Odd")
else:
print("Even")
|
p03455
|
a, b = list(map(int, input().split())) # 5 7
if (a*b)%2 == 0:
print('Even')
else:
print('Odd')
|
a, b = list(map(int, input().split()))
if a%2==0 or b%2==0:
print("Even")
else:
print("Odd")
|
p03455
|
a, b = list(map(int, input().split()))
if a*b%2 == 1:
print("Odd")
else:
print("Even")
|
a, b = list(map(int, input().split()))
print(('Odd'if a&b&1 else 'Even'))
|
p03455
|
a, b = list(map(int, input().split()))
a = int(a)
b = int(b)
i = a*b
if i%2 == 0:
print('Even')
else:
print('Odd')
|
a, b = list(map(int, input().split()))
i = a * b
if i % 2 ==0:
print('Even')
else:
print('Odd')
|
p03455
|
# -*- coding: utf-8 -*-
a, b = list(map(int, input().split()))
if a * b % 2 == 0:
print('Even')
else:
print('Odd')
|
# -*- coding: utf-8 -*-
a, b = list(map(int, input().split()))
out = ['Even', 'Odd']
print((out[a * b % 2]))
|
p03455
|
string = input().split(' ')
first = string[0]
second = string[1]
if int(first)*int(second)%2 == 0:
print("Even")
else:
print("Odd")
|
s = input().split(" ")
a = int(s[0])
b = int(s[1])
if (a*b)%2 == 0:
print("Even")
else:
print("Odd")
|
p03455
|
def ketanowa(p):
ans=0
p=str(p)
for i in p:
ans+=int(i)
return ans
def main():
temp=input().split(" ")
n=int(temp[0])
a=int(temp[1])
if n*a%2==0:
print("Even")
else:
print("Odd")
if __name__ == '__main__':
main()
|
a,b=input().split()
c=int(a)*int(b)
if c%2==0:
print("Even")
else:
print("Odd")
|
p03455
|
a,b=list(map(int,input().split()))
if a*b % 2 ==0:
print("Even")
else:
print("Odd")
|
a,b=list(map(int,input().split()))
if (a*b)%2==0:
print("Even")
else:
print("Odd")
|
p03455
|
a,b=list(map(int,input().split()))
if a%2==0 or b%2==0:
print("Even")
else:
print("Odd")
|
a,b = list(map(int,input().split()))
if a%2==1 and b%2==1:
print("Odd")
else:
print("Even")
|
p03455
|
a = list(map(int, input().split()))
if(a[0] * a[1] % 2 == 0):
print('Even')
else:
print('Odd')
|
a,b = list(map(int, input().split()))
if(a * b % 2 == 0):
print('Even')
else:
print('Odd')
|
p03455
|
a,b = list(map(int,input().split()))
ans = 0
if a*b%2==0:
print('Even')
else:
print('Odd')
|
R= list(map(int,input().split()))
if R[0] * R[1] % 2 == 0:
print('Even')
else:
print('Odd')
|
p03455
|
a,b = [int(s) for s in input().split()]
print((('Even', 'Odd')[(a*b)%2]))
|
a,b = list(map(int, input().split()))
if ((a*b) % 2):
print('Odd')
else:
print('Even')
|
p03455
|
a, b = list(map(int, input().split()))
if a % 2 == 1 and b % 2 == 1:
print("Odd")
else:
print("Even")
|
def resolve():
a, b = list(map(int, input().split()))
if a % 2 == 1 and b % 2 == 1:
print("Odd")
else:
print("Even")
resolve()
|
p03455
|
a, b = list(map(int, input().split()))
sum = a*b
if sum % 2 == 0:
print("Even")
else:
print("Odd")
|
a, b = list(map(int,input().split()))
if (a*b) % 2 == 0:
print("Even")
else:
print("Odd")
|
p03455
|
a, b = list(map(int, input().split()))
if (a * b % 2) == 0:
print('Even')
else:
print('Odd')
|
a, b = list(map(int, input().split()))
if (a * b) % 2 == 0:
print('Even')
else:
print('Odd')
|
p03455
|
a, b = list(map(int, input().split()))
if a * b % 2 == 0:
print('Even')
else:
print('Odd')
|
a, b = list(map(int, input().split()))
print(('Odd' if a * b % 2 == 1 else 'Even'))
|
p03455
|
a,b = list(map(int, input().split()))
if a*b % 2 == 0:
print("Even")
else:
print("Odd")
|
a,b = list(map(int, input().split()))
ans = a * b
if ans % 2 == 0:
print("Even")
else:
print("Odd")
|
p03455
|
a, b = list(map(int, input().split()))
A=(a*b)%2
if A==0:
print("Even")
else:
print("Odd")
|
a,b=list(map(int,input().split()))
c=(a*b)%2
if c==1:
print('Odd')
else:
print('Even')
|
p03455
|
n = int(eval(input()))
x = [int(x) for x in input().split()]
inf = 10**9+7
a = 1
for i in range(n-1, 0, -1):
a *= i
b = a
key = 0
ans = 0
for i in range(n-1):
key += a//(i+1)
key %= inf
ans += key*(x[i+1]-x[i])
ans %= inf
print(ans)
|
n = int(eval(input()))
x = [int(x) for x in input().split()]
inf = 10**9+7
a = 1
for i in range(n-1, 0, -1):
a *= i
a %= inf
b = a
key = 0
ans = 0
for i in range(n-1):
key += a*pow((i+1), inf-2, inf)
key %= inf
ans += key*(x[i+1]-x[i])
ans %= inf
print(ans)
|
p02807
|
# modulo:mod
# inverse x^(-1)
def inv(x):
global mod
return pow(x,mod-2,mod)
# factorial x!
def fact(x):
global mod
res=1
for i in range(2,x+1):
res=res*i%mod
return res
# combination nCr
def combi(n,r):
if r<0 or r>n:
return 0
else:
return fact(n)*inv(fact(r))*inv(fact(n-r))%mod
mod=10**9+7
N=int(eval(input()))
x=[0]
x.extend(list(map(int,input().split())))
invs=[inv(d) for d in range(N)]
# print(invs)
ans=0
for i in range(1,N):
for j in range(i+1,N):
temp=(x[j]-x[i])*invs[j-i]*invs[j-i+1]%mod
ans=(ans+temp)%mod
temp=(x[N]-x[i])*invs[N-i]%mod
ans=(ans+temp)%mod
ans=ans*fact(N-1)%mod
print(ans)
|
# modulo:mod
# inverse x^(-1)
def inv(x):
global mod
return pow(x,mod-2,mod)
# factorial x!
def fact(x):
global mod
res=1
for i in range(2,x+1):
res=res*i%mod
return res
# combination nCr
def combi(n,r):
if r<0 or r>n:
return 0
else:
return fact(n)*inv(fact(r))*inv(fact(n-r))%mod
mod=10**9+7
N=int(eval(input()))
x=[0]
x.extend(list(map(int,input().split())))
invs=[inv(d) for d in range(N)]
# print(invs)
ans=0;s=0
for d in range(1,(N-1)//2+1):
s=(s+x[N-d]-x[d])%mod
ans=(ans+s*invs[d]*invs[d+1])%mod
if d!=N-d-1:
ans=(ans+s*invs[N-d-1]*invs[N-d])%mod
for i in range(1,N):
ans=(ans+(x[N]-x[i])*invs[N-i])%mod
ans=ans*fact(N-1)%mod
print(ans)
|
p02807
|
#coding:utf-8
import sys
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = lambda *something : print(*something) if DEBUG else 0
DEBUG = False
def main(given = sys.stdin.readline):
input = lambda : given().rstrip()
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
XLMIIS = lambda x : [LMIIS() for _ in range(x)]
MOD = 10**9+7
from math import factorial
N = II()
X = LMIIS()
# f = factorial(N-1)
# def calc(k,slimes):
# # print(slimes)
# if k == N-1:
# return 0
# r = 0
# # for i in range(N-k-1):
# # slimes2 = slimes[:]
# # r = (slimes2[i+1]-slimes2[i]) / float(N-k-1)
# # slimes2.pop(i)
# # r += calc(k+1,slimes2) % MOD
# i = N-k-2
# slimes2 = slimes[:]
# print(i,slimes2)
# r = (slimes2[i+1]-slimes2[i]) * f / (N-k-1) % MOD
# slimes2.pop(i)
# r += calc(k+1,slimes2)
# return r % MOD
f = factorial(N-1) % MOD
def calc(k,slimes):
r = 0
for k in range(N-1):
r += (slimes[-1]-slimes[-2-k]) * f * pow((N-k-1),MOD-2,MOD)
r %= MOD
return r
print(calc(0,X))
if __name__ == '__main__':
main()
|
#coding:utf-8
import sys
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = lambda *something : print(*something) if DEBUG else 0
DEBUG = False
def main(given = sys.stdin.readline):
input = lambda : given().rstrip()
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
XLMIIS = lambda x : [LMIIS() for _ in range(x)]
MOD = 10**9+7
from math import factorial
N = II()
X = LMIIS()
f = factorial(N-1) % MOD
def calc(k,slimes):
r = 0
for k in range(N-1):
r += (slimes[-1]-slimes[-2-k]) * f * pow((N-k-1),MOD-2,MOD)
r %= MOD
return r
print(calc(0,X))
if __name__ == '__main__':
main()
|
p02807
|
import sys
input = sys.stdin.readline
def inv(x):
return pow(x, MOD-2, MOD)
def C(n, r):
return fact[n]//fact[r]//fact[n-r]
N = int(eval(input()))
x = list(map(int, input().split()))
ans = 0
MOD = 10**9+7
fact = [1]
for i in range(1, N):
fact.append(fact[-1]*i)
for i in range(N-1):
for j in range(i+1, N):
#print(i, j)
r = j-i+1
if j==N-1:
r = N-2-i+1
ans += (x[j]-x[i])*C(N-1, r)*fact[r-1]*fact[N-1-r]
#print(C(N-1, r-1)*fact[N-1-r+1]*fact[r-2])
else:
r = j-i+1
ans += (x[j]-x[i])*C(N-1, r)*fact[j-i-1]*fact[N-1-r]
#print(x[j]-x[i])
#print(C(N-1, r)*fact[N-1-r]*fact[r-2])
#ans += (x[j]-x[i])*C(N-1, r)*fact[N-1-r]
#print('ans:', ans)
ans %= MOD
#ans *= fact[N-1]
ans %= MOD
print(ans)
|
N = int(eval(input()))
x = list(map(int, input().split()))
MOD = 10**9+7
D = x[-1]-x[0]
ans = 0
fact = [1]
for i in range(1, N):
fact.append(fact[-1]*i%MOD)
inv_table = [-1]*N
for i in range(N):
inv_table[i] = pow(i, MOD-2, MOD)
for i in range(N-1):
d = D-(x[i]-x[0])
ans += d*fact[N-1]*inv_table[i+1]
ans %= MOD
print(ans)
|
p02807
|
N = int(eval(input()))
x = list(map(int, input().split()))
MOD = 10**9+7
D = x[-1]-x[0]
ans = 0
fact = [1]
for i in range(1, N):
fact.append(fact[-1]*i%MOD)
inv_table = [-1]*N
for i in range(N):
inv_table[i] = pow(i, MOD-2, MOD)
for i in range(N-1):
d = D-(x[i]-x[0])
ans += d*fact[N-1]*inv_table[i+1]
ans %= MOD
print(ans)
|
import sys
input = sys.stdin.readline
def inv(x):
return pow(x, MOD-2, MOD)
N = int(eval(input()))
x = list(map(int, input().split()))
ans = 0
MOD = 10**9+7
fact = [1]
for i in range(1, N+1):
fact.append(fact[-1]*i%MOD)
inv_table = [-1]*(N+1)
for i in range(N+1):
inv_table[i] = inv(i)
inv_acc = [0]
for inv_i in inv_table:
inv_acc.append(inv_acc[-1]+inv_i)
for i in range(N-1):
ans += (x[i+1]-x[i])*(inv_acc[i+2]-inv_acc[1])
ans %= MOD
ans *= fact[N-1]
ans %= MOD
print(ans)
|
p02807
|
class Factorial():
def __init__(self, n, mod):
self.mod = mod
self.factorial = [0 for _ in range(n + 1)]
self.inv = [0 for _ in range(n + 1)]
self.factorial[0] = 1
self.inv[0] = 1
for i in range(n):
self.factorial[i + 1] = self.factorial[i] * (i + 1) % mod
self.inv[n] = pow(self.factorial[n], mod - 2, mod)
for i in range(n)[::-1]:
self.inv[i] = self.inv[i + 1] * (i + 1) % mod
def fact(self, m):
return self.factorial[m]
def invfact(self, m):
return self.inv[m]
MOD = 10**9 + 7
N = int(eval(input()))
X = list(map(int, input().split()))
D = [X[i + 1] - X[i] for i in range(N - 1)]
F = Factorial(N + 1, MOD)
res = 0
f = 0
for i in range(N - 1):
f = (i + 1) * f + F.fact(i)
res += D[i] * f * F.invfact(i + 1) * F.fact(N - 1)
res %= MOD
print(res)
|
class Factorial():
def __init__(self, n, mod):
self.mod = mod
self.factorial = [0 for _ in range(n + 1)]
self.inv = [0 for _ in range(n + 1)]
self.factorial[0] = 1
self.inv[0] = 1
for i in range(n):
self.factorial[i + 1] = self.factorial[i] * (i + 1) % mod
self.inv[n] = pow(self.factorial[n], mod - 2, mod)
for i in range(n)[::-1]:
self.inv[i] = self.inv[i + 1] * (i + 1) % mod
def fact(self, m):
return self.factorial[m]
def invfact(self, m):
return self.inv[m]
MOD = 10**9 + 7
N = int(eval(input()))
X = list(map(int, input().split()))
D = [X[i + 1] - X[i] for i in range(N - 1)]
F = Factorial(N + 1, MOD)
res = 0
f = 0
for i in range(N - 1):
f = (i + 1) * f + F.fact(i)
f %= MOD
res += D[i] * f * F.invfact(i + 1) * F.fact(N - 1)
res %= MOD
print(res)
|
p02807
|
import sys
input = sys.stdin.readline
mod = 10**9+7
def main():
N = int(eval(input()))
X = list(map(int, input().split()))
D = [0 for i in range(N)]
for i in range(N-1):
D[i] = X[i+1] - X[i]
import math
n = math.factorial(N-1)
ans = 0
r = 0
for i in range(1, N):
r += n // i
ans += D[i-1] * r
ans %= mod
print(ans)
if __name__ == '__main__':
main()
|
import sys
import math
input = sys.stdin.readline
mod = 10**9+7
def main():
N = int(eval(input()))
r1 = [1]
for i in range(N-1):
r1.append(r1[i] * (i+1) % mod)
r2 = [1]
for i in range(N-1):
r2.append(r2[i] * (N-1-i) % mod)
X = list(map(int, input().split()))
D = [0 for i in range(N)]
for i in range(N-1):
D[i] = X[i+1] - X[i]
ans = 0
r = 0
for i in range(N):
r += r1[i] * r2[N-i-2]
ans += D[i] * r
ans %= mod
print(ans)
if __name__ == '__main__':
main()
|
p02807
|
import sys
import math
input = sys.stdin.readline
mod = 10**9+7
def main():
N = int(eval(input()))
r1 = [1]
for i in range(N-1):
r1.append(r1[i] * (i+1) % mod)
r2 = [1]
for i in range(N-1):
r2.append(r2[i] * (N-1-i) % mod)
X = list(map(int, input().split()))
D = [0 for i in range(N)]
for i in range(N-1):
D[i] = X[i+1] - X[i]
ans = 0
r = 0
for i in range(N):
r += r1[i] * r2[N-i-2]
ans += D[i] * r
ans %= mod
print(ans)
if __name__ == '__main__':
main()
|
import sys
input = sys.stdin.readline
mod = 10**9+7
def main():
N = int(eval(input()))
X = list(map(int, input().split()))
r1 = [1]
r2 = [1]
for i in range(N-1):
r1.append(r1[i] * (i+1) % mod)
r2.append(r2[i] * (N-1-i) % mod)
r2.reverse()
ans = 0
r = 0
for i in range(N-1):
r += r1[i] * r2[i+1]
ans += (X[i+1] - X[i]) * r
ans %= mod
print(ans)
if __name__ == '__main__':
main()
|
p02807
|
import math
n = int(eval(input()))
x = list(map(int, input().split()))
d = [x[i+1] - x[i] for i in range(n - 1)]
def fact(m):
return m * fact(m-1) % 1000000007 if m != 1 else 1
fact_n_1 = math.factorial(n-1)
e = [None] * (n-1)
for i in range(n-1):
if i == 0:
e[i] = fact_n_1
else:
e[i] = (e[i - 1] + fact_n_1 // (i + 1)) % 1000000007
print((sum(e_i * d_i % 1000000007
for i, (d_i, e_i)
in enumerate(zip(d, e))) % 1000000007 ))
|
import sys
sys.setrecursionlimit(1000000)
n = int(eval(input()))
x = list(map(int, input().split()))
d = [x[i+1] - x[i] for i in range(n - 1)]
def pow(x, y):
if y == 0:
return 1
ans = 1
while y > 1:
if y % 2 != 0:
ans *= x
ans %= 1000000007
x *= x
x %= 1000000007
y //= 2
return ans * x % 1000000007
def fact(m):
return m * fact(m-1) % 1000000007 if m != 1 else 1
fact_n_1 = fact(n-1)
e = [None] * (n-1)
for i in range(n-1):
if i == 0:
e[i] = fact_n_1
else:
e[i] = (e[i - 1] + fact_n_1 * pow(i + 1, 1000000005)) % 1000000007
print((sum(e_i * d_i % 1000000007
for i, (d_i, e_i)
in enumerate(zip(d, e))) % 1000000007 ))
|
p02807
|
MOD=10**9+7
N=int(eval(input()))
x=list(map(int, input().split()))
y=[x[i+1]-x[i] for i in range(N-1)]
upp=[1]*(N+1)
for i in range(2, N+1):
upp[i]=upp[i-1]*i
upp[i]%=MOD
N_1=N-1
b=[0]*(N_1)
b[0]=upp[N_1]
tmp=upp[N_1]
for i in range(1, N_1):
a=tmp*pow(i+1, MOD-2, MOD)%MOD
b[i]=(b[i-1]+a)%MOD
print((sum([b[i]*y[i]%MOD for i in range(N_1)])%MOD))
|
MOD=10**9+7
N=int(eval(input()))
x=list(map(int, input().split()))
y=[x[i+1]-x[i] for i in range(N-1)]
upp=1
for i in range(2, N):
upp*=i
upp%=MOD
N_1=N-1
b=[0]*(N_1)
b[0]=upp
tmp=upp
out=b[0]*y[0]%MOD
for i in range(1, N_1):
a=tmp*pow(i+1, MOD-2, MOD)%MOD
b[i]=(b[i-1]+a)%MOD
out+=b[i]*y[i]%MOD
out%=MOD
print(out)
|
p02807
|
# -*- coding: utf-8 -*-
# dwacon6th-prelims/dwacon6th_prelims_b
import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
MAX = 10**5 + 100
MOD = 10**9 + 7
fac = [0] * MAX
finv = [0] * MAX
inv = [0] * MAX
coef = [0] * MAX
fac[0:2] = (1, 1)
finv[0:2] = (1, 1)
inv[1] = 1
coef[0:2] = (1, 1)
for i in range(2, MAX):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD%i] * int(MOD / i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
coef[i] = (coef[i - 1] * i) % MOD + fac[i - 1] % MOD
def main():
N = i2n()
n = N - 1
x = i2nn()
total = 0
for i in range(1, N):
d = x[i] - x[i - 1]
total = (total + (((coef[i] * fac[n]) % MOD * finv[i]) % MOD) * d % MOD) % MOD
print((total % MOD))
return
main()
|
# -*- coding: utf-8 -*-
# dwacon6th-prelims/dwacon6th_prelims_b
import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
MAX = 10**5 + 100
MOD = 10**9 + 7
fac = [1, 1] + [0] * MAX
finv = [1, 1] + [0] * MAX
inv = [1, 1] + [0] * MAX
coef = [1, 1] + [0] * MAX
for i in range(2, MAX):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
coef[i] = coef[i - 1] * i % MOD + fac[i - 1] % MOD
def main():
N = i2n()
n = N - 1
x = i2nn()
total = 0
for i in range(1, N):
d = x[i] - x[i - 1]
total = total + (coef[i] * fac[n] % MOD * finv[i] % MOD * d % MOD) % MOD
print((total % MOD))
return
main()
|
p02807
|
mod = 10**9 + 7
n = int(eval(input()))
lx = list(map(int, input().split()))
from math import factorial as kj
d = 0
ans = 0
for i in range(1, n):
d = (d * i + kj(i-1)) % mod
ans = (ans * i + (lx[i] - lx[i-1]) * d) % mod
print(ans)
|
mod = 10**9 + 7
n = int(eval(input()))
lx = list(map(int, input().split()))
d = 0
ans = 0
for i in range(1, n):
f = 1 if i == 1 else f * (i-1) % mod
d = (d * i + f) % mod
ans = (ans * i + (lx[i] - lx[i-1]) * d) % mod
print(ans)
|
p02807
|
mod = 10**9 + 7
n = int(eval(input()))
l = list(map(int, input().split()))
d = 0
ans = 0
for i in range(1, n):
f = 1 if i == 1 else f * (i-1) % mod
d = d * i + f
ans = (ans * i + (l[i] - l[i-1]) * d) % mod
print(ans)
|
mod = 10**9 + 7
n = int(eval(input()))
l = list(map(int, input().split()))
d, ans = 0, 0
for i in range(1, n):
f = 1 if i == 1 else f * (i-1) % mod
d = (d * i + f) % mod
ans = (ans * i + (l[i] - l[i-1]) * d) % mod
print(ans)
|
p02807
|
mod = 10**9 + 7
n = int(eval(input()))
l = list(map(int, input().split()))
d, ans = 0, 0
for i in range(1, n):
f = 1 if i == 1 else f * (i-1) % mod
d = (d * i + f) % mod
ans = (ans * i + (l[i] - l[i-1]) * d) % mod
print(ans)
|
m = 10**9 + 7
n = int(eval(input()))
l = list(map(int, input().split()))
f = 1
d = 0
A = 0
for i in range(1, n):
d = (d*i + f) % m
A = (A*i + (l[i]-l[i-1])*d) % m
f = f*i % m
print(A)
|
p02807
|
import sys
sys.setrecursionlimit(10**6)
def mod_inverse(n, mod=10**9+7):
return pow(n, mod-2, mod)
def combination(n, k, mod=10**9+7):
numer = denom = 1
for i in range(k):
numer = (numer * (n-i)) % mod
denom = (denom * (i+1)) % mod
return (numer * mod_inverse(denom, mod)) % mod
def factorial(n):
if n == 0:
return 1
return n * factorial(n-1) % mod
mod = 10**9+7
N = int(eval(input()))
x = [0] + list(map(int, input().split()))
fact = factorial(N-1)
ans = 0
for k in range(2, N):
ans = (ans + x[k] * (1 - mod_inverse(k)))
for k in range(1, N-1):
ans = (ans - x[k] * (1 - mod_inverse(N-k))) % mod
ans = ans * fact % mod
ans = (ans + fact * sum((x[N] - x[k]) * mod_inverse(N-k) for k in range(1, N))) % mod
print(ans)
|
from math import factorial
mod = 10**9+7
N = int(eval(input()))
x = [0] + list(map(int, input().split()))
ans = 0
inv = [0] + [pow(i, mod-2, mod) for i in range(1, N)]
for k in range(2, N):
ans = (ans + x[k] * (1 - inv[k])) % mod
for k in range(1, N-1):
ans = (ans - x[k] * (1 - inv[N-k])) % mod
for k in range(1, N):
ans = (ans + (x[N] - x[k]) * inv[N-k]) % mod
ans = ans * factorial(N-1) % mod
print(ans)
|
p02807
|
'''
研究室PCでの解答
'''
import math
#import numpy as np
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
mod = 10**9+7 #998244353
dir = [(-1,0),(1,0),(0,-1),(0,1)]
alp = "abcdefghijklmnopqrstuvwxyz"
def main():
n = int(ipt())
x = [int(i) for i in ipt().split()]
d = [x[i+1]-x[i] for i in range(n-1)]
k = [1]
for i in range(1,n):
k.append(k[-1]*i%mod)
#n!の逆元を求める
g2 = [1,1]
inverse = [0,1] #逆元テーブル計算用テーブル
for i in range(2,n+1):
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
ans = 0
na = 0
for i in range(1,n):
na = na*i+k[i-1]
ans += na*d[i-1]*k[-1]*g2[i]
ans %= mod
print(ans)
return None
if __name__ == '__main__':
main()
|
'''
研究室PCでの解答
'''
import math
#import numpy as np
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
mod = 10**9+7 #998244353
dir = [(-1,0),(1,0),(0,-1),(0,1)]
alp = "abcdefghijklmnopqrstuvwxyz"
def main():
n = int(ipt())
x = [int(i) for i in ipt().split()]
d = [x[i+1]-x[i] for i in range(n-1)]
k = [1]
for i in range(1,n):
k.append(k[-1]*i%mod)
#n!の逆元を求める
g2 = [1,1]
inverse = [0,1] #逆元テーブル計算用テーブル
for i in range(2,n+1):
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
ans = 0
na = 0
for i in range(1,n):
na = na*i+k[i-1]
na %= mod
ans += na*d[i-1]*k[-1]*g2[i]
ans %= mod
print(ans)
return None
if __name__ == '__main__':
main()
|
p02807
|
mod = 10**9+7
N = int(eval(input()))
x = list(map(int,input().split()))
fact = [1]*(N+1)
for i in range(N):
fact[i+1] = (i+1)*fact[i]
fact[i+1] %= mod
inv = [1]*(N+1)
for i in range(N):
inv[i] = pow(i,mod-2,mod)
x1 = []
for m in range(1,N-1):
x1.append(x[m]*m*inv[m+1]%mod)
x2 = []
for n in range(N-2):
x2.append(x[n]*(N-n-2)*inv[N-n-1]%mod)
x3 = []
for n in range(N-1):
x3.append((x[N-1]-x[n])*inv[N-n-1])
ans = fact[N-1]*(sum(x1)-sum(x2)+sum(x3))
ans %= mod
print(ans)
|
mod = 10**9+7
N = int(eval(input()))
x = list(map(int,input().split()))
ans = 0
for j in range(1,N-1):
ans += x[j]*j*pow(j+1,mod-2,mod)
ans %= mod
for i in range(N-2):
ans += x[i]*(-N+i+2)*pow(N-i-1,mod-2,mod)
ans %= mod
for i in range(N-1):
ans += (x[N-1]-x[i])*pow(N-1-i,mod-2,mod)
ans %= mod
for i in range(1,N):
ans *= i
ans %= mod
print(ans)
|
p02807
|
MOD=10**9+7
N=int(eval(input()))
xlist=list(map(int,input().split()))
inv_table = [0]+[1]
for i in range(2,N+1):
inv_table.append(-(MOD//i)*inv_table[MOD%i]%MOD)
fact_nm1=1
for i in range(1,N):
fact_nm1*=i
fact_nm1%=MOD
#print(fact_nm1)
answer=0
for i in range(N-1):
for j in range(i+1,N-1):
ji_inv=inv_table[j-i]
ji1_inv=inv_table[j-i+1]
term=(ji_inv*ji1_inv)%MOD
answer+=term*(xlist[j]-xlist[i])
answer%=MOD
#print(i,j,term)
ni_inv=inv_table[N-1-i]
term=ni_inv%MOD
answer+=term*(xlist[N-1]-xlist[i])
answer%=MOD
#print(i,N-1,term)
answer*=fact_nm1
answer%=MOD
print(answer)
|
MOD=10**9+7
N=int(eval(input()))
xlist=list(map(int,input().split()))
fact_nm1=1
for i in range(1,N):
fact_nm1*=i
fact_nm1%=MOD
#print(fact_nm1)
answer_bunshi=0
answer_bumbo=1
inv_bunshi=0
inv_bumbo=1
for i in range(1,N):
inv_bunshi=(i*inv_bunshi+inv_bumbo)%MOD
inv_bumbo=(inv_bumbo*i)%MOD
#print(inv_bunshi,inv_bumbo)
xdiff=xlist[i]-xlist[i-1]
term_bunshi=(xdiff*inv_bunshi)%MOD
answer_bunshi=(answer_bunshi*inv_bumbo+term_bunshi*answer_bumbo)%MOD
answer_bumbo=(answer_bumbo*inv_bumbo)%MOD
#print(answer_bunshi,answer_bumbo)
answer_bunshi=(answer_bunshi*fact_nm1)%MOD
answer=answer_bunshi*pow(answer_bumbo,MOD-2,MOD)
answer%=MOD
print(answer)
|
p02807
|
n=int(eval(input()));a=list(map(int,input().split()));mod=10**9+7;x=m=1;z=0
for i in range(2,n):x=m=m*i%mod
for i in range(n):z=z+x*(a[i]-a[i-1])%mod;x=x+m*pow(i+1,mod-2,mod)%mod
print((z%mod))
|
N,*X=list(map(int,open(0).read().split()));M,g,q,r=10**9+7,1,[1,1],0
for i in range(1,N):r,g=(r+q[-1]*(X[-1]-X[i-1]))%M,g*i%M;q+=[M//(-~i)*-q[M%(-~i)]%M]
print((r*g%M))
|
p02807
|
mod = 10**9+7
# N = 15
N = int(eval(input()))
xx = list(map(int, input().split()))
a = 1
for i in range(2,N):
a *= i
# a %= mod
aa = [a]
for i in range(N-2):
aa.append((aa[-1]+a*pow(i+2,mod-2,mod))%mod)
dx = [xx[i]-xx[i-1] for i in range(1,N)]
ans = 0
for a,d in zip(aa,dx):
ans += a*d
ans %= mod
print((ans%mod))
|
mod = 10**9+7
# N = 15
N = int(eval(input()))
xx = list(map(int, input().split()))
a = 1
for i in range(2,N):
a *= i
a %= mod
aa = [a]
for i in range(N-2):
aa.append((aa[-1]+a*pow(i+2,mod-2,mod))%mod)
dx = [xx[i]-xx[i-1] for i in range(1,N)]
ans = 0
for a,d in zip(aa,dx):
ans += a*d
ans %= mod
print((ans%mod))
|
p02807
|
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
@lru_cache(maxsize=None)
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
@mt
def slv(N, X):
M = Mod(10**9+7)
ne = [1]
for i in range(1, N+1):
ne.append(M.mul(i, ne[i-1]))
ans = 0
p = 0
for i in range(N-1):
d = X[i+1] - X[i]
p = M.add(p, M.div(ne[N-1], i+1))
ans = M.add(ans, M.mul(d, p))
return ans
def slv2(N, X):
ans = 0
s = Counter()
for p in permutations(range(N-1)):
x = X[:]
for i in p:
for j in range(i+1, N):
if x[j]:
break
ans += x[j] - x[i]
s[(j, i)] += 1
x[i] = None
for i in range(N-1):
for j in range(i+1, N):
print(i, j, s[(j,i)])
return ans
def main():
N = read_int()
X = read_int_n()
print(slv(N, X))
# print(slv2(N, X))
# N = 10**4
# X = list(range(1, N+1))
# print(slv(N, X))
if __name__ == '__main__':
main()
|
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
@lru_cache(maxsize=None)
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
@mt
def slv(N, X):
M = Mod(10**9+7)
ne = 1
for i in range(2, N):
ne = M.mul(i, ne)
ans = 0
p = 0
for i in range(N-1):
d = X[i+1] - X[i]
p = M.add(p, M.div(ne, i+1))
ans = M.add(ans, M.mul(d, p))
return ans
def main():
N = read_int()
X = read_int_n()
print(slv(N, X))
if __name__ == '__main__':
main()
|
p02807
|
from fractions import Fraction
n=int(eval(input()))
x=list(map(int,input().split()))
ans=0
for i in range(n):
ans=(ans+(x[-1]-x[i])*(Fraction(1,i+1)))%(10**9+7)
for i in range(1,n):
ans=ans*i%(10**9+7)
print(ans)
|
import math
n=int(eval(input()))
a=list(map(int,input().split()))
ans=math.factorial(n-1)%(10**9+7)
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
c=0
for i in range(1,n):
c+=(a[-1]-a[i-1])*modinv(i, mod=10**9+7)
print((ans*c%(10**9+7)))
|
p02807
|
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = float('INF')
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
X = LI()
d = [0] * (n - 1)
for i in range(n - 1):
d[i] = X[i + 1] - X[i]
fac = factorial(n - 1)
acc = list(accumulate([fac // i for i in range(1, n)]))
ret = 0
for j in range(n - 1):
ret += acc[j] * d[j]
print((ret % mod))
|
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = float('INF')
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
X = LI()
d = [0] * (n - 1)
for i in range(n - 1):
d[i] = (X[i + 1] - X[i]) % mod
fac = [1] * (n + 1)
inv = [1] * (n + 1)
for j in range(1, n + 1):
fac[j] = fac[j-1] * j % mod
for i in range(1, n):
inv[i] = pow(i, mod - 2, mod)
L = [fac[n - 1] * inv[i] % mod for i in range(1, n)]
for k in range(1, n - 1):
L[k] = (L[k] + L[k - 1]) % mod
ret = 0
for j in range(n - 1):
ret = (ret + L[j] * d[j] % mod) % mod
print((ret % mod))
|
p02807
|
N = int(eval(input()))
A = [int(a) for a in input().split()]
if N > 2000:
print((0))
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
import math
ans = 0
for i in range(1, N):
ans += cmb(N-1, N-i, mod)*math.factorial(i-1)*math.factorial(N-i-1)*(A[N-1]-A[i-1])
ans %= mod
for j in range(i+1, N):
ans += cmb(N-1, j-i+1, mod)*math.factorial(N-j+i-2)*math.factorial(j-i-1)*(A[j-1]-A[i-1])
ans %= mod
print(ans)
|
N = int(eval(input()))
A = [int(a) for a in input().split()]
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
L = [1]*N
for i in range(1, N):
L[i] *= L[i-1]*i
L[i] %= mod
ans = 0
for i in range(1, N):
ans += cmb(N-1, N-i, mod)*L[i-1]*L[N-i-1]*(A[N-1]-A[i-1])
ans %= mod
L2 = [0]*(N-1)
for i in range(N-1):
L2[i] = A[i+1]-A[i]
S = [0]*N
for i in range(N-1):
S[i+1] = S[i] + L2[i]
L3 = [0]*N
for i in range(1, N):
if N-i-1 >= i:
L3[i] = L3[i-1] + S[N-i-1] - S[i-1]
else:
L3[i] = L3[N-i-1]
for t in range(1, N-1):
ans += cmb(N-1, t+1, mod)*L[N-t-2]*L[t-1]*L3[t]
ans %= mod
print(ans)
|
p02807
|
N = int(eval(input()))
x = list(map(int, input().split()))
mod = 10 ** 9 + 7
f = [1]
for i in range(1,N+1):
f.append((f[-1] * i) % mod)
def comb(n,r):
return f[n] * (pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod) % mod
ans = 0
l = [0] + [(((comb(N-1,2+i) * f[N-(3+i)]) % mod) * f[i]) % mod for i in range(N-2)] + [f[N-2]]
for i in range(N-1):
for j in range(i+1,N):
ans += (l[j-i] * (x[j] - x[i])) % mod
ans %= mod
if j == N - 1:
l[j-i-1] = l[j-i-1] + l[j-i]
print(ans)
|
N = int(eval(input()))
x = list(map(int, input().split()))
mod = 10 ** 9 + 7
c = [1]
for i in range(1,N-1):
c.append(c[i-1]+pow(i+1,mod-2,mod))
ans = 0
for i in range(N-1):
ans += (c[i] * (x[i+1] - x[i])) % mod
ans %= mod
for i in range(1,N):
ans *= i
ans %= mod
print(ans)
|
p02807
|
n = int(eval(input()))
x = list(map(int, input().split()))
r = 10 ** 9 + 7
a = [1]
p = 1
for i in range(1, n - 1):
p *= i
q = p + a[0] * (i + 1)
a = [q] + a
ans = (x[n - 1] - x[n - 2]) * a[0]
ans %= r
k = n - 1
for i in range(2, n):
ans += (x[n - i] - x[n - i - 1]) * a[i - 1] * k
ans %= r
k *= n - i
print(ans)
|
n = int(eval(input()))
x = list(map(int, input().split()))
r = 10 ** 9 + 7
p = 1
for i in range(1,n):
p *= i
f = x[n - 1]
ans = 0
for i in range(n-1):
ans += (f - x[i]) * p
ans %= r
p = p * (i + 1) // (i + 2)
print(ans)
|
p02807
|
N = int(eval(input()))
X = list(map(int,input().split()))
S = []
dp = [1]
mod = 10**9+7
for i in range(N):
t = i+1
dp.append(dp[i]*t)
W = []
for i in range(1,N):
y = dp[N-1]//i
y % mod
W.append(y)
ans = 0
for i in range(N-1):
x = X[i]
S.append(X[N-1]-x)
ans = 0
for i in range(N-1):
x = S[i]
t = i + 1
ans += W[i]*x%mod
print((ans%mod))
|
N = int(eval(input()))
X = list(map(int,input().split()))
S = []
dp = [1]
mod = 10**9+7
for i in range(N):
t = i+1
dp.append(dp[i]*t%mod)
def power(a,b):
if b == 0:
return 1
if b % 2 == 0:
d = power(a,b//2)
return d*d%mod
elif b % 2 == 1:
return a*power(a,b-1)%mod
W = []
for i in range(1,N):
y = dp[N-1]*power(i,mod-2)%mod
W.append(y)
ans = 0
for i in range(N-1):
x = X[i]
S.append(X[N-1]-x)
ans = 0
for i in range(N-1):
x = S[i]
t = i + 1
ans += W[i]*x%mod
print((ans%mod))
|
p02807
|
import sys
input = sys.stdin.readline
from fractions import Fraction
def main():
N = int(eval(input()))
x = [int(i) for i in input().split()]
MOD = 10**9+7
answer = 0
frac = 0
for i in range(N-1):
frac += Fraction(1,i+1)
dist = (x[i+1] - x[i]) % MOD
answer = (answer + dist * frac) % MOD
for i in range(1,N):
answer = (answer * i) % MOD
print((int(answer)))
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.readline
# 1~nまでの逆元(mod m) O(n)
def mod_inv_list(n:int, m:int):
# inv_t[i]: iの法mの下での逆元
inv_t = [0] + [1]
for i in range(2,n):
inv_t += [inv_t[m % i] * (m - m//i) % m]
return inv_t
def main():
N = int(eval(input()))
x = [int(i) for i in input().split()]
MOD = 10**9 + 7
inv_acum = mod_inv_list(N,MOD)
for i in range(1,N):
inv_acum[i] = (inv_acum[i] + inv_acum[i-1]) % MOD
ans = 0
for i in range(1,N):
ans += (x[i] - x[i-1]) * inv_acum[i]
ans %= MOD
for i in range(1,N):
ans = (ans * i) % MOD
print(ans)
if __name__ == "__main__":
main()
|
p02807
|
from functools import reduce
# https://atcoder.jp/contests/dwacon6th-prelims/submissions/9425560
# 部分点解法
def main():
from functools import reduce
MOD = 10 ** 9 + 7
n = int(eval(input()))
*x, = list(map(int, input().split()))
fact = [1]
for i in range(1, n + 1):
fact.append(fact[-1] * i)
dist_to_r_edge = [x[-1] - x_ for x_ in x[:-1]]
ret = reduce(
lambda a, b: (a + b) % MOD,
(
d * pow(i, MOD - 2, MOD)
for i, d in enumerate(dist_to_r_edge, 1)
)
)
print((ret * fact[n - 1] % MOD))
if __name__ == '__main__':
main()
# ret = 0
# for i, d in enumerate(dist_to_r_edge, 1):
# ret = (ret + d * pow(i, MOD - 2, MOD)) % MOD
# print(ret * fact[n - 1] % MOD)
|
from functools import reduce
# 部分点
def main():
from functools import reduce
MOD = 10 ** 9 + 7
n = int(eval(input()))
*x, r = list(map(int, input().split()))
dist_to_r_edge = [r - x_ for x_ in x]
ret = reduce(
lambda a, b: (a + b) % MOD,
(
d * pow(i, MOD - 2, MOD)
for i, d in enumerate(dist_to_r_edge, 1)
)
)
f = 1
for i in range(1, n):
f = (f * i) % MOD
print((ret * f % MOD))
if __name__ == '__main__':
main()
|
p02807
|
from functools import reduce
# 部分点
def main():
from functools import reduce
MOD = 10 ** 9 + 7
n = int(eval(input()))
*x, r = list(map(int, input().split()))
dist_to_r_edge = [r - x_ for x_ in x]
ret = reduce(
lambda a, b: (a + b) % MOD,
(
d * pow(i, MOD - 2, MOD)
for i, d in enumerate(dist_to_r_edge, 1)
)
)
f = 1
for i in range(1, n):
f = (f * i) % MOD
print((ret * f % MOD))
if __name__ == '__main__':
main()
|
from functools import reduce
def build_cumsum_invs(ub, mod):
ret = [0]
t = 0
for i in range(1, ub + 1):
t = (t + pow(i, mod - 2, mod)) % mod
ret.append(t)
return ret
def main():
from functools import reduce
MOD = 10 ** 9 + 7
n = int(eval(input()))
*x, = list(map(int, input().split()))
coef = build_cumsum_invs(ub=n, mod=MOD)
# <---><---><---><---><--->
# x1/1 1/2 1/3 1/4 1/5
# x1/1 1/2 1/3 1/4
# x1/1 1/2 1/3
# x点から移動開始したスライムが区間を通過する確率
# 縦に和をとると、逆数の累積和coefになっている
prob = reduce(
lambda a, b: (a + b) % MOD,
(
(x[i] - x[i - 1]) * coef[i]
for i in range(1, n)
)
)
f = reduce(
lambda a, b: a * b % MOD,
list(range(1, n))
)
print(((prob * f) % MOD))
if __name__ == '__main__':
main()
# prob = 0
# for i in range(1, n):
# prob = (prob + (x[i] - x[i - 1]) * coef[i]) % MOD
# ret = (prob * reduce(lambda a, b: a * b % MOD, range(1, n))) % MOD
# print(ret)
|
p02807
|
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
class ModTools:
""" 階乗たくさん使う時用のテーブル準備 """
def __init__(self, MAX, MOD):
""" MAX：階乗に使う数値の最大以上まで作る """
MAX += 1
self.MAX = MAX
self.MOD = MOD
# 階乗テーブル
factorial = [1] * MAX
factorial[0] = factorial[1] = 1
for i in range(2, MAX):
factorial[i] = factorial[i-1] * i % MOD
# 階乗の逆元テーブル
inverse = [1] * MAX
# powに第三引数入れると冪乗のmod付計算を高速にやってくれる
inverse[MAX-1] = pow(factorial[MAX-1], MOD-2, MOD)
for i in range(MAX-2, 0, -1):
# 最後から戻っていくこのループならMAX回powするより処理が速い
inverse[i] = inverse[i+1] * (i+1) % MOD
self.fact = factorial
self.inv = inverse
def div(self, x, y):
""" MOD除算 """
return x * pow(y, self.MOD-2, self.MOD) % self.MOD
N = INT()
A = LIST()
B = [0] + [A[i+1] - A[i] for i in range(N-1)]
mt = ModTools(N, MOD)
add = mt.fact[N-1]
cnt = [0] * N
for i in range(1, N):
cnt[i] = round(cnt[i-1] + add)
cnt[i] %= MOD
add *= mt.div(i , (i+1))
add %+ MOD
ans = 0
for i in range(1, N):
ans += B[i] * cnt[i]
ans %= MOD
print(ans)
|
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
class ModTools:
""" 階乗たくさん使う時用のテーブル準備 """
def __init__(self, MAX, MOD):
""" MAX：階乗に使う数値の最大以上まで作る """
MAX += 1
self.MAX = MAX
self.MOD = MOD
# 階乗テーブル
factorial = [1] * MAX
factorial[0] = factorial[1] = 1
for i in range(2, MAX):
factorial[i] = factorial[i-1] * i % MOD
# 階乗の逆元テーブル
inverse = [1] * MAX
# powに第三引数入れると冪乗のmod付計算を高速にやってくれる
inverse[MAX-1] = pow(factorial[MAX-1], MOD-2, MOD)
for i in range(MAX-2, 0, -1):
# 最後から戻っていくこのループならMAX回powするより処理が速い
inverse[i] = inverse[i+1] * (i+1) % MOD
self.fact = factorial
self.inv = inverse
def div(self, x, y):
""" MOD除算 """
return x * pow(y, self.MOD-2, self.MOD) % self.MOD
N = INT()
A = LIST()
B = [0] + [A[i+1] - A[i] for i in range(N-1)]
mt = ModTools(N, MOD)
add = mt.fact[N-1]
cnt = [0] * N
for i in range(1, N):
cnt[i] = round(cnt[i-1] + add)
cnt[i] %= MOD
add *= mt.div(i , (i+1))
add %= MOD
ans = 0
for i in range(1, N):
ans += B[i] * cnt[i]
ans %= MOD
print(ans)
|
p02807
|
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def S_():
return input()
def LS():
return [i for i in input().split()]
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def NI(n):
return [int(input()) for i in range(n)]
def NI_(n):
return [int(input())-1 for i in range(n)]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def LtoS(ls):
return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)]
rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
#sys.setrecursionlimit(10**5)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
rmin,rmax=1,10
a=[random.randint(rmin,rmax) for _ in range(n)]
return n,a
class Comb:
def __init__(self,n,mo=10**9+7):
self.fac=[0]*(n+1)
self.inv=[1]*(n+1)
self.fac[0]=1
self.fact(n)
for i in range(1,n+1):
self.fac[i]=i*self.fac[i-1]%mo
self.inv[n]*=i
self.inv[n]%=mo
self.inv[n]=pow(self.inv[n],mo-2,mo)
for i in range(1,n):
self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
return
def fact(self,n):
return self.fac[n]
def invf(self,n):
return self.inv[n]
def comb(self,x,y):
if y<0 or y>x:
return 0
return self.fac[x]*self.inv[x-y]*self.inv[y]%mo
show_flg=False
show_flg=True
ans=0
n=I()
x=LI()
p=permutations(range(n-1))
cm=Comb(n+2)
StrN=[0]*(n+1)
StrN[1]=1
def St(n):
if n==1:
return 1
if StrN[n]!=0:
return StrN[n]
else:
#a(n+1)=(n+1)*a(n)+n!.
StrN[n]=(n)*StrN[n-1]+cm.fac[n-1]
return StrN[n]
for i in range(1,n):
St(i)
St(n-1)
Pat=[0]*(n+1)
for i in range(n):
Pat[i]=StrN[i]*cm.fac[n-1]*cm.inv[i]%mo
#show('Pat',Pat)
#show('St',StrN)
for i in range(n-1):
ans+=(x[i+1]-x[i])*Pat[i+1]
ans%=mo
print(ans%mo)
#show(SSS)
|
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def S_():
return input()
def LS():
return [i for i in input().split()]
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def NI(n):
return [int(input()) for i in range(n)]
def NI_(n):
return [int(input())-1 for i in range(n)]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def LtoS(ls):
return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)]
rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
sys.setrecursionlimit(10**5)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
rmin,rmax=1,10
a=[random.randint(rmin,rmax) for _ in range(n)]
return n,a
class Comb:
def __init__(self,n,mo=10**9+7):
self.fac=[0]*(n+1)
self.inv=[1]*(n+1)
self.fac[0]=1
self.fact(n)
for i in range(1,n+1):
self.fac[i]=i*self.fac[i-1]%mo
self.inv[n]*=i
self.inv[n]%=mo
self.inv[n]=pow(self.inv[n],mo-2,mo)
for i in range(1,n):
self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
return
def fact(self,n):
return self.fac[n]
def invf(self,n):
return self.inv[n]
def comb(self,x,y):
if y<0 or y>x:
return 0
return self.fac[x]*self.inv[x-y]*self.inv[y]%mo
show_flg=False
show_flg=True
ans=0
n=I()
x=LI()
p=permutations(range(n-1))
cm=Comb(n+20)
StrN=[0]*(n+10)
StrN[1]=1
StrN[0]=0
def St(n):
if n==1:
return 1
if StrN[n]!=0:
return StrN[n]
else:
#a(n+1)=(n+1)*a(n)+n!
StrN[n]=(n)*St(n-1)+cm.fac[n-1]
return StrN[n]
St(n)
Pat=[0]*(n+1)
for i in range(n):
Pat[i]=StrN[i]*cm.fac[n-1]*cm.inv[i]%mo
#show('Pat',Pat)
#show('St',StrN)
for i in range(n-1):
ans+=(x[i+1]-x[i])*Pat[i+1]
ans%=mo
print(ans%mo)
#show(SSS)
|
p02807
|
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def S_():
return input()
def LS():
return [i for i in input().split()]
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def NI(n):
return [int(input()) for i in range(n)]
def NI_(n):
return [int(input())-1 for i in range(n)]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def LtoS(ls):
return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)]
rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
sys.setrecursionlimit(10**5)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
rmin,rmax=1,10
a=[random.randint(rmin,rmax) for _ in range(n)]
return n,a
class Comb:
def __init__(self,n,mo=10**9+7):
self.fac=[0]*(n+1)
self.inv=[1]*(n+1)
self.fac[0]=1
self.fact(n)
for i in range(1,n+1):
self.fac[i]=i*self.fac[i-1]%mo
self.inv[n]*=i
self.inv[n]%=mo
self.inv[n]=pow(self.inv[n],mo-2,mo)
for i in range(1,n):
self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
return
def fact(self,n):
return self.fac[n]
def invf(self,n):
return self.inv[n]
def comb(self,x,y):
if y<0 or y>x:
return 0
return self.fac[x]*self.inv[x-y]*self.inv[y]%mo
show_flg=False
show_flg=True
ans=0
n=I()
x=LI()
cm=Comb(n+20)
StrN=[0]*(n+10)
StrN[1]=1
StrN[0]=0
def St(n):
if n==1:
return 1
if StrN[n]!=0:
return StrN[n]
else:
#a(n+1)=(n+1)*a(n)+n!
StrN[n]=(n)*St(n-1)+cm.fac[n-1]
return StrN[n]
St(n)
Pat=[0]*(n+1)
for i in range(n):
Pat[i]=StrN[i]*cm.fac[n-1]*cm.inv[i]%mo
#show('Pat',Pat)
#show('St',StrN)
for i in range(n-1):
ans+=(x[i+1]-x[i])*Pat[i+1]
ans%=mo
print(ans%mo)
#show(SSS)
|
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def S_():
return input()
def LS():
return [i for i in input().split()]
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def NI(n):
return [int(input()) for i in range(n)]
def NI_(n):
return [int(input())-1 for i in range(n)]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def LtoS(ls):
return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)]
rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
sys.setrecursionlimit(10**5)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
rmin,rmax=1,10
a=[random.randint(rmin,rmax) for _ in range(n)]
return n,a
class Comb:
def __init__(self,n,mo=10**9+7):
self.fac=[0]*(n+1)
self.inv=[1]*(n+1)
self.fac[0]=1
self.fact(n)
for i in range(1,n+1):
self.fac[i]=i*self.fac[i-1]%mo
self.inv[n]*=i
self.inv[n]%=mo
self.inv[n]=pow(self.inv[n],mo-2,mo)
for i in range(1,n):
self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
return
def fact(self,n):
return self.fac[n]
def invf(self,n):
return self.inv[n]
def comb(self,x,y):
if y<0 or y>x:
return 0
return self.fac[x]*self.inv[x-y]*self.inv[y]%mo
show_flg=False
show_flg=True
ans=0
n=I()
x=LI()
cm=Comb(n+20)
StrN=[0]*(n+10)
StrN[1]=1
StrN[0]=0
def St(n):
if n==1:
return 1
if StrN[n]!=0:
return StrN[n]
else:
#a(n+1)=(n+1)*a(n)+n!
StrN[n]=(n)*St(n-1)+cm.fac[n-1]
StrN[n]%=mo
return StrN[n]
St(n)
Pat=[0]*(n+1)
for i in range(n):
Pat[i]=StrN[i]*cm.fac[n-1]*cm.inv[i]%mo
#show('Pat',Pat)
#show('St',StrN)
for i in range(n-1):
ans+=(x[i+1]-x[i])*Pat[i+1]
ans%=mo
print(ans%mo)
#show(SSS)
|
p02807
|
import math
import sys
input = sys.stdin.readline
N = int(eval(input()))
x = list(map(int,input().split()))
d = [0]*(N-1)
for i in range(N-1):
d[i] = x[i+1]-x[i]
d[i] %= 10**9+7
kaijou = 1
for i in range(1,N):
kaijou *= i%(10**9+7)
#kaijou = math.factorial(N-1)%(10**9+7)
ans=0
x=0
k=10**9+5
def pow_r(x, n):
"""
O(log n)
"""
x %= (k+2)
if n == 0: # exit case
return 1
if n % 2 == 0: # standard case ① n is even
return pow_r(x ** 2, n // 2)%(k+2)
else: # standard case ② n is odd
return (x * pow_r(x ** 2, (n - 1) // 2))%(k+2)
for i in range(N-1):
#(i+1)**(10**9+5)を計算してyへ
y = pow_r(i+1,k)
#x+= kaijou//(i+1))%(10**9+7)
x += (kaijou*y)%(10**9+7)
ans+= d[i]*x
print((ans%(10**9+7)))
|
import math
import sys
input = sys.stdin.readline
N = int(eval(input()))
x = list(map(int,input().split()))
mod = 10**9+7
d = [0]*(N-1)
for i in range(N-1):
d[i] = x[i+1]-x[i]
d[i] %= mod
kaijou = 1
for i in range(1,N):
kaijou *= i
kaijou %= mod
ans=0
x=0
def pow_r(x, n):
"""
O(log n)
"""
x %= mod
if n == 0: # exit case
return 1
if n % 2 == 0: # standard case ① n is even
return pow_r(x ** 2, n // 2)%mod
else: # standard case ② n is odd
return (x * (pow_r(x ** 2, (n - 1) // 2)))%mod
for i in range(N-1):
#(i+1)%(mod-2)を計算してyへ
y = pow_r(i+1,mod-2)
#x+= kaijou//(i+1))%(10**9+7)
x += kaijou*y
ans += d[i]*x
ans %= mod
print(ans)
|
p02807
|
import math
import sys
input = sys.stdin.readline
N = int(eval(input()))
x = list(map(int,input().split()))
mod = 10**9+7
d = [0]*(N-1)
for i in range(N-1):
d[i] = x[i+1]-x[i]
d[i] %= mod
kaijou = 1
for i in range(1,N):
kaijou *= i
kaijou %= mod #これをしないとkaijouが発散
ans=0
x=0
def pow_a(a,n): #(modを取るように改良)
if n==0:
return 1
K = 1
while n>1:
if n%2 != 0:
K *= a
K %= mod
a *= a
a %= mod
n //= 2
return K*a
for i in range(N-1):
y = pow_a(i+1,mod-2) #i+1の逆元
x += kaijou*y
ans += d[i]*x
ans %= mod
print(ans)
|
import math
import sys
input = sys.stdin.readline
N = int(eval(input()))
x = list(map(int,input().split()))
mod = 10**9+7
d = [0]*(N-1)
for i in range(N-1):
d[i] = x[i+1]-x[i]
d[i] %= mod
kaijou = 1
for i in range(1,N):
i %= mod
kaijou *= i
kaijou %= mod #これをしないとkaijouが発散
ans=0
x=0
def pow_a(a,n): #(modを取るように改良)
if n==0:
return 1
K = 1
while n>1:
if n%2 != 0:
K *= a
K %= mod
a *= a
a %= mod
n //= 2
return (K*a)%mod
for i in range(N-1):
y = pow_a(i+1,mod-2) #i+1の逆元
x += kaijou*y
ans += d[i]*x
ans %= mod
print(ans)
|
p02807
|
import math
n = int(eval(input()))
x = list(map(int, input().split()))
mod = 10 ** 9 + 7
fac = math.factorial(n - 1)
def pow(n, p):
res = 1
while p > 0:
if p % 2 == 0:
n = n ** 2 % mod
p //= 2
else:
res = res * n % mod
p -= 1
return res % mod
res = 0
for i in range(n - 1):
d = x[n - 1] - x[i]
res += (d * fac * pow(i + 1, mod - 2)) % mod
print((res % mod))
|
import math
n = int(eval(input()))
x = list(map(int, input().split()))
mod = 10 ** 9 + 7
fac = math.factorial(n - 1) % mod
def pow(n, p):
res = 1
while p > 0:
if p % 2 == 0:
n = n ** 2 % mod
p //= 2
else:
res = res * n % mod
p -= 1
return res % mod
res = 0
for i in range(n - 1):
d = x[n - 1] - x[i]
res += (d * fac * pow(i + 1, mod - 2)) % mod
print((res % mod))
|
p02807
|
import sys
from itertools import count, accumulate
from operator import mul
from functools import reduce
lines = sys.stdin.readlines()
positions = [int(i) for i in lines[1].split(' ')]
distances = [ j - i for i, j in zip(positions, positions[1:])]
n = len(distances)
factorials = [1] + list(accumulate(list(range(1,n + 1)), mul))
combinations = dict()
def combination(i, j):
if (i, j) in combinations:
return combinations((i, j))
else:
return factorials[i] // (factorials [j] * factorials[i - j])
permutations = dict()
def permutation(i, j):
if (i, j) in permutations:
return permutations((i, j))
else:
return reduce(mul, list(range(j, i+1)))
s = 0
result = 0
for d, i in zip(distances, count(1)):
lt = i - 1
gt = n - i
t = factorials[lt] * combination(n, gt) * factorials[gt]
s += t
result += d * s
print((int(result % (pow(10,9) + 7))))
|
import sys
from itertools import count, accumulate
from operator import mul
from functools import reduce
lines = sys.stdin.readlines()
positions = [int(i) for i in lines[1].split(' ')]
distances = [ j - i for i, j in zip(positions, positions[1:])]
n = len(distances)
factorials = [1] + list(accumulate(list(range(1,n + 1)), mul))
combinations = dict()
def combination(i, j):
j = min(j, i - j)
if (i, j) in combinations:
return combinations((i, j))
else:
return factorials[i] // (factorials [j] * factorials[i - j])
permutations = dict()
def permutation(i, j):
if (i, j) in permutations:
return permutations((i, j))
else:
return reduce(mul, list(range(j, i+1)))
s = 0
result = 0
for d, i in zip(distances, count(1)):
lt = i - 1
gt = n - i
t = factorials[lt] * combination(n, gt) * factorials[gt]
s += t
result += d * s
print((int(result % (pow(10,9) + 7))))
|
p02807
|
import sys
from itertools import count, accumulate
from operator import mul
from functools import reduce
lines = sys.stdin.readlines()
positions = [int(i) for i in lines[1].split(' ')]
distances = [ j - i for i, j in zip(positions, positions[1:])]
n = len(distances)
factorials = [1] + list(accumulate(list(range(1,n + 1)), mul))
combinations = dict()
def combination(i, j):
j = min(j, i - j)
if (i, j) in combinations:
return combinations((i, j))
else:
return factorials[i] // (factorials [j] * factorials[i - j])
permutations = dict()
def permutation(i, j):
if (i, j) in permutations:
return permutations((i, j))
else:
return reduce(mul, list(range(j, i+1)))
s = 0
result = 0
for d, i in zip(distances, count(1)):
lt = i - 1
gt = n - i
t = factorials[n] // i
s += t
result += d * s
print((int(result % (pow(10,9) + 7))))
|
import sys
from itertools import count, accumulate
from operator import mul
from functools import reduce
lines = sys.stdin.readlines()
positions = [int(i) for i in lines[1].split(' ')]
distances = [ j - i for i, j in zip(positions, positions[1:])]
n = len(distances)
p = pow(10,9) + 7
factorials = [1] + list(accumulate(list(range(1,n + 1)), lambda x, y: (x * y) % p))
combinations = dict()
def combination(i, j):
j = min(j, i - j)
if (i, j) in combinations:
return combinations((i, j))
else:
return factorials[i] // (factorials [j] * factorials[i - j])
permutations = dict()
def permutation(i, j):
if (i, j) in permutations:
return permutations((i, j))
else:
return reduce(mul, list(range(j, i+1)))
def modpow(a, n, mod):
res = 1
while n > 0:
if n & 1:
res = res * a % mod
a = a * a % mod
n = n >> 1
return res
s = 0
result = 0
for d, i in zip(distances, count(1)):
lt = i - 1
gt = n - i
i_inv = modpow(i, p-2, p)
t = factorials[n] * i_inv
s += t
result += d * s
print((int(result % (pow(10,9) + 7))))
|
p02807
|
# 二項係数を"やるだけ"にしてくれるライブラリ
MAX = 510000
MOD = 1000000007
factrial = [0]*MAX
inverse = [0]*MAX
factrial_inverse = [0]*MAX
# テーブルを作る前処理
def COMinit():
global factrial, inverse, factrial_inverse
factrial[0] = 1
factrial[1] = 1
inverse[1] = 1
factrial_inverse[0] = 1
factrial_inverse[1] = 1
for i in range(2, MAX):
factrial[i] = factrial[i-1] * i % MOD
inverse[i] = MOD - inverse[MOD % i] * (MOD//i) % MOD
factrial_inverse[i] = factrial_inverse[i-1] * inverse[i] % MOD
# 二項係数計算
def COM(n, k):
global factrial, inverse, factrial_inverse
if n < k:
return 0
if n < 0 or k < 0:
return 0
return factrial[n] * (factrial_inverse[k] * factrial_inverse[n-k] % MOD) % MOD
# 前処理完了
COMinit()
N = int(eval(input()))
X = list(map(int, input().split()))
# expected_value = [1]
# for i in range(2, N):
# expected_value.append(expected_value[-1]+(1/i))
ans = 0
f = factrial[N-1]
c = 0
for i in range(1, N):
c += f * inverse[i]
c %= MOD
ans += c * (X[i] - X[i-1])
ans %= MOD
print((ans % MOD))
|
# 二項係数を"やるだけ"にしてくれるライブラリ
MAX = 100005
MOD = 1000000007
factrial = [0]*MAX
inverse = [0]*MAX
factrial_inverse = [0]*MAX
# テーブルを作る前処理
def COMinit():
global factrial, inverse, factrial_inverse
factrial[0] = 1
factrial[1] = 1
inverse[1] = 1
factrial_inverse[0] = 1
factrial_inverse[1] = 1
for i in range(2, MAX):
factrial[i] = factrial[i-1] * i % MOD
inverse[i] = MOD - inverse[MOD % i] * (MOD//i) % MOD
factrial_inverse[i] = factrial_inverse[i-1] * inverse[i] % MOD
# 二項係数計算
def COM(n, k):
global factrial, inverse, factrial_inverse
if n < k:
return 0
if n < 0 or k < 0:
return 0
return factrial[n] * (factrial_inverse[k] * factrial_inverse[n-k] % MOD) % MOD
# 前処理完了
COMinit()
N = int(eval(input()))
X = list(map(int, input().split()))
ans = 0
prepro = [1]
for i in range(2, N+1):
prepro.append((prepro[-1]+inverse[i]) % MOD)
for i in range(N-1):
ans += (X[i+1]-X[i]) * prepro[i] % MOD
ans *= factrial[N-1] # 期待値の総和に(N-1)!をかける
print((ans % MOD))
|
p02807
|
n = int(eval(input()))
x = list(map(int, input().split()))
d = []
for x1, x2 in zip(x, x[1:]):
d.append(x2 - x1)
mod = 10 ** 9 + 7
base = 1
for i in range(1, n):
base *= i
ans = 0
b = base
for i, di in enumerate(d):
ans += (base * di) % mod
ans %= mod
base += b // (i + 2)
base % mod
print(ans)
|
n = int(eval(input()))
x = list(map(int, input().split()))
d = []
for x1, x2 in zip(x, x[1:]):
d.append(x2 - x1)
mod = 10 ** 9 + 7
base = 1
P = 10**9 + 7
N = n+2
inv_t = [0]+[1]
for i in range(2,N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
for i in range(1, n):
base *= i
base %= mod
ans = 0
b = base
for i, di in enumerate(d):
ans += (base * di) % mod
ans %= mod
base += b * inv_t[i+2]
base % mod
print(ans)
|
p02807
|
MOD = 10**9+7
n = int(eval(input()))
F = [1]*(n+1)
for i in range(n):
F[i+1] = F[i]*(i+1) % MOD
X = list(map(int, input().split()))
D = [X[i+1]-X[i] for i in range(n-1)]
T = [1]*n
for i in range(2, n):
T[i] = T[i-1]*i+F[i-1]
T[i] %= MOD
t = 1
for i in range(1, n-1):
t *= (n-i) % MOD
T[n-1-i] *= t % MOD
ans = 0
for i in range(1, n):
ans += D[i-1]*T[i]
ans %= MOD
print(ans)
|
MOD = 10**9+7
n = int(eval(input()))
F = [1]*(n+1)
for i in range(n):
F[i+1] = F[i]*(i+1)
F[i+1] %= MOD
X = list(map(int, input().split()))
D = [X[i+1]-X[i] for i in range(n-1)]
T = [1]*n
for i in range(2, n):
T[i] = T[i-1]*i+F[i-1]
T[i] %= MOD
t = 1
for i in range(1, n-1):
t *= (n-i)
t %= MOD
T[n-1-i] *= t
T[n-1-i] %= MOD
ans = 0
for i in range(1, n):
ans += D[i-1]*T[i]
ans %= MOD
print(ans)
|
p02807
|
N = int(eval(input()))
X = list(map(int,input().split()))
MOD = 10**9+7
MAXN = N+5
fac = [1,1] + [0]*MAXN
finv = [1,1] + [0]*MAXN
inv = [0,1] + [0]*MAXN
for i in range(2,MAXN+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
c = 0
f = fac[N-1]
ans = 0
for i in range(1,N):
c += f * inv[i]
c %= MOD
ans += c * (X[i] - X[i-1])
ans %= MOD
print(ans)
|
N = int(eval(input()))
X = list(map(int,input().split()))
Y = [b-a for a,b in zip(X,X[1:])]
MOD = 10**9+7
MAXN = N+5
fac = [1,1] + [0]*MAXN
inv = [0,1] + [0]*MAXN
for i in range(2,MAXN+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
ans = m = 0
for i,y in enumerate(Y):
m += fac[N-1] * inv[i+1]
ans += y*m
ans %= MOD
print(ans)
|
p02807
|
class PERM_COMB_MOD():
def __init__(self, max_n=510000, mod=10**9+7):
self.fac = [0]*max_n
self.finv = [0]*max_n
self.inv = [0]*max_n
self.fac[0] = self.fac[1] = 1
self.finv[0] = self.finv[1] = 1
self.inv[1] = 1
self.max = max_n
self.mod = mod
self._maesyori()
def _maesyori(self):
for i in range(2,self.max):
self.fac[i] = self.fac[i-1] * i % self.mod
self.inv[i] = self.mod - self.inv[self.mod % i] * (self.mod // i) % self.mod
self.finv[i] = self.finv[i-1] * self.inv[i] % self.mod
def perm(self, n, k):
if n < k : return 0
if n < 0 or k < 0:return 0
return self.fac[n] * self.finv[n-k] % self.mod % self.mod
def comb(self, n, k):
if n < k : return 0
if n < 0 or k < 0:return 0
return self.fac[n] * (self.finv[k] * self.finv[n-k] % self.mod) % self.mod
mod = 10**9+7
P = PERM_COMB_MOD(2*10**5, mod=mod)
n = int(eval(input()))
x = list(map(int, input().split()))
base = x[-1]-x[0]
left = []
k = n-1
for i in range(k):
a = P.perm(k, k-(i+1))*P.fac[i]
left.append(a)
ans = base*P.fac[k]
for i in range(k):
for j in range(1, n-1-i):
ans += left[j]*(x[i+j+1]-x[i+j])
ans %= mod
print(ans)
|
class PERM_COMB_MOD():
def __init__(self, max_n=510000, mod=10**9+7):
self.fac = [0]*max_n
self.finv = [0]*max_n
self.inv = [0]*max_n
self.fac[0] = self.fac[1] = 1
self.finv[0] = self.finv[1] = 1
self.inv[1] = 1
self.max = max_n
self.mod = mod
self._maesyori()
def _maesyori(self):
for i in range(2,self.max):
self.fac[i] = self.fac[i-1] * i % self.mod
self.inv[i] = self.mod - self.inv[self.mod % i] * (self.mod // i) % self.mod
self.finv[i] = self.finv[i-1] * self.inv[i] % self.mod
def perm(self, n, k):
if n < k : return 0
if n < 0 or k < 0:return 0
return self.fac[n] * self.finv[n-k] % self.mod % self.mod
def comb(self, n, k):
if n < k : return 0
if n < 0 or k < 0:return 0
return self.fac[n] * (self.finv[k] * self.finv[n-k] % self.mod) % self.mod
mod = 10**9+7
P = PERM_COMB_MOD(2*10**5, mod=mod)
n = int(eval(input()))
x = list(map(int, input().split()))
base = x[-1]-x[0]
left = []
k = n-1
for i in range(k):
a = P.perm(k, k-(i+1))*P.fac[i]
left.append(a)
left[0] = 0
for i in range(1, k):
left[i] += left[i-1]
ans = base*P.fac[k]
for i in range(1, n-1):
tmp = x[i+1]-x[i]
ans += tmp*left[i]
ans %= mod
print(ans)
|
p02807
|
#----------------------------------------------------------
P = 10**9 + 7
N = 100001 #使う最大値+1以上にする、値に注意3*10^5とかにしとくと安心
inv = [0] + [1] # 1/x
finv = [1] + [1] # 1/x!
fac = [1] + [1] # x!
for i in range(2,N):
inv += [inv[P % i] * (P - int(P / i)) % P]
fac += [(fac[i-1] * i) % P]
finv += [(finv[i-1] * inv[i]) % P]
def comb(a, b):
if a<b or a<0 or b<0:
return 0 # error
return (fac[a] * ((finv[b] * finv[a-b]) % P)) %P
#----------------------------------------------------------
n=int(eval(input()))
x=list(map(int,input().split()))
ans=0
for i in range(n-1):
t = (x[n-1]-x[i])%P
o =(fac[i]*fac[n-2-i])%P
g = (comb(n-1,n-1-i)*o)%P
t = (t * g)%P
ans=(ans+t)%P
for i in range(n-1):
for j in range(i+1,n-1):
t = (x[j]-x[i])%P
o =(fac[n-1-j+i-1]*fac[j-i-1])%P
g = (comb(n-1,j-i+1)*o)%P
t = (t * g)%P
ans=(ans + t)%P
print((ans%P))
|
#----------------------------------------------------------
P = 10**9 + 7
N = 100001 #使う最大値+1以上にする、値に注意3*10^5とかにしとくと安心
inv = [0] + [1] # 1/x
finv = [1] + [1] # 1/x!
fac = [1] + [1] # x!
for i in range(2,N):
inv += [inv[P % i] * (P - int(P / i)) % P]
fac += [(fac[i-1] * i) % P]
finv += [(finv[i-1] * inv[i]) % P]
def comb(a, b):
if a<b or a<0 or b<0:
return 0 # error
return (fac[a] * ((finv[b] * finv[a-b]) % P)) %P
#----------------------------------------------------------
n=int(eval(input()))
x=list(map(int,input().split()))
s = [0] * n
for i in range(n):
s[i] = x[i] + (s[i-1] if i>0 else 0)
ans=0
for i in range(n-1):
t = (x[n-1]-x[n-2-i])%P
t = (t * (fac[n-1]*inv[i+1])%P)%P
ans=(ans+t)%P
for i in range(1, n-1):
t = (s[n-2] - s[i-1] - s[n-2-i])%P
p = (((fac[n-1] * inv[i])%P) * inv[i+1])%P
ans = (ans + (t*p)%P)%P
print((ans%P))
|
p02807
|
MOD = 10 ** 9 + 7
N = int(eval(input()))
x = list(map(int, input().split()))
x.sort()
kaijo = [1]
for i in range(1, N):
kaijo.append(kaijo[-1] * i)
ans = 0
for i in range(N - 1):
ans = (ans * (i + 1) + (x[-1] - x[i]) * kaijo[i]) % MOD
print(ans)
|
MOD = 10 ** 9 + 7
N = int(eval(input()))
x = list(map(int, input().split()))
x.sort()
kaijo = [1]
for i in range(1, N):
kaijo.append(kaijo[-1] * i % MOD)
ans = 0
for i in range(N - 1):
ans = (ans * (i + 1) + (x[-1] - x[i]) * kaijo[i]) % MOD
print(ans)
|
p02807
|
n, *x = list(map(int, open(0).read().split()))
mod = 10 ** 9 + 7
y = []
for i in range(n - 1):
y.append(x[i + 1] - x[i])
fac = [1] * (n + 1)
for i in range(1, n):
fac[i] = fac[i - 1] * i % mod
dp = [0] * n
ans = 0
p = 0
for i in range(n - 1):
p = (p + pow(i + 1, mod - 2, mod))
ans = (ans + p * y[i]) % mod
print((ans * fac[n - 1] % mod))
|
n, *x = list(map(int, open(0).read().split()))
mod = 10 ** 9 + 7
fac = [1] * n
for i in range(1, n):
fac[i] = fac[i - 1] * i % mod
ans = 0
p = 0
for i in range(n - 1):
p = (p + pow(i + 1, mod - 2, mod))
ans = (ans + p * (x[i + 1] - x[i])) % mod
print((ans * fac[n - 1] % mod))
|
p02807
|
n = int(eval(input()))
x = list(map(int, input().split()))
ans = 0
p = 1
for i in range(1, n):
p *= i
for i in range(n-1):
ans += (x[n-1]-x[i])*p//(i+1)
ans %= 1000000007
print(ans)
|
n = int(eval(input()))
x = list(map(int, input().split()))
ans = 0
mod = 1000000007
p = 1
for i in range(1, n):
p *= i
p %= mod
for i in range(n-1):
ans += (x[n-1]-x[i])*pow(i+1, mod-2, mod)
ans *= p
ans %= 1000000007
print(ans)
|
p02807
|
import sys
from fractions import Fraction
from math import factorial
rl = sys.stdin.readline
def solve():
N = int(rl())
x = list(map(int, rl().split()))
MOD = 10 ** 9 + 7
acc = [Fraction(0)] * N
for i in range(1, N):
acc[i] = acc[i - 1] + Fraction(1, i)
ans = 0
for i in range(N - 1):
ans = ans + (x[i + 1] - x[i]) * acc[i + 1] % MOD
ans = int(ans * factorial(N - 1) % MOD)
print(ans)
if __name__ == '__main__':
solve()
|
import sys
from math import factorial
rl = sys.stdin.readline
def mod_div(x, y, mod=10 ** 9 + 7):
return x * pow(y, mod - 2, mod) % mod
def solve():
N = int(rl())
x = list(map(int, rl().split()))
MOD = 10 ** 9 + 7
acc = [0] * N
k = factorial(N - 1)
for i in range(1, N):
acc[i] = (acc[i - 1] + k) % MOD
k = k * mod_div(i, i + 1) % MOD
ans = 0
for i in range(N - 1):
ans = (ans + (x[i + 1] - x[i]) * acc[i + 1]) % MOD
print(ans)
if __name__ == '__main__':
solve()
|
p02807
|
N = int(eval(input()))
Xs = [0] + list(map(int, input().split()))
mod = 10**9 + 7
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
NNN = (10**6)
g1 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
mxx = Xs[-1]
r = 0
for i in range(N):
i += 1
for j in range(1, N-i):
ue = mul(g1[N-1], Xs[i+j] - Xs[i])
ff = mul(mul(ue, inverse[j+1]), inverse[j])
r = (r + ff) % mod
ue = mul(g1[N-1], Xs[N]-Xs[i])
ff = mul(ue,inverse[N-i])
r = (r+ff)%mod
print(r)
|
N = int(eval(input()))
Xs = list(map(int, input().split()))
mod = 10**9 + 7
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
NNN = (10**6)
g1 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
mxx = Xs[-1]
r = 0
r2 = 0
for i in range(N-1):
r = (r+mul(mul(g1[N-1],inverse[i+1]),Xs[N-1]-Xs[i]))%mod
print(r)
|
p02807
|
N = int(eval(input()))
Xs = list(map(int, input().split()))
mod = 10**9 + 7
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
NNN = (10**6)
g1 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
mxx = Xs[-1]
r = 0
r2 = 0
for i in range(N-1):
r = (r+mul(mul(g1[N-1],inverse[i+1]),Xs[N-1]-Xs[i]))%mod
print(r)
|
N,*X=list(map(int,open(0).read().split()))
M,g,q,r=10**9+7,1,[1,1],0
for i in range(1,N):
r,g=(r+q[-1]*(X[-1]-X[i-1]))%M,g*i%M
q+=[M//(-~i)*-q[M%(-~i)]%M]
print((r*g%M))
|
p02807
|
N,*X=list(map(int,open(0).read().split()));M,g,r,h,i=10**9+7,1,0,[1],N;exec("i-=1;h+=[h[-1]*i%M];"*N+"r,g=(r+g*h[N-2-i]*(X[-1]-X[i]))%M,g*-~i%M;i+=1;"*N);print(r)
|
N,*X=list(map(int,open(0).read().split()));M,g,r,h,i=10**9+7,1,0,[1],N
while i:i-=1;h+=[h[-1]*i%M]
while i<N:r,g=(r+g*h[N-2-i]*(X[-1]-X[i]))%M,g*-~i%M;i+=1
print(r)
|
p02807
|
n = int(eval(input()))
x = list( map(int, input().split()))
def extgcd(a,b):
r = [1,0,a]
w = [0,1,b]
while w[2]!=1:
q = r[2]//w[2]
r2 = w
w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]
r = r2
w = w2
#[x,y]
return [w[0],w[1]]
def mod_inv(a,mod):
x = extgcd(a,mod)[0]
return (mod+x%mod)%mod
ans = 0
MOD = 10**9 + 7
factorial = 1
for i in range(2,n):
factorial = (factorial * i%MOD) %MOD
p = [0]*(n-1)
p[0] = 1 * factorial%MOD
for i in range(1,n-1):
p[i] = p[i-1] + factorial*mod_inv(i+1,MOD)
p[i] %= MOD
for i in range(n-1):
ans += (x[i+1]-x[i])%MOD*p[i]
ans %= MOD
print((int(ans)))
|
n = int(eval(input()))
x = list( map(int, input().split()))
MOD = 10**9 + 7
def make_mod_inv(l,p): # lまでの逆元を作る
mod_inv = [0, 1] + [0] * (l+3) # inv[n] = n^(-1) mod p, 0! = 1 だけど便宜上inv[0]=0にしてる
for i in range(2, l+5):
mod_inv[i] = -mod_inv[p % i] * (p // i) % p
return mod_inv
mod_inv = make_mod_inv(n-1,MOD)
ans = 0
factorial = 1
for i in range(2,n):
factorial = (factorial * i%MOD) %MOD
p = [0]*(n-1)
p[0] = 1 * factorial%MOD
for i in range(1,n-1):
p[i] = p[i-1] + factorial*mod_inv[i+1]
p[i] %= MOD
for i in range(n-1):
ans += (x[i+1]-x[i])%MOD*p[i]
ans %= MOD
print((int(ans)))
|
p02807
|
def per(n, r, mod):
if ( r<0 or r>n ):
return 0
r=n-r
return g1[n] * g2[r] % mod
mod = 10**9+7 #出力の制限
N = 10**5+5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
n=int(eval(input()))
A=[1]
for i in range(1,n-1):
A.append(A[-1]*(i+1)+per(i,i,mod))
X=list(map(int,input().split()))
Y=[X[1]-X[0]]
for i in range(2,n):
Y.append(X[i]-X[i-1])
ans=0
for i in range(n-1):
if n-2-i==0:
ans=ans+A[i]*Y[i]
else:
ans=(ans+A[i]*per(n-1,n-2-i,mod)*Y[i])%(10**9+7)
print((ans%mod))
|
n=int(eval(input()))
x=list(map(int,input().split()))
a=1
B=[1,1]
mod=10**9+7
for i in range(2,n):
a=a*i%mod
B.append(pow(i,mod-2,mod))
d=[0]*(n-1)
for i in range(n-1):
d[i]=x[i+1]-x[i]
D=[d[-1]]
for i in range(n-2):
D.append(D[-1]+d[-2-i])
D=D[::-1]
ans=0
for i in range(n-1):
ans=(ans+D[i]*a*B[i+1])%mod
print(ans)
|
p02807
|
N = int(eval(input()))
A = list(map(int, input().split()))
mod = int(1e+9 + 7)
p = mod - 2
S = []
while p != 0:
S = [p%2] + S[:]
p //= 2
frac = 1
for i in range(N - 1):
frac *= i+1
frac %= mod
T = 0
for i in range(N - 1):
k = 1
for j in range(len(S)):
if S[j] == 1:
k *= i+1
k %= mod
if j != len(S) - 1:
k *= k
k %= mod
T += (frac * k * (A[N - 1] - A[i])) % mod
T %= mod
print((T%mod))
|
N = int(eval(input()))
A = list(map(int, input().split()))
mod = int(1e+9 + 7)
def inved(a):
x, y, u, v, k, l = 1, 0, 0, 1, a, mod
while l != 0:
x, y, u, v = u, v, x - u * (k // l), y - v * (k // l)
k, l = l, k % l
return x
frac = 1
for i in range(N - 1):
frac *= i+1
frac %= mod
T = 0
for i in range(N - 1):
k = inved(i+1)
T += (k * (A[N - 1] - A[i])) % mod
T %= mod
print(((T*frac)%mod))
|
p02807
|
import sys
import bisect
input = sys.stdin.readline
def main():
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
odd = a[::2]
even = a[1::2]
odd.sort()
even.sort()
ans = 0
for i, v in enumerate(odd):
ans += bisect.bisect(even[i:], v)
print(ans)
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
a = [[int(eval(input())), i] for i in range(n)]
a.sort()
ans = 0
for i in range(n):
if i%2 != a[i][1]%2:
ans += 1
print((ans//2))
if __name__ == "__main__":
main()
|
p04021
|
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
B = tuple(sorted(A))
ans = 0
skip_flag = False
for i in range(N):
if skip_flag == False:
idx = A.index(B[i])
if abs(i - idx) % 2 == 0: # あまり０なら操作２だけで所定の位置に動かせる
continue
else:
ans += 1
# 次のやつも同時にできるか
if i < N-1:
next_idx = A.index(B[i+1])
if abs(i+1 - next_idx) % 2 == 1:
skip_flag = True
else:
skip_flag = False
continue
print(ans)
|
import math
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
idx_A = {}
for i in range(N):
idx_A[A[i]] = i
B = tuple(sorted(A))
"""
ソート後の位置までの距離が奇数だと操作１が一回必要になる
一度の操作１で最大で２個までのソート後の位置までの距離が奇数のものを偶数にずらしてあげられる
ので、正しい位置までの距離が奇数のものの個数をしらべて、最小の操作１の回数を求める
"""
cnt = 0
for i in range(N):
if abs(i - idx_A[B[i]]) % 2 == 0: # あまり０なら操作２だけで所定の位置に動かせる
continue
else:
cnt += 1
print((math.ceil(cnt/2)))
|
p04021
|
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
D = {a:i for i,a in enumerate(sorted(A))}
A = [D[A[i]] for i in range(N)]
odd = [A[i] for i in range(N) if i%2 == 0]
even = [A[i] for i in range(N) if i%2 == 1]
odd.sort()
even.sort()
B = []
for i in range(N):
if i%2 == 0:
B.append(odd[i//2])
else:
B.append(even[i//2])
count = 0
for i in range(N):
if i%2 == 0 and B[i]%2 != 0:
count += 1
print(count)
|
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
D = {a:i for i,a in enumerate(sorted(A))}
A = [D[A[i]] for i in range(N)]
count = 0
for i in range(N):
if i%2 == 0 and A[i]%2 != 0:
count += 1
print(count)
|
p04021
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
n = int(readline())
a = [int(readline()) for i in range(n)]
k = [ai for i,ai in enumerate(a) if i%2 == 0]
g = [ai for i,ai in enumerate(a) if i%2 == 1]
k.sort()
g.sort()
ans = 0
from bisect import insort
from collections import deque
for i in range(n-1):
K = (i+1)//2
G = i//2
p = k[K]; q = g[G]
if (K == G and p > q) or (K > G and p < q):
ans += 1
insort(k,q)
insort(g,p)
k = deque(k)
g = deque(g)
k.popleft()
g.popleft()
k = list(k)
g = list(g)
print(ans)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
n = int(readline())
a = [int(readline()) for i in range(n)]
k = [ai for i,ai in enumerate(a) if i%2 == 0]
k = set(k)
a.sort()
ans = 0
for i,ai in enumerate(a):
if ai in k and i%2 == 1:
ans += 1
print(ans)
|
p04021
|
n = int(eval(input()))
a = [int(eval(input()))for _ in range(n)]
o = a[::2]
e = a[1::2]
o.sort()
e.sort()
l = [0] * n
for i in range(n):
if i % 2 == 0:
l[i] = o[i // 2]
else:
l[i] = e[(i - 1) // 2]
ans = 0
for _ in range(n):
for i in range(n - 1):
if l[i] > l[i + 1]:
ans += 1
l[i], l[i + 1] = l[i + 1], l[i]
print(ans)
|
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
d = [{x: 0 for x in a} for _ in range(2)]
b = sorted(a)
for i in range(n):
if i % 2:
d[0][a[i]] += 1
d[1][b[i]] += 1
t1 = 0
t2 = 0
for v1, v2 in zip(list(d[0].values()), list(d[1].values())):
if v1 > v2:
t1 += v1 - v2
print(t1)
|
p04021
|
#!/usr/bin/env python3
#AGC3 C
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = [I() for _ in range(n)]
b = sorted(a)
lst = []
for i in range(n):
if a[i] != b[i]:
r = bl(b,a[i])
if i % 2 ^ r % 2 == 0:
continue
lst.append(a[i])
lst.sort()
m = len(lst)
ans = m//2
print(ans)
|
#!/usr/bin/env python3
#AGC3 C
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = [I() for _ in range(n)]
b = sorted(a)
lst = []
for i in range(n):
if a[i] != b[i]:
r = bl(b,a[i])
if i % 2 ^ r % 2 == 0:
continue
lst.append(a[i])
m = len(lst)
ans = m//2
print(ans)
|
p04021
|
import sys
from collections import defaultdict
input = sys.stdin.readline
def main():
N = int( eval(input()))
A = [ int( eval(input())) for _ in range(N)]
B = sorted(A)
d = defaultdict( int)
for i in range(N):
d[B[i]] = i
odd = 0
for i in range(N):
if (i+1)%2 == d[A[i]]%2 and d[A[i]]%2 == 1:
odd += 1
print(odd)
if __name__ == '__main__':
main()
|
# import sys
from collections import defaultdict
# input = sys.stdin.readline
def main():
N = int( eval(input()))
A = [ int( eval(input())) for _ in range(N)]
B = sorted(A)
d = defaultdict( int)
for i in range(N):
d[B[i]] = i
odd = 0
for i in range(N):
if (i+1)%2 == d[A[i]]%2 and d[A[i]]%2 == 1:
odd += 1
print(odd)
if __name__ == '__main__':
main()
|
p04021
|
n = int(eval(input()))
nums = [int(eval(input())) for _ in range(n)]
standard = nums[:]
standard.sort()
ans = 0
for i in range(n):
p = nums[i]
x = standard.index(p)
if abs(x - i) % 2 == 1:
ans += 1
print((ans // 2))
|
n = int(eval(input()))
nums = [[int(eval(input())), i] for i in range(n)]
nums.sort()
ans = 0
for i in range(n):
if abs (i - nums[i][1]) % 2 == 1:
ans += 1
print((ans // 2))
|
p04021
|
from heapq import heappop, heappush
N = int(eval(input()))
idx = {}
A = []
ans = 0
for i in range(N):
a = int(eval(input()))
idx[a] = i%2
heappush(A,a)
for i in range(N):
x = heappop(A)
if idx[x] != i%2:
ans += 1
print((ans//2))
|
from heapq import heappop, heappush
N = int(eval(input()))
A = []
memo = {}
count = 0
for i in range(N):
a = int(eval(input()))
if i%2 == 1:
memo[a] = 1
else:
memo[a] = 0
heappush(A,a)
for i in range(N):
x = heappop(A)
if i%2 != memo[x]:
count += 1
print((count//2))
|
p04021
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.