"""
attribute = 속성. class의 맴버함수 but ()이 필요 없음

<tensor class>
1. .requires_grad : 이 attribute를 True 로 설정하면, 그 tensor에서 이뤄진 모든 연산들을 추적(track)하기 시작
2. .backward() : 호출하여 모든 변화도(gradient)를 자동으로 계산
3. .grad 속성: 이 Tensor의 변화도가 누적됨.
4. .detach() : Tensor가 기록을 추적하는 것을 중단하게 하려면
5. with torch.no_grad(): gradient는 필요없고, 메모리는 절약하고 싶고, 학습가능한 매개변수로 찾고 싶을때.

<Function class>
부호화(encode)하여 순환하지 않는 그래프(acyclic graph)를 생성
1. .grad_fn : Tensor 를 생성한 Function 을 참조

"""
pass

x = torch.ones(2, 2, requires_grad=True)
y = x + 4
print(y)  # AddBackward0 : track all operations
print(y.grad_fn) # 사용자가 마지막으로 이 변수를 만들 때 사용하는 Function을 참조한다. (기억해 놓는다.)

# tensor에서 * / 는 행렬의 곱이 아니라, 같은 위치 원소의 연산이다.
k = torch.tensor([[1,2],[3,4]], requires_grad=True, dtype = torch.double)
print(k*k)

print(y.requires_grad)  # 이 방법으로 y가 gradient tracking 중인지 확인 가능
print(k.requires_grad_(False))   # 이 방법으로 k의 requires_grad 속성 값 변경 가능

x1 = torch.ones(2, 2, requires_grad=True)
x2 = x1 + 3
x3 = 3*(x2 ** 2)
out = torch.mean(x3)  # 1/4 처리가 된다. 4개 원소 평균이므로
# ()에 아무것도 넣지 않으면, torch.tensor(1.). 이 값이 Backpropa의 가장 첫번째 upstream gradient이다.
# 그래서 out이 스칼라여야 하는 것이다. mean을 안하고 x3 = out으로 하고 backward하면, 계산 불가.
out.backward()    # d_out/d_x1 = 3*2/4 ... = 3/2(x+3)|x = 1 = [[6,6],[6,6]]
print(x1.grad)    
# x1.grad는 # d_<backward한것> / d_<.grad 한것> 의 값이 나온다. 
# 생각해보면 d_Loss/d_x1를 이용해 x1을 갱신해야하므로, x1과 똑같은 size의 tensor가 print된다


''' 위에꺼 주석하고 이것도 해보기.
x3.backward(torch.tensor([[1,1],[1,1]],dtype=torch.double))    # d_out/d_x1 = 3*2/4 ... = 3/2(x+3)|x = 1 = [[6,6],[6,6]]
print(x1.grad)    # 생각해보면 d_Loss/d_x1를 이용해 x1을 갱신해야하므로, x1과 똑같은 size의 tensor가 print된다
'''
pass

# 이 with 내부에 작성한 모든 연산들은 gradient tracking을 하지 않는다.
with torch.no_grad():
    print((x1 ** 2).requires_grad)

# .detach() 를 호출하여 내용물(content)은 같지만 require_grad가 다른 새로운 Tensor를 가져옵니다
print(x3.requires_grad)
y3 = x3.detach()
print(y3.requires_grad)
print(x3.eq(y3).all())  # https://pytorch.org/docs/stable/tensors.html#torch.BoolTensor

import math

def solution(progresses, speeds):
    answer = []
    complete_day = []

    for i in range(len(progresses)):
        temp = math.ceil((100 - progresses[i]) / speeds[i] )
        complete_day.append(temp)
        # print(complete_day)
    
    first_of_each_distri = complete_day[0]
    num = 0
    answer = []
    for i in complete_day:
        if first_of_each_distri < i:
            answer.append(num)
            num = 1
            first_of_each_distri = i
        else :
            num += 1
    
    answer.append(num)
    print(answer)
    
    
    return answer

# torch 사용법 백과사전 : https://pytorch.org/docs/stable/
import torch
torch.__version__

# print function에 대하여, 2.x 3.x 버전 둘다 사용가능하게 해줌. print x,y; print(x,y)
from __future__ import print_function 

# 메모리 할당만 해주고, 값은 정의 하지 않는다. 쓰레기 값 저장되어 있을 것.
x = torch.empty(5,3)
print(x)
# 배열을 생성하고 싶을 때. 아래의 값들은 모두 tensor([[],[]])로 저장되어 있다. 
y = torch.rand(2,3)
z = torch.zeros(2,3)
k = torch.ones(2,3,dtype=torch.double)          # torch.double == torch.float64
j = torch.rand_like(k,dtype=torch.float)        # k와 동일한(like) 크기를 가지는 rand tensor를 만든다
# object.size() == object.shape. torch.size는 사실 튜플이다. 모든 곳에서 튜플처럼 이용할 수 있다. 
print(j.shape, ' ==? ',j.size())
n = torch.rand(j.shape) 
m = torch.rand(j.size())
print(type(j.size()))
# list를 가지고 있다면 직접 tensor생성
i = torch.tensor([1,2,3,4])

# operator 같은 size 텐서에서 + - 연산 가능
q = y+z 
q = torch.add(y,z)
q = torch.empty(9,8)    #; print(q)
torch.add(y,z,out=q)    #; print(q)  # torch.add 함수는 자동으로 print해준다.
y.add(z)                # ; y += z 

# 바꿔치기 연산자. 어떤 변수를 통체로 바꿔버리고 싶다면 _ 를 사용하는 메소드를 사용하라.
k.copy_(z)              # 아무리 그래도 y와 z의 shape는 같아야 한다.
y.t_()
# 슬라이싱도 사용할 수 있다. numpy와 같은 방식이다.
print( y[:,1].type(torch.int) )
print( y[:,1].to(torch.int) )

# np.reshape == torch.view
y = torch.randint(10,(2,3))  # 10을 최대 정수로. 2*3행렬 탄생
print(y)
y.resize(6)                 # view도 가능하고 reshape도 가능하고
print(y.resize(6))
y.view(3,2)
print(y.view(3,2))
y.view(-1,6)                # -1을 넣으면 알아서, 적당한 값으로 변환된다.
print(y.view(-1,6))
# 1*1 텐서의 값을 뽑아주는 item메소드
interger = torch.tensor([2]).item()  
print(interger)
print(type(interger))

# tensor와 numpy의 관계는 copy of referecne 관계이다.
a = torch.tensor([1,1,1,2,2])
b = a.numpy()
print(b)
a.add_(1)
print(b,"\n -----")

# numpy를 tensor로 변환
import numpy as np
a = np.ones([2,3])
b = torch.from_numpy(a)
np.add(a,1,out=a)
print(a,"\n",b)

# cuda 사용하기. to 메소드를 사용하면 된다.
if torch.cuda.is_available():
    device = torch.device("cuda")           #cuda사용할 수 있는 gpu id를 device라는 것
    y = torch.ones_like(x,device=device)    #변수 선언을 할 때 처음부터 device를 지정해도 되고, 
    x = x.to(device)                        #나중에 to메소드를 사용해서 device를 지정해도 된다. 
    z.to("cpu", torch.double)

def solution(words):
    answer = 0
    words.sort()
    
    
    for idx in [0, len(words)-1]:
        cases = -1 if idx > 0 else 1
        for order in range(len(words[idx])):
            try:
                if words[idx][order] == words[idx+cases][order]:
                    answer += 1
                else:
                    answer += 1
                    break
            except:
                answer += 1
                break
                
    
    for idx in range(1,len(words)-1):
        left = 0
        right = 0
        for order in range(len(words[idx])):
            try:
                if words[idx-1][order] == words[idx][order]:
                    left += 1
                else:
                    left += 1
                    break
            except:
                left += 1  
                break
        for order in range(len(words[idx])):
            try:
                if words[idx][order] == words[idx+1][order]:
                    right += 1
                else:
                    right += 1
                    break
            except:
                right += 1  
                break
        answer += max(left,right)
    return answer

def solution(words):    
    
    words.sort()
    
    # make zero vector
    counter_vector = []
    for i in range(len(words)):
        counter_vector.append([0 for j in range(len(words[i])+1)])
    
    # fill counter_vector
    word_stack = ['0']*MAX_COUNT
    for i in range(len(words)):
        fill_current_vector(i,words,counter_vector,word_stack)
    
    #print(counter_vector)

    # return answer
    answer = 0
    for i in range(len(words)):
        answer += sum(counter_vector[i])
    return answer




MAX_COUNT = 1000


def fill_current_vector(current_word,words,counter_vector,word_stack):
    while(1):
        current_step = counter_vector[current_word].index(0)
        word_stack[current_step] = words[current_word][current_step]
        
        for i in range(current_word,len(words)):
            if current_step > len(words[i])-1 : break
            if word_stack[current_step] == words[i][current_step] and counter_vector[i].index(0) == current_step :
                counter_vector[i][current_step] = 1
            else : break
        
        # break condition 1
        if counter_vector[current_word][-2] == 1 : break
        # break condition 2, 3
        if current_word == len(words)-1 : break
        else:
            if counter_vector[current_word+1][current_step] == 1 : pass
            else : break

def solution(words):
    char_freq = {}
    for word in words:
        cur = char_freq
        for char in word:
            try:
                cur[char]['num'] += 1
            except:
                cur[char] = {'num':1}
            cur = cur[char]  # cursor 를 마지막에 갱신

    res = 0

    for word in words:
        cur = char_freq
        for char in word:
            res += 1
            if cur[char]['num'] == 1:
                break
            else:
                cur = cur[char]
    return res

def solution(words):
    word_dict = build_dict(words)
    total_num = 0
    for word in words:
        for i in range(len(word)):
            if len(word_dict[word[:i+1]]) == 1:
                total_num += i + 1
                break
        else:
            total_num += len(word)
            
    return total_num

def build_dict(words):
    d = {}
    for word in words:
        for i in range(len(word)):
            if not d.get(word[:i+1]):
                d[word[:i+1]] = [word]
            else:
                d[word[:i+1]].append(word)
    return d