problem_id
stringclasses 100
values | submission_id
stringlengths 10
10
| status
stringclasses 2
values | code
stringlengths 6
806
|
|---|---|---|---|
p02554
|
s894585617
|
Accepted
|
import sys
input = sys.stdin.readline
N = int(input())
mod = 1e9+7
ten = 1
nine = 1
eight = 1
for _ in range(N):
ten *= 10
ten %= mod
nine *= 9
nine %= mod
eight *= 8
eight %= mod
ans = ten - 2 * nine + eight
ans = int(ans)
ans %= mod
if ans < 0:
ans += mod
print(int(ans))
|
p02554
|
s629420312
|
Accepted
|
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n = ni()
if n == 1:
print(0)
else:
print((pow(10, n, mod)-(2 * pow(9, n, mod) - pow(8, n, mod))) % mod)
|
p02554
|
s668642476
|
Accepted
|
n = int(input())
k = 1000000007
print(((10**n)%k - (2* 9**n)%k+(8**n)%k)%k)
|
p02554
|
s846974674
|
Accepted
|
n = int(input())
mod = 10**9 + 7
ans = pow(10,n,mod) - (pow(9,n,mod) * 2 -pow(8,n,mod))
print(ans%mod)
|
p02554
|
s490896948
|
Accepted
|
N=int(input())
if N == 1:
print(0)
else:
s=10**N + 8**N - 2*(9**N)
print(s%1000000007)
|
p02554
|
s556946614
|
Accepted
|
n=int(input())
#0-9
#1-9のみ
a8=1
a9=1
a10=1
for i in range(n):
a8=(a8*8)%(10**9+7)
a9=(a9*9)%(10**9+7)
a10=(a10*10)%(10**9+7)
#0-8のみ
print((a10-(2*a9-a8))%(10**9+7))
|
p02554
|
s308961557
|
Accepted
|
MOD = 10**9 + 7
N = int(input())
x = pow(10, N, MOD)
x -= pow(9, N, MOD) * 2
x += pow(8, N, MOD)
print(x % MOD)
|
p02554
|
s429500999
|
Accepted
|
n=int(input())
n2=10**n
n3=8**n
n4=9**n
n5=n4-n3
print((n2-n3-n5-n5)%(10**9+7))
|
p02554
|
s051572285
|
Accepted
|
MOD = 10 ** 9 + 7
n = int(input())
x = pow(10, n, MOD)
y = pow(9, n, MOD)
z = pow(8, n, MOD)
ans = (((x - ((2 * y) % MOD) + MOD) % MOD) + z) % MOD
print(ans)
|
p02554
|
s353276907
|
Accepted
|
N = int(input())
mod = 10 ** 9 + 7
print((pow(10, N, mod) - pow(9, N, mod) - pow(9, N, mod) + pow(8, N, mod)) % mod)
|
p02554
|
s407355591
|
Accepted
|
N = int(input())
mod = 10**9 + 7
total = pow(10, N, mod)
not_0 = pow(9, N, mod)
not_9 = not_0
not_9_and_0 = pow(8, N, mod)
ans = ( total - (not_0 + not_9 - not_9_and_0) ) % mod
print(ans)
|
p02554
|
s301239756
|
Accepted
|
n = int(input())
nAll = 10**n
nOne = 2*(9**n)
nBoth = 8**n
print((nAll - nOne + nBoth)%(10**9+7))
|
p02554
|
s693140565
|
Accepted
|
# coding: utf-8
def solve(*args: str) -> str:
n = int(args[0])
mod = 10**9+7
return str((pow(10, n, mod)-2*pow(9, n, mod)+pow(8, n, mod)) % mod)
if __name__ == "__main__":
print(solve(*(open(0).read().splitlines())))
|
p02554
|
s077583120
|
Accepted
|
mod=10**9+7
n=int(input())
print((pow(10,n,mod)-2*pow(9,n,mod)+pow(8,n,mod))%mod)
|
p02554
|
s072768828
|
Accepted
|
from scipy.special import comb
def main():
n = int(input())
# sum = 0
# for i in range(1, n):
# sum += comb(n, i, exact=True)
# sub = (n-2)*sum
# ans = n*(n-1)*(10**(n-2))-sub
ans = 10**n - 2*(9**n) + 8**n
print(int(ans%((10)**9+7)))
if __name__ == '__main__':
main()
|
p02554
|
s717107840
|
Accepted
|
n = int(input())
ans_max = 1
for i in range(n):
ans_max = ans_max * 10 % 1000000007
ans_mid = 1
for i in range(n):
ans_mid = ans_mid * 9 % 1000000007
ans_mid = ans_mid * 2 % 1000000007
ans_min = 1
for i in range(n):
ans_min = ans_min * 8 % 1000000007
ans = (ans_max - (ans_mid - ans_min)) % 1000000007
print(ans)
|
p02554
|
s506699521
|
Accepted
|
n=int(input())
kotae=(10**n-2*(9**n)+(8**n))%(10**9+7)
print(kotae)
|
p02554
|
s461562187
|
Accepted
|
mod = 10**9+7
N = int(input())
p = pow(10, N, mod)
q = pow( 9, N, mod)
r = pow( 8, N, mod)
print((p-q*2+r)%mod)
|
p02554
|
s952395534
|
Accepted
|
N = int(input())
M = 10 ** 9 + 7
set1 = (9 ** N) % M
set2 = (10 ** N) % M
set3 = (8 ** N) % M
tmp = (set2 + set3)% M
tmp = (tmp - set1)% M
print((tmp - set1)% M)
|
p02554
|
s070079919
|
Accepted
|
N = int(input())
print((-2*9**N+8**N+10**N)%(10**9+7))
|
p02554
|
s462316406
|
Accepted
|
N = int(input())
MOD = 10**9 + 7
c = 1
c0 = 0
c1 = 0
c01 = 0
for _ in range(N):
c01 = (c0+c1+c01*10)%MOD
c0 = (c + c0*9)%MOD
c1 = (c + c1*9)%MOD
c = (c*8)%MOD
print(c01)
|
p02554
|
s516845942
|
Accepted
|
def main(N):
if N==1:
return 0
elif N==2:
return 2
else:
return (10**N - (9**N*2 - 8**N))%(10**9 + 7)
if __name__ == '__main__':
N = int(input())
ans = main(N)
print(ans)
|
p02554
|
s172740260
|
Accepted
|
n=int(input())
if n==1:
print(0)
exit()
no09=8**n
no0=9**n
print((10**n-9**n-(no0-no09))%(10**9+7))
|
p02554
|
s273521159
|
Accepted
|
N = int(input())
mod = 10**9+7
ans = (pow(10,N,mod) +pow(8,N,mod) - 2*pow(9,N,mod)) % mod
if ans < 0:
ans += mod
print(ans)
|
p02554
|
s306645790
|
Accepted
|
n=int(input())
mod=10**9+7
e=pow(8,n,mod)
f=pow(9,n,mod)
g=pow(10,n,mod)
print((g-2*f+e)%mod)
|
p02554
|
s310932305
|
Accepted
|
n = int(input())
print((10**n - 2*9**n + 8**n)%(10**9+7))
|
p02554
|
s229766223
|
Accepted
|
# Aiは1桁の非負の整数
# Ai==0がある
# Ai==9がある
# 10通りある
mod = 10**9+7
N = int(input())
# 全てのパターンから，0がないパターン - 9がないパターン + 0も9もないパターン
# pow(base, exp, mod]) # modはoptional
ans = pow(10, N, mod) - pow(9, N, mod) - pow(9, N, mod) + pow(8, N, mod)
print(ans%mod)
|
p02554
|
s148096152
|
Accepted
|
n = int(input())
if n ==1:
print(0)
exit()
mod = 10**9 + 7
c = 10**n + 8**n
d = 9**n + 9**n
print((c-d)%mod)
|
p02554
|
s773514553
|
Accepted
|
n = int(input())
mod = 10**9+7
ans = pow(10,n,mod)-pow(9,n,mod)-(pow(9,n,mod)-pow(8,n,mod))
ans %= mod
print (ans)
|
p02554
|
s270076835
|
Accepted
|
import numpy as np
n = int(input())
div=1000000007
loop=(n)//10
amari=(n)%10
mod1=1
mod2=1
mod3=1
for i in range(0,loop):
mod1=(mod1*(10**10 % div) ) % div
mod2=(mod2*(9**10 % div) ) % div
mod3=(mod3*(8**10 % div) ) % div
mod1=mod1*(10**amari % div)
mod2=mod2*(9**amari % div)
mod3=mod3*(8**amari % div)
#print (loop, amari)
#print (mod1, mod2, mod3)
print((((mod1-mod2*2))+mod3) % div)
|
p02554
|
s839602367
|
Accepted
|
n=int(input())
if n==1:
print(0)
exit()
mod=10**9+7
ans=pow(10,n,mod) - pow(9,n,mod)- pow(9,n,mod)+ pow(8,n,mod)
print(ans%mod)
|
p02554
|
s122577934
|
Accepted
|
mod=10**9+7
N=int(input())
print((pow(10, N, mod)-pow(9, N, mod)*2+pow(8, N, mod))%mod)
|
p02554
|
s463993547
|
Accepted
|
n = int(input().rstrip())
if n==1:
print(0)
else:
MOD = 1_000_000_007
a = 1
b = 1
c = 1
for i in range(n):
a = (a*10)%MOD
b = (b*9)%MOD
c = (c*8)%MOD
print((a-b-b+c+MOD+MOD)%MOD)
|
p02554
|
s250386827
|
Accepted
|
def bekijou(a,x):
MOD = 1000000007
ret = 1
for _ in range(x):
ret *= a
ret %= MOD
return ret
n=int(input())
MOD = 1000000007
ret = (bekijou(10,n)+MOD-((2*bekijou(9,n)) % MOD)+bekijou(8,n))%MOD
print(ret)
|
p02554
|
s142654242
|
Accepted
|
import sys
n = int(input())
pmax = 10 ** 9 + 7
if n == 1 or n== 0 :
print('0')
sys.exit()
elif n == 2:
print('2')
sys.exit()
x = 10 ** n % pmax
y = 9 ** n % pmax
z = 9 ** n % pmax
yz = 8 ** n % pmax
ans = (x - y - z + yz) % pmax
print(ans)
|
p02554
|
s639797634
|
Accepted
|
n = int(input())
powof10 = 1
powof9 = 1
powof8 = 1
MOD = 10**9+7
for _ in range(n):
powof10 *= 10
powof10 %= MOD
powof9 *= 9
powof9 %= MOD
powof8 *= 8
powof8 %= MOD
print((powof10-2*powof9+powof8) % MOD)
|
p02554
|
s294830130
|
Accepted
|
n = int(input())
MOD = 1000000007
ans = pow(10,n,MOD) - pow(9,n,MOD) - pow(9,n,MOD) + pow(8,n,MOD)
print((ans+MOD)%MOD)
|
p02554
|
s388399906
|
Accepted
|
MOD = 10**9 + 7
n = int(input())
print((pow(10, n, MOD) - 2*pow(9, n, MOD) + pow(8,n,MOD))%MOD)
|
p02554
|
s211025863
|
Accepted
|
n = int(input())
mod = 10**9+7
a = 10**n-8**n
a%=mod
b = 10**n-9**n
b%=mod
c = b*2
d = c-a
d%=mod
print(d)
|
p02554
|
s551396903
|
Accepted
|
m = (10 ** 9) + 7
n = int(input())
ans = (10 ** n) + (8 ** n) - (2 * (9 ** n))
print(ans % m)
|
p02554
|
s831245764
|
Accepted
|
n = int(input())
mod = 10**9+7
ans = pow(10,n,mod) - 2*pow(9,n,mod) + pow(8,n,mod)
ans %= mod
print(ans)
|
p02554
|
s166366385
|
Accepted
|
def main():
num = int(input())
con = 10**9 + 7
a, b, c = 1, 1, 2
for i in range(num):
a *= 10
a %= con
b *= 8
b %= con
c *= 9
c %= con
if(a+b-c < 0):
print(a+b-c+con)
return 0
print(a+b-c)
if __name__ == '__main__':
main()
|
p02554
|
s515571672
|
Accepted
|
n = int(input())
mod = 10**9 + 7
ans = 10**n - 9**n * 2 + 8**n
ans %= mod
print(ans)
|
p02554
|
s953110751
|
Accepted
|
n = int(input())
x = 10 ** n
x -= 2 * (9 ** n)
x += 8 ** n
x = x % (10 ** 9 + 7)
print(x)
|
p02554
|
s854113879
|
Accepted
|
N = int(input())
Q = 10 ** 9 + 7
a10 = 1
a9 = 1
a8 = 1
for _ in range(N):
a10 *= 10
a9 *= 9
a8 *= 8
a10 %= Q
a9 %= Q
a8 %= Q
ans = (a10 - (2 * a9 - a8)) % Q
print(ans)
|
p02554
|
s029353674
|
Accepted
|
def binexp(a,b):
res = 1
while b>0:
if b&1:
res *= a
res%=mod
a *= a
a%=mod
b>>=1
return res
mod = 1000000007
n = int(input())
if n==1:
print(0)
elif n==2:
print(2)
else:
ans = binexp(10,n)
ans1 = binexp(9,n)
ans2 = binexp(8,n)
print((ans-2*ans1+ans2)%mod)
|
p02554
|
s157736544
|
Accepted
|
N=int(input())
print((10**N+8**N-2*9**N)%(10**9+7))
|
p02554
|
s046247524
|
Accepted
|
N = int(input())
mod = 10**9+7
a = pow(10,N,mod)
b = pow(8,N,mod)
c = pow(9,N,mod)
ans = a-2*c+b
while ans<0:
ans += mod
ans %= mod
print(ans)
|
p02554
|
s294122293
|
Accepted
|
n = int(input())
mod = 10 **9 + 7
print((pow(10,n,mod)-(pow(9,n,mod) *2) + pow(8,n,mod))%mod)
|
p02554
|
s153687153
|
Accepted
|
n=int(input())
print((10**n-(9**n)*2+8**n)%(10**9+7))
|
p02554
|
s607017173
|
Accepted
|
import sys
readline = sys.stdin.buffer.readline
n = int(readline())
if n > 1 : print((pow(10,n) - 2*pow(9,n) + pow(8,n)) % 1000000007)
else : print(0)
|
p02554
|
s741403439
|
Accepted
|
n = int(input())
mod = 10**9 + 7
ans = pow(10,n, mod)
ans = ans - pow(9, n, mod) - pow(9, n, mod) + pow(8, n, mod)
ans %= mod
print(ans)
|
p02554
|
s551482675
|
Accepted
|
N = int(input())
INF = 10 ** 9 + 7
print((pow(10, N, INF) - 2 * pow(9, N, INF) + pow(8, N, INF)) % INF)
|
p02554
|
s226394147
|
Accepted
|
import math
from typing import List, Any
def read_int() -> int:
return int(input().strip())
def read_ints() -> List[int]:
return list(map(int, input().strip().split(' ')))
def modpow(base, p, modulo):
answer = 1
for _ in range(p):
answer = (answer*base)%modulo
return answer
def solve() -> Any:
N = read_int()
modulo = 10**9+7
atleast = pow(10, N, modulo)-pow(9, N, modulo)
answer = pow(8, N, modulo)+2*atleast-pow(10, N, modulo)
return answer%modulo
if __name__ == '__main__':
print(solve())
|
p02554
|
s639665036
|
Accepted
|
n=int(input())
if n==1:
print(0)
else:
ans=(10**n-2*9**n+8**n)%(10**9+7)
print(ans)
|
p02554
|
s011159273
|
Accepted
|
n=int(input())
if n==1:exit(print(0))
m=10**9+7
total=pow(10,n,m)
total=(total-pow(9,n,m))%m # without zeros
total=(total-pow(9,n,m))%m # without ones
total=(total+pow(8,n,m))%m # without zeros and ones
print(total)
|
p02554
|
s449237613
|
Accepted
|
N=int(input())
X=10**N-2*9**N+8**N
print(X%(10**9+7))
|
p02554
|
s137196151
|
Accepted
|
import sys
sys.setrecursionlimit(250000)
# a = comb(n, r)
def main():
# a,b,c,d = map(int, input().split())
n = int(input())
# temp = (10 ** 9 + 7)
# sum = 0
# if n >= 2:
# for i in range(2, n+1):
# a = int(comb(i, 2)) * 2
# a = (a * 8**(i-2)) % temp
# sum = sum + a
# else:
# print(0)
print((10**n - 9**n*2 + 8**n) % (10 ** 9 + 7))
main()
|
p02554
|
s556618016
|
Accepted
|
n = int(input())
def modpow(b,e):
if e == 0:
return 1
elif e%2 == 1:
return b*modpow(b,e-1)
else:
return modpow(b*b,e//2)
total = modpow(10,n)
minus = modpow(9,n)
add = modpow(8,n)
answer = total - minus - minus + add
answer %= 1000000007
print(answer)
|
p02554
|
s508137776
|
Accepted
|
N=int(input())
M=10**9+7
A=pow(9,N,M)
B=pow(9,N,M)
C=pow(8,N,M)
A-=C
B-=C
S=pow(10,N,M)
ans=S-C-(A+B)
print(ans%M)
|
p02554
|
s781461561
|
Accepted
|
n = int(input())
mod = int(1e9) + 7
a = 1
b = 1
c = 1
for i in range(n):
a = (a * 10) % mod
b = (b * 8) % mod
c = (c * 9) % mod
ans = (a - (2*c - b % mod)%mod + mod) % mod
print(ans)
|
p02554
|
s252236221
|
Accepted
|
N=int(input())
print(((10**N-9**N)-(10**N-8**N)+(10**N-9**N))%(10**9+7))
|
p02554
|
s013146259
|
Accepted
|
N=int(input())
pr=10**9+7
print((pow(10,N,pr)-2*pow(9,N,pr)+pow(8,N,pr))%pr)
|
p02554
|
s815506701
|
Accepted
|
N = int(input())
mod = int(1e9 +7)
ans = pow(10, N, mod=mod)
ans -= 2*pow(9, N, mod=mod)
ans += pow(8, N, mod=mod)
print(ans%mod)
|
p02554
|
s862250141
|
Accepted
|
import sys
import math
#from queue import *
#import random
#sys.setrecursionlimit(int(1e6))
input = sys.stdin.readline
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
return(int(input()))
def inara():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
################################################################
############ ---- THE ACTUAL CODE STARTS BELOW ---- ############
n=inp()
mod=int(1e9+7)
ans=pow(10,n,mod)-(2*pow(9,n,mod)-pow(8,n,mod))
ans%=mod
ans+=mod
ans+=mod
ans%=mod
print(ans)
|
p02554
|
s175306422
|
Accepted
|
N = int(input())
ans = (10**N - (9**N+9**N-8**N)) % (10**9+7)
print(ans)
|
p02554
|
s637470048
|
Accepted
|
N = int(input())
MOD = 10**9+7
ans1 = 1
ans2 = 1
ans3 = 1
for _ in range(N):
ans1 = (ans1*10)%MOD
ans2 = (ans2*9)%MOD
ans3 = (ans3*8)%MOD
ans = ((ans1 + ans3)%MOD - (ans2*2)%MOD)%MOD
print(ans)
|
p02554
|
s436576810
|
Accepted
|
n = int(input())
lst = [8, 1, 1, 0]
for i in range(n - 1):
a = lst[0]*8
b = lst[0] + lst[1]*9
c = lst[0] + lst[2]*9
d = lst[3]*10 + lst[1] + lst[2]
a = a%(10**9 + 7)
b = b%(10**9 + 7)
c = c%(10**9 + 7)
d = d%(10**9 + 7)
lst = [a, b, c, d]
print(lst[3])
|
p02554
|
s949385395
|
Accepted
|
N = int(input())
ans = 10 ** N - 2 * (9 ** N) + 8 ** N
print(ans % (10 ** 9 + 7))
|
p02554
|
s172480855
|
Accepted
|
MOD = 10**9+7
n = int(input())
ans = pow(10,n,MOD) - 2 * pow(9,n,MOD) + pow(8,n,MOD)
if ans<0:
ans += MOD
if ans<0:
ans += MOD
ans %= MOD
print(ans)
|
p02554
|
s133115262
|
Accepted
|
N = int(input())
ans=1
num=1
ans1=1
a=(10**9)+7
for i in range(N):
ans*=10
ans=ans%a
num*=9
num=num%a
for i in range(N):
ans1*=8
ans1=ans1%a
print((ans-2*num+ans1)%(10**9+7))
|
p02554
|
s301985197
|
Accepted
|
N = int(input())
MOD = 10 ** 9 + 7
if N == 1:
ans = 0
elif N == 2:
ans = 2
else:
ans = 10 ** N
ans %= MOD
ans += 8 ** N
ans %= MOD
ans -= 2 * 9 ** N
ans %= MOD
print(ans)
|
p02554
|
s698770010
|
Accepted
|
def ri():
return int(input())
def rii():
return [int(v) for v in input().split()]
def solve():
N = ri()
m = int(1e9 + 7)
ans = 10 ** N % m
ans = (ans - 9 ** N) % m
ans = (ans - 9 ** N) % m
ans = (ans + 8 ** N) % m
print(ans)
if __name__ == "__main__":
solve()
|
p02554
|
s586157483
|
Accepted
|
mod = 1000000007
n = int(input())
print(((pow(10, n, mod) - 2*pow(9, n, mod)) % mod + pow(8, n, mod)) % mod)
|
p02554
|
s647098430
|
Accepted
|
N = int(input())
mod = 10**9 + 7
print((10 ** N - (9 ** N + 9 ** N - 8 ** N)) % mod)
|
p02554
|
s272926869
|
Accepted
|
n = int(input())
mod = 10**9 + 7
ans = -(10**n%mod - (10**n-9**n)*2%mod - 8**n%mod)
print(ans%mod)
|
p02554
|
s285235514
|
Accepted
|
NUM = 1000000007
N = int(input())
all_colab = pow(10, N)
except_0or9_colab = pow(9, N)
except_0and9_colab = pow(8, N)
include_0and9_colab = all_colab - (2*except_0or9_colab - except_0and9_colab)
print(include_0and9_colab % NUM)
|
p02554
|
s629659182
|
Accepted
|
n=int(input())
a=10**n-2*(9**n)+8**n
print(a%((10**9)+7))
|
p02554
|
s012051937
|
Accepted
|
N = int(input())
MOD = 10**9+7
ans = 1
for i in range(N):
ans*=10
ans%=MOD
sub = 2
for i in range(N):
sub*=9
sub%=MOD
sub2 = 1
for i in range(N):
sub2*=8
sub2%=MOD
print((ans-(sub-sub2))%MOD)
|
p02554
|
s203370643
|
Accepted
|
n = int(input())
mod = 10 ** 9 + 7
ans = (10 ** n - 2 * 9 ** n + 8 ** n) % mod
print(ans)
|
p02554
|
s611745886
|
Accepted
|
N = int(input())
M = 10**9 + 7
ans = pow(10, N, M)
ans = ans + M - pow(9, N, M)
ans = ans + M - pow(9, N, M)
ans = ans + pow(8, N, M)
ans = ans % M
print(ans)
|
p02554
|
s231907741
|
Accepted
|
N = int(input())
P = 10**9 + 7
ans = (pow(10, N, P) - pow(9, N, P))*2 - (pow(10, N, P) - pow(8, N, P))
print(ans%P)
|
p02554
|
s596153247
|
Accepted
|
def main():
n = int(input())
md = 10 ** 9 + 7
##0または9を使わない組み合わせ
tmp1 = 9 ** n % md + 9 ** n % md - 8 ** n % md
ans = 10 ** n - tmp1
ans %= md
print(ans)
if __name__ == '__main__':
main()
|
p02554
|
s327054598
|
Accepted
|
N = int(input())
ans = 10 ** N - ((9 ** N) * 2 - 8 ** N)
print(ans % (10 ** 9 + 7))
|
p02554
|
s725620068
|
Accepted
|
n = int(input())
mod = 10**9+7
ans = pow(10, n, mod) - 2*pow(9, n, mod) + pow(8, n, mod)
print(ans%mod)
|
p02554
|
s540964509
|
Accepted
|
n=int(input())
mod=10**9+7
def pw(k,t):
return pow(k,t,mod)
ans=pw(10,n)-pw(9,n)*2+pw(8,n)
print(ans%mod)
|
p02554
|
s694474365
|
Accepted
|
N = int(input())
ans = 10**9+7
allN = 10**N #全ての整数の列
left = 9 ** N #左端が0か9
right = 9 ** N #右端が0か9
ryoutan = 8 ** N #両端0か9
ncc = allN - left - right + ryoutan
print(int(ncc%ans))
|
p02554
|
s620864687
|
Accepted
|
N = int(input())
mod_num =int(1.0e+9+7)
all_num = pow(10,N,mod=mod_num)
not09_num = pow(9,N,mod=mod_num)
both09_num = pow(8,N,mod=mod_num)
print((all_num-not09_num*2+both09_num)%mod_num)
|
p02554
|
s590424178
|
Accepted
|
n = int(input())
a = 10**9 +7
b = pow(10,n,a) + pow(8,n,a) - 2 * pow(9,n,a)
if b >= 0:
print(b)
elif a+b >=0:
print(a+b)
else:
print(a+a+b)
|
p02554
|
s960929525
|
Accepted
|
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
n = int(input())
ans = pow(10, n, MOD)
ans -= 2 * pow(9, n, MOD)
ans += pow(8, n, MOD)
print(ans % MOD)
resolve()
|
p02554
|
s563176795
|
Accepted
|
n = int(input())
all = 10 ** n
o0q0 = 8 ** n
o0q1 = 9 ** n - o0q0
mod = 10 ** 9 + 7
a = (all - (o0q1 * 2) -o0q0) % mod
print(a)
|
p02554
|
s817891553
|
Accepted
|
import sys
input = sys.stdin.readline
def main():
MOD = 10 ** 9 + 7
n = int(input())
ans = pow(10, n, MOD) - 2 * pow(9, n, MOD) + pow(8, n, MOD)
print(ans % MOD)
main()
|
p02554
|
s287497908
|
Accepted
|
N = int(input())
mod = int(1e9) + 7
res = pow(10, N) % mod
res -= pow(9, N) % mod
res %= mod
res -= pow(9, N) % mod
res %= mod
res += pow(8, N) % mod
res %= mod
print(res)
|
p02554
|
s524991735
|
Accepted
|
N=int(input())
mod = 10**9+7
A=10**N%mod-2*9**N%mod+8**N%mod
print(A%mod)
|
p02554
|
s065168488
|
Accepted
|
# C
N = int(input())
nasi = 10**N - 9**N - 9**N + 8**N
wari = 10**9 + 7
ans = nasi % wari
print(ans)
|
p02554
|
s359163590
|
Accepted
|
n=int(input())
a=10**n-2*(9**n)+8**n
print(a%(10**9+7))
|
p02554
|
s948562615
|
Accepted
|
N = int(input())
ans = 10 ** N - 9 ** N - 9 ** N + 8 ** N
print(ans % (10 ** 9 + 7))
|
p02554
|
s964316159
|
Accepted
|
MOD=1000000007
ans=0
N=int(input())
def modpow(a,x):
ret=1
while x>0:
if x%2==1:
ret*=a
ret%=MOD
a*=a
x>>=1
return ret
ans=modpow(10,N)+2*(MOD-modpow(9,N))+modpow(8,N)
print(ans%MOD)
|
p02554
|
s718711006
|
Accepted
|
N = int(input())
print((10**N-(8**N+2*(9**N-8**N)))%(10**9+7))
|
p02554
|
s343138508
|
Accepted
|
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt, factorial
from copy import deepcopy
def main():
n = int(input())
ans = (10**n) - 2*(9**n) + (8**n)
print(ans%(10**9+7))
if __name__ == "__main__":
main()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.