척척석사의 코딩기록

import sys
import math
input = sys.stdin.readline
N = int(input())
result = 1
for i in range (1,N+1):
    result *= i
    while result % 10 == 0:
        result //= 10
    result %= 100_000_000_000

result %= 10
print(result)

인터넷에 여럿 코드가 있었는데, 어째서인지 제것에서 구현할때는 잘 안되더라고요.
최대 길이 4300자를 넘어갔다고 떴던 것으로 기억합니다.

한편 알고리즘은 간단합니다.
파이썬 내장 함수 math로 구할 수 있는 것은 알고 있으나 각 product - attempt마다 10으로 나눈 나머지가 0이 되지 않을때까지 (즉, 0이 사라질때까지) while문을 구현합니다.

그리고, 자릿수가 과도하게 많아지는 것을 방지하기 위해 적절하게 큰 수로 나누어주었습니다.

마지막으로, 마지막 자리수가 필요한 경우이므로 10으로 나눈 뒤 나머지를 구해주면 끝.

import sys
import math
input = sys.stdin.readline

N, K = map(int,input().split())
A = list(map(int,input().split()))
n = len(A)

A.sort(reverse=True)

cnt = 0

for a in A:
    m = A.index(a)
    A.remove(a)
    A.insert(m,K)
    for b in A:
        if a + b <= K:
            l = A.index(b)
            A.remove(b)
            A.insert(l,K)
            cnt += 1
            break
        else:
            continue
print(cnt)

결론적으로 그리디 알고리즘이 아닐까 싶습니다. 

import sys
import math
from decimal import Decimal
input = sys.stdin.readline
X,Y = map(int,input().split())
Z = int(Decimal(Y* 100/X)) 
if Z == 99 or Z == 100:
    print(-1)
else:
    a = Decimal((100*Y - X - Z*X)/(Z-99))
    result = Decimal(int((100*Y - X - Z*X)/(Z-99)) )
    if result - a == 0:
        print(result)
    else:
        print(result + 1)

역시 이런 문제는 부동소수점을 보았을 때 오차가 생길 수 있는데,
그것을 얼마나 "잘" 컨트롤 하느냐에 따른 것 같다.

Decimal을 활용하여 최대한 오차가 없도록 유의했다.

한편, if 이후의 식인데 이는 평범하게 방정식을 풀은 것으로,

Z <= 100*Y / X < Z+1 로 주어진 상황에서
Z + 1 <= 100(Y+a)/(X+a)가 되는 "최소의" a 를 찾는 것 이므로,
사실 그렇게 어려운 상황은 아니다.

위의 방정식을 풀다보면, (Z-99) or (99-Z)가 나올 수 있는데,
이 점이 가능 / 불가능을 나누는 Boundary가 되겠다.

import sys
input = sys.stdin.readline

N, a  = map(int,input().split())
##거듭제곱을 한 결과의 modular 연산에 유용한 툴.
특히, prime number로 나누는 경우## 
def power(a, b):
    if b == 0:
        return 1
    elif b == 1:
        return a
    
    tmp = power(a, b//2)
    if b%2 == 0:
        return tmp*tmp % 1_000_000_007
    return tmp*tmp*a % 1_000_000_007


result = (N * (N-1) *(power(N,a) - power(N-1,a)) 
+ power(N-1,a) * N) % 1_000_000_007


print(result)

항상 어떻게든 규칙성을 찾고 풀려는 기질이 다분하게 보이는 상황이라서 조금 웃기네요.
다른 좋은 방법도 많이 있을 것 같습니다.
코드로 풀어 쓸 것을 그냥 합공식으로 다 때려서 계산해버린 느낌이네요 ㅋㅋ.

Hint: 프랙탈의 둘레 길이는 각각의 step에서 이하와 같이 주어집니다.

Step 1: N^a x (N-1),
Step 2: N^{a-1} x (N-1)^2
Step a: N x (N-1)^a
Final Step: N x (N-1)^a로 주어진다.
Step 1~a의 합: N x (N-1)x (power(N,a)- power(N-1,a))이 되는 것은
N x (N-1)을 공통 인수로 취한 뒤, 등비수열 합공식을 사용하면 알아낼 수 있습니다.
Final step: power(N-1,a) x N

import sys
input = sys.stdin.readline
import math

a,b = map(int,input().split())
N = b * (math.log10(a))
N = int(N) + 1
print(N)

상용로그 함수를 사용하여 자릿수를 계산하는 간단한 문제입니다.

추가로 궁금하신 점이 있다면 말씀해 주세요.