뭐든지 다 알아보자

import sys

def fact(n):

    if n > 1:
        return n*fact(n-1)
    else :
        return 1
a = int(sys.stdin.readline())
print(fact(a))

# fact (10) = 10*fact(9)
# fact(9) = 9*fact(8)
#
#
#
# fact(2) = 2*fact(1)
# fact(1) = 1

import sys

N = int(sys.stdin.readline())

#2 4 -10 4 -9
#2는 -10 -9로 2개
#4는 2 -10 09로 3개
#-10은 0개
#4는 3개
#-9는 1개
A = list(map(int, sys.stdin.readline().rstrip().split()))

B = sorted(list(set(A)) , reverse= False)
dic = {}
for i in range(len(B)):
    dic[B[i]] = i
    #B[0] = -10 : 0
    #B[1] = -9 : 1
    #B[2] = 2 : 2
    #B[3] = 4 : 3
for i in A:
    print(dic[i] , end = ' ')
    #dic[2] = 2
    #dic[4] = 3

index는 시간복잡도 O(n) 으로 시간초과가 난다.

dictionary를 적극활용하자!

import sys
import math


def is_prime_num(n):
    res=[]
    array = []
    for i in range(n+1):
        array.append(True) #에라토스테네스의 체 사용위해 array에 True값 삽입
    array[0] , array[1] = 0 , 0
    for j in range(2, int(math.sqrt(n)) +1 ):
        if array[j] == True:
            k =2
            while j*k <= n:
                array[j*k] =0 #소수가 아니라면 0이라고 처리한다.
                k+=1
            res.append(j)
    return res #소수만 출력


T = int(sys.stdin.readline())
res = []
for k in range(T):
    a = int(sys.stdin.readline())

    #res_array = is_prime_num(a)


    c,d = a//2 , a//2
    while c > 0:
        if c in is_prime_num(c) and d in is_prime_num(d):
            res.append(f'{c} {d}')
            break
        else:
            c -= 1 #c를 -1
            d += 1 #d를 +1 하여 와리가리 하게 할 수 있다.
for i in res:
    print(i)

c -=1 과 d+=1 을 기억해서 처리하자.

import sys

N = int(sys.stdin.readline()) #72
M=N # M = 72
i=2
A=[]
while i<=N: #1 ) 2<= 72 2) 2<= 36
    if M%i==0: #72%2 == 0 36%2 == 0
        M = M//i #M = 72//2 = 36 M = 36//2 = 18
        A.append(i) 
    else:
        i+=1

A= sorted(A)
for i in A:
    print(i)

살짝 노가다성의 코드로 풀이

1. git lfs 다운로드

대용량 파일들을 업로드 하기 위해 git lfs를 사용할 수 있다.

https://git-lfs.github.com/

여기서 다운로드

or git lfs install


2. 추적 설정,업로드

git lfs track "*.csv"

3.git add .gitattributes ==> lfs로 트래킹하는 파일 정보는 .gitattributes를 통하여 관리가 된다.

4.git commit -m "~~~"

5.git push origin +master

VERSION 2.0

import sys

#설탕 봉지는 3kg , 5kg 봉지

#5x+3y = N

# 22g 5kg 봉지==> 22-(5*4(개)) ==2 22-(5*3(개)) == 7 22-(5*2(개)) == 12
# 6KG 5kg 봉지 ==? 6-(5*1(개)) ==1
N = int(sys.stdin.readline())
a = N//5 #첫 갯수
#print('a : ' ,a)
res = 0

if N%5 ==0:
    res += (N//5)
else:
    while True:
        B = N -(5*a)
        #print('B : ', B)
    
        if B%3 ==0:
            res+= a+ (B//3)
            break
        elif B%3 !=0:
            a-=1
        if a <= 0 :
            if N%3 == 0:
                res += N//3
            else:
                res = -1
            break
print(res)

VERSION 1.0

import sys
N = int(sys.stdin.readline())
five , three = 0 , 0
M = N
while True:
    if N%5 == 0:
        five = N//5
        break
    else:
        M -=3
        if M >= 0:
            three+=1
            if M %5 ==0:
                five = M//5
                break
        else:
            break
if (3*three) + (5*five) != N:
    print(-1)
else:
    result = five + three
    print(result)

VERSION 2.0

import sys
T = int(sys.stdin.readline()) #테스트케이스
res = []
for i in range(T):

    A = list(map(int, sys.stdin.readline().rstrip().split()))
    H =  A[0] #층수
    W = A[1] #각층의 방수
    N = A[2] #손님의 수

    son_floor = N%H
    if son_floor == 0:
        son_floor += H

    son_hosu = N//H
    if son_hosu < N/H:
        son_hosu+=1
    res.append("{}{:02d}".format(son_floor,son_hosu))
for i in res:
    print(i)

res.append("{}{:02d}".format() 형식 잘 기억해두자!!!!

VERSION 1.0

#W개의 방이 있는 H층 건물
#1<= H,W <=99
#방번호 :  YXX 나 YYXX 형태인데 여기서 Y 나 YY 는 층 수를 나타내고 
# XX 는 엘리베이터에서부터 세었을 때의 번호를 나타낸다. 
#다만 걷는 거리가 같을 때에는 아래층의 방을 더 선호한다. 예를 들면 102 호 방보다는 301 호 방을 더 선호하는데, 
# 102 호는 거리 2 만큼 걸어야 하지만 
# 301 호는 거리 1 만큼만 걸으면 되기 때문이다. 
# 같은 이유로 102 호보다 2101 호를 더 선호한다.
# N 번째로 도착한 손님에게 배정될 방 번호를 계산하는 프로그램이다. 
# 첫 번째 손님은 101 호, 두 번째 손님은 201 호 등과 같이 배정한다. 그림 1 의 경우를 예로 들면, 
# H = 6이므로 10 번째 손님은 402 호에 배정해야 한다.
import sys
import math

i=0
room=[]
T = int(sys.stdin.readline())
while i<T:
    H,W,N = map(int,sys.stdin.readline().split())#H층 W개방, N번째 도착손님

    a = N%H
    b = math.ceil(N/H)
    if a == 0:
        a = H
    #print("{}{:02d}".format(a,b))
    room.append("{}{:02d}".format(a,b))
    i+=1
for i in room:
    print(i) 
#10%6 = 4 
# 100%7 = 6
#6 12 10 ==>72개의 룸 
#101 201 301 401 501 601
#102 202 302 402 502 602
#7 24 100
#101 201 301 401 501 601 701 ==>7개
#7개*24 = 158개의 룸
#98개(14번째)
#115 215
#30 50 72 ==>30층 50호실 72번째 손님
#72%30 = 12
#72//30 = 2+1 =3
#2004호
#101~~~~~3001 (30개)
#102 ~~ 3002(30개) 
# 103~1003(10개) 1103 1203
#20 40 100
#101~2001(20개)
#105~1905(20*4 + 19) 2005

문제파악 및 알고리즘 분석단계

1. W개의 방이 있는 H층 건물

2. 1<= H,W <=99

3. 방번호 :  YXX 나 YYXX 형태인데 여기서 Y 나 YY 는 층 수를 나타내고 XX 는 엘리베이터에서부터 세었을 때의 번호를 나타낸다. 

4. 다만 걷는 거리가 같을 때에는 아래층의 방을 더 선호한다. 예를 들면 102 호 방보다는 301 호 방을 더 선호하는데, 102 호는 거리 2 만큼 걸어야 하지만  301 호는 거리 1 만큼만 걸으면 되기 때문이다. 같은 이유로 102 호보다 2101 호를 더 선호한다.

5. N 번째로 도착한 손님에게 배정될 방 번호를 계산하는 프로그램이다. 

6. 첫 번째 손님은 101 호, 두 번째 손님은 201 호 등과 같이 배정한다. 그림 1 의 경우를 예로 들면, 

 H = 6이므로 10 번째 손님은 402 호에 배정해야 한다.

==================

알고리즘 분석단계

==================

1. 10%6 = 4  100%7 = 6

2. 6 12 10 ==>72개의 룸(H층 W개의 호실, N번째 손님)

101 201 301 401 501 601

102 202 302 402 502 602

.

.

.

3.7 24 100 ==> 7층 24개호실 100번째 손님

101 201 301 401 501 601 701 ==>7개

올림(100//7) = 15

100%7 = 2

7개*24 = 158개의 룸

98개(14번째)

115 215

==> 215 배정

4.30 50 72 ==>30층 50호실 72번째 손님

72%30 = 12

72//30 + 1 = 2+1 =3

101~~~~~3001 (30개)

102 ~~ 3002(30개) 

103~1003(10개) 1103 1203

==> 1203호

5.20 40 100 ==>20층 40호실 100번째 손님  

100%20 = 0 ==> 0일경우 층수 그대로 출력

100//20 = 5

101~2001(20개)

.

.

.

.104~2004(20개 * 4)

105~1905  2005

==================

코딩

==================

17번째줄 : TestCase 횟수 입력

18번째줄: i값이 T보다 작을경우 반복문 계속 실행

19번째줄: H,W,N 값 받기

21번째줄 : a = N%H ==>N번째도착 손님 % H층의 나머지(층수)

22번째줄 : b = 올림(N/H) ==> N번째 도착 손님 / H층의 몫의 올림값 (호수)

23~24번째줄: 층수의 값이 0일경우 층수 그대로 출력

★★★KEY POINT★★★

1. N번째도착 손님 % H층의 나머지(층수) 에 대한 이해

2.  N번째 도착 손님 / H층의 몫의 올림값 (호수)

VERSION 2.0

import sys

#A = list(map(int, sys.stdin.readline().rstrip().split()))
#print(A)

# a = A[0]
# b = A[1]
# V = A[2]
# for i in range(3):
A = list(map(int, sys.stdin.readline().rstrip().split()))
a = A[0]
b = A[1]
V = A[2]
def func(k , a, b):
    res = (a-b)*k + b
    return res
k = (V-b)//(a-b)
if func(k ,a ,b) < V < func(k+1, a, b):
    print(k+1)

elif func(k,a,b) == V:
    print(k)

낮에 올라간 값들이 수열을 이룬다. 따라서 이를 분석해보자

VERSION 1.0

import sys
import math

A = list(map(int,sys.stdin.readline().split()))

#2 1 5 ==> 5//(2-1) = 5 if (2-1)*(5-2) + 2 >= 5 ==> 5-1 = 4 출력
#5 1 6 ==> 6//(5-1) ==>올림(2) if (5-1)*(2-2) + 5 >= 6 ==> +1 
# ==> (5-1)*(2-1) +5 >=6 ==> +1 ==> 2출력 
#2 -1 2 -1 2 -1 2
firstday = 0
a =2
#firstday = math.ceil((A[2]/(A[0]-A[1])))
#5 1 6 
#6/(5-1) = 1.5 ==> firstday = 2 
# 0 + 5 >=6 x ==> 2출력
#100 99 1000000000
#1000000000/1 = 1000000000
#1*999999998 + 100 > 1000000000
#1*999999900 + 100 > 1000000000
#500 450 5000 ==> firstday = 100 98*50=4900 95*50 = 4750 90*50= 4500
# 5000/ 500 = 9 100-(9+1) 90*50 = 4500 91*500
#500 450 5100 ==> 10.2 50*10 =5000 4500 5000 5500 
#5 1 6 ==>6/4=2 4*(2-3) + 5
#50* 100-(a=10) +500>=A[2]
#500 470 5000 ==> firstday = (5000-500)/30 =150 ==> 167 second =5000/500 = 10 167-10=157
#2 1 5 ==> firstday = 5/1 = 5 // A[2]=5 -2 
#1*3 + 2>=5
firstday = 0
a =2
firstday = math.ceil((A[2]-A[0])/(A[0]-A[1]))
# 2 1 5 firstday = (5-2)/1 = 3
#5 1 6 firstday = (6-5)/4 = 0.25 ==> 1 ===>하루+낮 ==>2일 
if ((A[0]-A[1]) *(firstday) + A[0])>=A[2] : #(하루치올라간 높이) * (꽉채운 일 수) + 낮에 올라가기 >= 전체 높이  
    #1*3 +2 >= 5 
    print(firstday+1) #낮에 올라간거 포함시켜야하므로 하루 더한다.
else: 
    #5 1 6 firstday = (6-5)/1 = 1
    #4*1 + 5>=1
    print(firstday) #

    #100 99 1000000000
    #

깔끔히 정리한 코드

======================================================================

import sys
import math

A = list(map(int,sys.stdin.readline().split()))
firstday = 0
firstday = math.ceil((A[2]-A[0])/(A[0]-A[1]))
if ((A[0]-A[1]) *(firstday) + A[0])>=A[2] : 
    print(firstday+1) 
else: 
    print(firstday)

달팽이 문제 파악 알고리즘 순서 : 

1.  V미터인 나무 막대 , 낮엔 A미터 올라가고 /// 밤엔 B미터 미끄러진다. 정상에 올라간 후에는 미끄러지지 않는다.

2. 낮에 A미터 올라갈려는 경우 V미터에 도달했을때 멈추게 된다.

3. ==>4번째줄 : A리스트에 A[0] = A미터 올라가기 A[1] = B미터 미끄러지기 A[2] = V미터인 나무 막대

         5번째줄 : firstday = 0 => 며칠걸리는지의 변수 선언

         6번째줄 : (V미터 나무막대 - A미터 올라가기)/(A미터 올라가기 - B미터 미끄러지기) 의 올림 값(math.ceil())

                     ==> 소요일을 파악할 수 있다.

          7번째줄~8번째줄 : (A미터 올라가기 - B미터 미끄러지기)*(소요일) + A미터올라가기 >= V미터

                                   print(소요일 +1)

                                  EX) V=6 A=2 B=1  ==> (6-2)/ 1 = 4

                                       (2-1) * 4 + 2 >= 6

                                       firstday = 4 +1  

                                       print(5)

                                  EX_2) V = 6 A=5 B=1 ==> (6-5)/4 = 0.25 ==> 1

                                          (5-1)*1 +5 >=6

                                          firstday = 1 + 1

                                          print(2)

                                  EX_3)V=1000000000 A =100 B=99 ==> (1000000000-100)/1 = 999999900

                                         (100-99)*999999900 + 100 >= 1000000000

                                         firstday = 999999900+1

          9번째줄~10번째줄

 ★★★KEY POINT★★★

1. (V미터 나무막대 - A미터 올라가기)/(A미터 올라가기 - B미터 미끄러지기) 의 올림 값

==> 소요일(다음날의 A미터 올라가기 전의)

2. (A미터 올라가기 - B미터 미끄러지기)*(소요일) + A미터올라가기 >= V미터

    ==>소요일 만큼 올라간후 그다음날의 A미터 올라갔을때 V미터에 도달 혹은 그 이상이라면 소요일+1값을 취해준다.