input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from functools import reduce
INF = int(1e9 + 7)
def modmulti(a, b):
# aとbを掛けた値をmodする(a * b mod p)
return a * b % INF
def factorial(x):
FCT = 1
FCT = reduce(modmulti, list(range(2, x + 1)), FCT)
return FCT
def main():
N, M = list(map(int, input().split()))
MIN_NM = factorial(min(N, M))
if N == M or N + 1 == M or N == M + 1:
print((modmulti(2, modmulti(MIN_NM, MIN_NM))
if N == M else modmulti(MIN_NM, modmulti(MIN_NM, max(N, M)))))
else:
print((0))
return
main()
| INF = int(1e9 + 7)
def modmulti(a, b):
# aとbを掛けた値をmodする(a * b mod p)
return a * b % INF
def factorial(x):
FCT = 1
for i in range(2, x + 1):
FCT = modmulti(i, FCT)
return FCT
def main():
N, M = list(map(int, input().split()))
MIN_NM = factorial(min(N, M))
if N == M or N + 1 == M or N == M + 1:
print((modmulti(2, modmulti(MIN_NM, MIN_NM))
if N == M else modmulti(MIN_NM, modmulti(MIN_NM, max(N, M)))))
else:
print((0))
return
main()
| p03681 |
INF = int(1e9 + 7)
def modmulti(a, b):
# aとbを掛けた値をmodする(a * b mod p)
return a * b % INF
def factorial(x):
FCT = 1
for i in range(2, x + 1):
FCT = modmulti(i, FCT)
return FCT
def main():
N, M = list(map(int, input().split()))
MIN_NM = factorial(min(N, M))
if N == M or N + 1 == M or N == M + 1:
print((modmulti(2, modmulti(MIN_NM, MIN_NM))
if N == M else modmulti(MIN_NM, modmulti(MIN_NM, max(N, M)))))
else:
print((0))
return
main()
| INF = int(1e9 + 7)
def modmulti(a, b):
# aとbを掛けた値をmodする(a * b mod p)
return a * b % INF
def factorial(x):
FCT = 1
for i in range(2, x + 1):
FCT = modmulti(i, FCT)
return FCT
def main():
N, M = list(map(int, input().split()))
MIN_NM = factorial(min(N, M))
if N == M:
print((modmulti(2, modmulti(MIN_NM, MIN_NM))))
elif abs(N - M) <= 1:
print((modmulti(MIN_NM, modmulti(MIN_NM, max(N, M)))))
else:
print((0))
return
main()
| p03681 |
INF = int(1e9 + 7)
def modmulti(a, b):
# aとbを掛けた値をmodする(a * b mod p)
return a * b % INF
def factorial(x):
FCT = 1
for i in range(2, x + 1):
FCT = modmulti(i, FCT)
return FCT
def main():
N, M = list(map(int, input().split()))
MIN_NM = factorial(min(N, M))
if N == M:
print((modmulti(2, modmulti(MIN_NM, MIN_NM))))
elif abs(N - M) <= 1:
print((modmulti(MIN_NM, modmulti(MIN_NM, max(N, M)))))
else:
print((0))
return
main()
| INF = int(1e9 + 7)
def factorial(x):
FCT = 1
for i in range(2, x + 1):
FCT = i * FCT % INF
return FCT
def main():
N, M = list(map(int, input().split()))
MIN_NM = factorial(min(N, M))
if N == M:
print((2 * MIN_NM * MIN_NM % INF))
elif abs(N - M) <= 1:
print((MIN_NM * MIN_NM * max(N, M) % INF))
else:
print((0))
return
main()
| p03681 |
def f(x):
k = 1
for i in range(1,x+1):
k *= i
return k % (10**9 + 7)
a,b = list(map(int,input().split()))
if abs(a-b) <= 1:
print(((f(a)*f(b)) % (10**9 + 7) if abs(a-b) == 1 else (2*f(a)*f(b)) % (10**9 + 7)))
else:
print((0)) | import math
def f(x):
return math.factorial(x) % (10**9 + 7)
a,b = list(map(int,input().split()))
if abs(a-b) <= 1:
print(((f(a)*f(b)) % (10**9 + 7) if abs(a-b) == 1 else (2*f(a)*f(b)) % (10**9 + 7)))
else:
print((0)) | p03681 |
n, m = list(map(int, input().split()))
mod = 10**9 + 7
def fact(n):
i = n
ret = 1
while i > 1:
ret *= i
i -= 1
return ret
if n == m:
print((fact(n) ** 2 * 2 % mod))
# elif n+1 == m or n-1 == m:
# print(fact(n) * fact(m))
elif n == m+1:
n_f = fact(n)
print((n_f * (n_f//n) % mod))
elif n == m-1:
m_f = fact(m)
print((m_f * (m_f//m) % mod))
else:
print((0)) | n, m = list(map(int, input().split()))
mod = 10**9 + 7
def fact(x):
ret = 1
for i in range(1, x+1):
ret = ret * i % mod
return ret
if n == m:
print((fact(n)**2 * 2 % mod))
elif n+1 == m or n-1 == m:
print((fact(n) * fact(m) % mod))
else:
print((0)) | p03681 |
import math
a,b=list(map(int, input().split()))
if abs(a-b) == 1:
print((math.factorial(a)*math.factorial(b)))
if abs(a-b) == 0:
print((math.factorial(a)*math.factorial(b)*2))
if abs(a-b) >= 2:
print((0)) | import math
a,b=list(map(int, input().split()))
if abs(a-b) == 1:
c = math.factorial(a)%(10**9+7)
d = math.factorial(b)%(10**9+7)
print((c*d%(10**9+7)))
if abs(a-b) == 0:
c = math.factorial(a)%(10**9+7)
d = math.factorial(b)%(10**9+7)
print((c*d*2%(10**9+7)))
if abs(a-b) >= 2:
print((0)) | p03681 |
import math
mod = 10**9+7
n,m = list(map(int,input().split()))
if abs(n-m) > 1:
print(0)
quit()
if max(n,m) > min(n,m):
print(math.factorial(max(n,m)) % mod * math.factorial(min(n,m)) % mod)
else :
print((((math.factorial(n))%mod)**2 * 2)%mod) |
mod = 10**9+7
n,m = list(map(int,input().split()))
def factorial(x):
retval = 1
for i in range(2,x+1):
retval = (retval * i)% mod
return retval
if abs(n-m) > 1:
print(0)
quit()
if max(n,m) > min(n,m):
print((factorial(max(n,m)) * factorial(min(n,m))) % mod)
else :
print(((factorial(n)**2)%mod * 2)%mod) | p03681 |
n, m = list(map(int, input().split()))
MOD = 1000000007
a, b = n, m
count_n = n
count_m =m
count = 0
if abs(n-m) == 1:
for _ in range(n-1):
n -= 1
count_n *= (n % MOD)
for _ in range(m-1):
m -= 1
count_m *= (m % MOD)
count = (count_m % MOD) * (count_n % MOD)
elif abs(n-m) == 0:
for _ in range(n-1):
n -= 1
count_n *= (n % MOD)
for _ in range(m-1):
m -= 1
count_m *= (m % MOD)
count = 2 * (count_m % MOD) * (count_n % MOD)
count %= MOD
else:
count = 0
print(count) | import math
n, m = list(map(int, input().split()))
MOD = 1000000007
count_n = 0
count_m = 0
count = 0
if abs(n-m) == 1:
count_n = math.factorial(n) % MOD
count_m = math.factorial(m) % MOD
count = count_m * count_n % MOD
elif abs(n-m) == 0:
count_n = math.factorial(n) % MOD
count_m = math.factorial(m) % MOD
count = 2 * count_m * count_n % MOD
else:
count = 0
print((count % MOD)) | p03681 |
import math
n, m = list(map(int, input().split()))
MOD = 1000000007
count_n = 0
count_m = 0
count = 0
if abs(n-m) == 1:
count_n = math.factorial(n) % MOD
count_m = math.factorial(m) % MOD
count = count_m * count_n % MOD
elif abs(n-m) == 0:
count_n = math.factorial(n) % MOD
count_m = math.factorial(m) % MOD
count = 2 * count_m * count_n % MOD
else:
count = 0
print((count % MOD)) | import math
N, M = list(map(int, input().split()))
mod = 10**9+7
if abs(N-M) > 1:
print((0))
exit()
if N < M:
N, M = M, N
if N == M:
ans = math.factorial(N)
ans %= mod
ans *= math.factorial(M)
ans %= mod
ans *= 2
ans %= mod
else:
ans = math.factorial(M)
ans %= mod
ans *= math.factorial(N)
ans %= mod
print(ans) | p03681 |
n, m = list(map(int, input().split()))
ans = 1
if n==m:
for i in range(1, n+1):
ans *= i
ans %= 10**9+7
print(((ans**2*2)%(10**9+7)))
elif abs(n-m)==1:
for i in range(1, n+1):
ans *= i
ans %= 10**9+7
for i in range(1, m+1):
ans *= i
ans %= 10**9+7
print((ans%(10**9+7)))
else:
print((0)) | n, m = list(map(int, input().split()))
ans = 1
mod = 10**9+7
if n==m:
for i in range(1, n+1):
ans *= i
ans %= mod
print(((ans**2*2)%mod))
elif abs(n-m)==1:
for i in range(1, n+1):
ans *= i
ans %= mod
for i in range(1, m+1):
ans *= i
ans %= mod
print(ans)
else:
print((0))
| p03681 |
n, m = list(map(int, input().split()))
ans = 1
mod = 10**9+7
a = lambda x, y: x*y % mod
if n==m:
for i in range(1, n+1):
ans = a(ans, i)
print(((ans**2*2)%(mod)))
elif abs(n-m)==1:
for i in range(1, n+1):
ans = a(ans, i)
for i in range(1, m+1):
ans = a(ans, i)
print(ans)
else:
print((0)) | n, m = list(map(int, input().split()))
ans = 1
mod = 10**9+7
def a(x, y):
return x*y%mod
if n==m:
for i in range(1, n+1):
ans = a(ans, i)
print(((ans**2*2)%(mod)))
elif abs(n-m)==1:
for i in range(1, n+1):
ans = a(ans, i)
for i in range(1, m+1):
ans = a(ans, i)
print(ans)
else:
print((0))
| p03681 |
def frac(n):
sum = 1
for i in range(1,n+1):
sum*=i
return sum
import sys,fractions
N,M=list(map(int,input().split(' ')))
# abs(N-M) > 1なら無理
if (abs(N-M) > 1):
print((0))
sys.exit()
# それぞれの階乗を求める
frac_n = frac(N)
frac_m = frac(M)
if N == M:
ans = frac_m * frac_n * 2
else:
ans = frac_n * frac_m
print((ans % (10**9 + 7))) | divisor = 10**9 + 7
def frac(n):
sum = 1
for i in range(1,n+1):
sum = sum * i % divisor
return sum
import sys,fractions
N,M=list(map(int,input().split(' ')))
# abs(N-M) > 1なら無理
if (abs(N-M) > 1):
print((0))
sys.exit()
# それぞれの階乗を求める
frac_n = frac(N)
frac_m = frac(M)
if N == M:
ans = frac_m * frac_n * 2
else:
ans = frac_n * frac_m
print((ans % (10**9 + 7))) | p03681 |
def 解():
iN,iM = [int(_) for _ in input().split()]
iD = 10**9+7
if abs(iN - iM) <= 1:
if iN < iM:
iN,iM = iM,iN
iFacM = 1
for i in range(1,iM+1):
iFacM *= i
iFacM %=iD
if iN == iM:
print(( iFacM * iFacM % iD * 2 % iD ))
else:
iFacN = iFacM
for i in range(iM+1,iN+1):
iFacN *= i
iFacN %=iD
print(( iFacM * iFacN % iD ))
else:
print((0))
解()
| def 解():
iN,iM = [int(_) for _ in input().split()]
iD = 10**9+7
if abs(iN - iM) <= 1:
if iN < iM:
iN,iM = iM,iN
iFacM = 1
for i in range(1,iM+1):
iFacM *= i
iFacM %=iD
if iN == iM:
print(( iFacM ** 2 % iD * 2 % iD ))
else:
#うーむ。たしかに。差分が1だからNかけるだけでいいわけだ。
print(( iFacM ** 2 % iD * iN % iD ))
else:
print((0))
解()
| p03681 |
# -*- coding: utf-8 -*-
from math import factorial
n, m = list(map(int, input().split()))
def solve(m, n):
if m > n:
m, n = n, m
if n - m > 1:
return 0
fct = factorial(m)
if n - m == 1:
return fct ** 2 * n
else: # n - m == 0
return fct ** 2 * 2
mod = 10 ** 9 + 7
ans = solve(m, n) % mod
print(ans)
| # -*- coding: utf-8 -*-
n, m = list(map(int, input().split()))
mod = 10 ** 9 + 7
def factorial(x):
ret = 1
for i in range(1, x + 1):
ret *= i
ret %= mod
return ret
def solve(m, n):
if m > n:
m, n = n, m
if n - m > 1:
return 0
fct = factorial(m)
if n - m == 1:
return fct ** 2 * n % mod
else: # n - m == 0
return fct ** 2 * 2 % mod
ans = solve(m, n)
print(ans)
| p03681 |
N, M = list(map(int, input().split()))
a = 1
b = 1
if N == M:
for i in range(1,N+1):
a *= i % 1000000007
b = a
elif N - M == 1:
for i in range(1,M+1):
b *= i % 1000000007
a = b * N
elif M - N == 1:
for i in range(1,N+1):
a *= i % 1000000007
b = a * M
if abs(N-M) == 1:
ans = a * b %1000000007
elif N == M:
ans = 2*a*b % 1000000007
else:
ans = 0
print(ans) | import math
import time
N, M = list(map(int, input().split()))
st = time.time()
a = math.factorial(N) % 1000000007
b = math.factorial(M) % 1000000007
"""
if N == M:
for i in range(1,N+1):
a *= i % 1000000007
b = a
elif N - M == 1:
for i in range(1,M+1):
b *= i % 1000000007
a = b * N
elif M - N == 1:
for i in range(1,N+1):
a *= i % 1000000007
b = a * M
"""
if abs(N-M) == 1:
ans = a * b %1000000007
elif N == M:
ans = 2*a*b % 1000000007
else:
ans = 0
print(ans)
ed = time.time() -st
#print(ed) | p03681 |
n,m=list(map(int,input().split()))
div=10**9+7
if abs(n-m)>1:
print((0))
else:
ans=1
for i in range(1,n+1):
ans=ans*i%div
for i in range(1,m+1):
ans=ans*i%div
if n==m:
ans*=2
print((ans%div)) | n,m=list(map(int,input().split()))
div=10**9+7
if abs(n-m)>1:
print((0))
else:
ans=1
for i in range(1,min(m,n)+1):
ans=ans*i%div
ans*=ans
if n!=m:
ans*=max(m,n)
if n==m:
ans*=2
print((ans%div)) | p03681 |
import math
n,m=list(map(int,input().split()))
ans=math.factorial(m)*math.factorial(n)
if n==m:
ans*=2
elif abs(n-m)>1:
ans=0
print(ans)
| import math
n,m=list(map(int,input().split()))
ans=math.factorial(m)*math.factorial(n)%(10**9+7)
if n==m:
ans*=2
ans%=(10**9+7)
elif abs(n-m)>1:
ans=0
print(ans) | p03681 |
import sys
readline = sys.stdin.readline
from math import factorial
MOD = 10 ** 9 + 7
def main():
N, M = list(map(int, readline().rstrip().split()))
if abs(N-M) > 1:
ans = 0
elif N == M:
ans = (factorial(N) % MOD) * (factorial(M) % MOD) * 2
else:
ans = (factorial(N) % MOD) * (factorial(M) % MOD)
print((ans % MOD))
if __name__ == '__main__':
main() | import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
def factorial(N, mod=MOD):
res = 1
for i in range(2, N+1):
res *= i
res %= mod
return res
def main():
N, M = list(map(int, readline().rstrip().split()))
if abs(N-M) > 1:
ans = 0
elif N == M:
ans = factorial(N) * factorial(M) * 2
else:
ans = factorial(N) * factorial(M)
print((ans % MOD))
if __name__ == '__main__':
main() | p03681 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
def factorial(N, mod=MOD):
res = 1
for i in range(2, N+1):
res *= i
res %= mod
return res
def main():
N, M = list(map(int, readline().rstrip().split()))
if abs(N-M) > 1:
ans = 0
elif N == M:
ans = factorial(N) * factorial(M) * 2
else:
ans = factorial(N) * factorial(M)
print((ans % MOD))
if __name__ == '__main__':
main() | import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
def factorial(N, mod=MOD):
res = 1
for i in range(2, N+1):
res *= i
res %= mod
return res
def main():
N, M = list(map(int, readline().rstrip().split()))
if abs(N-M) > 1:
ans = 0
elif N == M:
ans = factorial(N) ** 2 * 2
else:
ans = factorial(min(N, M)) ** 2 * max(N, M)
print((ans % MOD))
if __name__ == '__main__':
main() | p03681 |
n,m = list(map(int,input().split()))
lst = [0]
for i in range(n - 1):
lst.append(lst[-1] + int(eval(input())))
ans = 0
num = 0
for i in range(m):
a = int(eval(input()))
ans += abs(lst[num] - lst[num + a])
ans %= 100000
num += a
print(ans)
| def solve():
n,m = list(map(int,input().split()))
lst = [0]
for i in range(n - 1):
lst.append(lst[-1] + int(eval(input())))
ans = 0
num = 0
for i in range(m):
a = int(eval(input()))
ans += abs(lst[num] - lst[num + a])
num += a
print((ans % 100000))
solve()
| p00472 |
def solve(n):
ans=0
for a in range(int(n/4)+1):
for b in range(a,int(n/3)+1):
if b>1000:
break
for c in range(b,int(n/2)+1):
if c>1000:
break
d=n-(a+b+c)
if d>=c:
if a==b==c==d:
ans+=1#4!/4!
elif a==b==c or b==c==d:
ans+=4#4!/3!
elif a==b and c==d:
ans+=6#4!/(2!*2!)
elif (a==b and c!=d) or (b==c) or (a!=b and c==d):
ans+=12#4!/2!
else:
ans+=24#4!
else:
break
return ans
while True:
try:
n=int(eval(input()))
print((solve(n)))
except EOFError:
break | M = 1000
DM = M * 2 + 1
def count(n):
global M
res = n + 1
if n > M:
res -= (n-M) * 2
return res
def solve(n):
cnt = 0
for a in range(min(DM, n), -1, -1):
b = n - a
if b > DM:
break
cnt += count(a) * count(b)
return cnt
while True:
try:
l = eval(input())
except EOFError:
break
nm = int(l)
print((solve(nm))) | p00096 |
b=[0]*2001
for i in range(1001):
for j in range(1001):
b[i+j]+=1
while 1:
try:n=int(eval(input()))
except:break
c=0;a=[1000,n][n<1000]
for i in range(2*a+1):
for j in range(2*a+1):
if i+j==n:c+=b[i]*b[j]
print(c) | s=[0]*4001
for i in range(2001):
a=a+2*(i-999)*(i-1000) if i>1000 else 0
s[i]=(i+3)*(i+2)*-~i//6-a
s[4000-i]=s[i]
while 1:
try:print((s[int(eval(input()))]))
except:break | p00096 |
import sys
a=[0]*4001
for i in range(1999):a[i]=a[4000-i]=(i+3)*(i+2)*(i+1)//6-a[i-1001]*4*(i>999)
for e in sys.stdin:print((a[int(e)]))
| import sys
a=[0]*4001
for i in range(2001):a[i]=a[4000-i]=(i+3)*(i+2)*(i+1)//6-a[i-1001]*4*(i>999)
for e in sys.stdin:print((a[int(e)]))
| p00096 |
from collections import Counter
two_dict = Counter()
for i in range(1001):
for j in range(1001):
two_dict[i + j] += 1
while True:
try:
n = int(eval(input()))
ans = 0
for i in range(n + 1):
ans += two_dict[i] * two_dict[n - i]
print(ans)
except EOFError:
break
| from collections import Counter
pair_dict = Counter()
for i in range(2001):
pair_dict[i] = min(i, 2000 - i) + 1
while True:
try:
n = int(eval(input()))
ans = 0
for i in range(n + 1):
ans += pair_dict[i] * pair_dict[n - i]
print(ans)
except EOFError:
break
| p00096 |
# -*- coding: utf-8 -*-
import sys
import os
for s in sys.stdin:
n = int(s)
T = [0] * 2001
for a in range(1001):
for b in range(1001):
T[a+b] += 1
sum_n_num = 0
for a_b_sum in range(0, n+1):
c_d_sum = n - a_b_sum
if a_b_sum <= 2000 and c_d_sum <= 2000:
sum_n_num += T[a_b_sum] * T[c_d_sum]
print(sum_n_num) | # -*- coding: utf-8 -*-
import sys
import os
import math
T = [0] * 2001
for a in range(1001):
for b in range(1001):
T[a + b] += 1
for s in sys.stdin:
n = int(s)
sum_n_num = 0
for a_b_sum in range(0, n+1):
c_d_sum = n - a_b_sum
if a_b_sum <= 2000 and c_d_sum <= 2000:
sum_n_num += T[a_b_sum] * T[c_d_sum]
print(sum_n_num) | p00096 |
while True:
try:
n = int(input())
count = 0
for a in range(1000,-1,-1):
if 0 <= n - a <= 3000:
for b in range(1000,-1,-1):
if n - a - b > 2000:
break
elif 0 <= n - a - b <= 1000:
count += n-a-b+1
elif 1001 < n - a - b <= 2000:
count += (2000 - (n-a-b) + 1)
print(count)
except:
break | while True:
try:
n = int(input())
count = 0
for a in range(1000,-1,-1):
na = n - a
if 3000 < na:
break
elif 0 <= na <= 3000:
for b in range(1000,-1,-1):
nab = n - a - b
if nab > 2000:
break
elif 0 <= nab <= 1000:
count += nab+1
elif 1001 < nab <= 2000:
count += (2000 - nab + 1)
print(count)
except:
break | p00096 |
T = 1000
memo = [[0] * (2 * T + 1) for _ in range(3)]
#Java: int[][] memo = new int[3][2*T+1];
memo[0][0] = 1
for i in range(1,3):
for j in range(i*T+1):
memo[i][j] = sum([memo[i-1][k] for k in range(max(0,j-T),j+1)])
while True:
try:
n = eval(input())
except EOFError:
break
cnt = 0
for a in range(T+1):
for b in range(T+1):
cnt += memo[2][n-(a+b)] if 0 <= n - (a + b) <= 2 * T else 0
# 0 <= n - (a + b) <= 2 * T ? memo[n-(a+b)] : 0
print(cnt)
#O(T^2), 2.15s | T = 1000
N = 4000
dp = [[0] * (N + 1) for _ in range(5)]
#Java: int[][] dp = new int[5][N];
dp[0][0] = 1
for i in range(1,5):
for j in range(i*T+1):
dp[i][j] = sum([dp[i-1][k] for k in range(max(0,j-T),j+1)])
while True:
try:
n = eval(input())
except EOFError:
break
print(dp[4][n])
#O(T^2), 0.954 | p00096 |
T = 1000
N = 4000
dp = [[0] * (N + 1) for _ in range(5)]
#Java: int[][] dp = new int[5][N];
dp[0][0] = 1
for i in range(1,5):
for j in range(i*T+1):
dp[i][j] = sum([dp[i-1][k] for k in range(max(0,j-T),j+1)])
while True:
try:
n = eval(input())
except EOFError:
break
print(dp[4][n])
#O(T^2), 0.954 | T = 1000
def f(x):
return max(0, T + 1 - abs(T - x))
while True:
try:
n = eval(input())
except EOFError:
break
cnt = 0
for i in range(n+1):
cnt += f(i) * f(n-i)
print(cnt)
#O(n), | p00096 |
# -*- coding: utf-8 -*-
"""
Sum of 4 Integers II
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0096
"""
import sys
from sys import stdin
from collections import defaultdict
input = stdin.readline
def main(args):
lut = defaultdict(list)
for a in range(1001):
for b in range(1001):
lut[a+b].append((a, b))
for line in sys.stdin:
n = int(line)
ans = 0
for i in range(n+1):
for a, b in lut[i]:
for c, d in lut[n-i]:
ans += 1
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
| # -*- coding: utf-8 -*-
"""
Sum of 4 Integers II
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0096
"""
import sys
from sys import stdin
from collections import defaultdict
input = stdin.readline
def main(args):
lut = defaultdict(int)
for a in range(1001):
for b in range(1001):
lut[a+b] += 1
for line in sys.stdin:
n = int(line)
ans = 0
for i in range(n+1):
ans += lut[i] * lut[n-i]
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
| p00096 |
import sys
a=[0]*2001
b=[0]*4001
n=1001
for i in range(n):
for j in range(n):
a[i+j]+=1
n=2001
for i in range(n):
for j in range(n):
b[i+j]+=a[i]*a[j]
for i in sys.stdin:
print(b[int(i)]) | import sys
n=1001
a=[0]*2001
for i in range(n):
for j in range(n):
a[i+j]+=1
for n in map(int,sys.stdin):
x=0
for i in range(max(0,n-2000),min(n,2000)+1):
x+=a[i]*a[n-i]
print(x) | p00096 |
import sys
n=1001
a=[0]*2001
for i in range(n):
for j in range(n):
a[i+j]+=1
for n in map(int,sys.stdin):
x=0
for i in range(max(0,n-2000),min(n,2000)+1):
x+=a[i]*a[n-i]
print(x) | import sys
n=1001
a=list(range(1,n))
a+=[n]+a[::-1]
for n in map(int,sys.stdin):
x=0
for i in range(max(0,n-2000),min(n,2000)+1):
x+=a[i]*a[n-i]
print(x) | p00096 |
import sys
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
s = LS2()
a = ''.join(s[0:5])
b = ''.join(s[6:13])
c = ''.join(s[14:19])
print(('{} {} {}'.format(a,b,c)))
| import sys
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
s = LS2()
s[5] = ' '
s[13] = ' '
print((''.join(s)))
| p03834 |
s = list( map( str, input().split(",") ) )
print(( s[0] + " " + s[1] + " " + s[2] )) | print(( input().replace( ",", " " ) )) | p03834 |
print((input().replace(',', ' '))) | *S, = input()
S[5] = S[13] = ' '
print(*S, sep='')
| p03834 |
s = input().split(",")
s = " ".join(s)
print(s) | S = input().strip()
x = S[:5]+" "+S[6:13]+" "+S[14:]
print(x) | p03834 |
s1, s2, s3 = input().split(',')
print((s1 + ' ' + s2 + ' ' + s3)) | s = list(input().split(','))
print((' '.join(s))) | p03834 |
L,R = list(map(int,input().split()))
mod = 10**9+7
m = 64 +1
fac = [1]*m
ninv = [1]*m
finv = [1]*m
for i in range(2,m):
fac[i] = fac[i-1]*i%mod
ninv[i] = (-(mod//i)*ninv[mod%i])%mod
finv[i] = finv[i-1]*ninv[i]%mod
def comb(n,k):
return (fac[n]*finv[k]%mod)*finv[n-k]%mod
def f(L,R):
if L>R : return 0
R = bin(R)[2:]
N = len(R)
ret = f(L,int("0"+"1"*(N-1),2))
L = bin(L)[2:]
if len(L) != N : L = "1"+"0"*(N-1)
for i in range(N):
if R[i] == "0" : continue
R2 = R[:i] + "0" + "?"*(N-i-1)
if i==0: R2 = R
for j in range(N):
if L[j] == "1" and j!=0 : continue
L2 = L[:j] + "1" + "?"*(N-j-1)
if j==0 : L2 = L
if L2[0] == "0" : break
tmp = 1
for r,l in zip(R2[1:],L2[1:]):
if r=="0" and l=="1" : tmp *= 0
if r=="?" and l=="?" : tmp *= 3
if r=="?" and l=="0" : tmp *= 2
if r=="1" and l=="?" : tmp *= 2
tmp %= mod
ret += tmp
ret %= mod
return ret%mod
print((f(L,R))) | L,R = list(map(int,input().split()))
mod = 10**9+7
def f(L,R):
if L>R : return 0
R = bin(R)[2:]
N = len(R)
ret = f(L,int("0"+"1"*(N-1),2))
L = bin(L)[2:]
if len(L) != N : L = "1"+"0"*(N-1)
for i in range(N):
if R[i] == "0" : continue
R2 = R[:i] + "0" + "?"*(N-i-1)
if i==0: R2 = R
for j in range(N):
if L[j] == "1" and j!=0 : continue
L2 = L[:j] + "1" + "?"*(N-j-1)
if j==0 : L2 = L
if L2[0] == "0" : break
tmp = 1
for r,l in zip(R2[1:],L2[1:]):
if r=="0" and l=="1" : tmp *= 0 ; break
if r=="?" and l=="?" : tmp = tmp*3%mod
if r=="?" and l=="0" : tmp = tmp*2%mod
if r=="1" and l=="?" : tmp = tmp*2%mod
ret += tmp
ret %= mod
return ret
print((f(L,R))) | p02938 |
L,R = list(map(int,input().split()))
mod = 10**9+7
def f(L,R):
if L>R : return 0
R = bin(R)[2:]
N = len(R)
ret = f(L,int("0"+"1"*(N-1),2))
L = bin(L)[2:]
if len(L) != N : L = "1"+"0"*(N-1)
for i in range(N):
if R[i] == "0" : continue
R2 = R[:i] + "0" + "?"*(N-i-1)
if i==0: R2 = R
for j in range(N):
if L[j] == "1" and j!=0 : continue
L2 = L[:j] + "1" + "?"*(N-j-1)
if j==0 : L2 = L
if L2[0] == "0" : break
tmp = 1
for r,l in zip(R2[1:],L2[1:]):
if r=="0" and l=="1" : tmp *= 0 ; break
if r=="?" and l=="?" : tmp = tmp*3%mod
if r=="?" and l=="0" : tmp = tmp*2%mod
if r=="1" and l=="?" : tmp = tmp*2%mod
ret += tmp
ret %= mod
return ret
print((f(L,R))) | L,R = list(map(int,input().split()))
mod = 10**9+7
def f(L,R):
if L>R : return 0
R = bin(R)[2:]
N = len(R)
ret = f(L,int("0"+"1"*(N-1),2))
L = bin(L)[2:]
if len(L) != N : L = "1"+"0"*(N-1)
for i in range(N):
if R[i] == "0" : continue
R2 = R[:i] + "0" + "?"*(N-i-1)
if i==0: R2 = R
for j in range(N):
if L[j] == "1" and j!=0 : continue
L2 = L[:j] + "1" + "?"*(N-j-1)
if j==0 : L2 = L
tmp = 1
for r,l in zip(R2,L2):
if r=="0" and l=="1" : tmp *= 0 ; break
elif r=="?" and l=="?" : tmp = tmp*3%mod
elif r=="?" and l=="0" : tmp = tmp*2%mod
elif r=="1" and l=="?" : tmp = tmp*2%mod
ret += tmp
ret %= mod
return ret
print((f(L,R))) | p02938 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
input=lambda :sys.stdin.buffer.readline().rstrip()
class ModInt(object):
__MOD=10**9+7
def __init__(self,x):
self.__x=x%self.__MOD
def __repr__(self):
return str(self.__x)
def __add__(self,other):
return ModInt(self.__x+other.__x) if isinstance(other,ModInt) else ModInt(self.__x+other)
def __sub__(self,other):
return ModInt(self.__x-other.__x) if isinstance(other,ModInt) else ModInt(self.__x-other)
def __mul__(self,other):
return ModInt(self.__x*other.__x) if isinstance(other,ModInt) else ModInt(self.__x*other)
def __truediv__(self,other):
return ModInt(self.__x*pow(other.__x,self.__MOD-2,self.__MOD)) if isinstance(other, ModInt) else ModInt(self.__x*pow(other, self.__MOD-2,self.__MOD))
def __pow__(self,other):
return ModInt(pow(self.__x,other.__x,self.__MOD)) if isinstance(other,ModInt) else ModInt(pow(self.__x,other,self.__MOD))
__radd__=__add__
def __rsub__(self,other):
return ModInt(other.__x-self.__x) if isinstance(other,ModInt) else ModInt(other-self.__x)
__rmul__=__mul__
def __rtruediv__(self,other):
return ModInt(other.__x*pow(self.__x,self.__MOD-2,self.__MOD)) if isinstance(other,ModInt) else ModInt(other*pow(self.__x,self.__MOD-2,self.__MOD))
def __rpow__(self,other):
return ModInt(pow(other.__x,self.__x,self.__MOD)) if isinstance(other,ModInt) else ModInt(pow(other,self.__x,self.__MOD))
def resolve():
from itertools import product
L,R=list(map(int,input().split()))
D=61
dp=[[[[ModInt(0)]*2 for _ in range(2)] for _ in range(2)] for _ in range(D+1)]
dp[D][0][0][0]=ModInt(1)
for d in range(D-1,-1,-1):
lb=L>>d&1; rb=R>>d&1
for i,j,m,x,y in product([0,1],repeat=5):
ni,nj,nm=i,j,m
if(x>y): continue
# i:L<=X
if(i==0 and lb>x): continue
if(lb<x): ni=1
# j:Y<=R
if(j==0 and y>rb): continue
if(y<rb): nj=1
# m:MSB
if(m==0 and x!=y): continue
if(x==1 and y==1): nm=1
dp[d][ni][nj][nm]+=dp[d+1][i][j][m];
print((sum(dp[0][i][j][m] for i,j,m in product([0,1],repeat=3))))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
input=lambda :sys.stdin.buffer.readline().rstrip()
class ModInt(object):
__MOD=10**9+7
def __init__(self,x):
self.__x=x%self.__MOD
def __repr__(self):
return str(self.__x)
def __add__(self,other):
return ModInt(self.__x+other.__x) if isinstance(other,ModInt) else ModInt(self.__x+other)
def __sub__(self,other):
return ModInt(self.__x-other.__x) if isinstance(other,ModInt) else ModInt(self.__x-other)
def __mul__(self,other):
return ModInt(self.__x*other.__x) if isinstance(other,ModInt) else ModInt(self.__x*other)
def __truediv__(self,other):
return ModInt(self.__x*pow(other.__x,self.__MOD-2,self.__MOD)) if isinstance(other, ModInt) else ModInt(self.__x*pow(other, self.__MOD-2,self.__MOD))
def __pow__(self,other):
return ModInt(pow(self.__x,other.__x,self.__MOD)) if isinstance(other,ModInt) else ModInt(pow(self.__x,other,self.__MOD))
__radd__=__add__
def __rsub__(self,other):
return ModInt(other.__x-self.__x) if isinstance(other,ModInt) else ModInt(other-self.__x)
__rmul__=__mul__
def __rtruediv__(self,other):
return ModInt(other.__x*pow(self.__x,self.__MOD-2,self.__MOD)) if isinstance(other,ModInt) else ModInt(other*pow(self.__x,self.__MOD-2,self.__MOD))
def __rpow__(self,other):
return ModInt(pow(other.__x,self.__x,self.__MOD)) if isinstance(other,ModInt) else ModInt(pow(other,self.__x,self.__MOD))
def resolve():
from itertools import product
L,R=list(map(int,input().split()))
D=R.bit_length()
dp=[[[[ModInt(0)]*2 for _ in range(2)] for _ in range(2)] for _ in range(D+1)]
dp[D][0][0][0]=ModInt(1)
for d in range(D-1,-1,-1):
lb=L>>d&1; rb=R>>d&1
for i,j,m,x,y in product([0,1],repeat=5):
ni,nj,nm=i,j,m
if(x>y): continue
# i:L<=X
if(i==0 and lb>x): continue
if(lb<x): ni=1
# j:Y<=R
if(j==0 and y>rb): continue
if(y<rb): nj=1
# m:MSB
if(m==0 and x!=y): continue
if(x==1 and y==1): nm=1
dp[d][ni][nj][nm]+=dp[d+1][i][j][m];
print((sum(dp[0][i][j][m] for i,j,m in product([0,1],repeat=3))))
resolve() | p02938 |
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
dp = [[a[i] if i==j else max(a[i],a[(i+1)%n]) if (i+1)%n==j else 0 for j in range(n)] for i in range(n)]
for i in range(3 if n%2==0 else 2,n,2):
for l in range(n):
r = (l+i)%n
pat = []
for x,nextl,nextr in [(l,(l+1)%n,r),(r,l,(r+n-1)%n)]:
if a[nextl] > a[nextr]:
nextl = (nextl+1)%n
else:
nextr = (nextr+n-1)%n
pat.append(a[x] + dp[nextl][nextr])
dp[l][r] = max(pat)
print((max(dp[(i+1)%n][i] for i in range(n)))) | n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
dp = [0 for _ in range(n)]
for i in range(n):
if i%2 == n%2:
dp = [ dp[(l+1)%n] if a[l]>a[(l+i)%n] else dp[l] for l in range(n)]
else:
dp = [ max( a[l]+dp[(l+1)%n], a[(l+i)%n]+dp[l] ) for l in range(n)]
print((max(dp))) | p00538 |
n, q, s, t = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(n + 1)]
for _ in range(q):
l, r, x = list(map(int, input().split()))
for i in range(l, r + 1):
a[i] += x
temp = 0
for i in range(1, n + 1):
temp += (a[i - 1] - a[i]) * s if a[i] > a[i - 1] else (a[i - 1] - a[i]) * t
print(temp)
| n, q, s, t = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(n + 1)]
for i in range(1, n + 1)[::-1]:
a[i] -= a[i - 1]
count = 0
for i in range(n + 1):
count -= a[i] * s if a[i] > 0 else a[i] * t
for _ in range(q):
l, r, x = list(map(int, input().split()))
count += a[l] * s if a[l] > 0 else a[l] * t
a[l] += x
count -= a[l] * s if a[l] > 0 else a[l] * t
if r < n:
count += a[r + 1] * s if a[r + 1] > 0 else a[r + 1] * t
a[r + 1] -= x
count -= a[r + 1] * s if a[r + 1] > 0 else a[r + 1] * t
print(count)
| p00559 |
# -*- coding: utf-8 -*-
n=int(eval(input()))
m=int(eval(input()))
ans=c=m
for i in range(n):
a,b=[int(a) for a in input().split()]
if c<0:
continue
c+=a-b
if ans<c:
ans=c
if c<0:
ans=0
print(ans) | n=int(eval(input()))
ans=c=m=int(eval(input()))
for i in[0]*n:
a,b=list(map(int,input().split()))
if c<0:ans=0;break
c+=a-b
ans=max(ans,c)
print(ans) | p00510 |
from collections import deque
n, m = int(eval(input())), int(eval(input()))
B, S = 0, m
d = deque([0]*m)
for _ in range(n):
cars = list(map(int, input().split()))
for _ in range(cars[0]): d.append(0)
try:
for _ in range(cars[1]): d.pop()
except IndexError:
B = 1
S = max(S, len(d))
print((0 if B else S)) | n, m = int(eval(input())), int(eval(input()))
B, S = 0, m
d = [0]*m
for _ in range(n):
cars = list(map(int, input().split()))
for _ in range(cars[0]): d.append(0)
try:
for _ in range(cars[1]): d.pop()
except IndexError:
B = 1
S = max(S, len(d))
print((0 if B else S)) | p00510 |
n = int(eval(input()))
m = int(eval(input()))
S_max = m
for i in range(n):
a, b = list(map(int, input().split()))
m += a - b
if m < 0:
print((0))
break
S_max = max(S_max, m)
else:
print(S_max)
| n = int(eval(input()))
m = int(eval(input()))
S_max = m
for i in range(n):
a, b = list(map(int, input().split()))
m += a - b
if m < 0:
S_max = 0
break
S_max = max(S_max, m)
print(S_max)
| p00510 |
n = eval(input())
lis = []
for i in range(n):
com = input()
try:
com, x = com.split()
if com == 'insert':
lis.append(x)
elif com == 'delete':
l = len(lis) - 1
while (lis[l] != x) and l >= 0:
l -= 1
if lis[l] == x:
lis.pop(l)
except:
if com == 'deleteFirst':
lis.pop()
if com == 'deleteLast':
lis.pop(0)
print(" ".join( map(str, reversed(lis)) )) | n = eval(input())
lis = []
bot = 0
for i in range(n):
com = input()
if com[0] == 'i':
lis.append(com[7:])
elif com[6] == ' ':
try:
lis.pop(~lis[::-1].index(com[7:]))
except:
pass
elif com[6] == 'F':
lis.pop()
else:
bot += 1
print(' '.join( map(str, reversed(lis[bot:])) )) | p02265 |
#coding:utf-8
from collections import deque
n = int(eval(input()))
day = deque()
for i in range(n):
order = list(input().split())
if order[0] == "insert":
day.appendleft(order[1])
if order[0] == "delete":
try:
day.remove(order[1])
except:
continue
if order[0] == "deleteFirst":
day.popleft()
if order[0] == "deleteLast":
day.pop()
day = " ".join(day)
print(day)
| #coding:utf-8
from collections import deque
n = int(eval(input()))
day = deque()
for i in range(n):
order = list(input().split())
if order[0] == "insert":
day.appendleft(order[1])
elif order[0] == "delete":
try:
day.remove(order[1])
except:
continue
elif order[0] == "deleteFirst":
day.popleft()
elif order[0] == "deleteLast":
day.pop()
day = " ".join(day)
print(day)
| p02265 |
class Node:
def __init__(self, key, prev, next):
self.key = key
self.prev = prev
self.next = next
class LinkedList:
def __init__(self):
self.nil = Node(None, None, None)
self.nil.prev = self.nil
self.nil.next = self.nil
def insert(self, key):
node = Node(key, self.nil, self.nil.next)
self.nil.next.prev = node
self.nil.next = node
def search(self, key):
cur = self.nil.next
while cur != self.nil and cur.key != key:
cur = cur.next
return cur
def delete_node(self, node):
if node == self.nil:
return
node.prev.next = node.next
node.next.prev = node.prev
def delete_first(self):
self.delete_node(self.nil.next)
def delete_last(self):
self.delete_node(self.nil.prev)
def delete_key(self, key):
node = self.search(key)
self.delete_node(node)
def main():
n = int(input())
ll = LinkedList()
for i in range(n):
order = input().split()
if order[0] == "insert":
ll.insert(int(order[1]))
elif order[0] == "delete":
ll.delete_key(int(order[1]))
elif order[0] == "deleteFirst":
ll.delete_first()
else:
ll.delete_last()
cur = ll.nil
while cur.next != ll.nil:
if cur != ll.nil:
print(" ", end="")
cur = cur.next
print(cur.key, end="")
print()
if __name__ == '__main__':
main()
| import sys
class Node:
def __init__(self, key, prev, next):
self.key = key
self.prev = prev
self.next = next
class LinkedList:
def __init__(self):
self.nil = Node(None, None, None)
self.nil.prev = self.nil
self.nil.next = self.nil
def insert(self, key):
node = Node(key, self.nil, self.nil.next)
self.nil.next.prev = node
self.nil.next = node
def search(self, key):
cur = self.nil.next
while cur != self.nil and cur.key != key:
cur = cur.next
return cur
def delete_node(self, node):
if node == self.nil:
return
node.prev.next = node.next
node.next.prev = node.prev
def delete_first(self):
self.delete_node(self.nil.next)
def delete_last(self):
self.delete_node(self.nil.prev)
def delete_key(self, key):
node = self.search(key)
self.delete_node(node)
def main():
n = int(input())
ll = LinkedList()
for i in range(n):
order = sys.stdin.readline().split()
if order[0] == "insert":
ll.insert(int(order[1]))
elif order[0] == "delete":
ll.delete_key(int(order[1]))
elif order[0] == "deleteFirst":
ll.delete_first()
else:
ll.delete_last()
cur = ll.nil
while cur.next != ll.nil:
cur = cur.next
if cur.next == ll.nil:
print(cur.key)
else:
print(cur.key, end=" ")
if __name__ == '__main__':
main()
| p02265 |
import sys
class Node:
def __init__(self, key, prev, next):
self.key = key
self.prev = prev
self.next = next
class LinkedList:
def __init__(self):
self.nil = Node(None, None, None)
self.nil.prev = self.nil
self.nil.next = self.nil
def insert(self, key):
node = Node(key, self.nil, self.nil.next)
self.nil.next.prev = node
self.nil.next = node
def search(self, key):
cur = self.nil.next
while cur != self.nil and cur.key != key:
cur = cur.next
return cur
def delete_node(self, node):
if node == self.nil:
return
node.prev.next = node.next
node.next.prev = node.prev
def delete_first(self):
self.delete_node(self.nil.next)
def delete_last(self):
self.delete_node(self.nil.prev)
def delete_key(self, key):
node = self.search(key)
self.delete_node(node)
def main():
n = int(input())
ll = LinkedList()
for i in range(n):
order = sys.stdin.readline().split()
if order[0] == "insert":
ll.insert(int(order[1]))
elif order[0] == "delete":
ll.delete_key(int(order[1]))
elif order[0] == "deleteFirst":
ll.delete_first()
else:
ll.delete_last()
cur = ll.nil
while cur.next != ll.nil:
cur = cur.next
if cur.next == ll.nil:
print(cur.key)
else:
print(cur.key, end=" ")
if __name__ == '__main__':
main()
| import sys
class Node:
def __init__(self, key, prev, next):
self.key = key
self.prev = prev
self.next = next
class LinkedList:
def __init__(self):
self.nil = Node(None, None, None)
self.nil.prev = self.nil
self.nil.next = self.nil
def insert(double_lst, key):
node = Node(key, double_lst.nil, double_lst.nil.next)
double_lst.nil.next.prev = node
double_lst.nil.next = node
def search(double_lst, key):
cur = double_lst.nil.next
while cur != double_lst.nil and cur.key != key:
cur = cur.next
return cur
def delete_node(double_lst, node):
if node == double_lst.nil:
return
node.prev.next = node.next
node.next.prev = node.prev
def delete_first(double_lst):
delete_node(double_lst, double_lst.nil.next)
def delete_last(double_lst):
delete_node(double_lst, double_lst.nil.prev)
def delete_key(double_lst, key):
node = search(double_lst, key)
delete_node(double_lst, node)
def main():
n = int(input())
ll = LinkedList()
for i in range(n):
order = sys.stdin.readline().split()
if order[0] == "insert":
insert(ll, int(order[1]))
elif order[0] == "delete":
delete_key(ll, int(order[1]))
elif order[0] == "deleteFirst":
delete_first(ll)
else:
delete_last(ll)
cur = ll.nil
while cur.next != ll.nil:
cur = cur.next
if cur.next == ll.nil:
print(cur.key)
else:
print(cur.key, end=" ")
if __name__ == '__main__':
main()
| p02265 |
from collections import deque
arr = []
for i in range(int(eval(input()))):
command_line = input().split(" ")
command = command_line[0]
arg = ""
if len(command_line) > 1: arg = command_line[1]
if command == "insert":
arr.insert(0, arg)
if command == "delete":
try:
arr.remove(arg)
except ValueError:
pass
if command == "deleteFirst":
arr.pop(0)
if command == "deleteLast":
arr.pop()
print((" ".join(arr))) | from collections import deque
q = deque()
for i in range(int(eval(input()))):
command_line = input().split(" ")
command = command_line[0]
arg = ""
if len(command_line) > 1: arg = command_line[1]
if command == "insert":
q.appendleft(arg)
elif command == "delete":
try:
q.remove(arg)
except ValueError:
pass
elif command == "deleteFirst":
q.popleft()
else:
q.pop()
print((" ".join(q))) | p02265 |
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 21 08:50:28 2017
@author: syaga
"""
COMMAND = ["insert", "delete", "deleteFirst", "deleteLast"]
if __name__ == "__main__":
n = int(eval(input()))
com = []
for i in range(n):
com.append(input().split())
ans = []
for i in com:
if i[0] == COMMAND[0]:
ans.insert(0, i[1])
elif i[0] == COMMAND[1]:
if i[1] in ans:
ans.remove(i[1])
elif i[0] == COMMAND[2]:
ans.pop(0)
elif i[0] == COMMAND[3]:
ans.pop()
print((" ".join(ans))) | # -*- coding: utf-8 -*-
"""
Created on Wed Jun 21 09:13:28 2017
@author: syaga
"""
COMMAND = ["insert", "delete", "deleteFirst", "deleteLast"]
if __name__ == "__main__":
n = int(eval(input()))
com = []
for i in range(n):
com.append(input().split())
ans = []
for i in com:
if i[0] == COMMAND[0]:
ans.append(i[1])
elif i[0] == COMMAND[1]:
if i[1] in ans:
ind = len(ans)-1-ans[::-1].index(i[1])
del ans[ind]
elif i[0] == COMMAND[2]:
ans.pop()
elif i[0] == COMMAND[3]:
ans.pop(0)
ans.reverse()
print((" ".join(ans))) | p02265 |
# -*- coding: utf-8 -*-
from collections import deque
COMMAND = ("insert", "delete", "deleteFirst", "deleteLast")
if __name__ == "__main__":
n = int(eval(input()))
ans = deque()
for i in range(n):
com = input().split()
if com[0] == COMMAND[0]:
ans.appendleft(com[1])
elif com[0] == COMMAND[1]:
if com[1] in ans:
ans.remove(com[1])
elif com[0] == COMMAND[2]:
ans.popleft()
elif com[0] == COMMAND[3]:
ans.pop()
print((" ".join(ans))) | # -*- coding: utf-8 -*-
from collections import deque
import sys
COMMAND = ("insert", "delete", "deleteFirst", "deleteLast")
if __name__ == "__main__":
n = int(sys.stdin.readline())
ans = deque()
inp = sys.stdin.readlines()
for i in range(n):
com = inp[i].split()
if com[0] == COMMAND[0]:
ans.appendleft(com[1])
elif com[0] == COMMAND[1]:
if com[1] in ans:
ans.remove(com[1])
elif com[0] == COMMAND[2]:
ans.popleft()
elif com[0] == COMMAND[3]:
ans.pop()
print((" ".join(ans))) | p02265 |
n = int(eval(input()))
dlist = []
for i in range(n):
arr = input().split()
cmd = ''
key = 0
cmd = arr[0]
if len(arr) > 1:
key = int(arr[1])
if cmd == 'insert':
dlist.insert(0, key)
elif cmd == 'delete':
if dlist.count(key) > 0:
idx = dlist.index(key)
if idx != -1:
dlist.pop(idx)
elif cmd == 'deleteFirst':
dlist.pop(0)
elif cmd == 'deleteLast':
dlist.pop(-1)
print((' '.join(map(str, dlist))))
| n = int(eval(input()))
dlist = []
for i in range(n):
arr = input().split()
cmd = ''
key = 0
cmd = arr[0]
if len(arr) > 1:
key = arr[1]
if cmd == 'insert':
dlist.insert(0, key)
elif cmd == 'delete':
if dlist.count(key) > 0:
idx = dlist.index(key)
if idx != -1:
dlist.pop(idx)
elif cmd == 'deleteFirst':
dlist.pop(0)
elif cmd == 'deleteLast':
dlist.pop(-1)
print((' '.join(dlist)))
| p02265 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
???????????£????????????
??\?????????????????????????????????????????£???????????????????£??????????????????????
insert x: ??£?????????????????????????????? x ?????????????´?????¶?????¶???????
delete x: ?????? x ??????????????????????´??????£????????????????????????????????????????????????????´?????????¨???????????´????????????????????????
deleteFirst?????????????????????????´???????????????????
deleteLast: ????????????????°????????´???????????????????
"""
class Dlist:
MAX = 1000000
def __init__(self):
""" ????????????????????? """
self.si = 0
self.ei = 0
self.cnt = 0
self.data = [0 for r in range(Dlist.MAX)]
def insert(self,x):
""" ??£?????????????????????????????? x ?????????????´?????¶?????¶???? """
self.si -= 1
if self.si < 0:
self.si = Dlist.MAX - 1
self.data[self.si] = x
self.cnt += 1
def delete(self,x):
""" ?????? x ??????????????????????´??????£????????????????????????????????????????????????????´?????????¨???????????´????????????????????????"""
if self.cnt > 0:
hit = False
for i in range(self.cnt):
pi = self.si + i
if pi >= Dlist.MAX:
pi -= Dlist.MAX
if self.data[pi] == x:
hit = True
break
if hit == True:
for j in range(i, self.cnt):
pi = self.si + j
if pi >= Dlist.MAX:
pi -= Dlist.MAX
ni = pi + 1
if ni >= Dlist.MAX:
ni -= Dlist.MAX
self.data[pi] = self.data[ni]
self.ei -= 1
if self.ei < 0 :
self.ei = Dlist.MAX - 1
self.cnt -= 1
def deleteFirst(self):
""" ?????????????????????????´???????????????? """
if self.cnt > 0:
self.data[self.si] = 0
self.si += 1
if self.si >= Dlist.MAX:
self.si = 0
self.cnt -= 1
def deleteLast(self):
""" ????????????????°????????´???????????????????"""
if self.cnt > 0:
self.ei -= 1
if self.ei < 0 :
self.ei = Dlist.MAX - 1
self.data[self.ei] = 0
self.cnt -= 1
def getList(self):
return self.data[self.si:self.ei]
# ?????????
num = int(input().strip())
dl = Dlist()
for i in range(num):
cmd = list(input().strip().split())
if cmd[0] == "insert":
dl.insert(cmd[1])
elif cmd[0] == "delete":
dl.delete(cmd[1])
elif cmd[0] == "deleteFirst":
dl.deleteFirst()
elif cmd[0] == "deleteLast":
dl.deleteLast()
# print()
# print(cmd)
# print("si={} ei={} cnt={}".format(dl.si, dl.ei, dl.cnt))
# print(dl.data)
print((" ".join(map(str,dl.getList())))) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
???????????£????????????
??\?????????????????????????????????????????£???????????????????£??????????????????????
insert x: ??£?????????????????????????????? x ?????????????´?????¶?????¶???????
delete x: ?????? x ??????????????????????´??????£????????????????????????????????????????????????????´?????????¨???????????´????????????????????????
deleteFirst?????????????????????????´???????????????????
deleteLast: ????????????????°????????´???????????????????
"""
# ?????????
num = int(input().strip())
dl = []
for i in range(num):
cmd = list(input().strip().split())
if cmd[0] == "insert":
dl.insert(0,cmd[1])
elif cmd[0] == "delete":
try:
dl.remove(cmd[1])
except ValueError:
i = 1
elif cmd[0] == "deleteFirst":
dl.pop(0)
elif cmd[0] == "deleteLast":
dl.pop()
print((" ".join(map(str,dl)))) | p02265 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
???????????£????????????
??\?????????????????????????????????????????£???????????????????£??????????????????????
insert x: ??£?????????????????????????????? x ?????????????´?????¶?????¶???????
delete x: ?????? x ??????????????????????´??????£????????????????????????????????????????????????????´?????????¨???????????´????????????????????????
deleteFirst?????????????????????????´???????????????????
deleteLast: ????????????????°????????´???????????????????
"""
import sys
class Dlist:
""" ??????????????????????????? """
MAX = 2000000
NoValue = -1
Prev = 0
Next = 1
Value = 2
def __init__(self):
""" ????????????????????? """
self.items = [0] * Dlist.MAX
self.clear()
def clear(self):
""" ????´?????????????????????¢ """
self.si = -1
self.ei = -1
self.pos = -1
self.uniqid = 0
self.cnt = 0
def insert(self,x):
""" ??£?????????????????????????????? x ?????????????´?????¶?????¶???? """
t = [Dlist.NoValue, Dlist.NoValue, x]
if self.cnt == 0: # ?????????????´?
self.ei = self.uniqid
else:
s = self.items[self.si]
s[Dlist.Prev] = self.uniqid
t[Dlist.Next] = self.si
self.items[self.uniqid] = t
self.si = self.uniqid
self.uniqid += 1
self.cnt += 1
def delete(self,x):
""" ?????? x ??????????????????????´??????£????????????????????????????????????????????????????´?????????¨???????????´????????????????????????"""
if self.cnt > 0:
hit = False
i = self.si
while hit == False:
if i == Dlist.NoValue:
break
if self.items[i][Dlist.Value] == x:
hit = True
if i == self.si:
self.deleteFirst() # ?????????????´??????????
elif i == self.ei:
self.deleteLast() # ????°????????´??????????
else:
n = self.items[i][Dlist.Next]
p = self.items[i][Dlist.Prev]
self.items[n][Dlist.Prev] = p
self.items[p][Dlist.Next] = n
# self.items[i][Dlist.Value] = Dlist.NoValue
self.cnt -= 1
else:
i = self.items[i][Dlist.Next]
def deleteFirst(self):
""" ?????????????????????????´???????????????? """
if self.cnt < 2:
self.clear()
else:
n = self.items[self.si][Dlist.Next]
if n != Dlist.NoValue:
self.items[n][Dlist.Prev] = Dlist.NoValue
# self.items[self.si][Dlist.Value] = Dlist.NoValue
self.si = n
self.cnt -= 1
def deleteLast(self):
""" ????????????????°????????´???????????????????"""
if self.cnt < 2:
self.clear()
else:
p = self.items[self.ei][Dlist.Prev]
if p != Dlist.NoValue:
self.items[p][Dlist.Next] = Dlist.NoValue
# self.items[self.ei][Dlist.Value] = Dlist.NoValue
self.ei = p
self.cnt -= 1
def getList(self):
a = []
if self.cnt > 0:
i = self.si
while i != Dlist.NoValue:
a.append(self.items[i][Dlist.Value])
i = self.items[i][Dlist.Next]
return a
def main():
""" ????????? """
num = int(input().strip())
istr = sys.stdin.read()
cmds = list(istr.split("\n"))
dl = Dlist()
for i in range(num):
cmd = list(cmds[i].split())
if cmd[0] == "insert":
dl.insert(cmd[1])
elif cmd[0] == "delete":
dl.delete(cmd[1])
elif cmd[0] == "deleteFirst":
dl.deleteFirst()
elif cmd[0] == "deleteLast":
dl.deleteLast()
# print()
# print(cmd)
# print("si={} ei={} cnt={}".format(dl.si, dl.ei, dl.cnt))
# print(dl.debugList())
print((" ".join(dl.getList())))
if __name__ == '__main__':
main() | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
???????????£????????????
??\?????????????????????????????????????????£???????????????????£??????????????????????
insert x: ??£?????????????????????????????? x ?????????????´?????¶?????¶???????
delete x: ?????? x ??????????????????????´??????£????????????????????????????????????????????????????´?????????¨???????????´????????????????????????
deleteFirst?????????????????????????´???????????????????
deleteLast: ????????????????°????????´???????????????????
"""
import sys
NoValue = -1
Prev = 0
Next = 1
Value = 2
class Dlist:
""" ??????????????????????????? """
def __init__(self):
""" ????????????????????? """
self.items = [0] * 2000000
self.clear()
def clear(self):
""" ????´?????????????????????¢ """
self.si = NoValue
self.ei = NoValue
self.pos = NoValue
self.uniqid = 0
self.cnt = 0
def insert(self,x):
""" ??£?????????????????????????????? x ?????????????´?????¶?????¶???? """
n = NoValue
if self.cnt == 0: # ?????????????´?
self.ei = self.uniqid
else:
self.items[self.si][Prev] = self.uniqid
n = self.si
self.items[self.uniqid] = [NoValue, n, x]
self.si = self.uniqid
self.uniqid += 1
self.cnt += 1
def delete(self,x):
""" ?????? x ??????????????????????´??????£????????????????????????????????????????????????????´?????????¨???????????´????????????????????????"""
if self.cnt > 0:
hit = False
i = self.si
while hit == False:
if i == -1:
break
if self.items[i][Value] == x:
hit = True
if i == self.si:
self.deleteFirst() # ?????????????´??????????
elif i == self.ei:
self.deleteLast() # ????°????????´??????????
else:
p = self.items[i][Prev]
n = self.items[i][Next]
self.items[n][Prev] = p
self.items[p][Next] = n
# self.items[i][Value] = NoValue
self.cnt -= 1
else:
i = self.items[i][Next]
def deleteFirst(self):
""" ?????????????????????????´???????????????? """
if self.cnt < 2:
self.clear()
else:
n = self.items[self.si][Next]
if n != NoValue:
self.items[n][Prev] = NoValue
# self.items[self.si][Value] = NoValue
self.si = n
self.cnt -= 1
def deleteLast(self):
""" ????????????????°????????´???????????????????"""
if self.cnt < 2:
self.clear()
else:
p = self.items[self.ei][Prev]
if p != -1:
self.items[p][Next] = NoValue
# self.items[self.ei][Value] = NoValue
self.ei = p
self.cnt -= 1
def getList(self):
a = []
if self.cnt > 0:
i = self.si
while i != -1:
a.append(self.items[i][Value])
i = self.items[i][Next]
return a
def main():
""" ????????? """
num = int(input().strip())
istr = sys.stdin.read()
cmds = list(istr.splitlines())
dl = Dlist()
for i in cmds:
if i[6] == "F":
dl.deleteFirst()
elif i[6] == "L":
dl.deleteLast()
elif i[0] == "i":
dl.insert(i[7:])
elif i[0] == "d":
dl.delete(i[7:])
# print()
# print(i)
# print("si={} ei={} cnt={}".format(dl.si, dl.ei, dl.cnt))
# print(dl.getList())
print((" ".join(dl.getList())))
if __name__ == '__main__':
main() | p02265 |
class Node():
key = 0
def __init__( self, key ):
self.key = key
self.next = -1
self.pre = -1
def insert( self, othernode ): # othernodeにはinsert前の先頭のノードを入れる
self.next = othernode
othernode.pre = self
return self
def delete( self, x ): #先頭ノードで実行
FirstNode = self
if self.key == x:
if self.pre == -1:
self.next.pre = -1
FirstNode = self.next
else :
self.pre.next = self.next
self.next.pre = self.pre
else:
if self.next != -1:
self.next.delete( x )
return FirstNode
def printNodes( self ): #先頭ノードで実行
if self.next.next != -1:
print( str( self.key ), end=" " )
self.next.printNodes()
elif self.next != -1:
print( str( self.key ), end="\n" )
def deleteFirst( self ):
self.next.pre = -1
return self.next #新しい先頭ノードを返す
def deleteLast( self ):
if self.next != -1:
self.next.deleteLast()
else :
self.pre.next = -1
def main():
n = int( input() )
commands = []
vals = []
for i in range(n):
tmp = input().split()
tmp.append( 0 )
commands.append( tmp[0] )
vals.append( int(tmp[1]) )
FirstNode = Node( None )
for i in range(n):
if commands[i] == "insert":
TmpNode = Node( vals[i] )
FirstNode = TmpNode.insert( FirstNode )
elif commands[i] == "delete":
FirstNode = FirstNode.delete( vals[i] )
elif commands[i] == "deleteFirst":
FirstNode = FirstNode.deleteFirst()
elif commands[i] == "deleteLast":
FirstNode.deleteLast()
else :
print("command error!")
FirstNode.printNodes()
if __name__ == '__main__':
main()
| class Node():
key = 0
def __init__( self, key ):
self.key = key
self.next = -1
self.pre = -1
def insert( self, othernode ): # othernodeにはinsert前の先頭のノードを入れる
self.next = othernode
othernode.pre = self
return self
def delete( self, x ): #先頭ノードで実行
FirstNode = self
if self.key == x:
if self.pre == -1:
self.next.pre = -1
FirstNode = self.next
else :
self.pre.next = self.next
self.next.pre = self.pre
else:
if self.next != -1:
self.next.delete( x )
return FirstNode
def printNodes( self ): #先頭ノードで実行
if self.next.next != -1:
print( str( self.key ), end=" " )
self.next.printNodes()
elif self.next != -1:
print( str( self.key ), end="\n" )
def deleteFirst( self ):
self.next.pre = -1
return self.next #新しい先頭ノードを返す
def deleteLast( self ):
if self.next != -1:
self.next.deleteLast()
else :
self.pre.next = -1
def main():
n = int( input() )
FirstNode = Node( None )
for i in range(n):
tmp = input().split()
if tmp[0] == "insert":
TmpNode = Node( tmp[1] )
FirstNode = TmpNode.insert( FirstNode )
elif tmp[0] == "delete":
FirstNode = FirstNode.delete( tmp[1] )
elif tmp[0] == "deleteFirst":
FirstNode = FirstNode.deleteFirst()
elif tmp[0] == "deleteLast":
FirstNode.deleteLast()
else :
print("command error!")
FirstNode.printNodes()
if __name__ == '__main__':
main()
| p02265 |
from collections import deque
queue = deque([])
n = int(input())
for i in range(n):
commands = input().split(" ")
command = commands[0]
if command == "insert":
queue.appendleft(commands[1])
elif command == "delete":
try:
queue.remove(commands[1])
except ValueError:
pass
elif command == "deleteFirst":
queue.popleft()
elif command == "deleteLast":
queue.pop()
last = queue.pop()
for i in queue:
print(i, end=" ")
print(last)
| from collections import deque
queue = deque([])
for _ in range(int(eval(input()))):
commands = input().split(" ")
command = commands[0]
if command == "insert":
queue.appendleft(commands[1])
elif command == "delete":
try:
queue.remove(commands[1])
except ValueError:
pass
elif command == "deleteFirst":
queue.popleft()
elif command == "deleteLast":
queue.pop()
print((" ".join(queue))) | p02265 |
from collections import deque
queue = deque([])
for _ in range(int(eval(input()))):
commands = input().split(" ")
command = commands[0]
if command == "insert":
queue.appendleft(commands[1])
elif command == "delete":
try:
queue.remove(commands[1])
except ValueError:
pass
elif command == "deleteFirst":
queue.popleft()
elif command == "deleteLast":
queue.pop()
print((" ".join(queue))) | from collections import deque
queue = deque()
for _ in range(int(eval(input()))):
commands = input().split(" ")
if commands[0] == "insert":
queue.appendleft(commands[1])
elif commands[0] == "delete":
try:
queue.remove(commands[1])
except ValueError:
pass
elif commands[0] == "deleteFirst":
queue.popleft()
elif commands[0] == "deleteLast":
queue.pop()
print((" ".join(queue))) | p02265 |
from collections import deque
def main():
queue = deque()
for _ in range(int(eval(input()))):
commands = input().split(" ")
if commands[0] == "insert":
queue.appendleft(commands[1])
elif commands[0] == "delete":
try:
queue.remove(commands[1])
except ValueError:
pass
elif commands[0] == "deleteFirst":
queue.popleft()
elif commands[0] == "deleteLast":
queue.pop()
print((" ".join(queue)))
main() | import sys
from collections import deque
queue = deque()
for _ in range(int(sys.stdin.readline())):
commands = sys.stdin.readline()[:-1].split(" ")
if commands[0] == "insert":
queue.appendleft(commands[1])
elif commands[0] == "delete":
try:
queue.remove(commands[1])
except ValueError:
pass
elif commands[0] == "deleteFirst":
queue.popleft()
elif commands[0] == "deleteLast":
queue.pop()
print((" ".join(queue))) | p02265 |
# coding: utf-8
import sys
from collections import deque
output_str = deque()
data_cnt = int(eval(input()))
for i in range(data_cnt):
line = input().rstrip()
if line.find(" ") > 0:
in_command, in_str = line.split(" ")
else:
in_command = line
if in_command == "insert":
output_str.appendleft(in_str)
elif in_command == "delete":
if output_str.count(in_str) > 0:
output_str.remove(in_str)
elif in_command == "deleteFirst":
output_str.popleft()
elif in_command == "deleteLast":
output_str.pop()
print((" ".join(output_str))) | # coding: utf-8
import sys
from collections import deque
output_str = deque()
data_cnt = int(eval(input()))
for i in range(data_cnt):
in_command = input().rstrip().split(" ")
if in_command[0] == "insert":
output_str.appendleft(in_command[1])
elif in_command[0] == "delete":
if output_str.count(in_command[1]) > 0:
output_str.remove(in_command[1])
elif in_command[0] == "deleteFirst":
output_str.popleft()
elif in_command[0] == "deleteLast":
output_str.pop()
print((" ".join(output_str))) | p02265 |
n = int(input())
xlist = []
for i in range(n):
command = list(map(str,input().split()))
if (command[0] == 'insert'):
x = command[1]
if (len(xlist) == 0):
xlist.append(int(x))
else:
xlist.append(int(x))
for i in range(1,len(xlist)):
k = len(xlist) - i
j = k-1
xlist[j], xlist[k] = xlist[k], xlist[j]
#print(xlist)
elif (command[0] == 'delete'):
x = command[1]
if (int(x) in xlist) :
xlist.remove(int(x))
#print(xlist)
elif (command[0] == 'deleteFirst'):
if (len(xlist) > 0):
del xlist[0]
#print(xlist)
elif (command[0] == 'deleteLast'):
if (len(xlist) > 0):
del xlist[-1]
#print(xlist)
n = len(xlist)
for i in range(n):
if (i == n-1):
print('{}'.format(xlist[i]), end = '')
else:
print('{} '.format(xlist[i]), end = '')
print()
| n = int(input())
xlist = []
for i in range(n):
command = list(map(str,input().split()))
if (command[0] == 'insert'):
x = command[1]
if (len(xlist) == 0):
xlist.append(int(x))
else:
xlist = [int(x)] + xlist
#print(xlist)
elif (command[0] == 'delete'):
x = command[1]
if (int(x) in xlist) :
xlist.remove(int(x))
#print(xlist)
elif (command[0] == 'deleteFirst'):
if (len(xlist) > 0):
del xlist[0]
#print(xlist)
elif (command[0] == 'deleteLast'):
if (len(xlist) > 0):
del xlist[-1]
#print(xlist)
n = len(xlist)
for i in range(n):
if (i == n-1):
print('{}'.format(xlist[i]), end = '')
else:
print('{} '.format(xlist[i]), end = '')
print()
| p02265 |
from sys import stdin
class DList:
class Cell:
def __init__(self, k):
self.key = k
self.prev = None
self.next = None
def __init__(self):
self.head = DList.Cell(None)
self.last = DList.Cell(None)
self.head.next = self.last
self.last.prev = self.head
def insert(self, x):
c = DList.Cell(x)
c.prev = self.head
c.next = self.head.next
c.next.prev = c
self.head.next = c
def delete(self, x):
c = self.__find(x)
if c != None:
self.__delete(c)
def __delete(self, c):
c.prev.next = c.next
c.next.prev = c.prev
def __find(self, x):
c = self.head.next
while c != None and c.key != x:
c = c.next
return c
def deleteFirst(self):
self.__delete(self.head.next)
def deleteLast(self):
self.__delete(self.last.prev)
def print(self):
c = self.head.next
sep = ''
while c != self.last:
print(sep + str(c.key), end='')
c = c.next
sep = ' '
print()
dlist = DList()
n = int(stdin.readline())
for i in range(n):
cmd = tuple(stdin.readline().split())
if cmd[0] == 'insert':
dlist.insert(int(cmd[1]))
elif cmd[0] == 'delete':
dlist.delete(int(cmd[1]))
elif cmd[0] == 'deleteFirst':
dlist.deleteFirst()
elif cmd[0] == 'deleteLast':
dlist.deleteLast()
dlist.print()
| from sys import stdin
class DList:
class Cell:
def __init__(self, k):
self.key = k
self.prev = None
self.next = None
def __init__(self):
self.head = DList.Cell(None)
self.last = DList.Cell(None)
self.head.next = self.last
self.last.prev = self.head
def insert(self, x):
c = DList.Cell(x)
c.prev = self.head
c.next = self.head.next
c.next.prev = c
self.head.next = c
def delete(self, x):
c = self.__find(x)
if c != None:
self.__delete(c)
def __delete(self, c):
c.prev.next = c.next
c.next.prev = c.prev
def __find(self, x):
c = self.head.next
while c != None and c.key != x:
c = c.next
return c
def deleteFirst(self):
self.__delete(self.head.next)
def deleteLast(self):
self.__delete(self.last.prev)
def print(self):
c = self.head.next
ls = []
while c != self.last:
ls.append(c.key)
c = c.next
print(' '.join(map(str, ls)))
dlist = DList()
n = int(stdin.readline())
for i in range(n):
cmd = tuple(stdin.readline().split())
if cmd[0] == 'insert':
dlist.insert(int(cmd[1]))
elif cmd[0] == 'delete':
dlist.delete(int(cmd[1]))
elif cmd[0] == 'deleteFirst':
dlist.deleteFirst()
elif cmd[0] == 'deleteLast':
dlist.deleteLast()
dlist.print()
| p02265 |
from collections import deque
n = int(eval(input()))
q = deque()
for i in range(n):
cmd = input().strip().split()
try:
if cmd[0][0] == 'i':
q.appendleft(cmd[1])
elif cmd[0][-1] == 'e':
q.remove(cmd[1])
elif cmd[0][6] == 'F':
q.popleft()
else:
q.pop()
except:
pass
print((' '.join(q))) | from collections import deque
n = int(eval(input()))
q = deque()
for i in range(n):
cmd = input().strip().split()
if cmd[0] == 'insert':
q.appendleft(cmd[1])
continue
if cmd[0] == 'delete':
try:
q.remove(cmd[1])
except:
pass
continue
if cmd[0] == 'deleteFirst':
q.popleft()
continue
if cmd[0] == 'deleteLast':
q.pop()
continue
print((' '.join(q))) | p02265 |
n = int(eval(input()))
L = []
i = 0
while i < n:
s = list(map(str, input().split(' ')))
if s[0] == 'insert':
L.insert(0, int(s[1]))
elif s[0] == 'delete':
if int(s[1]) in L:
L.remove(int(s[1]))
elif s[0] == 'deleteFirst':
del L[0]
elif s[0] == 'deleteLast':
del L[-1]
i += 1
print((' '.join(map(str, L))))
| n = int(eval(input()))
L = []
i = 0
while i < n:
s = list(map(str, input().split(' ')))
if s[0] == 'insert':
L.insert(0, int(s[1]))
elif s[0] == 'delete':
try:
L.remove(int(s[1]))
except:
pass
elif s[0] == 'deleteFirst':
del L[0]
elif s[0] == 'deleteLast':
del L[-1]
i += 1
print((' '.join(map(str, L))))
| p02265 |
from collections import deque
def pr(A,n):
for i in range(n):
if i!=n-1:
print(A[i],end=" ")
else:
print(A[i])
n=int(input())
que_r=deque()
c=0
for i in range(n):
s=input().split()
if s[0]=="insert":
que_r.appendleft(int(s[1]))
elif s[0]=="delete" and que_r.count(int(s[1]))>=1:
que_r.remove(int(s[1]))
elif s[0]=="deleteFirst":
gav=que_r.popleft()
elif s[0]=="deleteLast":
gav=que_r.pop()
pr(que_r,len(que_r))
| from collections import deque
def pr(A,n):
for i in range(n):
if i!=n-1:
print(A[i],end=" ")
else:
print(A[i])
n=int(input())
que_r=deque()
for i in range(n):
s=input().split()
if s[0]=="insert":
que_r.appendleft(int(s[1]))
elif s[0]=="delete" and que_r.count(int(s[1]))>=1:
que_r.remove(int(s[1]))
elif s[0]=="deleteFirst":
gav=que_r.popleft()
elif s[0]=="deleteLast":
gav=que_r.pop()
pr(que_r,len(que_r))
| p02265 |
class DLList:
class Cell:
def __init__(self, data, pre, nex):
self.data = data
self.pre = pre
self.nex = nex
def __init__(self):
self.top = DLList.Cell(None, None, None)
def insert(self, x):
if self.top.nex == None:
w = DLList.Cell(x, self.top, self.top)
self.top.nex = w
self.top.pre = w
else:
w = DLList.Cell(x, self.top, self.top.nex)
self.top.nex.pre = w
self.top.nex = w
def delete(self, x):
w = self.top.nex
while w != self.top:
if w.data == x:
w.pre.nex = w.nex
w.nex.pre = w.pre
break
w = w.nex
def deleteFirst(self):
w = self.top.nex
w.pre.nex = w.nex
w.nex.pre = w.pre
def deleteLast(self):
w = self.top.pre
w.pre.nex = w.nex
w.nex.pre = w.pre
def pri(self):
w = self.top.nex
while w != self.top:
if w.nex == self.top:
print(w.data)
break
else:
print(w.data,end=" ")
w = w.nex
a = DLList()
n = int(input())
for i in range(n):
s = input().split(" ")
if s[0] == "insert":
a.insert(int(s[1]))
elif s[0] == "delete":
a.delete(int(s[1]))
elif s[0] == "deleteLast":
a.deleteLast()
elif s[0] == "deleteFirst":
a.deleteFirst()
a.pri()
| class DLList:
class Cell:
def __init__(self, data, pre, nex):
self.data = data
self.pre = pre
self.nex = nex
def __init__(self):
self.top = DLList.Cell(None,None,None)
self.top.nex = self.top
def insert(self, x):
w = DLList.Cell(x, self.top, self.top.nex)
self.top.nex.pre = w
self.top.nex = w
def delete(self, x):
w = self.top.nex
while w != self.top:
if w.data == x:
w.pre.nex = w.nex
w.nex.pre = w.pre
break
w = w.nex
def deleteFirst(self):
w = self.top.nex
w.pre.nex = w.nex
w.nex.pre = w.pre
def deleteLast(self):
w = self.top.pre
w.pre.nex = w.nex
w.nex.pre = w.pre
def pri(self):
w = self.top.nex
while w != self.top:
if w.nex == self.top:
print(w.data)
break
else:
print(w.data,end=" ")
w = w.nex
a = DLList()
n = int(input())
for i in range(n):
s = input().split(" ")
if s[0] == "insert":
a.insert(int(s[1]))
elif s[0] == "delete":
a.delete(int(s[1]))
elif s[0] == "deleteLast":
a.deleteLast()
elif s[0] == "deleteFirst":
a.deleteFirst()
a.pri()
| p02265 |
from collections import deque
n = int( eval(input( )) )
que = deque( )
for i in range( n ):
op = input( ).split( " " )
if "insert" == op[0]:
que.appendleft( op[1] )
elif "delete" == op[0]:
if op[1] in que:
que.remove( op[1] )
elif "deleteFirst" == op[0] :
que.popleft( )
elif "deleteLast" == op[0]:
que.pop( )
print(( " ".join( que ) )) | import sys
from collections import deque
n = int( sys.stdin.readline( ) )
que = deque( )
lines = sys.stdin.readlines()
for line in lines:
op = line.rstrip().split( " " )
if "insert" == op[0]:
que.appendleft( op[1] )
elif "delete" == op[0]:
if op[1] in que:
que.remove( op[1] )
elif "deleteFirst" == op[0] :
que.popleft( )
elif "deleteLast" == op[0]:
que.pop( )
print(( " ".join( que ) )) | p02265 |
n = int(input())
commands = []
for a in range(n):
raw = input().split()
try:
commands.append([raw[0], int(raw[1])])
except:
commands.append([raw[0], 'none'])
result = []
for a in commands:
command, x = a[0], a[1]
if command == 'insert':
result.append(x)
elif command == 'delete':
if x in result:
if result.count(x) == 1:
result.remove(x)
else:
for i in range(len(result)-1, -1, -1):
if result[i] == x:
del result[i]
break
else:
continue
elif command == 'deleteFirst':
del result[-1]
else:
del result[0]
for i in range(len(result)-1, -1, -1):
if i == 0:
print(result[i])
else:
print(result[i], end=' ')
| n = int(input())
result = []
for a in range(n):
c = input().split()
if c[0] == 'insert':
result.append(int(c[1]))
elif c[0] == 'delete':
c[1] = int(c[1])
if c[1] in result:
if result.count(c[1]) == 1:
result.remove(c[1])
else:
for i in range(len(result)-1, -1, -1):
if result[i] == c[1]:
del result[i]
break
else:
continue
elif c[0] == 'deleteFirst':
del result[-1]
else:
del result[0]
for i in range(len(result)-1, -1, -1):
if i == 0:
print(result[i])
else:
print(result[i], end=' ')
| p02265 |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
''' ???????????£???????????? '''
from collections import deque
functions = {"insert": lambda obj, x: obj.insert(x),
"delete": lambda obj, x: obj.delete(x),
"deleteFirst": lambda obj: obj.deleteFirst(),
"deleteLast": lambda obj: obj.deleteLast()}
class DoublyLinkedList(object):
""" Doubly Linked List """
def __init__(self):
# self.list = []
self.list = deque()
def insert(self, x):
""" ???????????????x?????????????´?????????\ """
# self.list = [x] + self.list
self.list.appendleft(x)
def delete(self, x):
""" ??????x??????????????????????´?????????? """
# for i in range(len(self.list)):
# if self.list[i] == x:
# self.list.pop(i)
# break
if x in self.list:
self.list.remove(x)
def deleteFirst(self):
""" ?????????????????????????´?????????? """
# self.list.pop(0)
self.list.popleft()
def deleteLast(self):
""" ????????????????°????????´?????????? """
self.list.pop()
if __name__ == '__main__':
N = int(eval(input()))
dll = DoublyLinkedList()
for i in range(N):
command = input().split()
if len(command) == 1:
functions[command[0]](dll)
elif len(command) == 2:
functions[command[0]](dll, int(command[1]))
print((' '.join(map(str, dll.list)))) | #! /usr/bin/env python
# -*- coding: utf-8 -*-
''' ???????????£???????????? '''
from collections import deque
functions = {"insert": lambda obj, x: obj.insert(x),
"delete": lambda obj, x: obj.delete(x),
"deleteFirst": lambda obj: obj.deleteFirst(),
"deleteLast": lambda obj: obj.deleteLast()}
class DoublyLinkedList(object):
""" Doubly Linked List """
def __init__(self):
# self.list = []
self.list = deque()
def insert(self, x):
""" ???????????????x?????????????´?????????\ """
# self.list = [x] + self.list
self.list.appendleft(x)
def delete(self, x):
""" ??????x??????????????????????´?????????? """
# for i in range(len(self.list)):
# if self.list[i] == x:
# self.list.pop(i)
# break
if x in self.list:
self.list.remove(x)
def deleteFirst(self):
""" ?????????????????????????´?????????? """
# self.list.pop(0)
self.list.popleft()
def deleteLast(self):
""" ????????????????°????????´?????????? """
self.list.pop()
if __name__ == '__main__':
N = int(eval(input()))
q = deque()
for i in range(N):
command = input().split()
if command[0] == 'insert':
q.appendleft(command[1])
elif command[0] == 'delete':
if command[1] in q:
q.remove(command[1])
elif command[0] == 'deleteFirst':
q.popleft()
elif command[0] == 'deleteLast':
q.pop()
print((' '.join(map(str, q))))
# dll = DoublyLinkedList()
# for i in range(N):
# command = input().split()
# if len(command) == 1:
# functions[command[0]](dll)
# elif len(command) == 2:
# functions[command[0]](dll, int(command[1]))
# print(' '.join(map(str, dll.list))) | p02265 |
class Node:
def __init__(self, key, prevNode, nextNode):
self.key = key
self.prevNode = prevNode
self.nextNode = nextNode
def deleteNode(node):
if node == fNode:
return
node.prevNode.nextNode = node.nextNode
node.nextNode.prevNode = node.prevNode
def searchNode(key):
global fNode
node = fNode.nextNode
while node != fNode and node.key != key:
node = node.nextNode
return node
def searchLast():
global fNode
node = fNode.nextNode
while node != fNode:
prevNode = node
node = node.nextNode
return prevNode
def nodeList():
global fNode
node = fNode.nextNode
keys = []
while node != fNode:
keys.append(node.key)
node = node.nextNode
print((" ".join(keys)))
# ????????????????????????
fNode = Node(None, None, None)
fNode.prevNode = fNode
fNode.nextNode = fNode
n = int(eval(input()))
for i in range(0, n):
inputs = input().split(' ')
command = inputs.pop(0)
if inputs:
key = inputs.pop(0)
if command == 'insert':
insertNode = Node(key, fNode, fNode.nextNode)
fNode.nextNode.prevNode = insertNode
fNode.nextNode = insertNode
if command == 'delete':
deleteNode(searchNode(key))
if command == 'deleteFirst':
deleteNode(fNode.nextNode)
if command == 'deleteLast':
deleteNode(fNode.prevNode)
#deleteNode(searchLast())
nodeList() | class Node:
def __init__(self, key, prevNode, nextNode):
self.key = key
self.prevNode = prevNode
self.nextNode = nextNode
def deleteNode(node):
if node == fNode:
return
node.prevNode.nextNode = node.nextNode
node.nextNode.prevNode = node.prevNode
def searchNode(key):
global fNode
node = fNode.nextNode
while node != fNode and node.key != key:
node = node.nextNode
return node
'''
def searchLast():
global fNode
node = fNode.nextNode
while node != fNode:
prevNode = node
node = node.nextNode
return prevNode
'''
def nodeList():
global fNode
node = fNode.nextNode
keys = []
while node != fNode:
keys.append(node.key)
node = node.nextNode
print((" ".join(keys)))
# ????????????????????????
fNode = Node(None, None, None)
fNode.prevNode = fNode
fNode.nextNode = fNode
n = int(eval(input()))
for i in range(0, n):
inputs = input().split(' ')
command = inputs[0]
if command == 'insert':
insertNode = Node(inputs[1], fNode, fNode.nextNode)
fNode.nextNode.prevNode = insertNode
fNode.nextNode = insertNode
if command == 'delete':
deleteNode(searchNode(inputs[1]))
if command == 'deleteFirst':
deleteNode(fNode.nextNode)
if command == 'deleteLast':
deleteNode(fNode.prevNode)
#deleteNode(searchLast())
nodeList() | p02265 |
import sys
res = dict()
dll = [None] * 2000000
left = 0
right = 0
n = int(eval(input()))
for inpt in sys.stdin.read().splitlines():
i = inpt.split()
if i[0] == "insert":
x = int(i[1])
dll[left] = x
if(x in res):
res[x].append(left)
else:
res[x] = [left]
left += 1
if i[0] == "delete":
x = int(i[1])
if(x in res):
ind = max(res[x])
dll[ind] = None
res[x].remove(ind)
if(len(res[x]) == 0):
del res[x]
if(ind == (left - 1)):
left = ind
if(ind == right):
right += 1
if i[0] == "deleteFirst":
left -= 1
x = dll[left]
res[x].remove(left)
if(len(res[x]) == 0):
del res[x]
dll[left] = None
if i[0] == "deleteLast":
right += 1
# print(dll[right:left])
ret = []
for x in dll[right:left]:
if(x is not None):
ret.append(str(x))
ret.reverse()
print((" ".join(ret))) | import sys
res = dict()
dll = [None] * 2000000
left = 0
right = 0
n = int(eval(input()))
for inpt in sys.stdin.read().splitlines():
i = inpt.split()
if i[0] == "insert":
x = int(i[1])
dll[left] = x
if(x in res):
res[x].add(left)
else:
res[x] = set([left])
left += 1
if i[0] == "delete":
x = int(i[1])
if(x in res):
ind = max(res[x])
dll[ind] = None
res[x].remove(ind)
if(len(res[x]) == 0):
del res[x]
if(ind == (left - 1)):
left = ind
if(ind == right):
right += 1
if i[0] == "deleteFirst":
left -= 1
x = dll[left]
res[x].remove(left)
if(len(res[x]) == 0):
del res[x]
dll[left] = None
if i[0] == "deleteLast":
right += 1
# print(dll[right:left])
ret = []
for x in dll[right:left]:
if(x is not None):
ret.append(str(x))
ret.reverse()
print((" ".join(ret))) | p02265 |
import sys
class Node:
def __init__(self, value):
self.value = value
self.prev = None
self.next = None
class DoublyLinkedList:
def __init__(self):
self.head = None
self.tail = None
self.size = 0
def get_size(self):
return self.size
def is_empty(self):
return self.size == 0
def insert(self, value):
node = Node(value)
if self.is_empty():
self.head = self.tail = node
else:
self.head.prev = node
node.next = self.head
self.head = node
self.size += 1
def deleteFirst(self):
if self.is_empty():
return
if self.size == 1:
self.head = self.tail = None
else:
self.head = self.head.next
self.head.prev = None
self.size -= 1
def deleteLast(self):
if self.is_empty():
return
if self.size == 1:
self.head = self.tail = None
else:
self.tail = self.tail.prev
self.tail.next = None
self.size -= 1
def delete(self, value):
if self.is_empty():
return
if self.head.value == value:
self.deleteFirst()
else:
node1 = self.head.next
node2 = self.tail
node3 = None
while node1 != None:
if node1.value == value:
prev = node1.prev
next = node1.next
prev.next = next
if next != None:
next.prev = prev
else:
self.tail = prev
self.size -= 1
break
elif node1 == node2:
if node3 == None:
break;
else:
node1 = node3
else:
node1 = node1.next
if node2.value == value:
node3 = node2
node2 = node2.prev
return
def print(self):
node = self.head
while node != None:
sys.stdout.write(str(node.value))
node = node.next
if node != None:
sys.stdout.write(' ')
print()
n = int(input())
dll = DoublyLinkedList()
for i in range(n):
cmd = str(input())
if cmd == 'deleteFirst':
dll.deleteFirst()
elif cmd == 'deleteLast':
dll.deleteLast()
else:
cmd, value = cmd.split()
if cmd == 'insert':
dll.insert(int(value))
else:
dll.delete(int(value))
dll.print()
| import sys
class Node:
def __init__(self, value):
self.value = value
self.prev = None
self.next = None
class DoublyLinkedList:
def __init__(self):
self.head = None
self.tail = None
self.size = 0
def get_size(self):
return self.size
def is_empty(self):
return self.size == 0
def insert(self, value):
node = Node(value)
if self.is_empty():
self.head = self.tail = node
else:
self.head.prev = node
node.next = self.head
self.head = node
self.size += 1
def deleteFirst(self):
if self.is_empty():
return
if self.size == 1:
self.head = self.tail = None
else:
self.head = self.head.next
self.head.prev = None
self.size -= 1
def deleteLast(self):
if self.is_empty():
return
if self.size == 1:
self.head = self.tail = None
else:
self.tail = self.tail.prev
self.tail.next = None
self.size -= 1
def delete(self, value):
if self.is_empty():
return
if self.head.value == value:
self.deleteFirst()
else:
node1 = self.head.next
node2 = self.tail
node3 = None
while node1 != None:
if node1.value == value:
prev = node1.prev
next = node1.next
prev.next = next
if next != None:
next.prev = prev
else:
self.tail = prev
self.size -= 1
break
elif node1 == node2:
if node3 == None:
break;
else:
node1 = node3
else:
node1 = node1.next
if node2.value == value:
node3 = node2
node2 = node2.prev
return
def print(self):
node = self.head
while node != None:
sys.stdout.write(str(node.value))
node = node.next
if node != None:
sys.stdout.write(' ')
print()
n = int(input())
dll = DoublyLinkedList()
for n in range(n):
cmd = sys.stdin.readline().strip().split()
if cmd[0] == 'deleteFirst':
dll.deleteFirst()
elif cmd[0] == 'deleteLast':
dll.deleteLast()
else:
if cmd[0] == 'insert':
dll.insert(int(cmd[1]))
else:
dll.delete(int(cmd[1]))
dll.print()
| p02265 |
import sys
class Node:
def __init__(self, value):
self.value = value
self.prev = None
self.next = None
class DoublyLinkedList:
def __init__(self):
self.head = None
self.tail = None
self.size = 0
def get_size(self):
return self.size
def is_empty(self):
return self.size == 0
def insert(self, value):
node = Node(value)
if self.is_empty():
self.head = self.tail = node
else:
self.head.prev = node
node.next = self.head
self.head = node
self.size += 1
def deleteFirst(self):
if self.is_empty():
return
if self.size == 1:
self.head = self.tail = None
else:
self.head = self.head.next
self.head.prev = None
self.size -= 1
def deleteLast(self):
if self.is_empty():
return
if self.size == 1:
self.head = self.tail = None
else:
self.tail = self.tail.prev
self.tail.next = None
self.size -= 1
def delete(self, value):
if self.is_empty():
return
if self.head.value == value:
self.deleteFirst()
else:
node1 = self.head.next
node2 = self.tail
node3 = None
while node1 != None:
if node1.value == value:
prev = node1.prev
next = node1.next
prev.next = next
if next != None:
next.prev = prev
else:
self.tail = prev
self.size -= 1
break
elif node1 == node2:
if node3 == None:
break;
else:
node1 = node3
else:
node1 = node1.next
if node2.value == value:
node3 = node2
node2 = node2.prev
return
def print(self):
node = self.head
while node != None:
sys.stdout.write(str(node.value))
node = node.next
if node != None:
sys.stdout.write(' ')
print()
n = int(input())
dll = DoublyLinkedList()
for n in range(n):
cmd = sys.stdin.readline().strip().split()
if cmd[0] == 'deleteFirst':
dll.deleteFirst()
elif cmd[0] == 'deleteLast':
dll.deleteLast()
else:
if cmd[0] == 'insert':
dll.insert(int(cmd[1]))
else:
dll.delete(int(cmd[1]))
dll.print()
| class Node(object):
def __init__(self, num, prv = None, nxt = None):
self.num = num
self.prv = prv
self.nxt = nxt
class DoublyLinkedList(object):
def __init__(self):
self.start = self.last = None
def insert(self, num):
new_elem = Node(num)
if self.start is None:
self.start = self.last = new_elem
else:
new_elem.nxt = self.start
self.start.prv = new_elem
self.start = new_elem
def delete_num(self, target):
it = self.start
while it is not None:
if it.num == target:
if it.prv is None and it.nxt is None:
self.start = self.last = None
else:
if it.prv is not None:
it.prv.nxt = it.nxt
else:
self.start = self.start.nxt
if it.nxt is not None:
it.nxt.prv = it.prv
else:
self.last = self.last.prv
break
it = it.nxt
def delete_start(self):
if self.start is self.last:
self.start = self.last = None
else:
self.start.nxt.prv = None
self.start = self.start.nxt
def delete_last(self):
if self.start is self.last:
self.start = self.last = None
else:
self.last.prv.nxt = None
self.last = self.last.prv
def get_content(self):
ret = []
it = self.start
while it is not None:
ret.append(it.num)
it = it.nxt
return ' '.join(ret)
def _main():
from sys import stdin
n = int(eval(input()))
lst = DoublyLinkedList()
for _ in range(n):
cmd = stdin.readline().strip().split()
if cmd[0] == 'insert':
lst.insert(cmd[1])
elif cmd[0] == 'delete':
lst.delete_num(cmd[1])
elif cmd[0] == 'deleteFirst':
lst.delete_start()
elif cmd[0] == 'deleteLast':
lst.delete_last()
print((lst.get_content()))
if __name__ == '__main__':
_main()
| p02265 |
class LinkedListNode:
def __init__(self, key, prev_node, next_node):
self.key = key
self.prev_node = prev_node
self.next_node = next_node
class LinkedList:
def __init__(self):
self.front_node = None
self.last_node = None
self.size = 0
def insert(self, key):
new_node = LinkedListNode(key, None, self.front_node)
if self.front_node != None:
self.front_node.prev_node = new_node
self.front_node = new_node
if self.last_node == None:
self.last_node = new_node
self.size += 1
def delete(self, key):
node = self.front_node
while node != None:
if node.key == key:
if node == self.front_node:
self.front_node = self.front_node.next_node
if node == self.last_node:
self.last_node = self.last_node.prev_node
if node.prev_node != None:
node.prev_node.next_node = node.next_node
if node.next_node != None:
node.next_node.prev_node = node.prev_node
self.size -= 1
break
node = node.next_node
def delete_first(self):
if self.size == 0:
return
elif self.size == 1:
self.front_node = None
self.last_node = None
self.size -= 1
else:
self.front_node = self.front_node.next_node
self.front_node.prev_node = None
self.size -= 1
def delete_last(self):
if self.size == 0:
return
elif self.size == 1:
self.front_node = None
self.last_node = None
self.size -= 1
else:
self.last_node = self.last_node.prev_node
self.last_node.next_node = None
self.size -= 1
def to_a(self):
a = []
node = self.front_node
while node != None:
a.append(node.key)
node = node.next_node
return a
l = LinkedList()
n = int(eval(input()))
for i in range(n):
ins = input().split()
command = ins[0]
if command == "insert":
x = int(ins[1])
l.insert(x)
elif command == "delete":
x = int(ins[1])
l.delete(x)
elif command == "deleteFirst":
l.delete_first()
elif command == "deleteLast":
l.delete_last()
print((" ".join(map(str, l.to_a())))) | import sys
class LinkedListNode:
def __init__(self, key, prev_node, next_node):
self.key = key
self.prev_node = prev_node
self.next_node = next_node
class LinkedList:
def __init__(self):
self.front_node = None
self.last_node = None
self.size = 0
def insert(self, key):
new_node = LinkedListNode(key, None, self.front_node)
if self.front_node != None:
self.front_node.prev_node = new_node
self.front_node = new_node
if self.last_node == None:
self.last_node = new_node
self.size += 1
def delete(self, key):
node = self.front_node
while node != None:
if node.key == key:
if node == self.front_node:
self.front_node = self.front_node.next_node
if node == self.last_node:
self.last_node = self.last_node.prev_node
if node.prev_node != None:
node.prev_node.next_node = node.next_node
if node.next_node != None:
node.next_node.prev_node = node.prev_node
self.size -= 1
break
node = node.next_node
def delete_first(self):
if self.size == 0:
return
elif self.size == 1:
self.front_node = None
self.last_node = None
self.size -= 1
else:
self.front_node = self.front_node.next_node
self.front_node.prev_node = None
self.size -= 1
def delete_last(self):
if self.size == 0:
return
elif self.size == 1:
self.front_node = None
self.last_node = None
self.size -= 1
else:
self.last_node = self.last_node.prev_node
self.last_node.next_node = None
self.size -= 1
def to_a(self):
a = []
node = self.front_node
while node != None:
a.append(node.key)
node = node.next_node
return a
l = LinkedList()
n = int(eval(input()))
lines = sys.stdin.readlines()
for i in range(n):
ins = lines[i].split()
command = ins[0]
if command == "insert":
x = int(ins[1])
l.insert(x)
elif command == "delete":
x = int(ins[1])
l.delete(x)
elif command == "deleteFirst":
l.delete_first()
elif command == "deleteLast":
l.delete_last()
print((" ".join(map(str, l.to_a())))) | p02265 |
# -*- coding: utf-8 -*-
from collections import deque
n = int(input())
key = deque()
for i in range(n):
command = list(input().split())
if command[0] == 'insert':
key.insert(0, command[1])
elif command[0] == 'delete' and command[1] in key:
key.remove(command[1])
elif command[0] == 'deleteFirst':
del key[0]
elif command[0] == 'deleteLast':
del key[-1]
for i in range(len(key)):
if i == len(key) - 1:
print('{0}'.format(key[i]))
else:
print('{0}'.format(key[i]), end=' ')
| # -*- coding: utf-8 -*-
from collections import deque
n = int(input())
key = deque()
for i in range(n):
command = list(input().split())
if command[0] == 'insert':
key.insert(0, command[1])
elif command[0] == 'delete' and command[1] in key:
key.remove(command[1])
elif command[0] == 'deleteFirst':
key.popleft()
elif command[0] == 'deleteLast':
key.pop()
for i in range(len(key)):
if i == len(key) - 1:
print('{0}'.format(key[i]))
else:
print('{0}'.format(key[i]), end=' ')
| p02265 |
# -*- coding: utf-8 -*-
from collections import deque
n = int(input())
key = deque()
for i in range(n):
command = list(input().split())
if command[0] == 'insert':
key.insert(0, command[1])
elif command[0] == 'delete' and command[1] in key:
key.remove(command[1])
elif command[0] == 'deleteFirst':
key.popleft()
elif command[0] == 'deleteLast':
key.pop()
for i in range(len(key)):
if i == len(key) - 1:
print('{0}'.format(key[i]))
else:
print('{0}'.format(key[i]), end=' ')
| # -*- coding: utf-8 -*-
from collections import deque
n = int(input())
key = deque()
for i in range(n):
command = list(input().split())
if command[0] == 'insert':
key.appendleft(command[1])
elif command[0] == 'delete':
try:
key.remove(command[1])
except:
pass
elif command[0] == 'deleteFirst':
key.popleft()
elif command[0] == 'deleteLast':
key.pop()
for i in range(len(key)):
if i == len(key) - 1:
print('{0}'.format(key[i]))
else:
print('{0}'.format(key[i]), end=' ')
| p02265 |
class Node(object):
def __init__(self, num, prev = None, nxt = None):
self.num = num;
self.prev = prev;
self.nxt = nxt;
class Double_Linked_List(object):
def __init__(self):
self.first = self.last = None;
def insert(self, num):
node = Node(num);
if self.first is not None:
self.first.prev = node;
node.nxt = self.first;
self.first = node;
else:
self.first = node;
self.last = node;
def delete(self, num):
current = self.first;
while current is not None:
if current.num == num:
prev = current.prev;
nxt = current.nxt;
if prev is not None:
current.prev = None;
prev.nxt = nxt;
if nxt is not None:
current.nxt = None;
nxt.prev = prev;
if nxt is None:
self.last = prev;
if prev is None:
self.first = nxt;
break;
else:
current = current.nxt;
def delete_first(self):
if self.first is not None:
nxt = self.first.nxt;
if nxt is not None:
self.first.nxt = None;
nxt.prev = None;
self.first = nxt;
else:
self.first = None;
self.last = None;
def delete_last(self):
if self.last is not None:
prev = self.last.prev;
if prev is not None:
self.last.prev = None;
prev.nxt = None;
self.last = prev;
else:
self.first = None;
self.last = None;
def get_content(self):
ret = [];
append = ret.append;
current = self.first;
while current is not None:
append(current.num);
current = current.nxt;
return " ".join(ret);
def main():
double_linked_list = Double_Linked_List();
count = int(eval(input()));
delete_first = double_linked_list.delete_first;
delete_last = double_linked_list.delete_last;
delete = double_linked_list.delete;
insert = double_linked_list.insert;
for i in range(count):
command = input().split();
if command[0] == "insert":
insert(command[1]);
if command[0] == "delete":
delete(command[1]);
elif command[0] == "deleteFirst":
delete_first();
elif command[0] == "deleteLast":
delete_last();
print((double_linked_list.get_content()));
main();
| class Node(object):
def __init__(self, num, prv = None, nxt = None):
self.num = num
self.prv = prv
self.nxt = nxt
class DoublyLinkedList(object):
def __init__(self):
self.start = self.last = None
def insert(self, num):
new_elem = Node(num)
if self.start is None:
self.start = self.last = new_elem
else:
new_elem.nxt = self.start
self.start.prv = new_elem
self.start = new_elem
def delete_num(self, target):
it = self.start
while it is not None:
if it.num == target:
if it.prv is None and it.nxt is None:
self.start = self.last = None
else:
if it.prv is not None:
it.prv.nxt = it.nxt
else:
self.start = self.start.nxt
if it.nxt is not None:
it.nxt.prv = it.prv
else:
self.last = self.last.prv
break
it = it.nxt
def delete_start(self):
if self.start is self.last:
self.start = self.last = None
else:
self.start.nxt.prv = None
self.start = self.start.nxt
def delete_last(self):
if self.start is self.last:
self.start = self.last = None
else:
self.last.prv.nxt = None
self.last = self.last.prv
def get_content(self):
ret = []
it = self.start
while it is not None:
ret.append(it.num)
it = it.nxt
return ' '.join(ret)
def _main():
from sys import stdin
n = int(eval(input()))
lst = DoublyLinkedList()
for _ in range(n):
cmd = stdin.readline().strip().split()
if cmd[0] == 'insert':
lst.insert(cmd[1])
elif cmd[0] == 'delete':
lst.delete_num(cmd[1])
elif cmd[0] == 'deleteFirst':
lst.delete_start()
elif cmd[0] == 'deleteLast':
lst.delete_last()
print((lst.get_content()))
if __name__ == '__main__':
_main()
| p02265 |
n = int(eval(input()))
A = [list(map(str,input().split())) for _ in range(n)]
B = []
for i in range(n):
if A[i][0] == 'insert':
B.insert(0,int(A[i][1]))
elif A[i][0] == 'delete':
if int(A[i][1]) in B:
B.remove(int(A[i][1]))
elif A[i][0] == 'deleteFirst':
del B[0]
elif A[i][0] == 'deleteLast':
del B[-1]
print((' '.join(map(str,B))))
| n = int(eval(input()))
B = []
for i in range(n):
A = list(map(str,input().split()))
if A[0] == 'insert':
B.insert(0,int(A[1]))
elif A[0] == 'delete':
if int(A[1]) in B:
B.remove(int(A[1]))
elif A[0] == 'deleteFirst':
del B[0]
elif A[0] == 'deleteLast':
del B[-1]
print((' '.join(map(str,B))))
| p02265 |
from collections import deque
def insert():
a.appendleft(command[1])
def delete():
try:
a.remove(command[1])
except ValueError:
pass
def deleteFirst():
a.popleft()
def deleteLast():
a.pop()
n = int(input())
a = deque([])
for i in range(n):
command = input().split()
if command[0] == "insert":
insert()
elif command[0] == "delete":
delete()
elif command[0] == "deleteFirst":
deleteFirst()
else:
deleteLast()
for i, e in enumerate(a):
if i == len(a) - 1:
print(e)
else:
print(e, end=' ')
| from collections import deque
a = deque([])
for i in range(int(input())):
c = input().split()
if c[0] == "insert":
a.appendleft(c[1])
elif c[0] == "delete":
try:
a.remove(c[1])
except ValueError:
pass
elif c[0] == "deleteFirst":
a.popleft()
else:
a.pop()
for i,e in enumerate(a):
if i == len(a) - 1:
print(e)
else:
print(e, end=" ")
| p02265 |
from collections import deque
class MyList(list):
def __init__(self):
self.__init__ = list
self.d = {'deleteFirst':self.delF, 'deleteLast':self.delL, 'insert':self.insX, 'delete':self.delX}
def cmd(self,command):
if ' ' in command:
ope, num = command.split()
num = int(num)
self.d[ope](num)
else:
self.d[command]()
def delF(self):
self.pop(0)
def delL(self):
self.pop(-1)
def insX(self,num):
self.insert(0,num)
def delX(self,num):
if num in self:
self.remove(num)
if __name__ == '__main__' :
l = MyList()
n = eval(input())
for i in range(n):
l.cmd(input())
q = deque(l)
for i in range(len(l)-1):
print(q.popleft(), end=' ')
print(l[-1]) | from collections import deque
class MyList(deque):
def __init__(self):
self.__init__ = deque
self.d = {'deleteFirst':self.delF, 'deleteLast':self.delL, 'insert':self.insX, 'delete':self.delX}
def cmd(self,command):
if ' ' in command:
ope, num = command.split()
num = int(num)
self.d[ope](num)
else:
self.d[command]()
def delF(self):
self.popleft()
def delL(self):
self.pop()
def insX(self,num):
self.appendleft(num)
def delX(self,num):
if num in self:
self.remove(num)
if __name__ == '__main__' :
l = MyList()
n = eval(input())
for i in range(n):
l.cmd(input())
q = deque(l)
for i in range(len(l)-1):
print(q.popleft(), end=' ')
print(l[-1]) | p02265 |
import sys
class mydeque:
class cell:
def __init__(self,x,y = None,z = None):
self.data = x
self.next = y
self.prev = z
def __init__(self):
head = mydeque.cell(None)
head.next = head
head.prev = head
self.size = 0
self.head = head
def push_front(self,x):
h = self.head
q = h.next
p = mydeque.cell(x,q,h)
h.next = p
q.prev = p
self.size += 1
def push_back(self,x):
h = self.head
p = h.prev
q = mydeque.cell(x,h,p)
h.prev = q
p.next = q
self.size += 1
def delete_top(self):
h = self.head
top = h.next
nexttop = top.next
h.next = nexttop
nexttop.prev = h
self.size -= 1
def delete_last(self):
h = self.head
last = h.prev
prevlast = last.prev
h.prev = prevlast
prevlast.next = h
self.size -= 1
def delete_find(self,target):
h = self.head
now_data = h.next
while now_data != self.head:
if now_data.data == target:
next_now = now_data.next
prev_now = now_data.prev
next_now.prev = prev_now
prev_now.next = next_now
self.size -= 1
break
now_data = now_data.next
def allprint(self):
h = self.head.next
for i in range(self.size):
if i == self.size - 1:
print(h.data)
else:
print(h.data, end=" ")
h = h.next
# with open("input.txt","r") as f:
queue = int(input())
length = 0
myd = mydeque()
for q in range(queue):
command = [n for n in input().strip("\n").split(' ')]
if command[0] == "insert":
myd.push_front(command[1])
elif command[0] == "delete":
myd.delete_find(command[1])
elif command[0] == "deleteFirst":
myd.delete_top()
else:
myd.delete_last()
myd.allprint()
| import sys
class mydeque:
class cell:
def __init__(self,x,y = None,z = None):
self.data = x
self.next = y
self.prev = z
def __init__(self):
head = mydeque.cell(None)
head.next = head
head.prev = head
self.size = 0
self.head = head
def push_front(self,x):
h = self.head
q = h.next
p = mydeque.cell(x,q,h)
h.next = p
q.prev = p
self.size += 1
def push_back(self,x):
h = self.head
p = h.prev
q = mydeque.cell(x,h,p)
h.prev = q
p.next = q
self.size += 1
def delete_top(self):
h = self.head
top = h.next
nexttop = top.next
h.next = nexttop
nexttop.prev = h
del top
self.size -= 1
def delete_last(self):
h = self.head
last = h.prev
prevlast = last.prev
h.prev = prevlast
prevlast.next = h
del last
self.size -= 1
def delete_find(self,target):
h = self.head
now_data = h.next
while now_data != self.head:
if now_data.data == target:
next_now = now_data.next
prev_now = now_data.prev
next_now.prev = prev_now
prev_now.next = next_now
del now_data
self.size -= 1
break
now_data = now_data.next
def allprint(self):
h = self.head.next
for i in range(self.size):
if i == self.size - 1:
print(h.data)
else:
print(h.data, end=" ")
h = h.next
# with open("input.txt","r") as f:
queue = int(input())
length = 0
myd = mydeque()
for q in range(queue):
command = [n for n in input().strip("\n").split(' ')]
if command[0] == "insert":
myd.push_front(command[1])
elif command[0] == "delete":
myd.delete_find(command[1])
elif command[0] == "deleteFirst":
myd.delete_top()
else:
myd.delete_last()
myd.allprint()
| p02265 |
class Node:
def __init__(self, key, prev, next):
self.key = key
self.prev = prev
self.next = next
class MyDLL:
def __init__(self):
self.linkedlist = []
self.length = 0
def insert(self, x):
# 連結リストの先頭にキー x を持つ要素を継ぎ足す。
if self.length==0:
# 連結リストが空の時
new = Node(x, None, None)
else:
# 連結リストが空ではない時
old = self.linkedlist[0] # 今まで先頭にいたノード
new = Node(x, None, old) # 新しく先頭になるノード
old.prev = new # 今まで先頭にいたノードの前に新しいノードを登録
self.linkedlist.insert(0, new)
self.length += 1 # 連結リストの長さを更新
def delete(self, x):
# キー x を持つ最初の要素を連結リストから削除する。そのような要素が存在しない場合は何もしない。
for node in self.linkedlist:
if node.key==x:# キー x を持つ最初の要素
if node.prev is None:# 先頭だった時
node.next.prev = None # 次の要素の前の要素をNoneにする
elif node.next is None:# 最後尾だった時
node.prev.next = None
else:# 途中だった時
prev_node = node.prev
next_node = node.next
prev_node.next = next_node
next_node.prev = prev_node
self.linkedlist.remove(node)# listから削除
self.length -= 1
break # キーxを持つ最初だけで良いのでbreak
def deleteFirst(self):
# リストの先頭の要素を削除する。
if not self.length==0:
first = self.linkedlist.pop(0)
if self.length>1:
first.next.prev = None
self.length -= 1
else:
print("List is empty")
def deleteLast(self):
# リストの末尾の要素を削除する。
if not self.length==0:
last = self.linkedlist.pop()
if self.length>1:
last.prev.next = None
self.length -= 1
else:
print("List is empty")
def print(self):
if not self.length==0:
print(' '.join([node.key for node in self.linkedlist]))
else:
print('')
def main():
n = int(input())
commands = (input() for i in range(n)) # generator式リスト内包表記
dll = MyDLL()
for c in commands:
if 'insert' in c:
dll.insert(c.split()[1])
elif 'First' in c:
dll.deleteFirst()
elif 'Last' in c:
dll.deleteLast()
elif 'delete' in c:
dll.delete(c.split()[1])
else:
print("the command dont't exist")
print(c)
dll.print()
main()
| class Node:
def __init__(self, key):
self.key = key
self.prev = None
self.next = None
class MyDLL:
def __init__(self):
# 番兵：仮想的な先頭
self.sentinel = Node(None)
self.sentinel.prev = self.sentinel
self.sentinel.next = self.sentinel
def insert(self, x):
# 連結リストの先頭にキー x を持つ要素を継ぎ足す。
new = Node(x)
new.next = self.sentinel.next # 新しく先頭.next = 番兵.next = 今まで先頭
self.sentinel.next.prev = new # 番兵.next.prev = 今まで先頭.prev = 新しく先頭
self.sentinel.next = new # 番兵.next = 新しく先頭
new.prev = self.sentinel # 新しく先頭.prev = 番兵
def listSearch(self, x):
cursor = self.sentinel.next # 番兵の次の要素から巡る
while (cursor != self.sentinel) & (cursor.key != x):
cursor = cursor.next
return cursor
def deleteNode(self, node):
# あるノードを削除するとき
# 例 A - B - C でBを削除
if node!=self.sentinel: # Bは番兵ではないことを確認
node.prev.next = node.next # B.prev.next = A.next = B.next = C
node.next.prev = node.prev # B.next.prev = C.prev = B.prev = A
def deleteKey(self, x):
self.deleteNode(self.listSearch(x))
def deleteFirst(self):
# リストの先頭の要素を削除する。
self.deleteNode(self.sentinel.next)
def deleteLast(self):
# リストの末尾の要素を削除する。
self.deleteNode(self.sentinel.prev)
def print(self):
cursor = self.sentinel.next
key_list = []
while cursor != self.sentinel:
key_list.append(cursor.key)
cursor = cursor.next
print(' '.join(key_list))
def main():
# input()
# n = 1786329# int(input())
n = int(input())
commands = (input() for i in range(n)) # generator式リスト内包表記
dll = MyDLL()
for c in commands:
if 'insert' in c:
dll.insert(c.split()[1])
elif 'First' in c:
dll.deleteFirst()
elif 'Last' in c:
dll.deleteLast()
elif 'delete' in c:
dll.deleteKey(c.split()[1])
else:
print("the command dont't exist")
print(c)
dll.print()
main()
| p02265 |
class DLL:
class Node:
def __init__(self, x, y, z):
self.v = x
self.prv = y
self.nxt = z
def __init__(self):
init = DLL.Node(None, None, None)
init.prv = init
init.nxt = init
self.size = 0
self.init = init
def insert(self, x):
i = self.init
j = i.nxt
k = DLL.Node(x, i, j)
i.nxt = k
j.prv = k
self.size += 1
def deleteFirst(self):
if self.size != 0:
i = self.init
k = i.nxt
j = k.nxt
i.nxt = j
j.prv = i
self.size -= 1
def deleteLast(self):
if self.size != 0:
i = self.init
k = i.prv
j = k.prv
i.prv = j
j.nxt = i
self.size -= 1
def delete(self, x):
if self.size != 0:
i = self.init
k = i.nxt
while 1:
if k.v == x:
i = k.prv
j = k.nxt
i.nxt = j
j.prv = i
self.size -= 1
break
else:
k = k.nxt
def prt(self):
f = self.init
s = f.nxt
l = f.prv
while 1:
if s != l:
print(s.v, end=' ')
s = s.nxt
else:
print(l.v)
break
n = int(input())
L = DLL()
for i in range(n):
com = input()
if com == "deleteFirst":
L.deleteFirst()
elif com == "deleteLast":
L.deleteLast()
else:
C = com.split()
if C[0] == "insert":
L.insert(int(C[1]))
elif C[0] == "delete":
L.delete(int(C[1]))
#L.prt()
L.prt()
| #16D8104025G 佐藤智裕 mist75__ Python3
class DLL:
class Node:
def __init__(self, x, y, z):
self.v = x
self.prv = y
self.nxt = z
def __init__(self):
init = DLL.Node(None, None, None)
init.prv = init
init.nxt = init
self.size = 0
self.init = init
def insert(self, x):
i = self.init
j = i.nxt
k = DLL.Node(x, i, j)
i.nxt = k
j.prv = k
self.size += 1
def deleteFirst(self):
if self.size != 0:
i = self.init
k = i.nxt
j = k.nxt
i.nxt = j
j.prv = i
self.size -= 1
def deleteLast(self):
if self.size != 0:
i = self.init
k = i.prv
j = k.prv
i.prv = j
j.nxt = i
self.size -= 1
def delete(self, x):
if self.size != 0:
i = self.init
k = i.nxt
while 1:
if k.v == x:
i = k.prv
j = k.nxt
i.nxt = j
j.prv = i
self.size -= 1
break
else:
if k.nxt == i:
break
else:
k = k.nxt
def prt(self):
f = self.init
s = f.nxt
l = f.prv
while 1:
if s != l:
print(s.v, end=' ')
s = s.nxt
else:
print(l.v)
break
n = int(input())
L = DLL()
for i in range(n):
com = input()
if com == "deleteFirst":
L.deleteFirst()
elif com == "deleteLast":
L.deleteLast()
else:
C = com.split()
if C[0] == "insert":
L.insert(int(C[1]))
elif C[0] == "delete":
L.delete(int(C[1]))
#L.prt()
L.prt()
| p02265 |
import sys
class Node:
def __init__(self, num):
self.prev = None
self.next_node = None
self.num = num
def delete(self):
if self.prev is not None:
self.prev.next_node = self.next_node
if self.next_node is not None:
self.next_node.prev = self.prev
class LinkedList:
def __init__(self):
self.start_node = None
self.last_node = None
def add(self, num):
node = Node(num)
if self.start_node is None:
self.start_node = node
self.last_node = node
elif self.last_node is None:
self.last_node = self.start_node
node.next_node = self.last_node
self.last_node.prev = node
self.start_node = node
else:
self.start_node.prev = node
node.next_node = self.start_node
self.start_node = node
def delete(self, num):
node = self.start_node
while node is not None:
if node.num == num:
if node == self.start_node:
self.delete_first()
elif node == self.last_node:
self.delete_last()
else:
node.delete()
break
node = node.next_node
def delete_last(self):
if self.start_node == self.last_node:
self.start_node = None
self.last_node = None
else:
node = self.last_node
self.last_node = self.last_node.prev
node.delete()
def delete_first(self):
if self.start_node == self.last_node:
self.start_node = None
self.last_node = None
else:
node = self.start_node
self.start_node = self.start_node.next_node
node.delete()
def __str__(self):
s = ""
node = self.start_node
while node is not None:
s += str(node.num) + " "
node = node.next_node
return s.strip()
def main():
linked_list = LinkedList()
c_num = int(sys.stdin.readline().strip())
for i in range(0, c_num):
line = sys.stdin.readline().strip().split(" ")
op = line[0]
if op == "insert":
linked_list.add(int(line[1]))
if op == "delete":
linked_list.delete(int(line[1]))
if op == "deleteFirst":
linked_list.delete_first()
if op == "deleteLast":
linked_list.delete_last()
#print linked_list
print(str(linked_list))
if __name__ == "__main__":
main() |
class Node(object):
def __init__(self, num, prv = None, nxt = None):
self.num = num
self.prv = prv
self.nxt = nxt
class DoublyLinkedList(object):
def __init__(self):
self.start = self.last = None
def insert(self, num):
new_elem = Node(num)
if self.start is None:
self.start = self.last = new_elem
else:
new_elem.nxt = self.start
self.start.prv = new_elem
self.start = new_elem
def delete_num(self, target):
it = self.start
while it is not None:
if it.num == target:
if it.prv is None and it.nxt is None:
self.start = self.last = None
else:
if it.prv is not None:
it.prv.nxt = it.nxt
else:
self.start = self.start.nxt
if it.nxt is not None:
it.nxt.prv = it.prv
else:
self.last = self.last.prv
break
it = it.nxt
def delete_start(self):
if self.start is self.last:
self.start = self.last = None
else:
self.start.nxt.prv = None
self.start = self.start.nxt
def delete_last(self):
if self.start is self.last:
self.start = self.last = None
else:
self.last.prv.nxt = None
self.last = self.last.prv
def get_content(self):
ret = []
it = self.start
while it is not None:
ret.append(it.num)
it = it.nxt
return ' '.join(ret)
def _main():
from sys import stdin
n = int(eval(input()))
lst = DoublyLinkedList()
for _ in range(n):
cmd = stdin.readline().strip().split()
if cmd[0] == 'insert':
lst.insert(cmd[1])
elif cmd[0] == 'delete':
lst.delete_num(cmd[1])
elif cmd[0] == 'deleteFirst':
lst.delete_start()
elif cmd[0] == 'deleteLast':
lst.delete_last()
print((lst.get_content()))
if __name__ == '__main__':
_main() | p02265 |
from sys import stdin
class Node:
def __init__(self, num):
self.prev = None
self.next_node = None
self.num = num
def delete(self):
if self.prev is not None:
self.prev.next_node = self.next_node
if self.next_node is not None:
self.next_node.prev = self.prev
class LinkedList:
def __init__(self):
self.start_node = None
self.last_node = None
def add(self, num):
node = Node(num)
if self.start_node is None:
self.start_node = node
self.last_node = node
elif self.last_node is None:
self.last_node = self.start_node
node.next_node = self.last_node
self.last_node.prev = node
self.start_node = node
else:
self.start_node.prev = node
node.next_node = self.start_node
self.start_node = node
def delete(self, num):
node = self.start_node
while node is not None:
if node.num == num:
if node == self.start_node:
self.delete_first()
elif node == self.last_node:
self.delete_last()
else:
node.delete()
break
node = node.next_node
def delete_last(self):
if self.start_node == self.last_node:
self.start_node = None
self.last_node = None
else:
node = self.last_node
self.last_node = self.last_node.prev
node.delete()
def delete_first(self):
if self.start_node == self.last_node:
self.start_node = None
self.last_node = None
else:
node = self.start_node
self.start_node = self.start_node.next_node
node.delete()
def __str__(self):
s = ""
node = self.start_node
while node is not None:
s += str(node.num) + " "
node = node.next_node
return s.strip()
def main():
linked_list = LinkedList()
c_num = int(stdin.readline().strip())
for i in range(0, c_num):
line = stdin.readline().strip().split(" ")
op = line[0]
if op == "insert":
linked_list.add(int(line[1]))
if op == "delete":
linked_list.delete(int(line[1]))
if op == "deleteFirst":
linked_list.delete_first()
if op == "deleteLast":
linked_list.delete_last()
#print linked_list
print((str(linked_list)))
if __name__ == "__main__":
main() | class Node(object):
def __init__(self, num, prv = None, nxt = None):
self.num = num
self.prv = prv
self.nxt = nxt
class DoublyLinkedList(object):
def __init__(self):
self.start = self.last = None
def insert(self, num):
new_elem = Node(num)
if self.start is None:
self.start = self.last = new_elem
else:
new_elem.nxt = self.start
self.start.prv = new_elem
self.start = new_elem
def delete_num(self, target):
it = self.start
while it is not None:
if it.num == target:
if it.prv is None and it.nxt is None:
self.start = self.last = None
else:
if it.prv is not None:
it.prv.nxt = it.nxt
else:
self.start = self.start.nxt
if it.nxt is not None:
it.nxt.prv = it.prv
else:
self.last = self.last.prv
break
it = it.nxt
def delete_start(self):
if self.start is self.last:
self.start = self.last = None
else:
self.start.nxt.prv = None
self.start = self.start.nxt
def delete_last(self):
if self.start is self.last:
self.start = self.last = None
else:
self.last.prv.nxt = None
self.last = self.last.prv
def get_content(self):
ret = []
it = self.start
while it is not None:
ret.append(it.num)
it = it.nxt
return ' '.join(ret)
def _main():
from sys import stdin
n = int(eval(input()))
lst = DoublyLinkedList()
for _ in range(n):
cmd = stdin.readline().strip().split()
if cmd[0] == 'insert':
lst.insert(cmd[1])
elif cmd[0] == 'delete':
lst.delete_num(cmd[1])
elif cmd[0] == 'deleteFirst':
lst.delete_start()
elif cmd[0] == 'deleteLast':
lst.delete_last()
print((lst.get_content()))
if __name__ == '__main__':
_main() | p02265 |
from collections import deque
n = int(input())
d = deque()
for _i in range(n):
line = input().split()
order = line[0]
if order in ('insert', 'delete'):
key = int(line[1])
if order == 'insert':
d.appendleft(key)
elif order == 'delete':
try:
d.remove(key)
except ValueError:
pass
elif order == 'deleteFirst':
d.popleft()
elif order == 'deleteLast':
d.pop()
else:
raise ValueError('Invalid order: {order}')
i = 0
while True:
try:
if i == 0:
print(d.popleft(), end='')
else:
print(f' {d.popleft()}', end='')
i += 1
except IndexError:
break
print()
| from collections import deque
n = int(eval(input()))
d = deque()
for _i in range(n):
line = input().split()
order = line[0]
if order in ('insert', 'delete'):
key = line[1]
if order == 'insert':
d.appendleft(key)
elif order == 'delete':
try:
d.remove(key)
except ValueError:
pass
elif order == 'deleteFirst':
d.popleft()
elif order == 'deleteLast':
d.pop()
else:
raise ValueError('Invalid order: {order}')
print((' '.join(d)))
| p02265 |
from collections import deque
n = int(eval(input()))
d = deque()
for _i in range(n):
line = input().split()
order = line[0]
if order in ('insert', 'delete'):
key = line[1]
if order == 'insert':
d.appendleft(key)
elif order == 'delete':
try:
d.remove(key)
except ValueError:
pass
elif order == 'deleteFirst':
d.popleft()
elif order == 'deleteLast':
d.pop()
else:
raise ValueError('Invalid order: {order}')
print((' '.join(d)))
| from collections import deque
n = int(eval(input()))
d = deque()
for _i in range(n):
line = input().split()
order = line[0]
if order == 'deleteFirst':
d.popleft()
elif order == 'deleteLast':
d.pop()
else:
key = line[1]
if order == 'insert':
d.appendleft(key)
elif order == 'delete':
try:
d.remove(key)
except ValueError:
pass
else:
raise ValueError('Invalid order: {order}')
print((' '.join(d)))
| p02265 |
def pr(data,next,head,tail):
i = head
while(1):
if i == -1:
print("")
break
print(data[i],end = "")
i = next[i]
if i != -1 :
print(" ",end = "")
def ins_f(data,next,prev,x,head,tail):
size = len(data)
if head != -1 :
data.append(x)
size += 1
next.append(head)
prev.append(-1)
prev[head] = size -1
head = size -1
else :
data.append(x)
size += 1
next.append(-1)
prev.append(-1)
tail = size-1
head = size-1
return head,tail
def dl(data,next,prev,x,head,tail):
i = head
while(1):
if data[i] == x:
if i == head:
head,tail = dl_f(next,prev,head,tail)
break
elif i == tail:
head,tail = dl_l(next,prev,head,tail)
break
else :
prev[next[i]] = prev[i]
next[prev[i]] = next[i]
break
elif i == tail:
break
i = next[i]
return head,tail
def dl_f(next,prev,head,tail):
if head == -1:
return head
elif next[head] == -1:
head = -1
tail = -1
else:
prev[next[head]] = -1
head = next[head]
return head,tail
def dl_l(next,prev,head,tail):
if tail == -1:
pass
elif prev[tail] == -1:
head = -1
tail = -1
else:
next[prev[tail]] = -1
tail = prev[tail]
return head,tail
n = int(input())
data = []
next = []
prev = []
head = -1
tail = -1
size = len(data)
for i in range(n):
x = input().split()
if x[0] == "insert":
head,tail = ins_f(data,next,prev,x[1],head,tail)
elif x[0] == "delete":
head,tail = dl(data,next,prev,x[1],head,tail)
elif x[0] == "deleteFirst":
head,tail = dl_f(next,prev,head,tail)
elif x[0] == "deleteLast":
head,tail = dl_l(next,prev,head,tail)
pr(data,next,head,tail)
| def pr(data,next,head,tail):
i = head
while(1):
if i == -1:
print("")
break
print(data[i],end = "")
i = next[i]
if i != -1 :
print(" ",end = "")
def ins_f(data,next,prev,x,head,tail):
size = len(data)
if head != -1 :
data.append(x)
size += 1
next.append(head)
prev.append(-1)
prev[head] = size -1
head = size -1
else :
data.append(x)
size += 1
next.append(-1)
prev.append(-1)
tail = size-1
head = size-1
return head,tail
def dl(data,next,prev,x,head,tail):
i = head
while(1):
if data[i] == x:
if i == head:
head,tail = dl_f(next,prev,head,tail)
break
elif i == tail:
head,tail = dl_l(next,prev,head,tail)
break
else :
prev[next[i]] = prev[i]
next[prev[i]] = next[i]
break
elif i == tail:
break
i = next[i]
return head,tail
def dl_f(next,prev,head,tail):
if head == -1:
return head
elif next[head] == -1:
head = -1
tail = -1
else:
prev[next[head]] = -1
head = next[head]
return head,tail
def dl_l(next,prev,head,tail):
if tail == -1:
pass
elif prev[tail] == -1:
head = -1
tail = -1
else:
next[prev[tail]] = -1
tail = prev[tail]
return head,tail
n = int(input())
data = []
next = []
prev = []
head = -1
tail = -1
size = len(data)
for i in range(n):
x = input()
l = len(x)
if x[0] == "i":
head,tail = ins_f(data,next,prev,x[7:],head,tail)
elif x[6] == " ":
head,tail = dl(data,next,prev,x[7:],head,tail)
elif l > 10:
head,tail = dl_f(next,prev,head,tail)
elif l > 6:
head,tail = dl_l(next,prev,head,tail)
pr(data,next,head,tail)
| p02265 |
from collections import deque
n = int(eval(input()))
output = deque()
for i in range(n):
li = input().split(' ')
if(li[0] == 'insert'):
output.appendleft(int(li[1]))
elif(li[0] == 'delete'):
try:
output.remove(int(li[1]))
except:
pass
elif(li[0] == 'deleteFirst'):
output.popleft()
elif(li[0] == 'deleteLast'):
output.pop()
str_l = [str(o) for o in output]
print((' '.join(str_l)))
| from collections import deque
n = int(eval(input()))
output = deque()
for i in range(n):
li = input().split(' ')
if(li[0] == 'insert'):
output.appendleft(li[1])
elif(li[0] == 'deleteFirst'):
output.popleft()
elif(li[0] == 'deleteLast'):
output.pop()
elif(li[0] == 'delete'):
try:
output.remove(li[1])
except:
pass
print((' '.join(output)))
| p02265 |
from collections import deque
def doubly_lined_list(n, A):
Q = deque()
for i in range(n):
if A[i][0] == 'insert':
Q.appendleft(A[i][1])
elif A[i][0] == 'delete':
try:
Q.remove(A[i][1])
except:
pass
elif A[i][0] == 'deleteFirst':
Q.popleft()
elif A[i][0] == 'deleteLast':
Q.pop()
print((' '.join(Q)))
if __name__ == '__main__':
n = int(eval(input()))
A = []
for i in range(n):
A.append(input().split())
doubly_lined_list(n, A) | import sys
from collections import deque
def doubly_lined_list():
n = int(eval(input()))
Q = deque()
for i in range(n):
line = sys.stdin.readline()
command = line.split()[0]
if command == 'insert':
Q.appendleft(line.split()[1])
elif command == 'delete':
try:
Q.remove(line.split()[1])
except:
pass
elif command == 'deleteFirst':
Q.popleft()
elif command == 'deleteLast':
Q.pop()
print((' '.join(Q)))
if __name__ == '__main__':
doubly_lined_list() | p02265 |
#coding:utf-8
#1_3_C
from collections import deque
n = int(eval(input()))
ary = deque()
for i in range(n):
cmd = input().split()
if cmd[0] == "insert":
ary.appendleft(cmd[1])
elif cmd[0] == "delete":
try:
ary.remove(cmd[1])
except ValueError:
pass
elif cmd[0] == "deleteFirst":
ary.popleft()
elif cmd[0] == "deleteLast":
ary.pop()
print((" ".join(ary))) | #coding:utf-8
#1_3_C
from collections import deque
n = int(eval(input()))
q = deque()
for i in range(n):
cmd = input().split()
if cmd[0] == "insert":
q.appendleft(cmd[1])
elif cmd[0] == "delete":
try:
q.remove(cmd[1])
except ValueError:
pass
elif cmd[0] == "deleteFirst":
q.popleft()
elif cmd[0] == "deleteLast":
q.pop()
print((" ".join(q))) | p02265 |
class LinkedList(object):
def __init__(self):
self.nodes = []
self.first = None
self.last = None
def insert(self, key):
node = {'key':key, 'next':None, 'prev':None}
if not self.nodes:
self.first = self.last = node
self.nodes.append(node)
else:
node['next'] = self.first
self.first['prev'] = node
self.first = node
self.nodes.append(node)
def delete(self, key):
node = self.first
if len(self.nodes) == 1 and node['key'] == key:
self.first = self.last = None
self.nodes = []
return
if self.first['key'] == key:
self.deleteFirst()
return
while node['next']:
if node['key'] == key:
node['prev']['next'] = node['next']
node['next']['prev'] = node['prev']
self.nodes.remove(node)
return
node = node['next']
if self.last['key'] == key:
self.deleteLast()
def deleteFirst(self):
if len(self.nodes) == 1:
self.first = self.last = None
self.nodes = []
else:
self.first['next']['prev'] = None
self.nodes.remove(self.first)
self.first = self.first['next']
def deleteLast(self):
if len(self.nodes) == 1:
self.first = self.last = None
self.nodes = []
else:
self.last['prev']['next'] = None
self.nodes.remove(self.last)
self.last = self.last['prev']
def show(self):
if not self.nodes:
print('')
return
node = self.first
res = [node['key']]
while node['next']:
node = node['next']
res.append(node['key'])
print((' '.join(res)))
def run():
n = int(eval(input()))
linked_list = LinkedList()
for _ in range(n):
order = [o.strip() for o in input().split()]
if order[0] == 'insert':
linked_list.insert(order[1])
elif order[0] == 'delete':
linked_list.delete(order[1])
elif order[0] == 'deleteFirst':
linked_list.deleteFirst()
elif order[0] == 'deleteLast':
linked_list.deleteLast()
linked_list.show()
if __name__ == '__main__':
run()
| class LinkedList(object):
def __init__(self):
self.first = None
self.last = None
def insert(self, key):
node = {'key':key, 'next':None, 'prev':None}
if not self.first:
self.first = self.last = node
else:
node['next'] = self.first
self.first['prev'] = node
self.first = node
def delete(self, key):
node = self.first
if self.first['key'] == key:
self.deleteFirst()
return
while node['next']:
if node['key'] == key:
node['prev']['next'] = node['next']
node['next']['prev'] = node['prev']
return
node = node['next']
if self.last['key'] == key:
self.deleteLast()
def deleteFirst(self):
if self.first == self.last:
self.first = self.last = None
else:
self.first['next']['prev'] = None
self.first = self.first['next']
def deleteLast(self):
if self.first == self.last:
self.first = self.last = None
else:
self.last['prev']['next'] = None
self.last = self.last['prev']
def show(self):
if not self.first:
print('')
return
node = self.first
res = [node['key']]
while node['next']:
node = node['next']
res.append(node['key'])
print((' '.join(res)))
def run():
n = int(eval(input()))
linked_list = LinkedList()
for _ in range(n):
order = [o.strip() for o in input().split()]
if order[0] == 'insert':
linked_list.insert(order[1])
elif order[0] == 'delete':
linked_list.delete(order[1])
elif order[0] == 'deleteFirst':
linked_list.deleteFirst()
elif order[0] == 'deleteLast':
linked_list.deleteLast()
linked_list.show()
if __name__ == '__main__':
run()
| p02265 |
class LinkedList(object):
def __init__(self):
self.first = None
self.last = None
def insert(self, key):
node = {'key':key, 'next':None, 'prev':None}
if not self.first:
self.first = self.last = node
else:
node['next'] = self.first
self.first['prev'] = node
self.first = node
def delete(self, key):
node = self.first
if self.first['key'] == key:
self.deleteFirst()
return
while node['next']:
if node['key'] == key:
node['prev']['next'] = node['next']
node['next']['prev'] = node['prev']
return
node = node['next']
if self.last['key'] == key:
self.deleteLast()
def deleteFirst(self):
if self.first == self.last:
self.first = self.last = None
else:
self.first['next']['prev'] = None
self.first = self.first['next']
def deleteLast(self):
if self.first == self.last:
self.first = self.last = None
else:
self.last['prev']['next'] = None
self.last = self.last['prev']
def show(self):
if not self.first:
print('')
return
node = self.first
res = [node['key']]
while node['next']:
node = node['next']
res.append(node['key'])
print((' '.join(res)))
def run():
n = int(eval(input()))
linked_list = LinkedList()
for _ in range(n):
order = [o.strip() for o in input().split()]
if order[0] == 'insert':
linked_list.insert(order[1])
elif order[0] == 'delete':
linked_list.delete(order[1])
elif order[0] == 'deleteFirst':
linked_list.deleteFirst()
elif order[0] == 'deleteLast':
linked_list.deleteLast()
linked_list.show()
if __name__ == '__main__':
run()
| class LinkedList(object):
def __init__(self):
self.first = None
self.last = None
def insert(self, key):
node = {'key':key, 'next':None, 'prev':None}
if not self.first:
self.first = self.last = node
else:
node['next'] = self.first
self.first['prev'] = node
self.first = node
def delete(self, key):
node = self.first
if self.first['key'] == key:
self.deleteFirst()
return
while node['next']:
if node['key'] == key:
node['prev']['next'] = node['next']
node['next']['prev'] = node['prev']
return
node = node['next']
if self.last['key'] == key:
self.deleteLast()
def deleteFirst(self):
if self.first == self.last:
self.first = self.last = None
else:
self.first['next']['prev'] = None
self.first = self.first['next']
def deleteLast(self):
if self.first == self.last:
self.first = self.last = None
else:
self.last['prev']['next'] = None
self.last = self.last['prev']
def show(self):
if not self.first:
print('')
return
node = self.first
res = [node['key']]
while node['next']:
node = node['next']
res.append(node['key'])
print((' '.join(res)))
def run():
n = int(eval(input()))
linked_list = LinkedList()
for _ in range(n):
order = input().split()
if order[0] == 'insert':
linked_list.insert(order[1])
elif order[0] == 'delete':
linked_list.delete(order[1])
elif order[0] == 'deleteFirst':
linked_list.deleteFirst()
elif order[0] == 'deleteLast':
linked_list.deleteLast()
linked_list.show()
if __name__ == '__main__':
run()
| p02265 |
# 2019-11-23 01:28:44(JST)
import sys
from string import ascii_lowercase as alphabet
def main():
n, s, k = sys.stdin.read().split()
n, k = list(map(int, [n, k]))
c = s[k-1]
for l in alphabet:
if l != c:
s = s.replace(l, '*')
print(s)
if __name__ == '__main__':
main()
| # 2019-11-23 01:28:44(JST)
import sys
def main():
n, s, k = sys.stdin.read().split()
n, k = list(map(int, [n, k]))
c = s[k-1]
letters = set(s) - set(c)
for l in letters:
s = s.replace(l, '*')
print(s)
if __name__ == '__main__':
main()
| p03068 |
from operator import itemgetter
n,q=list(map(int,input().split()))
c=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(q)]
for i in range(q):
l[i].append(i)
l2=sorted(l,key=itemgetter(1))
L=[-1]*(5*10**5+1)
class Bit:
def __init__(self,n):
self.size=n
self.tree=[0]*(n + 1)
self.depth=n.bit_length()
def sum(self,i):
s=0
while i>0:
s+=self.tree[i]
i-=i&-i
return s
def add(self,i,x):
while i<=self.size:
self.tree[i]+=x
i+=i&-i
BIT=Bit(n+1)
ans=[0]*q
ct=0
for i in range(q):
while ct<=l2[i][1]:
if L[c[ct-1]-1]!=-1:
BIT.add(L[c[ct-1]-1],-1)
L[c[ct-1]-1]=ct+1
BIT.add(ct+1,1)
ct+=1
ans[l2[i][2]]=BIT.sum(l2[i][1]+1)-BIT.sum(l2[i][0])
for i in range(q):
print((ans[i])) | n,q=list(map(int,input().split()))
c=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(q)]
for i in range(q):
l[i].append(i)
l2=sorted(l,key=lambda x:x[1])
L=[-1]*(5*10**5+1)
class Bit:
def __init__(self,n):
self.size=n
self.tree=[0]*(n + 1)
self.depth=n.bit_length()
def sum(self,i):
s=0
while i>0:
s+=self.tree[i]
i-=i&-i
return s
def add(self,i,x):
while i<=self.size:
self.tree[i]+=x
i+=i&-i
BIT=Bit(n+1)
ans=[0]*q
ct=0
for i in range(q):
while ct<=l2[i][1]:
if L[c[ct-1]-1]!=-1:
BIT.add(L[c[ct-1]-1],-1)
L[c[ct-1]-1]=ct+1
BIT.add(ct+1,1)
ct+=1
ans[l2[i][2]]=BIT.sum(l2[i][1]+1)-BIT.sum(l2[i][0])
for i in range(q):
print((ans[i])) | p02599 |
n,q=list(map(int,input().split()))
c=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(q)]
for i in range(q):
l[i].append(i)
l2=sorted(l,key=lambda x:x[1])
L=[-1]*(5*10**5+1)
class Bit:
def __init__(self,n):
self.size=n
self.tree=[0]*(n + 1)
self.depth=n.bit_length()
def sum(self,i):
s=0
while i>0:
s+=self.tree[i]
i-=i&-i
return s
def add(self,i,x):
while i<=self.size:
self.tree[i]+=x
i+=i&-i
BIT=Bit(n+1)
ans=[0]*q
ct=0
for i in range(q):
while ct<=l2[i][1]:
if L[c[ct-1]-1]!=-1:
BIT.add(L[c[ct-1]-1],-1)
L[c[ct-1]-1]=ct+1
BIT.add(ct+1,1)
ct+=1
ans[l2[i][2]]=BIT.sum(l2[i][1]+1)-BIT.sum(l2[i][0])
for i in range(q):
print((ans[i])) | n,q=list(map(int,input().split()))
c=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(q)]
for i in range(q):
l[i].append(i)
l.sort(key=lambda x:x[1])
L=[-1]*(5*10**5+1)
class Bit:
def __init__(self,n):
self.size=n
self.tree=[0]*(n + 1)
self.depth=n.bit_length()
def sum(self,i):
s=0
while i>0:
s+=self.tree[i]
i-=i&-i
return s
def add(self,i,x):
while i<=self.size:
self.tree[i]+=x
i+=i&-i
BIT=Bit(n+1)
ans=[0]*q
ct=0
for i in range(q):
while ct<=l[i][1]:
if L[c[ct-1]-1]!=-1:
BIT.add(L[c[ct-1]-1],-1)
L[c[ct-1]-1]=ct+1
BIT.add(ct+1,1)
ct+=1
ans[l[i][2]]=BIT.sum(l[i][1]+1)-BIT.sum(l[i][0])
for i in range(q):
print((ans[i])) | p02599 |
import sys
input=sys.stdin.readline
from operator import itemgetter
n,q=list(map(int,input().split()))
c=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(q)]
for i in range(q):
l[i].append(i)
l.sort(key=lambda x:x[1])
L=[-1]*(5*10**5+1)
class Bit:
def __init__(self,n):
self.size=n
self.tree=[0]*(n + 1)
self.depth=n.bit_length()
def sum(self,i):
s=0
while i>0:
s+=self.tree[i]
i-=i&-i
return s
def add(self,i,x):
while i<=self.size:
self.tree[i]+=x
i+=i&-i
BIT=Bit(n+1)
ans=[0]*q
ct=0
for i in range(q):
while ct<=l[i][1]:
if L[c[ct-1]-1]!=-1:
BIT.add(L[c[ct-1]-1],-1)
L[c[ct-1]-1]=ct+1
BIT.add(ct+1,1)
ct+=1
ans[l[i][2]]=BIT.sum(l[i][1]+1)-BIT.sum(l[i][0])
for i in ans:
print(i) | import sys
input=sys.stdin.readline
n,q=list(map(int,input().split()))
c=list(map(int,input().split()))
l=[]
for i in range(q):
L,R=list(map(int,input().split()))
l.append([L,R,i])
l.sort(key=lambda x:x[1])
L=[-1]*(5*10**5+1)
class Bit:
def __init__(self,n):
self.size=n
self.tree=[0]*(n + 1)
self.depth=n.bit_length()
def sum(self,i):
s=0
while i>0:
s+=self.tree[i]
i-=i&-i
return s
def add(self,i,x):
while i<=self.size:
self.tree[i]+=x
i+=i&-i
BIT=Bit(n+1)
ans=[0]*q
ct=0
for i in range(q):
while ct<=l[i][1]:
if L[c[ct-1]-1]!=-1:
BIT.add(L[c[ct-1]-1],-1)
L[c[ct-1]-1]=ct+1
BIT.add(ct+1,1)
ct+=1
ans[l[i][2]]=BIT.sum(l[i][1]+1)-BIT.sum(l[i][0])
for i in range(q):
print((ans[i])) | p02599 |
import sys
input=sys.stdin.readline
n,q=list(map(int,input().split()))
c=list(map(int,input().split()))
l=[]
for i in range(q):
L,R=list(map(int,input().split()))
l.append([L,R,i])
l.sort(key=lambda x:x[1])
L=[-1]*(5*10**5+1)
class Bit:
def __init__(self,n):
self.size=n
self.tree=[0]*(n + 1)
self.depth=n.bit_length()
def sum(self,i):
s=0
while i>0:
s+=self.tree[i]
i-=i&-i
return s
def add(self,i,x):
while i<=self.size:
self.tree[i]+=x
i+=i&-i
BIT=Bit(n+1)
ans=[0]*q
ct=0
for i,j,k in l:
while ct<=j:
if L[c[ct-1]-1]!=-1:
BIT.add(L[c[ct-1]-1],-1)
L[c[ct-1]-1]=ct+1
BIT.add(ct+1,1)
ct+=1
ans[k]=BIT.sum(j+1)-BIT.sum(i)
for i in ans:
print(i) | import sys
input=sys.stdin.readline
n,q=list(map(int,input().split()))
c=list(map(int,input().split()))
l=[]
for i in range(q):
L,R=list(map(int,input().split()))
l.append([L,R,i])
l.sort(key=lambda x:x[1])
L=[-1]*(5*10**5+1)
class Bit:
def __init__(self,n):
self.size=n
self.tree=[0]*(n + 1)
self.depth=n.bit_length()
def sum(self,i):
s=0
while i>0:
s+=self.tree[i]
i-=i&-i
return s
def add(self,i,x):
while i<=self.size:
self.tree[i]+=x
i+=i&-i
BIT=Bit(n+1)
ans=[0]*q
ct=0
for i in range(q):
while ct<=l[i][1]:
if L[c[ct-1]-1]!=-1:
BIT.add(L[c[ct-1]-1],-1)
L[c[ct-1]-1]=ct+1
BIT.add(ct+1,1)
ct+=1
ans[l[i][2]]=BIT.sum(l[i][1]+1)-BIT.sum(l[i][0])
for i in range(q):
print((ans[i])) | p02599 |
from dataclasses import dataclass
class BIT:
'''
All methods use 0-based index while the implementation use 1-based index
'''
def __init__(self, N, val=0):
self.data = [val] * (N + 1)
self.N = N
def add_at(self, idx, val):
i = idx + 1
while i <= self.N:
self.data[i] += val
i += i & (-i)
def sum_to(self, idx):
res = 0
i = idx + 1
while i > 0:
res += self.data[i]
i -= i & (-i)
return res
def sum_in(self, l, r): # [l, r]
return self.sum_to(r) - self.sum_to(l - 1)
@dataclass
class Query:
i: int
l: int
r: int
N, Q = list(map(int, input().split()))
C = list(map(int, input().split()))
queries = [[] for _ in range(N)]
for i in range(Q):
l, r = list(map(int, input().split()))
l, r = l - 1, r - 1
queries[r].append(Query(i, l, r))
V = max(C)
bit = BIT(N)
last = [-1] * (max(C) + 1)
query_idx = 0
ans = [-1] * Q
for i, c in enumerate(C):
if last[c] != -1:
bit.add_at(last[c], -1)
bit.add_at(i, +1)
last[c] = i
for q in queries[i]:
ans[q.i] = bit.sum_in(q.l, q.r)
print(('\n'.join(map(str, ans)))) |
class BIT:
'''
All methods use 0-based index while the implementation use 1-based index
'''
def __init__(self, N, val=0):
self.data = [val] * (N + 1)
self.N = N
def add_at(self, idx, val):
i = idx + 1
while i <= self.N:
self.data[i] += val
i += i & (-i)
def sum_to(self, idx):
res = 0
i = idx + 1
while i > 0:
res += self.data[i]
i -= i & (-i)
return res
def sum_in(self, l, r): # [l, r]
return self.sum_to(r) - self.sum_to(l - 1)
class Query:
def __init__(self, i, l, r):
self.i = i
self.l = l
self.r = r
N, Q = list(map(int, input().split()))
C = list(map(int, input().split()))
queries = [[] for _ in range(N)]
for i in range(Q):
l, r = list(map(int, input().split()))
l, r = l - 1, r - 1
queries[r].append(Query(i, l, r))
bit = BIT(N)
last = [-1] * (max(C) + 1)
query_idx = 0
ans = [-1] * Q
for i, c in enumerate(C):
if last[c] != -1:
bit.add_at(last[c], -1)
bit.add_at(i, +1)
last[c] = i
for q in queries[i]:
ans[q.i] = bit.sum_in(q.l, q.r)
print(('\n'.join(map(str, ans)))) | p02599 |
import sys
input = sys.stdin.readline
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(n+1)
self.value = [0]*(n+1)
def summarize(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.value[i] += x
while i <= self.n:
self.bit[i] += x
i += i & -i
def init(self, n, lis):
self.n = n
self.bit = [0]*(n+1)
self.value = lis
for i in range(n):
self.add(i, lis[i])
def get_value(self, i):
return self.value[i]
def get_sum(self, i, j):
return self.summarize(j) - self.summarize(i)
def main():
n, q = list(map(int, input().split()))
c = [int(x) for x in input().split()]
judge = dict()
key = [-1]*n
for i in range(n):
if c[i] in judge:
key[i] = judge[c[i]]
judge[c[i]] = i
query = [None]*q
for i in range(q):
l, r = list(map(int, input().split()))
query[i] = (r-1, l-1, i)
query.sort()
bit = BIT(n)
ans = [0]*q
index = 0
for i in range(n):
bit.add(i+1, 1)
if key[i] != -1:
bit.add(key[i]+1, -1)
while True:
if index == q:
break
r, l = query[index][0], query[index][1]
if r == i:
ans[query[index][2]] = bit.get_sum(l, r+1)
index += 1
else:
break
if index == q:
break
for v in ans:
print(v)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(n+1)
self.value = [0]*(n+1)
def summarize(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.value[i] += x
while i <= self.n:
self.bit[i] += x
i += i & -i
def init(self, n, lis):
self.n = n
self.bit = [0]*(n+1)
self.value = lis
for i in range(n):
self.add(i, lis[i])
def get_value(self, i):
return self.value[i]
def get_sum(self, i, j):
return self.summarize(j) - self.summarize(i)
def main():
n, q = list(map(int, input().split()))
c = [int(x) for x in input().split()]
judge = dict()
key = [-1]*n
for i in range(n):
if c[i] in judge:
key[i] = judge[c[i]]
judge[c[i]] = i
query = [None]*q
for i in range(q):
l, r = list(map(int, input().split()))
query[i] = (r-1, l-1, i)
query.sort()
bit = BIT(n)
ans = [0]*q
index = 0
count = 0
for i in range(n):
if key[i] != -1:
count += 1
bit.add(key[i]+1, 1)
while True:
if index == q:
break
r, l, c = query[index]
if r == i:
ans[c] = r-l+1-count+bit.summarize(l)
index += 1
else:
break
if index == q:
break
for v in ans:
print(v)
if __name__ == "__main__":
main()
| p02599 |
from collections import Counter
from operator import add
class SegmentTree():
def __init__(self, iterable, func, e):
self.func = func
self.e = e
ls = list(iterable)
self.n = 1 << len(ls).bit_length()
ls.extend( [self.e] * (self.n - len(ls)) )
self.data = [self.e] * self.n + ls
for i in range(self.n-1, 0, -1):
self.data[i] = self.func(self.data[2*i], self.data[2*i+1])
def replace(self, index, value):
index += self.n
self.data[index] = value
index //= 2
while index > 0:
self.data[index] = self.func(self.data[2*index], self.data[2*index+1])
index //= 2
def folded(self, l, r):
left_folded = self.e
right_folded = self.e
l += self.n
r += self.n
while l < r:
if l % 2:
left_folded = self.func(left_folded, self.data[l])
l += 1
if r % 2:
r -= 1
right_folded = self.func(self.data[r], right_folded)
l //= 2
r //= 2
return self.func(left_folded, right_folded)
N, Q = list(map(int, input().split()))
cs = list(map(int, input().split()))
lrs = [tuple(map(int, input().split())) for _ in range(Q)]
to_consider = []
for c, n in list(Counter(cs).items()):
if n >= 2:
to_consider.append(c)
sets = SegmentTree([Counter([e]) if e in to_consider else Counter() for e in cs], add, Counter())
for l, r in lrs:
ans = r - l + 1
for k, v in list(sets.folded(l-1, r).items()):
ans -= (v - 1)
print(ans)
| from operator import add
class BIT():
def __init__(self, length_or_list, func, e):
self.func = func
self.e = e
if isinstance(length_or_list, int):
self.n = length_or_list + 1
self.data = [self.e] * self.n
else:
self.n = len(length_or_list) + 1
self.data = [self.e] + length_or_list
for i in range(1, self.n):
self.data[i + (i & -i)] = self.func(self.data[i + (i & -i)], self.data[i])
def point_append(self, index, delta):
index += 1
while index < self.n:
self.data[index] = self.func(self.data[index], delta)
index += index & -index
def prefix_folded(self, end):
res = 0
while end > 0:
res = self.func(res, self.data[end])
end -= end & -end
return res
N, Q = map(int, input().split())
cs = list(map(int, input().split()))
lrs = [tuple(map(int, input().split())) for _ in range(Q)]
#クエリを終了位置rでソート。
ilrs = [(i, l-1, r-1) for i, (l, r) in enumerate(lrs)]
ilrs.sort(key = lambda t: t[2])
#重複を区間としてし、終了位置でソートされた状態で列挙。
duplicates = []
indices = [-1 for _ in range(N+1)]
for i, c in enumerate(cs):
if indices[c] != -1:
duplicates.append((indices[c], i))
indices[c] = i
#あとは平面走査と呼ばれる探査
ilrs.reverse()
duplicates.reverse()
starts = BIT(N, add, 0)
ans = [-1] * Q
for i in range(N):
if duplicates and duplicates[-1][1] == i:
dupstart, _ = duplicates.pop()
starts.point_append(dupstart, 1)
while ilrs[-1][2] == i:
ans_i, l, r = ilrs.pop()
ans[ans_i] = (r - l + 1) - (starts.prefix_folded(r + 1) - starts.prefix_folded(l))
if not ilrs:
break
else:
continue
break
print(*ans, sep = '\n')
| p02599 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.