input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
n = int(eval(input()))
ans = 0
for a in range(1, n+1):
b=1
while n-a*b>0:
ans += 1
b+=1
print(ans)
|
n = int(eval(input()))
ans = 0
for a in range(1, n+1):
b=1
while n>a*b:
ans += 1
b+=1
print(ans)
|
p02548
|
import sys, os, math, bisect, itertools, collections, heapq, queue, copy, array
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
INF = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
ret = 0
for a in range(1, N):
b = N // a
if N - (a * b) <= 0:
ret += b - 1
else:
ret += b
print(ret)
if __name__ == '__main__':
main()
|
import sys
import os
import math
import bisect
import itertools
import collections
import heapq
import queue
import array
# 時々使う
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque
# 再帰の制限設定
sys.setrecursionlimit(10000000)
def ii(): return int(sys.stdin.buffer.readline().rstrip())
def il(): return list(map(int, sys.stdin.buffer.readline().split()))
def fl(): return list(map(float, sys.stdin.buffer.readline().split()))
def iln(n): return [int(sys.stdin.buffer.readline().rstrip())
for _ in range(n)]
def iss(): return sys.stdin.buffer.readline().decode().rstrip()
def sl(): return list(map(str, sys.stdin.buffer.readline().decode().split()))
def isn(n): return [sys.stdin.buffer.readline().decode().rstrip()
for _ in range(n)]
def lcm(x, y): return (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
INF = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
ret = 0
for i in range(1, N):
ret += (N - 1) // i
print(ret)
if __name__ == '__main__':
main()
|
p02548
|
N = int(eval(input()))
ans = 0
for i in range(1, N):
if N % i == 0:
ans += (N // i) - 1
else:
ans += N // i
print(ans)
|
N = int(eval(input()))
ans = 0
for i in range(1, N):
ans += (N-1) // i
print(ans)
|
p02548
|
N=int(eval(input()))
ans=0
for i in range(1,N):
if N%i!=0:
for j in range(1,N//i+1):
a=i*j+N-i*j
if a==N:
ans+=1
else:
for j in range(1,N//i):
a=i*j+N-i*j
if a==N:
ans+=1
print(ans)
|
N=int(eval(input()))
ans=0
for i in range(1,N):
if N%i!=0:
for j in range(1,N//i+1):
ans+=1
else:
for j in range(1,N//i):
ans+=1
print(ans)
|
p02548
|
n = int(eval(input()))
count = 0
for a in range(1,n):
for b in range(1,n):
if a*b<n:
count+=1
else:
break
print(count)
|
n = int(eval(input()))
count = 0
for a in range(1,n):
if n%a==0:
b = n//a - 1
else:
b = n//a
count+=b
print(count)
|
p02548
|
n = int(eval(input()))
ans = 0
for a in range(1, n):
for b in range(1, n):
if a * b < n:
ans += 1
else:
break
print(ans)
|
n = int(eval(input()))
print((sum((n - 1) // a for a in range(1, n))))
|
p02548
|
n=int(eval(input()))
count=0
for i in range(1,n):
wan=n//i
for j in range(1,wan+1):
charo=i*j
if charo>=n:
break
else:
count+=1
else:
continue
print(count)
|
n=int(eval(input()))
count=0
for i in range(1,n):
if i>=n/2:
count+=1
continue
else:
syou,amari=divmod(n,i)
if amari==0:
count+=syou-1
else:
count+=syou
print(count)
|
p02548
|
a = int(eval(input()))
cnt = 1
count =0
for i in range(1,a):
for j in range(1,a):
c = i*j
num = a-c
if num >0:
count +=1
else:
break
print(count)
|
a = int(eval(input()))
cnt = 1
count =0
for i in range(1,a):
for j in range(1,a):
if a>i*j:
count +=1
else:
break
print(count)
|
p02548
|
n = int(eval(input()))
ans = 0
for i in range(1, n):
for j in range(1, (n - 1) // i + 1):
if i * j <= n - 1:
ans += 1
print(ans)
|
n = int(eval(input()))
ans = 0
for i in range(1, n):
ans += (n - 1) // i
print(ans)
|
p02548
|
N = int(eval(input()))
count = 0
for A in range(1,N):
for B in range(1,int(N/A)+1+1):
if N - A * B >= 1:
count += 1
print(count)
|
N = int(eval(input()))
count = 0
for A in range(1,int((N)**0.5)+2):
for B in range(A,int((N)/A)+2):
if A*B < N:
count += 1
if A != B:
count += 1
print(count)
|
p02548
|
from bisect import bisect_right
N = int(eval(input()))
num = [i for i in range(1, N)]
cnt = 0
for a in range(1, N):
n = (N - 1) // a
b = bisect_right(num, n)
cnt += b
print(cnt)
|
N = int(eval(input()))
cnt = 0
for a in range(1, N):
n = (N - 1) // a
cnt += n
print(cnt)
|
p02548
|
N = int(eval(input()))
ans = 0
i = 1
while i < N:
j = 1
while i*j < N:
ans += 1
j += 1
i+= 1
print(ans)
|
N = int(eval(input()))
ans = 0
i = 1
while i**2 < N:
j = i
while i*j < N:
if i == j:
ans += 1
else:
ans += 2
j += 1
i+= 1
print(ans)
|
p02548
|
import itertools
N = int(eval(input()))
ans = 0
for a in range(2,N - 1):
for b in range(2,N - 1):
if a * b < N:
ans += 1
elif a * b >= N:
break
print((ans + ((N - 1) * 2 - 1)))
|
import math
N = int(eval(input()))
ans = 0
for a in range(1,N):
ans = ans + math.floor((N - 1)/a)
print(ans)
|
p02548
|
n = int(eval(input()))
ans = 0
for a in range(1, n):
for b in range(1, n):
if a * b < n:
ans += 1
else:
break
print(ans)
|
n = int(eval(input()))
ans = 0
for a in range(1, n):
ans += (n - 1) // a
print(ans)
|
p02548
|
n = int(eval(input()))
ans = 0
for a in range(1, n+1):
for b in range(1, n+1):
if a*b < n:
ans += 1
else:
break
print(ans)
|
n = int(eval(input()))
ans = 0
for a in range(1, n+1):
ans += (n-1)//a
print(ans)
|
p02548
|
N = int(eval(input()))
count = 0
for i in range(N - 1):
A = i + 1
for j in range(N-1):
B = j + 1
if A * B < N:
count += 1
else:
break
print(count)
|
N = int(eval(input()))
count = 0
for i in range(N - 1):
A = i + 1
B = N / A
if B == int(B):
count += B-1
else:
count += int(B)
print((int(count)))
|
p02548
|
N = int(eval(input()))
counter = 0
for A in range(1,N):
for B in range(1,N//A+1):
if 0< N - A*B:
counter += 1
print(counter)
|
N = int(eval(input()))
counter = 0
for A in range(1,N):
for B in range(1,N//A+1):
if 0 < A*B < N:
counter += 1
print(counter)
|
p02548
|
n = int(eval(input()))
count = 0
for a in range(1,n+1):
for b in range(1,(n//a)+1):
if n-b*a > 0:
count += 1
print(count)
|
n = int(eval(input()))
count = 0
for a in range(1,n):
count += (n-1)//a
print(count)
|
p02548
|
N = int(eval(input()))
cnt = 0
for A in range(1, N):
for B in range(1, N // A + 1):
if A * B < N:
cnt += 1
print(cnt)
|
N = int(eval(input()))
cnt = 0
for A in range(1, N):
for B in range(1, (N - 1) // A + 1):
cnt += 1
print(cnt)
|
p02548
|
N=int(eval(input()))
c=0
for i in range(1,N+1):
for j in range(1,N+1):
if i*j<N:
c+=1
else:
break
print(c)
|
N=int(eval(input()))
c=0
for i in range(1,N+1):
d=(N-1)//i
c+=d
print(c)
|
p02548
|
n = int(eval(input()))
ans = 0
t = 0
J = 0
for i in range(1,n):
for j in range(i,n):
if i*j >= n:break
if i == j : t+=1
ans +=1
J = j
print((2*ans -t))
|
n = int(eval(input()))-1
ans = 0
t = 0
J = 0
for i in range(1,n+1): ans += n//(i)
print(ans)
|
p02548
|
N = int(eval(input()))
ans = 0
for i in range(1, N):
ans += (N - 1) // i
print(ans)
|
N = int(eval(input()))
ans = 0
for a in range(1, N):
ans += (N - 1) // a
print(ans)
|
p02548
|
N=int(eval(input()))
#A,B,C>0 C=N-A*B
count=(N-1)*2-1
for A in range(2,N):
for B in range(2,N):
if N-(A*B)<0:
break
elif N-(A*B)>0:
count+=1
# print(A,B,N-A*B)
print(count)
|
N=int(eval(input()))
count=0
for A in range(1,N):
count+=int((N-1)/A)
print(count)
|
p02548
|
N = int(eval(input()))
pair_list = []
ans = 0
for a in range(1, N+1):
b = 1
while (a*b < N):
ans += 1
b += 1
print(ans)
|
N = int(eval(input()))
ans = 0
for a in range(1, N+1):
if N%a==0:
b_max = int(N/a)-1
else:
b_max = int(N//a)
ans += b_max
print(ans)
|
p02548
|
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n = int(eval(input()))
ans = 0
for a in range(1,n):
if a ** 2 >= n:
break
for b in range(a,n):
if a * b >= n:
break
if a == b:
ans += 1
else:
ans += 2
print(ans)
if __name__=='__main__':
main()
|
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n = int(eval(input()))
ans = 0
for a in range(1,n):
ans += -(-n//a) - 1
print(ans)
if __name__=='__main__':
main()
|
p02548
|
n = int(eval(input()))
a = 0
b = 0
c = 0
while a < n:
a+=1
b=0
if a == n:
break
while a*b-n<0:
b+=1
if a*b-n>=0:
break
c+=1
print(c)
|
n = int(eval(input()))
a = 0
b = 0
c = 0
while a < n:
a+=1
if a == n:
break
if n%a == 0:
c+= n//a - 1
else:
c+= n//a
print(c)
|
p02548
|
n = int(eval(input()))
res=0
for i in range(1,n):
for j in range(1,n):
if i*j < n:
res+=1
else:
break
print(res)
|
from math import ceil
n = int(eval(input()))
res=0
for i in range(1,ceil(n/2)):
for j in range(i+1,n):
if i*j < n:
res+=1
else:
break
if int(n**0.5) == n**0.5:
print((res*2 + int(n**0.5) - 1))
else:
print((res*2 + int(n**0.5)))
|
p02548
|
N = int(eval(input()))
count = 0
for i in range(1, N):
for j in range(1, N):
if i * j < N:
count += 1
else:
break
print(count)
|
N = int(eval(input()))
count = 0
for i in range(1, N):
count += int(N / i)
if N % i == 0:
count -= 1
print(count)
|
p02548
|
N = int(eval(input()))
table = [0] * (N+5)
for i in range(1, N+3):
for j in range(i, N+2, i):
table[j] += 1
ans = 0
for i in range(N):
ans += table[i]
print(ans)
|
N = int(eval(input()))
ans = 0
for i in range(1, N):
ans += (N-1) // i
print(ans)
|
p02548
|
N=int(eval(input()))
result=0
for A in range(1,N):
for B in range(1,int(N/A)+1):
if (N-A*B)>=1:
result+=1
print(result)
|
N=int(eval(input()))
result=0
for A in range(1,N):
result+=int((N-1)/A)
print(result)
|
p02548
|
l = int(eval(input()))
sum = 0
c = 0
for i in range(1,l):
for ii in range(1,l):
sum = i * ii
if sum >= l:
break
else:
c+=1
print(c)
|
l = int(eval(input()))
sum = 0
c = 0
for i in range(1,l):
for ii in range(i,l):
sum = i * ii
if sum >= l:
break
else:
if i != ii:
c+=2
else:
c+=1
print(c)
|
p02548
|
N = int(eval(input()))
A = 1
B = 1
p = 0
while A < N:
while A * B < N:
p += 1
B += 1
A += 1
B = 1
print(p)
|
N = int(eval(input()))
A = 1
B = 1
d = 0
e = 0
while A < N:
while A * B < N:
if A == B:
e += 1
else:
d += 1
B += 1
A += 1
B = A
print((d*2+e))
|
p02548
|
# -*- coding: utf-8 -*-
N = int(eval(input()))
count = 0
for A in range(1,N):
for B in range(1,N):
if A*B >= N:
break
else:
count += 1
print(count)
|
# -*- coding: utf-8 -*-
N = int(eval(input()))
count = 0
for A in range(1,N):
if N % A == 0:
count += (N//A) - 1
else:
count += (N//A)
print(count)
|
p02548
|
n = int(eval(input()))
count = 0
for a in range(1,n):
for b in range(1,int(n/a)+1):
if n - a * b > 0:
count += 1
print(count)
|
n = int(eval(input()))
count = 0
for a in range(1,n):
count += (n-1)//a
print(count)
|
p02548
|
n = int(eval(input()))
ans = 0
for i in range(1, n):
ans += n//i if n%i != 0 else n//i-1
print(ans)
|
n = int(eval(input()))
ans = 0
for i in range(1, n):
ans += (n-1)//i
print(ans)
|
p02548
|
N=int(eval(input()))
a=1
b=1
count=0
while a<N:
while a*b<N:
count=count+1
b=b+1
else:
b=1
a=a+1
else:
print(count)
|
N=int(eval(input()))
a=1
count=0
while a<N:
count=count+(N-1)//a
a=a+1
else:
print(count)
|
p02548
|
z=int(eval(input()))
i=1
re=0
f=3
b=1
while z>i:
b=1
while True:
x=i*b
if z>x:
re+=1
else:
break
b+=1
i+=1
print(re)
|
z=int(eval(input()))
i=1
re=0
b=1
d=1
while z>i:
b=1
while True:
x=i*(i+b)
if z>x:
re+=2
else:
break
b+=1
i+=1
while True:
if d*d<z:
d+=1
re+=1
else:
break
print(re)
|
p02548
|
N = int(eval(input()))
cnt = 0
for a in range(1, N):
# print(f'{a=}, {N // a}')
if N % a == 0:
cnt += N // a - 1
else:
cnt += N // a
print(cnt)
|
N = int(eval(input()))
cnt = 0
for a in range(1, N):
# print(f'{a=}, {N // a}')
cnt += (N - 1) // a
print(cnt)
|
p02548
|
n=int(eval(input()))
ar=3
sv=[0]*(10**6+2)
for i in range(2,len(sv)):
if not sv[i]:
sv[i]=i
for j in range(2*i,len(sv),i):
sv[j]=i
def di(x):
an=1
if sv[x]==x:
return 2
while x>1:
ct=0;cr=sv[x]
while x%cr==0:
ct+=1;x//=cr
an*=(ct+1)
return an
for i in range(4,n+1):
ar=ar+di(i-1)
if n==2:
ar=1
print(ar)
|
n=int(eval(input()))
ar=0
for i in range(1,n+1):
ar+=(n-1)//i
print(ar)
|
p02548
|
n=int(eval(input()))
c=0
for i in range(1,n+1):
j=1
while j*i<n:
c+=1
j+=1
print(c)
|
n=int(eval(input()))
c=0
for i in range(1,n):
c+=(n-1)//i
print(c)
|
p02548
|
n = int(eval(input()))
ans = 0
for i in range(n):
a = i + 1
for j in range(n):
b = j + 1
c = n - a * b
if c <= 0:
break
ans += 1
print(ans)
|
import math
n = int(eval(input()))
ans = 0
for i in range(n):
a = i + 1
b = 1
c = n - a * b
ans += math.ceil(c / a)
print(ans)
|
p02548
|
N = int(eval(input()))
def count_comb(a, b):
if a == b:
return 1
else:
return 2
count = 0
for A in range(1, N):
for B in range(A, N):
seki = A*B
if seki > N-1:
break
count += count_comb(A, B)
print(count)
|
N = int(eval(input()))
count = 0
for A in range(1, N):
max_a = int((N-1)/A)
# AとBが同じものが1件あるので-1する
count += max_a
print(count)
|
p02548
|
N = int(eval(input()))
ct = 0
for a in range(1, N):
for b in range(1, N):
if a*b >= N:
break
ct += 1
print(ct)
|
N = int(eval(input()))
ct = 0
for i in range(1, N):
if i * i >= N:
break
x = int((N - 1)/i)
ct += (x - i)*2 + 1
print(ct)
|
p02548
|
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7
n=int(eval(input()))
cnt=0
for i in range(1,n+1):
for j in range(1,n+1):
if i*j<n:
cnt+=1
else:
break
print(cnt)
|
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7
n=int(eval(input()))
cnt=0
for i in range(1,n+1):
for j in range(i+1,n+1):
if i*j<n:
cnt+=2
else:
break
for j in range(1,n+1):
if j*j<n:
cnt+=1
print(cnt)
|
p02548
|
def c_a_times_b_plus_c():
N = int(eval(input()))
ans = 0
for a in range(1, N + 1):
for b in range(N // a, 0, -1):
if N - a * b >= 1:
ans += 1
return ans
print((c_a_times_b_plus_c()))
|
def c_a_times_b_plus_c():
N = int(eval(input()))
return sum((N - 1) // a for a in range(1, N))
print((c_a_times_b_plus_c()))
|
p02548
|
import math
t = 1
for tc in range(t):
n = int(eval(input()))
ans = 0
i = 1
while i < n:
j = 1
while i*j < n :
c = n - i*j
if c > 0:
ans += 1
j += 1
i += 1
print(ans)
|
import math
t = 1
for tc in range(t):
n = int(eval(input()))
ans = 0
for i in range(1,n+1):
j = 1
ans += (n-1) // i
# while i*j + 1 <= n:
# ans += 1
# j += 1
print(ans)
|
p02548
|
n=int(eval(input()))
point=0
for a in range(1, n):
b=1
while a*b<n:
b+=1
point+=1
print(point)
|
n = int(eval(input()))
ans = 0
for a in range(1, n):
ans += (n - 1) // a
print(ans)
|
p02548
|
N = int(eval(input()))
ans = 0
for a in range(1, N+1):
b = 1
while a * b < N:
ans += 1
b += 1
print(ans)
|
N = int(eval(input()))
ans = 0
for a in range(1, N+1):
x = N // a
if N % a == 0:
ans += x - 1
else:
ans += x
print(ans)
|
p02548
|
N=int(eval(input()))
ans=0
for i in range(1,10**6):
for j in range(1,(10**6)//i+1):
if N > i*j:
ans += 1
print(ans)
|
N=int(eval(input()))
ans=0
for i in range(1,10**6):
for j in range(i,10**6//i+1):
if N > i*j:
if i==j:
ans += 1
else:
ans += 2
print(ans)
|
p02548
|
n = int(eval(input()))
ans = 0
for a in range(1, n):
for b in range(1, n):
c = n - a * b
if c <= 0:
break
ans += 1
print(ans)
|
def func(x):
ans = 0
for a in range(1, n):
for b in range(1, n):
c = n - a * b
if c <= 0:
break
ans += 1
return ans
n = int(eval(input()))
print((func(n)))
|
p02548
|
n = int(eval(input()))
ans = 0
count = 0
a, b, c = 1, 1, 1
while a <= n:
# print("A : {0}".format(a))
while a * b < n:
# print("B : {0}".format(b))
ans += 1
# if c >= n - (a * b) :
# ans += 1
# while a * b + c <= n:
# # print("C : {0}".format(c))
# count += 1
# if a * b + c == n :
# ans += 1
# c += 1
b += 1
c = 1
a += 1
b, c = 1, 1
# print("計算実行回数 : {0}".format(count))
print(ans)
|
n = int(eval(input()))
ans = 0
count = 0
a, b, c = 1, 1, 1
while a <= n:
# print("A : {0}".format(a))
# print("追加パターン : {0}".format( (n // a) ))
if a == 1 :
ans = ans + ( (n // a) - 1)
else :
if n // a == 1 :
ans = ans + 1
else :
if n % a == 0 :
ans = ans + ( (n // a) - 1)
else :
ans = ans + ( (n // a) )
# if n % a == 0 :
# ans = ans + ( (n / a) - 1 )
# else :
# ans = ans + ( (n // a) - 1 )
# ans = ans + (n / a) - 1
# print("A : {0}".format(a))
# while a * b < n:
# print("B : {0}".format(b))
# ans += 1
# b += 1
# c = 1
a += 1
b, c = 1, 1
# print("計算実行回数 : {0}".format(count))
print((ans - 1))
|
p02548
|
n = int(eval(input()))
ans = 0
count = 0
a, b, c = 1, 1, 1
while a <= n:
# print("A : {0}".format(a))
# print("追加パターン : {0}".format( (n // a) ))
if a == 1 :
ans = ans + ( (n // a) - 1)
else :
if n // a == 1 :
ans = ans + 1
else :
if n % a == 0 :
ans = ans + ( (n // a) - 1)
else :
ans = ans + ( (n // a) )
# if n % a == 0 :
# ans = ans + ( (n / a) - 1 )
# else :
# ans = ans + ( (n // a) - 1 )
# ans = ans + (n / a) - 1
# print("A : {0}".format(a))
# while a * b < n:
# print("B : {0}".format(b))
# ans += 1
# b += 1
# c = 1
a += 1
b, c = 1, 1
# print("計算実行回数 : {0}".format(count))
print((ans - 1))
|
n = int(eval(input()))
ans = 0
a = 1
while a <= n:
if a == 1 :
ans = ans + (n - 1)
else :
if n % a == 0 :
ans = ans + ( (n // a) - 1)
else :
ans = ans + ( (n // a) )
a += 1
print(ans)
|
p02548
|
N = int(eval(input()))
result = 0
for i in range(1, N + 1):
s = int(N / i) + 1
for j in range(1, s + 1):
if N - i * j > 0:
result = result + 1
else:
break
print(result)
|
N = int(eval(input()))
result = 0
for i in range(1, N + 1):
s = int(N / i) + 1
for j in range(s + 1, 0, -1):
if N - i * j > 0:
result = result + j
break
print(result)
|
p02548
|
n = int(eval(input()))
ans = 0
for i in range(1, n):
for j in range(1, n):
if i*j >= n:
break
ans += 1
print(ans)
|
n = int(eval(input()))
ans = 0
for i in range(1, n):
for j in range(i, n):
if i*j >= n:
break
if i == j:
ans += 1
else:
ans += 2
print(ans)
|
p02548
|
n=int(eval(input()))
cnt=0
for i in range(1,n+1):
for j in range(1,n+1):
if i*j>=n:
break
else:
cnt+=1
print(cnt)
|
n = int(eval(input()))
ans = 0
for a in range(1, n):
ans += (n - 1) // a
print(ans)
|
p02548
|
def f(x):
return pow(x, 2)
while True:
try:
d = int(eval(input()))
except:
break
print((sum(f(x) * d for x in range(d, 600, d))))
|
while True:
try:
d = int(eval(input()))
except:
break
print((sum(d * x**2 for x in range(d, 600, d))))
|
p00014
|
import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
ans = 0
cnt = [[0]*45 for _ in range(45)]
for _ in range(n):
a = list(map(str, input().rstrip().split(".")))
x = 0
if len(a) == 1:
x = int(a[0]) * 10**9
else:
x = int(a[0]) * 10**9 + int(a[1]) * pow(10, 9-len(a[1]))
cnt_2, cnt_5 = 0, 0
while x % 2 == 0:
cnt_2 += 1
x //= 2
while x % 5 == 0:
cnt_5 += 1
x //= 5
for i in range(45):
for j in range(45):
if cnt_2 + i >= 18 and cnt_5 + j >= 18:
ans += cnt[i][j]
cnt[cnt_2][cnt_5] += 1
print(ans)
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
ans = 0
cnt = [[0]*20 for _ in range(45)]
for _ in range(n):
a = list(map(str, input().rstrip().split(".")))
x = 0
if len(a) == 1:
x = int(a[0]) * 10**9
else:
x = int(a[0]) * 10**9 + int(a[1]) * pow(10, 9-len(a[1]))
cnt_2, cnt_5 = 0, 0
while x % 2 == 0:
cnt_2 += 1
x //= 2
while x % 5 == 0:
cnt_5 += 1
x //= 5
for i in range(45):
for j in range(20):
if cnt_2 + i >= 18 and cnt_5 + j >= 18:
ans += cnt[i][j]
cnt[cnt_2][cnt_5] += 1
print(ans)
if __name__ == "__main__":
main()
|
p02588
|
# problem a
# score 300
from collections import defaultdict
N = int(eval(input()))
A = []
from decimal import Decimal
for i in range(N):
x = float(eval(input()))
x = Decimal(x*(10**9))
A.append(x)
remove = 0
for i in range(N):
if (A[i]**2) % (10**18) == 0:
remove += 1
D = defaultdict(int)
data = []
for x in A:
order2 = 0
order5 = 0
K = x
while K % 2 == 0:
order2 += 1
K = K//2
while K % 5 == 0:
order5 += 1
K = K//5
data.append((order2, order5))
for i in range(order2+1):
for j in range(order5+1):
D[2**i*5**j] += 1
ans = 0
for ord2, ord5 in data:
new_ord2 = max(0, 18-ord2)
new_ord5 = max(0, 18-ord5)
ans += D[(2**new_ord2)*(5**new_ord5)]
ans-=remove
ans = ans//2
print(ans)
|
# problem a
# score 300
from collections import defaultdict
N = int(eval(input()))
A = []
for i in range(N):
x = float(eval(input()))
x = "{:.9f}".format(x)
x=int(x[:-10]+x[-9:])
A.append(x)
remove = 0
for i in range(N):
if (A[i]**2) % (10**18) == 0:
remove += 1
D = defaultdict(int)
data = []
for x in A:
order2 = 0
order5 = 0
K = x
while K % 2 == 0:
order2 += 1
K = K//2
while K % 5 == 0:
order5 += 1
K = K//5
data.append((order2, order5))
for i in range(order2+1):
for j in range(order5+1):
D[2**i*5**j] += 1
ans = 0
for ord2, ord5 in data:
new_ord2 = max(0, 18-ord2)
new_ord5 = max(0, 18-ord5)
ans += D[(2**new_ord2)*(5**new_ord5)]
ans-=remove
ans = ans//2
print(ans)
|
p02588
|
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N = I()
A = []
for _ in range(N):
a = LS2()
if not '.' in a:
a = int(''.join(a))
a *= 10**9
b,c = 0,0
while a % 2 == 0:
a //= 2
b += 1
while a % 5 == 0:
a //= 5
c += 1
A.append((b-9,c-9))
else:
i = a.index('.')
l = len(a)
del a[i]
a += ['0']*(9-l+1+i)
a = int(''.join(a))
b, c = 0, 0
while a % 2 == 0:
a //= 2
b += 1
while a % 5 == 0:
a //= 5
c += 1
A.append((b - 9, c - 9))
from collections import defaultdict
d = defaultdict(int)
for i in range(N):
d[A[i]] += 1
ans = 0
for a in list(d.keys()):
b,c = a
x = 0
for e in list(d.keys()):
f,g = e
if f >= -b and g >= -c:
x += d[e]
ans += d[a]*x
for a in list(d.keys()):
b,c = a
if b >= 0 and c >= 0:
ans -= d[a]
print((ans//2))
|
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N = I()
A = [] # A[i] = A_iが2,5で各々何回割り切れるか
for _ in range(N):
a = LS2()
if not '.' in a:
a = int(''.join(a))
b,c = 0,0
while a % 2 == 0:
a //= 2
b += 1
while a % 5 == 0:
a //= 5
c += 1
A.append((b,c))
else:
i = a.index('.')
l = len(a)
del a[i]
a += ['0']*(9-l+1+i)
a = int(''.join(a)) # 与えられた実数を10**9倍したもの
b,c = 0,0
while a % 2 == 0:
a //= 2
b += 1
while a % 5 == 0:
a //= 5
c += 1
A.append((b-9,c-9))
from collections import defaultdict
d = defaultdict(int)
for i in range(N):
d[A[i]] += 1
ans = 0
for a in list(d.keys()):
b,c = a
x = 0
for e in list(d.keys()):
f,g = e
if f >= -b and g >= -c: # 積が整数
x += d[e]
ans += d[a]*x
# 自分自身どうしの積が整数となるものを取り除く
for a in list(d.keys()):
b,c = a
if b >= 0 and c >= 0:
ans -= d[a]
print((ans//2))
|
p02588
|
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def a_int(): return int(read())
def ints(): return list(map(int, read().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, zip(*ret)))
def read_tuple(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_matrix(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter, xor, add
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from functools import reduce
# 画像でおいた自分の解説見て
N = a_int()
B = []
for _ in ra(N):
A = read()[:-1] # floatで扱うと誤差で死ぬ
if '.' not in A:
A += '.'
for _ in range(9 - A[::-1].index('.')):
A += '0'
B.append(int(A[:-10] + A[-9:]))
N = []
M = []
for b in B:
n = 0
while ~b & 1: # 偶数である限り
b >>= 1
n += 1
N.append(n)
m = 0
while b % 5 == 0: # 5で割れる限り
b //= 5
m += 1
M.append(m)
cnt = [[0] * 19 for _ in ra(19)]
ans = 0
for n, m in zip(N, M):
x = max(18 - n, 0)
y = max(18 - m, 0)
for i, j in product(range(x, 19), range(y, 19)):
ans += cnt[i][j]
# このデータをcntに追加
cnt[min(n, 18)][min(m, 18)] += 1
print(ans)
|
import sys
read = sys.stdin.readline
ra = range
enu = enumerate
def a_int(): return int(read())
from itertools import product
# 画像でおいた自分の解説見て
N = a_int()
B = []
for _ in ra(N):
A = read()[:-1] # floatで扱うと誤差で死ぬ
if '.' not in A:
A += '.'
for _ in range(9 - A[::-1].index('.')):
A += '0'
B.append(int(A[:-10] + A[-9:]))
N = []
M = []
for b in B:
n = 0
while ~b & 1: # 偶数である限り
b >>= 1
n += 1
N.append(n)
m = 0
while b % 5 == 0: # 5で割れる限り
b //= 5
m += 1
M.append(m)
cnt = [[0] * 19 for _ in ra(19)]
ans = 0
for n, m in zip(N, M):
x = max(18 - n, 0)
y = max(18 - m, 0)
for i, j in product(list(range(x, 19)), list(range(y, 19))):
ans += cnt[i][j]
# このデータをcntに追加
cnt[min(n, 18)][min(m, 18)] += 1
print(ans)
|
p02588
|
N, *A = open(0).read().split()
class BIT():
def __init__(self, n, x=1):
self.n = n
self.T = [[0]*20 for _ in [0]*20]
def add(self, i, y, x):
i += 1
y += 1
while i <= self.n:
j = y
while j <= self.n:
self.T[i][j] += x
j += j & -j
i += i & -i
def _sum(self, i, y):
i += 1
y += 1
ret = 0
while i > 0:
j = y
while j > 0:
ret += self.T[i][j]
j ^= j & -j
i ^= i & -i
return ret
def sum(self, i, j):
return self._sum(18, 18) - self._sum(i-1, 18) - self._sum(18, j-1) + self._sum(i-1, j-1)
ans = 0
B = BIT(19)
def fact(n):
cnt2 = cnt5 = 0
for _ in range(18):
if n % 2:
break
n //= 2
cnt2 += 1
for _ in range(18):
if n % 5:
break
n //= 5
cnt5 += 1
return cnt2, cnt5
for a in A:
if '.' in a:
a, b = a.split('.')
cnt2 = cnt5 = 9 - len(b)
a = int(a) * (10**len(b)) + int(b)
c2, c5 = fact(a)
cnt2 += c2
cnt5 += c5
else:
cnt2 = 9
cnt5 = 9
a = int(a)
c2, c5 = fact(a)
cnt2 += c2
cnt5 += c5
cnt2 = min(18, cnt2)
cnt5 = min(18, cnt5)
ans += B.sum(18-cnt2, 18-cnt5)
B.add(cnt2, cnt5, 1)
print(ans)
|
import sys
input = sys.stdin.readline
N = int(eval(input()))
T = [[0]*19 for _ in [0]*19]
def count25(x):
c2 = c5 = 0
while x % 2 == 0:
x //= 2
c2 += 1
while x % 5 == 0:
x //= 5
c5 += 1
return c2, c5
for _ in range(N):
a, *b = input().split('.')
x = int(a) * 10**9
if b:
x += int(b[0])*10**(10-len(b[0]))
c2, c5 = count25(x)
T[min(18, c2)][min(18, c5)] += 1
ans = 0
for c2 in range(19):
for c5 in range(19):
tt = T[c2][c5]
if tt == 0:
continue
for i in range(18-c2, 19):
for j in range(18-c5, 19):
if c2 == i and c5 == j:
ans += tt*(tt-1)
else:
ans += tt * T[i][j]
print((ans//2))
|
p02588
|
from collections import defaultdict
def decomp(m):
pf=defaultdict(int)
for i in range(2,int(m**0.5)+1):
while m%i==0:
pf[i]+=1
m//=i
if m>1:pf[m]=1
return (pf[2], pf[5])
n=int(eval(input()))
table=[[0]*50 for _ in range(50)]
ans=0
for i in range(n):
a=eval(input())
ax=round(float(a)*(10**9))
p2,p5=decomp(ax)
if i!=0:
for j in range(18-p2,19):
ans+=sum(table[j][18-p5:])
table[p2][p5]+=1
print(ans)
|
def decomp(m):
p2=0
p5=0
while m%2==0:
m//=2
p2+=1
while m%5==0:
m//=5
p5+=1
return p2,p5
n=int(eval(input()))
table=[[0]*50 for _ in range(50)]
ans=0
for i in range(n):
a=input().split('.')
if len(a)==1:
ax=int(a[0]+'0'*9)
else:
ax=int(a[0]+a[1]+'0'*(9-len(a[1])))
p2,p5=decomp(ax)
if i!=0:
for j in range(18-p2,50):
ans+=sum(table[j][18-p5:])
table[p2][p5]+=1
print(ans)
|
p02588
|
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
readline = input
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
from fractions import Fraction
@mt
def slv(N, A):
d = defaultdict(Counter)
d5 = defaultdict(Counter)
de = defaultdict(Counter)
nd = Counter()
for a in A:
a += '.0'
t = a.split('.')
b = int(t[0]) * 10**9 + int(t[1]) * 10**(9- len(t[1]))
e = str(b)
for i in range(100):
if e[-(i+1)] != '0':
break
d[i][b] += 1
if e[-(i+1)] == '5':
d5[i][b] += 1
elif int(e[-(i+1)]) % 2 == 0:
de[i][b] += 1
nd[i] += 1
ans = 0
rk = sorted(d.keys(), reverse=True)
for k, kk in combinations(rk, r=2):
nk = nd[k]
nkk = nd[kk]
if k + kk >= 18:
ans += nk * nkk
else:
for av, an in d5[k].items():
for bv, bn in de[kk].items():
if (av * bv) % 10**18 == 0:
ans += an * bn
for av, an in de[k].items():
for bv, bn in d5[kk].items():
if (av * bv) % 10**18 == 0:
ans += an * bn
for k in rk:
nk = nd[k]
if 2*k >= 18:
ans += nk * (nk-1) // 2
else:
for av, an in d5[k].items():
for bv, bn in de[k].items():
if (av * bv) % 10**18 == 0:
ans += an * bn
return ans
def ref(N, A):
B = []
for a in A:
t = a.split('.')
b = 0
if len(t) == 1:
b = int(t[0]) * 10**9
else:
b = int(t[0]) * 10**9 + int(t[1]) * 10**(9 - len(t[1]))
B.append(b)
ans = 0
for a, b in combinations(B, r=2):
if (a * b ) % 10**18 == 0:
print(a, b)
ans += 1
return ans
def main():
N = read_int()
A = [input() for _ in range(N)]
print(slv(N, A))
# print(ref(N, A))
# N = 2 * 10**5
# for _ in range(1000):
# A = []
# for _ in range(N):
# b = str(random.randint(1, 10)) + '.' + str(random.randint(0, 10**2))
# A.append(b)
# a = slv(N, A)
# # b = ref(N, A)
# # print(a, b)
# # if a != b:
# # print(a, b)
# # print(A)
# # break
if __name__ == '__main__':
main()
|
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
readline = input
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
from fractions import Fraction
@mt
def slv(N, A):
c = Counter()
for a in A:
a += '.0'
t = a.split('.')
b = int(t[0]) * 10**9 + int(t[1]) * 10**(9-len(t[1]))
n5 = 0
n2 = 0
while b % 2 == 0:
n2 += 1
b //= 2
while b % 5 == 0:
n5 += 1
b //= 5
c[(n2, n5)] += 1
ans = 0
for k, kk in combinations_with_replacement(c.keys(), r=2):
if k[0] + kk[0] >= 18 and k[1] + kk[1] >= 18:
if k == kk:
ans += c[k] * (c[k]-1) // 2
else:
ans += c[k] * c[kk]
return ans
def main():
N = read_int()
A = [input() for _ in range(N)]
print(slv(N, A))
if __name__ == '__main__':
main()
|
p02588
|
def five(x):
cnt1 = 0
while x%5==0:
cnt1+= 1
x = x//5
cnt2 = 0
while x%2==0:
cnt2+= 1
x = x//2
return (min(cnt1,18), min(cnt2,18))
N = int(eval(input()))
F = []
for i in range(N):
A = float(eval(input()))
A = round(A*(10**9))
F.append(five(A))
F.sort()
# print(F)
j = 0
temp = 0
dp = [0]*19
k = 0
for i in range(N-1):
if N-1-j < i:
dp[min(F[i][1], 18)] -= 1
# print(i, N - j - 1, dp)
while N-1-j> i and F[i][0]+F[N-1-j][0] >= 18:
dp[min(F[N-1-j][1],18)] += 1
# print(i, N - j - 1, dp)
j += 1
k = sum(dp[:18-F[i][1]])
temp += min(j, N-i-1) - k
# print(j, N-i-1, k, temp)
print(temp)
"""
5
1
1
1
1
1
"""
|
def five(x):
cnt1 = 0
while x%5==0:
cnt1+= 1
x = x//5
cnt2 = 0
while x%2==0:
cnt2+= 1
x = x//2
return (min2(cnt1,18), min2(cnt2,18))
def min2(x,y):
return x if x < y else y
import sys
input = sys.stdin.readline
N = int(eval(input()))
F = []
for i in range(N):
A = float(eval(input()))
A = round(A*(10**9))
F.append(five(A))
F.sort()
j = 0
temp = 0
dp = [0]*19
k = 0
for i in range(N-1):
if N-1-j < i:
dp[min2(F[i][1], 18)] -= 1
while N-1-j> i and F[i][0]+F[N-1-j][0] >= 18:
dp[min2(F[N-1-j][1],18)] += 1
j += 1
k = sum(dp[:18-F[i][1]])
temp += min2(j, N-i-1) - k
print(temp)
|
p02588
|
import sys
readline = sys.stdin.readline
from math import floor
from decimal import Decimal
N = int(readline())
A = [Decimal(readline()) for _ in range(N)]
G = 10**10
Aint = [int(a) for a in A if int(a) == a]
Afl = [int(a*G) for a in A if int(a) != a]
H = 200
geta = 100
Grid = [[0]*H for _ in range(H)]
i25 = []
for ai in Aint:
i2 = 0
i5 = 0
while ai%2 == 0:
ai //= 2
i2 += 1
while ai%5 == 0:
ai //= 5
i5 += 1
i25.append((i2, i5))
for af in Afl:
i2 = -10
i5 = -10
while af%2 == 0:
af //= 2
i2 += 1
while af%5 == 0:
af //= 5
i5 += 1
i25.append((i2, i5))
for i2, i5 in i25:
Grid[geta+i2][geta+i5] += 1
for i in range(geta+90, geta-90, -1):
for j in range(geta+90, geta-90, -1):
Grid[i][j] += Grid[i][j+1]
for j in range(geta+90, geta-90, -1):
for i in range(geta+90, geta-90, -1):
Grid[i][j] += Grid[i+1][j]
lai = len(Aint)
ans = 0
for i2, i5 in i25:
ans += Grid[geta-i2][geta-i5]
#print(i2, i5, Grid[geta-i2][geta-i5])
print(((ans-lai)//2))
|
import sys
readline = sys.stdin.readline
G = 10**10
lai = 0
def Decimal(x):
global lai
a = x.strip().split('.')
if len(a) == 1 or all([ai == '0' for ai in a[1]]):
lai += 1
return int(a[0])*G
lf = len(a[1])
i, f = list(map(int, a))
return (i*10**(lf) + f)*10**(10-lf)
N = int(readline())
A = [Decimal(readline()) for _ in range(N)]
H = 200
geta = 100
Grid = [[0]*H for _ in range(H)]
i25 = []
for af in A:
i2 = -10
i5 = -10
while af%2 == 0:
af //= 2
i2 += 1
while af%5 == 0:
af //= 5
i5 += 1
i25.append((i2, i5))
for i2, i5 in i25:
Grid[geta+i2][geta+i5] += 1
for i in range(geta+90, geta-90, -1):
for j in range(geta+90, geta-90, -1):
Grid[i][j] += Grid[i][j+1]
for j in range(geta+90, geta-90, -1):
for i in range(geta+90, geta-90, -1):
Grid[i][j] += Grid[i+1][j]
ans = 0
for i2, i5 in i25:
ans += Grid[geta-i2][geta-i5]
#print(i2, i5, Grid[geta-i2][geta-i5])
print(((ans-lai)//2))
|
p02588
|
#AGC047-A Integer Product
"""
小数または整数が与えられるので、その積が整数となるペアの個数を求めよ。
まず入力に10**9をかけることで、
問題を「その積が10**18の倍数となるペアの個数を求めよ」
とする。
その場合、とりあえず10**18を素因数分解すると2**18と5**18なので、
片方が因数分解済みであるとした時に、
dp[i][j] : 2**iかつ5**jの個数
として、もう片方を2**aかつ5**bであると考えた時に、
2**(i+a)>=18かつ5**(j+b)>=18となるならば、それは条件を満たす
と考えられる。
よってこの個数を数えることで問題が解けた。
"""
import sys
from decimal import Decimal
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
n = int(readline())
lst1 = []
for i in range(n):
s = readline().rstrip().decode('utf-8')
lst1.append(int(Decimal(s)*(10**9)))
dp = [[0]*20 for _ in range(50)]
ans = 0
for i in range(n):
res = lst1[i]
t,f = 0,0
while True:
if res%2==0:
res //= 2
t += 1
else:
break
while True:
if res%5==0:
res //= 5
f += 1
else:
break
#i+t>=18かつj+f>=18であるような場所からカウント
for i in range(18-t,50):
for j in range(18-f,20):
ans += dp[i][j]
dp[t][f] += 1
print(ans)
|
#AGC047-A Integer Product
"""
小数または整数が与えられるので、その積が整数となるペアの個数を求めよ。
まず入力に10**9をかけることで、
問題を「その積が10**18の倍数となるペアの個数を求めよ」
とする。
その場合、とりあえず10**18を素因数分解すると2**18と5**18なので、
片方が因数分解済みであるとした時に、
dp[i][j] : 2**iかつ5**jの個数
として、もう片方を2**aかつ5**bであると考えた時に、
2**(i+a)>=18かつ5**(j+b)>=18となるならば、それは条件を満たす
と考えられる。
よってこの個数を数えることで問題が解けた。
"""
import sys
from decimal import Decimal
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
n = int(readline())
lst1 = []
for i in range(n):
s = readline().rstrip().decode('utf-8')
lst1.append(int(Decimal(s)*(10**9)))
dp = [[0]*20 for _ in range(45)]
ans = 0
for i in range(n):
res = lst1[i]
t,f = 0,0
while True:
if res%2==0:
res //= 2
t += 1
else:
break
while True:
if res%5==0:
res //= 5
f += 1
else:
break
#i+t>=18かつj+f>=18であるような場所からカウント
for i in range(18-t,45):
for j in range(18-f,20):
ans += dp[i][j]
dp[t][f] += 1
print(ans)
|
p02588
|
from collections import defaultdict
N = int(eval(input()))
b = 10**9
A = [int(round(float(eval(input()))*b)) for i in range(N)]
dic = defaultdict(int)
for a in A:
c2, c5 = 0, 0
while a % 2 == 0:
c2 += 1
a //= 2
while a % 5 == 0:
c5 += 1
a //= 5
dic[(c2, c5)] += 1
ans = 0
for i in range(50):
for j in range(25):
for k in range(50):
for l in range(25):
if i+k >= 18 and j+l >= 18:
if i == k and j == l:
ans += dic[(i, j)] * (dic[(i, j)] - 1)
else:
ans += dic[(i, j)] * dic[(k, l)]
print((ans//2))
|
from collections import defaultdict
N = int(eval(input()))
b = 10**9
A = [int(round(float(eval(input()))*b)) for i in range(N)]
dic = defaultdict(int)
for a in A:
c2, c5 = 0, 0
while a % 2 == 0 and c2 < 18:
c2 += 1
a //= 2
while a % 5 == 0 and c5 < 18:
c5 += 1
a //= 5
dic[(c2, c5)] += 1
ans = 0
for i in range(50):
for j in range(25):
for k in range(50):
for l in range(25):
if i+k >= 18 and j+l >= 18:
if i == k and j == l:
ans += dic[(i, j)] * (dic[(i, j)] - 1)
else:
ans += dic[(i, j)] * dic[(k, l)]
print((ans//2))
|
p02588
|
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque, defaultdict
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → にn回ローテート
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations,product#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
from functools import reduce,lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("## ",*x,file=sys.stderr)
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def binr(x): return bin(x)[2:]
def bitcount(x): #xは64bit整数
x= x - ((x >> 1) & 0x5555555555555555)
x= (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x= (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x+= (x >> 8); x+= (x >> 16); x+= (x >> 32)
return x & 0x7f
def primes(n):
a = Counter()
while n % 2 == 0:
a[2]+=1
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a[f]+=1
n //= f
else:
f += 2
if n != 1:
a[n]+=1
return a
def daccumulate(s):#二次元累積和
n=len(s); m=len(s[0])
acc=[[0]*m for _ in range(n)]
for i in range(n):
si=s[i]; ai=acc[i]
for j in range(m):
tot=si[j]
if i>0: tot+=acc[i-1][j]
if j>0:
tot+=ai[j-1]
if i>0: tot-=acc[i-1][j-1]
ai[j]=tot
return acc
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reverse=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(str, input().split())) #1行ベクトル
A = tuple(input() for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
ans=0
dp=[[0]*19 for _ in range(19)]
t9=10**9
bas=100
for a in A:
ta=0
ta=round(float(a)*t9)
c=primes(ta)
n2=min(18,c[2])
n5=min(18,c[5])
dp[18-n2][18-n5]+=1
ddp=daccumulate(dp)
ans=0
for i in range(19):
for j in range(19):
t2=18-i
t5=18-j
c=dp[t2][t5]
ta=ddp[i][j]
if i*2>=18 and j*2>=18:
ta-=c
ans+=c*(c-1)
ans+=ta*c
print(ans//2)
if __name__ == "__main__":
main()
|
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque, defaultdict
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → にn回ローテート
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations,product#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
from functools import reduce,lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("## ",*x,file=sys.stderr)
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def binr(x): return bin(x)[2:]
def bitcount(x): #xは64bit整数
x= x - ((x >> 1) & 0x5555555555555555)
x= (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x= (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x+= (x >> 8); x+= (x >> 16); x+= (x >> 32)
return x & 0x7f
def primes(n):
a = Counter()
while n % 2 == 0:
a[2]+=1
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a[f]+=1
n //= f
else:
f += 2
if n != 1:
a[n]+=1
return a
def daccumulate(s):#二次元累積和
n=len(s); m=len(s[0])
acc=[[0]*m for _ in range(n)]
for i in range(n):
si=s[i]; ai=acc[i]
for j in range(m):
tot=si[j]
if i>0: tot+=acc[i-1][j]
if j>0:
tot+=ai[j-1]
if i>0: tot-=acc[i-1][j-1]
ai[j]=tot
return acc
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reverse=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(str, input().split())) #1行ベクトル
A = tuple(input() for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
ans=0
dp=[[0]*19 for _ in range(19)]
t9=10**9
bas=100
for a in A:
ta=0
ta=round(float(a)*t9)
n2=0
n5=0
while ta%2==0:
n2+=1
ta//=2
while ta%5==0:
n5+=1
ta//=5
n2=min(18,n2)
n5=min(18,n5)
dp[18-n2][18-n5]+=1
ddp=daccumulate(dp)
ans=0
for i in range(19):
for j in range(19):
t2=18-i
t5=18-j
c=dp[t2][t5]
ta=ddp[i][j]
if i*2>=18 and j*2>=18:
ta-=c
ans+=c*(c-1)
ans+=ta*c
print(ans//2)
if __name__ == "__main__":
main()
|
p02588
|
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
MAX = 50
def resolve():
n = int(eval(input()))
D = [[0] * MAX for _ in range(MAX)]
for _ in range(n):
a = int(round(float(eval(input())) * 10 ** 9))
t = a
x = 0
while t % 2 == 0:
t //= 2
x += 1
t = a
y = 0
while t % 5 == 0:
t //= 5
y += 1
D[x][y] += 1
res = 0
for x1 in range(MAX):
for y1 in range(MAX):
for x2 in range(max(0, 18 - x1), MAX):
for y2 in range(max(0, 18 - y1), MAX):
if x1 == x2 and y1 == y2:
res += D[x1][y1] * (D[x1][y1] - 1)
else:
res += D[x1][y1] * D[x2][y2]
print((res // 2))
if __name__ == '__main__':
resolve()
|
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 998244353
def resolve():
n = int(eval(input()))
A = []
for _ in range(n):
a = float(eval(input()))
a = round(a * 10 ** 9 + 0.1)
A.append(a)
L = [[0] * 25 for _ in range(45)]
D = []
for a in A:
tmp = a
ex2 = ex5 = 0
while tmp % 2 == 0:
tmp //= 2
ex2 += 1
tmp = a
while tmp % 5 == 0:
tmp //= 5
ex5 += 1
L[ex2][ex5] += 1
D.append((ex2, ex5))
res = 0
check = [[False] * 25 for _ in range(45)]
for i in range(45):
for j in range(25):
if L[i][j] == 0:
check[i][j] = True
continue
for k in range(18 - i, 45):
for l in range(18 - j, 25):
if check[k][l]:
continue
if k == i and l == j:
res += L[i][j] * (L[k][l] - 1) // 2
else:
res += L[i][j] * L[k][l]
check[i][j] = True
print(res)
if __name__ == '__main__':
resolve()
|
p02588
|
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
N = I()
A = []
dic = DD(int)
for _ in range(N):
s = S().split(".")
if len(s) == 1:
temp = int(s[0])*(10**9)
else:
temp = int(s[0])*(10**9)+int(s[1])*(10**(9-len(s[1])))
_2,_5 = 0,0
for p,n in factorization(temp):
if p==2:_2 = min(n,18)
if p==5:_5 = min(n,18)
dic[(_2,_5)] += 1
ans1 = 0
ans2 = 0
for i2 in range(19):
for j2 in range(18-i2,19):
for i5 in range(19):
for j5 in range(18-i5,19):
if (i2,i5)==(j2,j5):
ans1 += dic[(i2,i5)]*(dic[(j2,j5)]-1)
else:
ans2 += dic[(i2,i5)]*dic[(j2,j5)]
print(((ans1+ans2)//2))
|
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
N = I()
A = []
dic = DD(int)
for _ in range(N):
s = S().split(".")
if len(s) == 1:
temp = int(s[0])*(10**9)
else:
temp = int(s[0])*(10**9)+int(s[1])*(10**(9-len(s[1])))
_2,_5 = 0,0
copy = temp
while copy%2 == 0:
_2 += 1
copy //= 2
if _2 == 18: break
copy = temp
while copy%5 == 0:
_5 += 1
copy //= 5
if _5 == 18: break
dic[(_2,_5)] += 1
ans1 = 0
ans2 = 0
for i2 in range(19):
for j2 in range(18-i2,19):
for i5 in range(19):
for j5 in range(18-i5,19):
if (i2,i5)==(j2,j5):
ans1 += dic[(i2,i5)]*(dic[(j2,j5)]-1)
else:
ans2 += dic[(i2,i5)]*dic[(j2,j5)]
print(((ans1+ans2)//2))
|
p02588
|
N = int(eval(input()))
A = [0] * N
for i in range(N):
A[i] = round(float(eval(input()))*(10**9))
from itertools import combinations
base = list(combinations(A,2))
floatans=0
for i in range(len(base)):
a=base[i][0]*base[i][1]
if a%(10**18)==0:
floatans+=1
print(floatans)
|
N = int(eval(input()))
A = [0] * N
for i in range(N):
A[i] = round(float(eval(input()))*(10**9))
floatans=0
for i in range(N):
for j in range(i+1,N):
if (A[i]*A[j])%(10**18)==0:
floatans+=1
print(floatans)
|
p02588
|
from fractions import Fraction
from decimal import Decimal
n = int(eval(input()))
a = []
b = []
for i in range(0,n):
c = float(eval(input()))
a.append(c)
d = str(a[i])
f = Fraction(Decimal(d))
b.append(f)
x = []
y = []
for i in range(0,n):
x.append(b[i].numerator)
y.append(b[i].denominator)
count = 0
for i in range(0,n) :
for j in range(i+1,n):
if (x[i]*x[j]) % (y[i]*y[j]) == 0:
count += 1
print(count)
|
from math import gcd
from collections import Counter
import sys
N = int(eval(input()))
K = 10**9
L = 10**18
A = [0] * N
C = Counter()
ans = 0
for i in range(N):
A[i] = round(K * float(eval(input())))
C[gcd(A[i],L)] += 1
for k1,v1 in list(C.items()):
for k2 ,v2 in list(C.items()):
if k1 == k2:
if k1*k2 % L == 0:
ans += v1*(v1-1)/2
elif k1 < k2:
if k1*k2 % L == 0:
ans += v1 * v2
print((int(ans)))
|
p02588
|
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)
from decimal import Decimal
def get_primes(n):
divs = defaultdict(int)
if n == 0: return divs
for i in [2,5]:
c = 0
while n % i == 0:
n = n // i
c += 1
if c > 0:
divs[i] = c
return divs
L = 10**9
N = ri()
A = []
for i in range(N):
d = Decimal(rs())
A.append(int(d*L))
#print(A)
R = [0] * N
for i, a in enumerate(A):
R[i] = A[i] % L
#print(R)
M = 18
K = 0
C = []
D = []
for i in range(N):
r = R[i]
a = A[i]
if r > 0:
ps = get_primes(a)
C.append([min(ps[2], M), min(ps[5], M)])
else:
ps = get_primes(a)
D.append([min(ps[2], M), min(ps[5], M)])
#print('C',C)
#print('D',D)
h = defaultdict(int)
ans0 = 0
for c in C:
d = [M-c[0], M-c[1]]
i, j = d[0], d[1]
for i in range(d[0], M+1):
for j in range(d[1], M+1):
if (i, j) in h:
ans0 += h[(i,j)] - (c == (i,j))
h[tuple(c)] += 1
ans1 = len(D)*(len(D)-1)//2
ans2 = 0
for c in D:
d = [M-c[0], M-c[1]]
for i in range(d[0], M+1):
for j in range(d[1], M+1):
if (i, j) in h:
ans2 += h[(i,j)] - (c == (i,j))
#print(ans0, ans1, ans2)
ans = ans0 + ans1 + ans2
print(ans)
|
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)
from decimal import Decimal
def gcd(a, b):
return gcd(b, a%b) if b else a
L = 10**9
LL = 10**18
N = ri()
A = []
for i in range(N):
d = Decimal(rs())
A.append(int(d*L))
h = defaultdict(int)
for i in range(N):
g = gcd(A[i], LL)
h[g] += 1
ans = 0
for g, c in list(h.items()):
for g2, c2 in list(h.items()):
if g == g2:
if g*g % LL == 0:
ans += c*(c-1)//2
elif g < g2:
if g*g2 % LL == 0:
ans += c * c2
print(ans)
|
p02588
|
N, *A = open(0).read().split()
S = [[0] * 21 for _ in range(21)]
ans = 0
for a in A:
if (idx := a.find(".")) == -1:
c2 = c5 = 0
else:
c2 = c5 = -(len(a) - idx - 1)
a = int(a.replace(".", ""))
while a % 2 == 0:
c2 += 1
a //= 2
while a % 5 == 0:
c5 += 1
a //= 5
c2 = min(c2, 10)
c5 = min(c5, 10)
ans += sum(S[i][j] for i in range(10 - c2, 21) for j in range(10 - c5, 21))
S[c2 + 10][c5 + 10] += 1
print(ans)
|
N, *A = open(0).read().split()
S = [[0] * 21 for _ in range(21)]
ans = 0
for a in A:
idx = a.find(".")
if idx == -1:
c2 = c5 = 0
else:
c2 = c5 = -(len(a) - idx - 1)
a = int(a.replace(".", ""))
while a % 2 == 0:
c2 += 1
a //= 2
while a % 5 == 0:
c5 += 1
a //= 5
c2 = min(c2, 10)
c5 = min(c5, 10)
ans += sum(S[i][j] for i in range(10 - c2, 21) for j in range(10 - c5, 21))
S[c2 + 10][c5 + 10] += 1
print(ans)
|
p02588
|
N=int(eval(input()))
A=[]
PRECISION_DIGITS=9
cnt={}
for n in range(N):
tmpA = float(eval(input()))
tmpA = round(tmpA*(10**PRECISION_DIGITS))
#print(tmpA)
two = 0
five = 0
while (tmpA % 2) == 0:
two += 1
tmpA /= 2
while (tmpA % 5) == 0:
five += 1
tmpA /= 5
if (two,five) in cnt:
cnt[(two,five)]+=1
else:
cnt[(two,five)]=1
keys=sorted(cnt.keys())
# print(keys)
ans = 0
for t1 in keys:
for t2 in keys:
# 2**a(a>=0) and 5**b(b>=0) => integer
if 18 <= t1[0]+t2[0] and 18 <= t1[1]+t2[1]:
cnt1 = cnt[(t1[0],t1[1])]
cnt2 = cnt[(t2[0],t2[1])]
if t1 < t2:
ans += int(cnt1*cnt2)
elif t1 == t2:
# same entry
# Total number of combinations choose 2 items
# nC2 = n*(n-1)/2
ans += int(cnt1*(cnt1-1)/2)
print(ans)
|
N=int(eval(input()))
A=[]
PRECISION_DIGITS=9
cnt={}
for n in range(N):
tmpA = float(eval(input()))
tmpA = round(tmpA*10**PRECISION_DIGITS)
#print(tmpA)
five = 0
two = 0
while (tmpA % 2) == 0:
two += 1
tmpA //= 2
while (tmpA % 5) == 0:
five += 1
tmpA //= 5
# (10**9) -> (two,five)=(9,9)
two -= PRECISION_DIGITS
five -= PRECISION_DIGITS
if (two,five) in cnt:
cnt[(two,five)]+=1
else:
cnt[(two,five)]=1
# print(cnt)
ans = 0
for t1, cnt1 in list(cnt.items()):
for t2, cnt2 in list(cnt.items()):
# 2**a(a>=0) and 5**b(b>=0) => integer
if 0 <= t1[0]+t2[0] and 0 <= t1[1]+t2[1]:
if t1 < t2:
ans += int(cnt1*cnt2)
elif t1 == t2:
# same entry
# Total number of combinations choose 2 items
# nC2 = n*(n-1)/2
ans += int((cnt1*(cnt2-1))/2)
print(ans)
|
p02588
|
import collections
N=int(eval(input()))
A=[]
PRECISION_DIGITS=9
cnt=collections.defaultdict(int)
for n in range(N):
tmpA = float(eval(input()))
tmpA = round(tmpA*10**PRECISION_DIGITS)
#print(tmpA)
five = 0
two = 0
while (tmpA % 2) == 0:
two += 1
tmpA //= 2
while (tmpA % 5) == 0:
five += 1
tmpA //= 5
# (10**9) -> (two,five)=(9,9)
two -= PRECISION_DIGITS
five -= PRECISION_DIGITS
cnt[(two,five)]+=1
# print(cnt)
ans = 0
for t1, cnt1 in list(cnt.items()):
for t2, cnt2 in list(cnt.items()):
# 2**a(a>=0) and 5**b(b>=0) => integer
if 0 <= t1[0]+t2[0] and 0 <= t1[1]+t2[1]:
if t1 < t2:
ans += int(cnt1*cnt2)
elif t1 == t2:
# same entry
# Total number of combinations choose 2 items
# nC2 = n*(n-1)/2
ans += int((cnt1*(cnt2-1))/2)
print(ans)
|
# import collections
N=int(eval(input()))
A=[]
PRECISION_DIGITS=9
cnt={} #collections.defaultdict(int)
for n in range(N):
tmpA = float(eval(input()))
tmpA = round(tmpA*10**PRECISION_DIGITS)
#print(tmpA)
five = 0
two = 0
while (tmpA % 2) == 0:
two += 1
tmpA //= 2
while (tmpA % 5) == 0:
five += 1
tmpA //= 5
# (10**9) -> (two,five)=(9,9)
two -= PRECISION_DIGITS
five -= PRECISION_DIGITS
cnt.setdefault((two,five),0)
cnt[(two,five)]+=1
# print(cnt)
ans = 0
for t1, cnt1 in list(cnt.items()):
for t2, cnt2 in list(cnt.items()):
# 2**a(a>=0) and 5**b(b>=0) => integer
if 0 <= t1[0]+t2[0] and 0 <= t1[1]+t2[1]:
if t1 < t2:
ans += int(cnt1*cnt2)
elif t1 == t2:
# same entry
# Total number of combinations choose 2 items
# nC2 = n*(n-1)/2
ans += int((cnt1*(cnt2-1))/2)
print(ans)
|
p02588
|
from decimal import Decimal
def waru(N,num):
cnt = 0
while N%num==0:
N //= num
cnt += 1
return cnt
def solve():
N = int(eval(input()))
num = [[0]*101 for _ in range(101)]
lis = [0]*N
for i in range(N):
a = int(round(float(eval(input()))*10**9))
p,q = waru(a,2)-9-50,waru(a,5)-9-50
num[p][q] += 1
lis[i] = [p,q]
cum2 = [[0]*101 for _ in range(101)]
for i in range(99,-1,-1):
for j in range(99,-1,-1):
cum2[i][j] = cum2[i+1][j]+cum2[i][j+1]-cum2[i+1][j+1]+num[i][j]
ans = 0
for i in range(N):
p,q = lis[i]
x,y = p+50,q+50
p = -x-50
q = -y-50
ans += cum2[p][q]
if x>=0 and y>=0:
ans -= 1
return ans//2
print((solve()))
|
import sys
input = sys.stdin.readline
def waru(N,num):
cnt = 0
while N%num==0:
N //= num
cnt += 1
return cnt
def solve():
N = int(eval(input()))
num = [[0]*101 for _ in range(101)]
lis = [0]*N
for i in range(N):
a = int(round(float(eval(input()))*10**9))
p,q = waru(a,2)-9-50,waru(a,5)-9-50
num[p][q] += 1
lis[i] = [p,q]
cum2 = [[0]*101 for _ in range(101)]
for i in range(99,-1,-1):
for j in range(99,-1,-1):
cum2[i][j] = cum2[i+1][j]+cum2[i][j+1]-cum2[i+1][j+1]+num[i][j]
ans = 0
for i in range(N):
p,q = lis[i]
x,y = p+50,q+50
p = -x-50
q = -y-50
ans += cum2[p][q]
if x>=0 and y>=0:
ans -= 1
return ans//2
print((solve()))
|
p02588
|
c=eval('[0]*50,'*50)
r=0
for a in[*open(0)][1:]:
a=round(float(a)*10**9);x=y=0
while a%2<1:a//=2;x+=1
while a%5<1:a//=5;y+=1
r+=sum(sum(d[max(0,18-y):])for d in c[max(0,18-x):]);c[x][y]+=1
print(r)
|
c=eval('[0]*50,'*50)
r=0
for a in[*open(0)][1:]:
a=round(float(a)*1e9);x=y=0
while a%2<1:a//=2;x+=1
while a%5<1:a//=5;y+=1
r+=sum(sum(d[max(0,18-y):])for d in c[max(0,18-x):]);c[x][y]+=1
print(r)
|
p02588
|
c=eval('[0]*50,'*50)
r=0
for a in[*open(0)][1:]:
a=round(float(a)*1e9);x=y=1
while a%2**x<1:x+=1
while a%5**y<1:y+=1
r+=sum(sum(d[max(0,20-y):])for d in c[max(0,20-x):]);c[x][y]+=1
print(r)
|
c=eval('[0]*50,'*50)
r=0
for a in[*open(0)][1:]:
a=round(float(a)*1e9);y=1
while a%5**y<1:y+=1
x=len(bin(a&-a));r+=sum(sum(d[max(0,20-y):])for d in c[max(0,24-x):]);c[x][y]+=1
print(r)
|
p02588
|
from collections import defaultdict
def conv(s):
if "." not in s:
s += '.'
s = s.rstrip('0')
t = len(s) - s.find('.') - 1
a = int(s.replace('.', ''))
if a == 0:
return (0, 0)
x, y = -t, -t
while a % 5 == 0:
x += 1
a //= 5
y += len(bin(a&-a))-3
return (x, y)
_, *A = open(0).read().split()
d = defaultdict(int)
for a in A:
d[conv(a)] += 1
result = 0
d = list(d.items())
for i, ((x, y), cnt) in enumerate(d):
if x >= 0 and y >= 0:
result += cnt * (cnt - 1) // 2
for (m, n), cnt2 in d[i+1:]:
if x + m >= 0 and y + n >= 0:
result += cnt * cnt2
print(result)
|
import sys
from collections import defaultdict
from math import gcd
def input(): return sys.stdin.readline().strip()
K = 10**9
L = 10**18
D = defaultdict(int)
for _ in range(int(eval(input()))):
D[gcd(round(float(eval(input())) * K), L)] += 1
D = tuple(D.items())
ans = 0
for i, (k1, v1) in enumerate(D):
if k1*k1 % L == 0:
ans += v1*(v1-1) // 2
for k2, v2 in D[i+1:]:
if k1*k2 % L == 0:
ans += v1 * v2
print(ans)
|
p02588
|
import bisect
from decimal import Decimal
N, *A = [Decimal(_) for _ in open(0).read().split()]
N = int(N)
c = [[0, 0] for _ in range(N)]
for i, a in enumerate(A):
a = int(a * 10**9)
while True:
if a % 2:
break
c[i][0] += 1
a //= 2
while True:
if a % 5:
break
c[i][1] += 1
a //= 5
c.sort()
#cum[i][j]:c[x][1]>=i (j<=x)となるようなxの個数
cum = [[0] * (N + 1) for _ in range(19)]
for i in range(19):
for j in range(N - 1, -1, -1):
cum[i][j] = cum[i][j + 1]
if c[j][1] >= i:
cum[i][j] += 1
ans = 0
for i, c2c5 in enumerate(c):
c2, c5 = c2c5
if c2 > 9 or (c2 == 9 and c5 >= 9):
i2 = i + 1
else:
i2 = bisect.bisect_left(c, [18 - c2, -1])
ans += cum[18 - c5][i2]
print(ans)
|
import bisect
from decimal import Decimal
N, *A = open(0).read().split()
N = int(N)
c = [[0, 0] for _ in range(N)]
for i, a in enumerate(A):
if '.' in a:
p, q = a.split('.')
q += '0' * (9 - len(q))
else:
p = a
q = '0' * 9
a = int(p + q)
while True:
if a % 2:
break
c[i][0] += 1
a //= 2
while True:
if a % 5:
break
c[i][1] += 1
a //= 5
c.sort()
#cum[i][j]:c[x][1]>=i (j<=x)となるようなxの個数
cum = [[0] * (N + 1) for _ in range(19)]
for i in range(19):
for j in range(N - 1, -1, -1):
cum[i][j] = cum[i][j + 1]
if c[j][1] >= i:
cum[i][j] += 1
ans = 0
for i, c2c5 in enumerate(c):
c2, c5 = c2c5
if c2 > 9 or (c2 == 9 and c5 >= 9):
i2 = i + 1
else:
i2 = bisect.bisect_left(c, [18 - c2, -1])
ans += cum[18 - c5][i2]
print(ans)
|
p02588
|
def div(n, d):
cnt = 0
while n % d == 0 and cnt < 18:
n //= d
cnt += 1
return cnt
n = int(eval(input()))
dp = [[0]*19 for _ in range(19)]
#dp[i][j] -> 2の素因数がi以上,5の素因数がj以上の数字の数
ans = 0
for _ in range(n):
x = round(float(eval(input())) * pow(10, 9))
two = div(x, 2)
five = div(x, 5)
ans += dp[18 - two][18 - five]
for i in range(two + 1):
for j in range(five + 1):
dp[i][j] += 1
print(ans)
|
"""
小数の状態だと処理しづらいので、与えられた数を全て10**9倍して小数を確実になくした上で
問題文を下記のように言い換える。
「積が10**18の倍数になるような数の組み合わせの数がいくつあるか」
数Aiがあり、Aiの2の素因数の数がn, 5の素因数の数がmのとき、
数Ai自体ですでにmin(n,m)個の0の数を持っている。この場合、のこり必要な0の数はx = 18-min(n,m)個である。
ここで、n == mの場合：
Aiの相方は少なくとも2,5の素因数をそれぞれx個以上持っていなくてはならない。
n > mの場合：
Aiの相方は少なくとも2の素因数をx-(n-m)個、5の素因数をx個持っていなくてはいけない。
m > nの場合：
Aiの相方は少なくとも2の素因数をx個以上、5の素因数をx-(m-n)個以上持っていなくてはならない。
"""
N = int(eval(input()))
dp = [[0]*(19) for _ in range(19)]
ans = 0
for _ in range(N):
a = round(float(eval(input()))*pow(10,9))
two = 0
while a % 2 == 0 and two < 18:
a //= 2
two += 1
five = 0
while a % 5 == 0 and five < 18:
a //= 5
five += 1
ans += dp[18-two][18-five]
for i in range(two+1):
for j in range(five+1):
dp[i][j] += 1
print(ans)
|
p02588
|
import sys
readline = sys.stdin.readline
N = int(readline())
C = [[0] * 19 for i in range(19)]
for i in range(N):
a = readline().rstrip()
if "." in a:
keta = len(a.split(".")[1])
a = int(a.replace(".","")) * (10 ** (9 - keta))
else:
a = int(a) * (10 ** 9)
temp = a
cnt2 = 0
cnt5 = 0
while a % 2 == 0:
a //= 2
cnt2 += 1
while a % 5 == 0:
a //= 5
cnt5 += 1
C[min(cnt2, 18)][min(cnt5, 18)] += 1
#for c in C:
# print(c)
ans = 0
# まず、同じグループから2つの数を選ぶ場合の数
for i in range(9, 19):
for j in range(9, 19):
n = C[i][j]
ans += (n * (n - 1)) // 2
# 異なるグループから選ぶ場合の数
ans_diff = 0
for i in range(19):
for j in range(19):
for p in range(19):
for q in range(19):
if i == p and j == q:
continue # カウント済
if i + p < 18 or j + q < 18:
continue
ans_diff += C[i][j] * C[p][q]
ans += ans_diff // 2 # 二回カウントしている
print(ans)
|
import sys
readline = sys.stdin.readline
N = int(readline())
C = [[0] * 19 for i in range(19)]
for i in range(N):
a = readline().rstrip()
if "." in a:
keta = len(a.split(".")[1])
a = int(a.replace(".","")) * (10 ** (9 - keta))
else:
a = int(a) * (10 ** 9)
cnt2 = 0
cnt5 = 0
while a % 2 == 0:
a //= 2
cnt2 += 1
while a % 5 == 0:
a //= 5
cnt5 += 1
C[min(cnt2, 18)][min(cnt5, 18)] += 1
#for c in C:
# print(c)
ans = 0
# まず、同じグループから2つの数を選ぶ場合の数
for i in range(9, 19):
for j in range(9, 19):
n = C[i][j]
ans += (n * (n - 1)) // 2
# 異なるグループから選ぶ場合の数
ans_diff = 0
for i in range(19):
for j in range(19):
for p in range(19):
for q in range(19):
if i == p and j == q:
continue # カウント済
if i + p < 18 or j + q < 18:
continue
ans_diff += C[i][j] * C[p][q]
ans += ans_diff // 2 # 二回カウントしている
print(ans)
|
p02588
|
a=[2,3,5,10,12,15]
b=[380,550,850,1520,1870,2244]
while 1:
n=int(eval(input()))
if n==0:break
n//=100
dp=[0]+[1<<29]*n
for i in range(5,-1,-1):
for j in range(n+1):
if j+a[i]<=n and dp[j]!=1<<29:dp[j+a[i]]=min(dp[j+a[i]],dp[j]+b[i])
print((dp[n]))
|
a=[(2,380),(3,550),(5,850),(10,1520),(12,1870),(15,2244)]
dp=[1<<20]*51
for i,j in a:
dp[i]=j
for k in range(51-i):
if dp[k]!=1<<20 and dp[k+i]>dp[k]+j:
dp[k+i]=dp[k]+j
while 1:
n=int(eval(input()))
if n==0:break
print((dp[n//100]))
|
p00106
|
while True:
N = int(eval(input()))
if N==0: break
ans = float('inf')
for c200 in range(N//200+1):
for c300 in range(N//300+1):
for c500 in range(N//500+1):
if 200 * c200 + c300 * 300 + c500 * 500 == N:
ans = min(ans, 1520*(c200//5)+380*(c200%5)+1870*(c300//4)+550*(c300%4)+2244*(c500//3)+850*(c500%3))
print(ans)
|
a=[1e4]*51
for i,j in[(2,380),(3,550),(5,850),(10,1520),(12,1870),(15,2244)]:
a[i]=j
for k in range(51-i):
if a[k+i]>a[k]+j:a[k+i]=a[k]+j
for n in iter(input,'0'):print((a[int(n)//100]))
|
p00106
|
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0106&lang=jp
"""
import sys
def solve(amount):
"""
:param amount: ?????\???????????°?????????
:return: ?????????
"""
best_price = (amount + 199) // 200 * 380
for a in range(amount // 200 + 1):
for b in range(amount // 300 + 1):
for c in range(amount // 500 + 1):
for a1 in range(amount // 1000 + 1):
for b1 in range(amount // 1200 + 1):
for c1 in range(amount // 1500 + 1):
if a*200 + b*300 + c*500 + a1*1000 + b1*1200 + c1*1500 == amount:
price = a*380 + b*550 + c*850 + a1*1520 + b1*1870 + c1*2244
if price < best_price:
best_price = price
return best_price
def main(args):
while True:
amount = int(eval(input()))
if amount == 0:
break
result = solve(amount)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
|
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0106&lang=jp
"""
import sys
def solve(amount):
"""
:param amount: ?????\???????????°?????????
:return: ?????????
"""
best_price = (amount + 199) // 200 * 380
for a in range(amount // 200 + 1):
for b in range(amount // 300 + 1):
for c in range(amount // 500 + 1):
for a1 in range(amount // 1000 + 1):
for b1 in range(amount // 1200 + 1):
for c1 in range(amount // 1500 + 1):
if a*200 + b*300 + c*500 + a1*1000 + b1*1200 + c1*1500 == amount:
price = a*380 + b*550 + c*850 + a1*1520 + b1*1870 + c1*2244
if price < best_price:
best_price = price
return best_price
def solve2(amount):
"""
???????¨???????????????¨?????????????????§???
"""
packages = [(0, 0), (2, 380), (3, 550), (5, 850), (10, 1520), (12, 1870), (15, 2244)] # 1?¢??????????(100g??????)??¨??????????????¢l
# dp??¨???2?¬??????????????¨?????????????(100g??????)?????????????????¨??§??????packages????¨????
# 999999...??????INF??¨?????? (phthon 3.5??\??????????????????math.inf????????¨??§??????)
cart = [[99999999] * (amount//100 + 1) for _ in range(len(packages))]
for i in range(len(packages)):
cart[i][0] = 0 # 0g???????????\????????´??????0???????????????
for i in range(1, len(packages)):
for j in range(1, len(cart[0])):
w = packages[i][0] # ??????
p = packages[i][1] # ??????
if j < w:
cart[i][j] = cart[i-1][j]
else:
# ???????????????????????????????????????????????????????????????????????????????¨????
cart[i][j] = min(cart[i-1][j], cart[i-1][max(0, j-w)]+p, cart[i][max(0, j-w)]+p)
return cart[-1][-1]
def main(args):
while True:
amount = int(eval(input()))
if amount == 0:
break
#result = solve(amount)
#print(result)
result = solve2(amount)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
|
p00106
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
class Node(object):
__slots__ = ('parent', 'depth', 'type', 'children')
def __init__(self):
self.parent = -1
self.type = ''
self.depth = 0
self.children = []
def dfs(node_idx, node_list, d=0):
node_list[node_idx].depth = d
for child in node_list[node_idx].children:
dfs(child, node_list, d=d + 1)
return None
def print_result(_node):
print('parent = ' + str(_node.parent) + ',', end=' ')
print('depth = ' + str(_node.depth) + ',', end=' ')
print(_node.type + ',', end=' ')
print(_node.children)
return None
def generate_tree(_array, node_list):
for each in _array:
idx, k, *children = [x for x in each]
node_list[idx].children = children
if k:
node_list[idx].type = 'internal node'
else:
node_list[idx].type = 'leaf'
for child_idx in children:
node_list[child_idx].parent = idx
root_idx = [i for i, x in enumerate(node_list) if x.parent == -1][0]
node_list[root_idx].type = 'root'
dfs(node_idx=root_idx, node_list=node_list)
return node_list
if __name__ == '__main__':
_input = sys.stdin.readlines()
array_length = int(_input[0])
array = list(map(lambda x: list(map(int, x.split())), _input[1:]))
# assert len(array) == array_length
init_node_list = [Node() for _ in range(array_length)]
ans = generate_tree(_array=array, node_list=init_node_list)
for key, node in enumerate(ans):
print('node ' + str(key) + ':', end=' ')
print_result(_node=node)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
class Node(object):
__slots__ = ('parent', 'depth', 'type', 'children')
def __init__(self):
self.parent = -1
self.type = ''
self.depth = 0
self.children = []
def dfs(node_idx, node_list, depth=0):
node_list[node_idx].depth = depth
for child in node_list[node_idx].children:
dfs(child, node_list, depth=depth + 1)
return None
def print_result(_node):
print('parent = ' + str(_node.parent) + ',', end=' ')
print('depth = ' + str(_node.depth) + ',', end=' ')
print(_node.type + ',', end=' ')
print(_node.children)
return None
def generate_tree(_array, node_list):
for each in _array:
idx, k, *children = [int(x) for x in each]
node_list[idx].children = children
if k:
node_list[idx].type = 'internal node'
else:
node_list[idx].type = 'leaf'
for child_idx in children:
node_list[child_idx].parent = idx
root_idx = [i for i, x in enumerate(node_list) if x.parent == -1][0]
node_list[root_idx].type = 'root'
dfs(node_idx=root_idx, node_list=node_list)
return node_list
if __name__ == '__main__':
_input = sys.stdin.readlines()
array_length = int(_input[0])
array = list(map(lambda x: x.split(), _input[1:]))
# assert len(array) == array_length
init_node_list = [Node() for _ in range(array_length)]
ans = generate_tree(_array=array, node_list=init_node_list)
for key, node in enumerate(ans):
print('node ' + str(key) + ':', end=' ')
print_result(_node=node)
|
p02279
|
"""Rooted Trees."""
class Node:
def __init__(self, num, parent, *children):
self.id = num
self.parent = parent
self.children = list(children)
self.depth = 0
def show_info(self):
print('node {0}: '.format(self.id), end = '')
print('parent = {0}, '.format(self.parent), end = '')
print('depth = {0}, '.format(self.depth), end = '')
if self.children and self.parent != -1:
print('internal node, ', end = '')
elif self.parent != -1:
print('leaf, ', end = '')
else:
print('root, ', end = '')
print(self.children)
class RootedTree():
def __init__(self, n):
self.nodes = [Node(i, -1) for i in range(n)]
def set_node(self, i_p):
i_p = list(map(int, i_p.split()))
num = i_p[0]
children = i_p[2:]
if children:
self.nodes[num].children = children
for n in children:
self.nodes[n].parent = num
def set_depth(self):
for n in self.nodes:
t_n = n
while t_n.parent != -1:
n.depth += 1
t_n = self.nodes[t_n.parent]
def show_nodes_info(self):
for n in self.nodes:
n.show_info()
import sys
n = int(sys.stdin.readline())
T = RootedTree(n)
for x in sys.stdin.readlines():
T.set_node(x)
T.set_depth()
T.show_nodes_info()
|
class Node:
def __init__(self, num, parent, *children):
self.id = num
self.parent = parent
self.children = list(children)
self.depth = 0
def show_info(self):
print('node {0}: '.format(self.id), end = '')
print('parent = {0}, '.format(self.parent), end = '')
print('depth = {0}, '.format(self.depth), end = '')
if self.children and self.parent != -1:
print('internal node, ', end = '')
elif self.parent != -1:
print('leaf, ', end = '')
else:
print('root, ', end = '')
print(self.children)
def set_node(i_p):
i_p = list(map(int, i_p.split()))
num = i_p[0]
children = i_p[2:]
if children:
T[num].children = children
for n in children:
T[n].parent = num
def find_root(node):
while node.parent != -1:
node = T[node.parent]
return node
def set_depth(node, depth):
node.depth = depth
for n in node.children:
set_depth(T[n], depth + 1)
import sys
n = int(sys.stdin.readline())
T = [Node(i, -1) for i in range(n)]
for x in sys.stdin.readlines():
set_node(x)
r_n = find_root(T[0])
set_depth(r_n, 0)
for n in T:
n.show_info()
|
p02279
|
class Node:
def __init__(self, num, parent, children):
self.id = num
self.parent = -1
self.children = children
self.depth = 0
def show_info(self):
print('node {0}: '.format(self.id), end = '')
print('parent = {0}, '.format(self.parent), end = '')
print('depth = {0}, '.format(self.depth), end = '')
if self.children and self.parent != -1:
print('internal node, ', end = '')
elif self.parent != -1:
print('leaf, ', end = '')
else:
print('root, ', end = '')
print(self.children)
def set_node(i_s):
i_l = list(map(int, i_s.split()))
num = i_l[0]
children = i_l[2:]
node = Node(num, -1, children)
T[num] = node
for n in children:
rn_check_list.remove(n)
def set_pd(node, parent, depth):
node.parent = parent
node.depth = depth
for n in node.children:
set_pd(T[n], node.id, depth + 1)
import sys
n = int(sys.stdin.readline())
T = [None for i in range(n)]
rn_check_list = [i for i in range(n)]
for x in sys.stdin.readlines():
set_node(x)
rn_i = rn_check_list[0]
set_pd(T[rn_i], -1, 0)
for n in T:
n.show_info()
|
class Node:
def __init__(self, num, parent, children):
self.id = num
self.parent = -1
self.children = children
self.depth = 0
def show_info(self):
print('node {0}: '.format(self.id), end = '')
print('parent = {0}, '.format(self.parent), end = '')
print('depth = {0}, '.format(self.depth), end = '')
if self.children and self.parent != -1:
print('internal node, ', end = '')
elif self.parent != -1:
print('leaf, ', end = '')
else:
print('root, ', end = '')
print(self.children)
def set_node(i_s):
i_l = list(map(int, i_s.split()))
num = i_l[0]
children = i_l[2:]
node = Node(num, -1, children)
T[num] = node
for n in children:
T[-1] -= n
def set_pd(node, parent, depth):
node.parent = parent
node.depth = depth
for n in node.children:
set_pd(T[n], node.id, depth + 1)
import sys
n = int(sys.stdin.readline())
T = [None for i in range(n)]
T.append(int(n * (n - 1) / 2))
for x in sys.stdin.readlines():
set_node(x)
set_pd(T[T[-1]], -1, 0)
for n in T[:-1]:
n.show_info()
|
p02279
|
class Node:
def __init__(self, num, parent, children):
self.id = num
self.parent = -1
self.children = children
self.depth = 0
def show_info(self):
print('node {0}: '.format(self.id), end = '')
print('parent = {0}, '.format(self.parent), end = '')
print('depth = {0}, '.format(self.depth), end = '')
if self.children and self.parent != -1:
print('internal node, ', end = '')
elif self.parent != -1:
print('leaf, ', end = '')
else:
print('root, ', end = '')
print(self.children)
def set_node(i_s):
i_l = list(map(int, i_s.split()))
num = i_l[0]
children = i_l[2:]
node = Node(num, -1, children)
T[num] = node
for n in children:
T[-1] -= n
def set_pd(n_i, parent, depth):
node = T[n_i]
node.parent = parent
node.depth = depth
for n in node.children:
set_pd(n, n_i, depth + 1)
import sys
n = int(sys.stdin.readline())
T = [None] * n
T.append(int(n * (n - 1) / 2))
for x in sys.stdin.readlines():
set_node(x)
set_pd(T[-1], -1, 0)
for n in T[:-1]:
n.show_info()
|
class Node:
def __init__(self, num, parent, children):
self.id = num
self.parent = -1
self.depth = 0
self.type = None
self.children = children
def show_info(self):
print(('node {0}: parent = {1}, depth = {2}, {3}, {4}'.format(self.id,
self.parent,
self.depth,
self.type,
self.children)))
def set_node(i_s):
i_l = list(map(int, i_s.split()))
num = i_l[0]
children = i_l[2:]
node = Node(num, -1, children)
T[num] = node
for n in children:
T[-1] -= n
def set_pdt(n_i, parent, depth):
node = T[n_i]
node.parent = parent
node.depth = depth
if node.children:
node.type = 'internal node'
for n in node.children:
set_pdt(n, n_i, depth + 1)
else:
node.type = 'leaf'
import sys
n = int(sys.stdin.readline())
T = [None] * n
T.append(int(n * (n - 1) / 2))
for x in sys.stdin.readlines():
set_node(x)
set_pdt(T[-1], -1, 0)
T[T[-1]].type ='root'
for n in T[:-1]:
n.show_info()
|
p02279
|
# -*- coding: utf-8 -*-
class Node_Class():
def __init__(self, c_list):
self.c_list = c_list
n = int(input())
node_dic = {}
p_list = [0]*n
d_list = [0]*n
t_list = ['']*n
for i in range(n):
line = list(map(str, input().split()))
if int(line[1]) > 0:
node_dic[int(line[0])] = Node_Class(list(map(int, line[2:])))
else:
node_dic[int(line[0])] = Node_Class([])
#parent
for i in range(n):
flag = False
for j in range(n):
if i in node_dic[j].c_list:
p_list[i] = j
flag = True
break
if not flag:
p_list[i] = -1
#depth
for i in range(n):
j = i
while p_list[j] > -1:
j = p_list[j]
d_list[i] += 1
#type
for i in range(n):
if p_list[i] == -1:
t_list[i] = t_list[i] + "root"
else:
if len(node_dic[i].c_list):
t_list[i] = t_list[i] + "internal node"
else:
t_list[i] = t_list[i] + "leaf"
#print
for i in range(n):
s = "node %d: parent = %d, depth = %d, %s," %(i, p_list[i], d_list[i], t_list[i])
print(s, node_dic[i].c_list)
|
# -*- coding: utf-8 -*-
class Node_Class():
def __init__(self, c_list):
self.c_list = c_list
n = int(input())
node_dic = {}
p_list = [0]*n
d_list = [0]*n
t_list = ['']*n
root = 0
for i in range(n):
root += i
for i in range(n):
line = list(map(str, input().split()))
if int(line[1]) > 0:
node_dic[int(line[0])] = Node_Class(list(map(int, line[2:])))
else:
node_dic[int(line[0])] = Node_Class([])
#parent
for i in range(n):
for j in node_dic[i].c_list:
p_list[j] = i
root -= j
p_list[root] = -1
#depth
for i in range(n):
j = i
while p_list[j] > -1:
j = p_list[j]
d_list[i] += 1
#type
for i in range(n):
if p_list[i] == -1:
t_list[i] = t_list[i] + "root"
else:
if len(node_dic[i].c_list):
t_list[i] = t_list[i] + "internal node"
else:
t_list[i] = t_list[i] + "leaf"
#print
for i in range(n):
s = "node %d: parent = %d, depth = %d, %s," %(i, p_list[i], d_list[i], t_list[i])
print(s, node_dic[i].c_list)
|
p02279
|
def q(a,h):
d[a]=str(h)
for b in t[a]:q(b,h+1)
t,p,d={},{},{}
for _ in[0]*int(eval(input())):
e=input().split()
t[e[0]]=e[2:]
for i in e[2:]:p[i]=e[0]
r=(set(t)-set(p)).pop()
p[r]='-1'
q(r,0)
for i in sorted(map(int,t)):
i=str(i)
f='root'if'-1'==p[i]else'internal node'if t[i]else'leaf'
print(f'node {i}: parent = {p[i]}, depth = {d[i]}, {f}, {list(map(int,t[i]))}')
|
def q(a,h):
d[a]=str(h)
for b in t[a]:q(b,h+1)
t,p,d={},{},{}
for _ in[0]*int(eval(input())):
e=input().split()
t[e[0]]=e[2:]
for i in e[2:]:p[i]=e[0]
r=(set(t)-set(p)).pop()
p[r]='-1'
q(r,0)
for i in sorted(map(int,t)):i=str(i);print(f"node {i}: parent = {p[i]}, depth = {d[i]}, {'root'if'-1'==p[i]else'internal node'if t[i]else'leaf'}, [{', '.join(t[i])}]")
|
p02279
|
def q(a,h):
d[a]=str(h)
for b in t[a]:q(b,h+1)
t,p,d={},{},{}
for _ in[0]*int(eval(input())):
e=input().split()
t[e[0]]=e[2:]
for i in e[2:]:p[i]=e[0]
r=(set(t)-set(p)).pop()
p[r]='-1'
q(r,0)
print(('\n'.join(f"node {i}: parent = {p[i]}, depth = {d[i]}, {'root'if'-1'==p[i]else'internal node'if t[i]else'leaf'}, [{', '.join(t[i])}]"for i in map(str,sorted(map(int,t))))))
|
import sys
def q(a,h):
d[a]=str(h)
for b in t[a]:q(b,h+1)
t,p,d={},{},{}
eval(input())
for e in sys.stdin:
e=e.split()
t[e[0]]=e[2:]
for i in e[2:]:p[i]=e[0]
r=(set(t)-set(p)).pop()
p[r]='-1'
q(r,0)
print(('\n'.join(f"node {i}: parent = {p[i]}, depth = {d[i]}, {'root'if'-1'==p[i]else'internal node'if t[i]else'leaf'}, [{', '.join(t[i])}]"for i in map(str,sorted(map(int,t))))))
|
p02279
|
class Tree:
def __init__(self):
self.id = 0
self.p = -1
self.depth = -1
self.type = "leaf"
self.len_c = 0
self.c = []
def __str__(self):
return f"node {self.id}: parent = {self.p}, depth = {self.depth}, {self.type}, {self.c}"
n = int(eval(input()))
li = [Tree() for _ in range(n)]
for _ in range(n):
id, k, *c = list(map(int, input().split()))
if k == 0:
c = []
else:
li[id].type = "internal node"
li[id].id = id
li[id].c = c
for j in c:
li[j].p = id
root = 0
while True:
a = li[root].p
if a == -1:
li[root].type = "root"
li[root].depth = 0
break
root = a
dp = [(root, 0)]
while dp:
id, d = dp.pop()
for i in li[id].c:
li[i].depth = d + 1
dp.append((i, d + 1))
for i in range(n):
print((li[i]))
|
import sys
readline = sys.stdin.readline
class Tree:
def __init__(self):
self.id = 0
self.p = -1
self.depth = -1
self.type = "leaf"
self.len_c = 0
self.c = []
def __str__(self):
return f"node {self.id}: parent = {self.p}, depth = {self.depth}, {self.type}, {self.c}"
n = int(eval(input()))
li = [Tree() for _ in range(n)]
for _ in range(n):
id, k, *c = list(map(int, readline().split()))
if k == 0:
c = []
else:
li[id].type = "internal node"
li[id].id = id
li[id].c = c
for j in c:
li[j].p = id
root = 0
while True:
a = li[root].p
if a == -1:
li[root].type = "root"
li[root].depth = 0
break
root = a
dp = [(root, 0)]
while dp:
id, d = dp.pop()
for i in li[id].c:
li[i].depth = d + 1
dp.append((i, d + 1))
for i in range(n):
print((li[i]))
|
p02279
|
import sys
readline = sys.stdin.readline
class Tree:
def __init__(self):
self.id = 0
self.p = -1
self.depth = -1
self.type = "leaf"
self.len_c = 0
self.c = []
def __str__(self):
return f"node {self.id}: parent = {self.p}, depth = {self.depth}, {self.type}, {self.c}"
n = int(eval(input()))
li = [Tree() for _ in range(n)]
for _ in range(n):
id, k, *c = list(map(int, readline().split()))
if k == 0:
c = []
else:
li[id].type = "internal node"
li[id].id = id
li[id].c = c
for j in c:
li[j].p = id
root = 0
while True:
a = li[root].p
if a == -1:
li[root].type = "root"
li[root].depth = 0
break
root = a
dp = [(root, 0)]
while dp:
id, d = dp.pop()
for i in li[id].c:
li[i].depth = d + 1
dp.append((i, d + 1))
for i in range(n):
print((li[i]))
|
import sys
readline = sys.stdin.readline
class Tree:
__slots__ = ['id', 'p', 'depth', 'type', 'len_c', 'c']
def __init__(self):
self.id = 0
self.p = -1
self.depth = -1
self.type = "leaf"
self.len_c = 0
self.c = []
def __str__(self):
return f"node {self.id}: parent = {self.p}, depth = {self.depth}, {self.type}, {self.c}"
n = int(eval(input()))
li = [Tree() for _ in range(n)]
for _ in range(n):
id, k, *c = list(map(int, readline().split()))
if k == 0:
c = []
else:
li[id].type = "internal node"
li[id].id = id
li[id].c = c
for j in c:
li[j].p = id
root = 0
while True:
a = li[root].p
if a == -1:
li[root].type = "root"
li[root].depth = 0
break
root = a
dp = [(root, 0)]
while dp:
id, d = dp.pop()
for i in li[id].c:
li[i].depth = d + 1
dp.append((i, d + 1))
for i in range(n):
print((li[i]))
|
p02279
|
import sys
readline = sys.stdin.readline
class Tree:
__slots__ = ['id', 'p', 'depth', 'type', 'c']
def __init__(self):
self.id = 0
self.p = -1
self.depth = -1
self.type = "leaf"
self.c = []
def __str__(self):
return f"node {self.id}: parent = {self.p}, depth = {self.depth}, {self.type}, {self.c}"
n = int(input())
li = [Tree() for _ in range(n)]
for _ in range(n):
id, k, *c = map(int, readline().split())
if k == 0:
c = []
else:
li[id].type = "internal node"
li[id].id = id
li[id].c = c
for j in c:
li[j].p = id
root = 0
while True:
a = li[root].p
if a == -1:
li[root].type = "root"
li[root].depth = 0
break
root = a
dp = [(root, 0)]
while dp:
id, d = dp.pop()
d += 1
for i in li[id].c:
li[i].depth = d
dp.append((i, d))
print(*li, sep="\n")
|
import sys
readline = sys.stdin.readline
class Tree:
__slots__ = ['id', 'p', 'depth', 'type', 'c']
def __init__(self):
self.id = 0
self.p = -1
self.depth = -1
self.type = "leaf"
self.c = []
def __str__(self):
return f"node {self.id}: parent = {self.p}, depth = {self.depth}, {self.type}, {self.c}"
n = int(input())
li = tuple(Tree() for _ in range(n))
for _ in range(n):
id, k, *c = map(int, readline().split())
if k == 0:
c = []
else:
li[id].type = "internal node"
li[id].id = id
li[id].c = c
for j in c:
li[j].p = id
root = 0
while True:
a = li[root].p
if a == -1:
li[root].type = "root"
li[root].depth = 0
break
root = a
dp = [(root, 0)]
while dp:
id, d = dp.pop()
d += 1
for i in li[id].c:
li[i].depth = d
dp.append((i, d))
print(*li, sep="\n")
|
p02279
|
class Tree:
nodes = []
def __init__(self, root = None):
self.root = root
def insert(self, label, children = []):
self.nodes.append(Node(label, children))
def search_label(self, label):
for i in self.nodes:
if i.label == label:
return i
def find_parent(self):
for i in self.nodes:
if i.children != []:
for k in i.children:
self.search_label(k).parent = i.label
def distribute_type(self):
for i in self.nodes:
if i.parent != -1:
if i.children == []:
i.type_ = "leaf"
else:
i.type_ = "internal node"
def distribute_depth(self, node):
if node.children == []:
return
for i in node.children:
x = self.search_label(i)
x.depth += node.depth + 1
self.distribute_depth(x)
class Node:
# type_は0:root, 1:internal node, 2:leaf
def __init__(self, label, children = []):
self.label = label
self.type_ = "root"
self.depth = 0
self.parent = -1
self.children = children
tree = Tree()
n = int(eval(input()))
for i in range(n):
a = list(map(int, input().split()))
label = a[0]
if a[1] > 0:
children = a[2:]
tree.insert(label, children)
else:
tree.insert(label)
tree.find_parent()
tree.distribute_type()
tree.nodes.sort(key = lambda x: x.label)
for i in tree.nodes:
if i.type_ == "root":
tree.distribute_depth(i)
for i in tree.nodes:
print(("node {0:}: parent = {1:}, depth = {2:}, {3:}, {4:}".format(i.label, i.parent, i.depth, i.type_, i.children)))
|
class Tree:
nodes = []
def __init__(self, root = None):
None
def insert(self, label, children = []):
if children != []:
for i in children:
self.nodes[label].children.append(self.nodes[i])
self.nodes[i].parent = self.nodes[label]
self.nodes[i].type_ = "internal node"
def depth(self, node):
if node.children == []:
node.type_ = "leaf"
else:
for i in node.children:
i.depth = node.depth + 1
self.depth(i)
class Node:
def __init__(self, label, children = []):
self.label = label
self.type_ = "root"
self.depth = 0
self.parent = -1
self.children = [] # self.children = childrenにするとハマる
tree = Tree()
n = int(input())
for i in range(n):
tree.nodes.append(Node(i))
for i in range(n):
children = []
label, num, *children = map(int, input().split())
tree.insert(label, children)
for i in tree.nodes:
if i.parent == -1:
tree.depth(i)
None
if n == 1:
tree.nodes[0].type_ = "root"
for i in tree.nodes:
print("node {0:}: parent = {1:}, depth = {2:}, {3:}, ".\
format(i.label, i.parent if i.parent == -1 else i.parent.label,\
i.depth, i.type_), end = "")
print([i.label for i in i.children])
|
p02279
|
# coding: utf-8
# Here your code !
from collections import deque
class Node:
def __init__(self):
self.id = -1
self.k = -1
self.depth = -1
self.parent = -1
self.type = 'root'
self.end = False
self.children = []
def find_root_id(nodes):
i = 0
rootid = -1
while nodes[i].parent != -1:
nodes[i]
i += 1
else:
rootid = nodes[i].id
return rootid
def set_depth(rootid, nodes):
que = deque()
depth = 0
node = nodes[rootid]
que = deque(node.children)
for i in que:
nodes[i].depth = depth + 1
depth += 1
while que:
for i in range(len(que)):
for child in nodes[que.popleft()].children:
que.append(child)
for j in que:
nodes[j].depth = depth + 1
depth += 1
n = int(input())
nodes = []
for i in range(n):
node = Node()
ls = list(map(int, input().split()))
node.id = ls[0]
node.k = ls[1]
if node.k == 0:
pass
else:
node.children = ls[2:]
nodes.append(node)
nodes = sorted(nodes, key=lambda node:node.id)
for node in nodes:
for child in node.children:
nodes[child].parent = node.id
for node in nodes:
if node.children == []:
if node.parent != -1:
node.type = 'leaf'
else:
if node.parent != -1:
node.type = 'internal node'
rootid = find_root_id(nodes)
nodes[rootid].depth = 0
def set_depth(rootid, nodes):
que = deque()
depth = 0
node = nodes[rootid]
que = deque(node.children)
for i in que:
nodes[i].depth = depth + 1
depth += 1
while que:
for i in range(len(que)):
for child in nodes[que.popleft()].children:
que.append(child)
for j in que:
nodes[j].depth = depth + 1
depth += 1
set_depth(rootid, nodes)
for node in nodes:#sorted(nodes, key=lambda node:node.id):
print('node %s: parent = %s, depth = %s, %s, %s'%(node.id,
node.parent, node.depth, node.type, node.children))
|
# coding: utf-8
from collections import deque
class Node:
def __init__(self):
self.id = -1
self.k = -1
self.depth = -1
self.parent = -1
self.type = 'root'
self.end = False
self.children = []
def find_root_id(nodes):
i = 0
rootid = -1
while nodes[i].parent != -1:
nodes[i]
i += 1
else:
rootid = nodes[i].id
return rootid
def set_depth(rootid, nodes):
que = deque()
depth = 0
node = nodes[rootid]
que = deque(node.children)
for i in que:
nodes[i].depth = depth + 1
depth += 1
while que:
for i in range(len(que)):
for child in nodes[que.popleft()].children:
que.append(child)
for j in que:
nodes[j].depth = depth + 1
depth += 1
n = int(input())
nodes = []
for i in range(n):
node = Node()
ls = list(map(int, input().split()))
node.id = ls[0]
node.k = ls[1]
if node.k == 0:
pass
else:
node.children = ls[2:]
nodes.append(node)
nodes = sorted(nodes, key=lambda node:node.id)
for node in nodes:
for child in node.children:
nodes[child].parent = node.id
for node in nodes:
if node.children == []:
if node.parent != -1:
node.type = 'leaf'
else:
if node.parent != -1:
node.type = 'internal node'
rootid = find_root_id(nodes)
nodes[rootid].depth = 0
set_depth(rootid, nodes)
for node in nodes:
print('node %s: parent = %s, depth = %s, %s, %s'%(node.id, node.parent, node.depth, node.type, node.children))
|
p02279
|
class Node:
def __init__(self):
self.p = None
self.depth = None
self.l = None
self.r = None
def show(self, i):
global T
ans = 'node {}: parent = {}, depth = {}, {}, {}'.format(i, self.p, self.depth, self.t(), self.degree(T))
print(ans)
def degree(self, T):
if self.l != None:
deg = [self.l]
ch = T[self.l]
while ch.r != None:
deg.append(ch.r)
ch = T[ch.r]
return deg
else:
return []
def t(self):
if self.p == -1:
return 'root'
elif self.l == None:
return 'leaf'
else:
return 'internal node'
def set_depth(root, d):
r = T[root]
r.depth = d
if r.r != None:
set_depth(r.r, d)
if r.l != None:
set_depth(r.l, d+1)
n = int(eval(input()))
T = [Node() for x in range(n)]
for i in range(n):
A = list(map(int, input().split()))
l = 0
for x in range(A[1]):
if x == 0:
T[A[0]].l = A[2:][x]
else:
T[l].r = A[2:][x]
l = A[2:][x]
T[A[2:][x]].p = A[0]
root = None
for i in range(n):
if T[i].p == None:
root = i
T[root].p = -1
set_depth(root, 0)
count = 0
for node in T:
node.show(count)
count += 1
|
def set_info(i, p, d):
r = T[i]
r[1], r[2] = p, d
for c in r[0]:
set_info(c, i, d+1)
n = int(eval(input()))
T = [None] * n
root = set(range(n))
for i in range(n):
A = list(map(int, input().split()))
ch = A[2:]
T[A[0]] = [ch, None, None]
root -= set(ch)
set_info(root.pop(), -1, 0)
for i,node in enumerate(T):
ch, p, d = node
print(('node {}: parent = {}, depth = {}, {}, {}'.format(
i, p, d, 'root' if not d else 'internal node' if ch else 'leaf', ch
)))
|
p02279
|
def set_pdt(i, p, d):
u = tree[i]
u[0], u[1] = p, d
for c in u[3]:
set_pdt(c, i, d+1)
else:
if u[0] == -1:
u[2] = "root"
elif u[3]:
u[2] = "internal node"
else:
u[2] = "leaf"
n = int(eval(input()))
# p d t ch
tree = [[-1,0,0,0] for _ in range(n)]
root = set(range(n))
for _ in range(n):
i, k, *c = list(map(int, input().split()))
tree[i][3] = c
root -= set(c)
for u in root:
set_pdt(u, -1, 0)
for i in range(n):
u = tree[i]
print(("node {}: parent = {}, depth = {}, {}, {}".format(i, *u)))
|
def set_pdt(i, p, d):
u = tree[i]
u[0], u[1] = p, d
for c in u[3]:
set_pdt(c, i, d+1)
else:
if u[0] == -1:
u[2] = "root"
elif u[3]:
u[2] = "internal node"
else:
u[2] = "leaf"
n = int(eval(input()))
tree = [[-1,0,0,0] for _ in range(n)]
root = set(range(n))
for _ in range(n):
i, k, *c = list(map(int, input().split()))
tree[i][3] = c
root -= set(c)
set_pdt(root.pop(), -1, 0)
for i in range(n):
u = tree[i]
print(("node {}: parent = {}, depth = {}, {}, {}".format(i, *u)))
|
p02279
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.