exestudiary

The Curious Case of Benjamin Button

6

a = input().split()
print(len(a))

a = input().strip().split()
print(len(a))

정답이었다.

2
3 ABC
5 /HTP

AAABBBCCC
/////HHHHHTTTTTPPPPP

n = int(input())

for i in range(n):
    x, y = map(str, input().split())
    for j in y:
        print(j*int(x), end = "")
    print()

이번 문제 보면서 나누기만 하면 되겠다고 생각했다.

문자열을 split()함수로 나눠주고 반복문을 통해 하니씩 출력해주면 답이 나올 것이라고 생각했다.

import string
x = input()

alphabet_lower = string.ascii_lowercase

for i in range(len(alphabet_lower)):
    if alphabet_lower[i] in x:
      print(x.index(alphabet_lower[i]), end = " ")
    else:
      print(-1)

import string
alphabet_upper = string.ascii_uppercase
print(alphabet_upper)

n = int(input())

print(' '*(n+1) + '+' + '-'*n + '+')

for i in range(n, 0, -1):
  print(' '*i + '/' + ' '*n + '/' + ' '*(n-i) + '|')

print('+' + '-'*n + '+' + ' '*(n) + '+')

for i in range(n, 0, -1):
  print('|' + ' '*n + '|' + ' '*(i-1) + '/')

print('+' + '-'*n + '+')

r = int(input())
g = int(input())
b = int(input())

print(f"#{r:02X}{g:02X}{b:02X}")

1. r = int(input()): 사용자로부터 정수를 입력받아 변수 r에 저장. 
2. g = int(input()): 사용자로부터 정수를 입력받아 변수 g에 저장.
3. b = int(input()): 사용자로부터 정수를 입력받아 변수 b에 저장.
4. print(f"#{r:02X}{g:02X}{b:02X}")는 입력받은 RGB 값을 16진수로 변환하여 문자열로 출력. :02X는 각 값을 두 자리 16진수로 표현하도록 하는 포맷 코드. 예) "#FF00AA"

코칭스터디 2024

1. 데이터 구성

• Kaggle 데이터셋( https://www.kaggle.com/blastchar/telco-customer-churn )은 통신사 고객 이탈(Churn)에 대한 정보
• IBM에서 제공했으며 고객 데이터를 분석하여 고객 유지 프로그램을 개발하는 데 도움이 됨.
  • 고객 인구 통계 정보(Demographic info): 고객의 성별, 연령대, 배우자 및 부양 가족의 유무(Gender, SeniorCitizen, Partner, Dependents)
  • 고객 이탈(Churn) 정보: 서비스를 중단 여부에 대한 정보
  • 서비스 가입 정보(Services subscribed): 고객들이 가입한 서비스들, 예를 들어 전화, 다중 라인, 인터넷, 온라인 보안, 온라인 백업, 장치 보호, 기술 지원, 스트리밍 TV 및 영화( honeService, MultipleLine, InternetService, OnlineSecurity, OnlineBackup, DeviceProtection, TechSupport, StreamingTV, StreamingMovies) 등에 대한 정보
  • 고객 계정 정보(Customer account info): 고객이 얼마나 오래 서비스를 이용했는지, 계약 유형, 결제 방법, 무페이퍼 청구 여부, 월별 요금, 총 요금 (CustomerID, Contract, PaperlessBilling, PaymentMethod, MonthlyCharges, TotalCharges, Tenure)등의 정보

2. 필요한 라이브러리로드

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

3. 데이터셋 로드

df = pd.read_csv("https://bit.ly/telco-csv", index_col="customerID")
df.shape

df.head() # 데이터 확인

df.info() # 데이터 집합과 각 열들의 자료형 확인

# df.isnull().sum()는 컬럼별로 결측치의 합계를 구합니다.
print(df.isnull().sum())
# df.isnull().sum().sum() 전체 결측치의 합계를 구합니다.
df.isnull().sum().sum()

4. 학습, 예측 데이터셋 나누기

5. 학습, 예측에 사용할 컬럼 

# 학습, 예측에 사용할 컬럼에 이름을 지정
# 범주형 데이터 (object, category)는 전처리가 따로 필요
# 따라서 수치데이터만을 사용
feature_names = df.select_dtypes(include = "number").columns
feature_names

# train 과 test 로 나누기 위해 데이터를 기준을 정함.
split_count = int(df.shape[0] * 0.8)
split_count

6. 정답값이자 예측해야할 값

label_name = "Churn"
label_name #정답값

7. 학습, 예측 데이터셋 만들기

# 데이터의 80%을 나눌 기준 인덱스(split_count)로 문제 데이터(X)를 train, test로 나눔.
# 데이터의 80%을 나눌 기준 인덱스(split_count)로 정답 데이터(y)를 train, test로 나눔.
train = df[:split_count].copy()
test = df[split_count:].copy()

X_train = train[feature_names]
y_train = train[label_name]

X_test = test[feature_names]
y_test = test[label_name]

X_train.shape, X_test.shape, y_train.shape, y_test.shape

8. 머신러닝 알고리즘 가져오기

DecisionTreeClassifier(
    *,
    criterion='gini', # 분할방법 {"gini", "entropy"}, default="gini"
    splitter='best',
    max_depth=None, # The maximum depth of the tree
    min_samples_split=2, # The minimum number of samples required to split an internal node
    min_samples_leaf=1, # The minimum number of samples required to be at a leaf node.
    min_weight_fraction_leaf=0.0, # The minimum weighted fraction of the sum total of weights
    max_features=None, # The number of features to consider when looking for the best split
    random_state=None,
    max_leaf_nodes=None,
    min_impurity_decrease=0.0,
    class_weight=None,
    ccp_alpha=0.0,
)

• 주요 파라미터
  • criterion: 가지의 분할의 품질을 측정하는 기능
  • max_depth: 트리의 최대 깊이
  • min_samples_split:내부 노드를 분할하는 데 필요한 최소 샘플 수
  • min_samples_leaf: 리프 노드에 있어야 하는 최소 샘플 수
  • max_leaf_nodes: 리프 노드 숫자의 제한치
  • random_state: 추정기의 무작위성을 제어. 실행했을 때 같은 결과가 나오도록 함.

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()

9. 학습(훈련)

model.fit(X_train, y_train)

10. 예측

# 데이터를 머신러닝 모델로 예측(predict)
y_predict = model.predict(X_test)
y_predict[:5]

11. 트리 알고리즘 분석하기

from sklearn.tree import plot_tree

plt.figure(figsize=(20, 10))

tree = plot_tree(model,
                 feature_names = feature_names,
                 filled = True,
                 fontsize = 10,
                 max_depth = 4)

12. 정확도 측정하기

# 피처 중요도를 시각화
sns.barplot(x = model.feature_importances_, y=feature_names)

from sklearn.metrics import accuracy_score

accuracy_score(y_test, y_predict)

함수를 둘러싼 환경을 유지하고 다시 꺼내서 사용하는 함수

def calc():
    a = 3 
    b = 5 

    def mul_add(x):
        return a * x + b

    print(f"{locals()['a'], locals()['b'] = }")

    return(mul_add)

c = calc()
print(c(1), c(2), c(3), c(4), c(5))

def calc():
    a = 3 
    b = 5
    return lambda x: a * x + b 

c = calc()
print(c(1), c(2), c(3))

def calc():
    a = 3
    b = 5
    total = 0

    def mul_add(x):
        nonlocal total
        print(total)
        total = total + a * x + b
        print(total)

    return mul_add 
    

c = calc()

c(1)
c(2)

def outer():
    x = 100

    def inner(y):
        nonlocal x
        return x+y
        
    return inner

foo = outer()
foo(5)

배우면 배울수록 답답한 느낌이 계속 든다.

이게 아무것도 몰라서 그런 것이 아니라 공부를 하는 것이 쌓여야 하는데

쌓이기는 커녕 배우는 족족 머릿 속에서 빠져나가는 느낌

이상한 사람처럼 보일 수도 있겠지만 처음 배울 때는 뭔가 새롭고 재밌고 설레어서

이러다 나중에 무슨 일 내는거 아닌가 싶었는데

하면 할수록 내가 많이 무지하구나 느껴지고 안 풀리면 답답해서 혼자 화내고

그러다가 지금이라도 알아서 다행이다의 연속

특히 수학과 코딩같은 경우에는 

진짜 쌓아가고 앞에 내용 제대로 숙지 못하면

뒤에 있는 내용 따라가는 거 조차 힘들다는 걸 깨닫게 되었다.

모든 과목이 뭐 그렇겠지만 유달리 나한테는 수학과 코딩이 그런듯

이럴 때 생각나는 곡선

더닝크루거의 우매함의 봉우리

나는 지금 절망의 계곡에 있는 것 같은데

뭐 '그냥 하는거지;;' 마인드로 

절망의 계곡 탈출하면 될 듯하다.

깨달음의 비탈길에 도착하면 뭐 자축이나 할까나 

그런 깨달음의 기분이 들면 치킨이나 뜯어먹어야겠다~

냠냠 

그때 먹는 치킨 지금 정해놔야겠다.

바로 교촌 레드 콤보!

그때까지 파이팅

# 동전을 3번 던졌을 때 3번 연속 앞면이나 뒷면이 나오는 확률
n = 100000
count = 0

for(i in 1:n){
    u = runif(3, 0, 1)
    coin = as.numeric(u > 0.5)
    
    if(coin[1] == coin[2] & coin[2] == coin[3]){
        count = count + 1
    }
}

# 동전을 10번 던졌을 때 3번 연속 앞면이나 뒷면이 나오는 확률 
n = 10000
count = 0

for(i in 1:n){
    u = runif(10, 0, 1)
    coin = as.numeric(u > 0.5)
    
    for(j in 1:8){
        if(coin[j]==coin[j+1] & coin[j+1]==coin[j+2]){
            count = count + 1
            break
        }
    }
}
count/n


## 주사위 던지기 ====
### 주사위를 trial번 만큼 던져서 1/6에 근접하는지 확인 ====
trial = c(30, 50, 100, 500)

for (n in trial){
    u = runif(n, 0, 1)
    
    dot = numeric(n)
    case = numeric(n)
    
    for(i in 1:n){
        if(u[i] < 1/6){
            dot[i] = 1
        } else if(u[i] < 2/6){
            dot[i] = 2
        } else if(u[i] < 3/6){
            dot[i] = 3
        } else if(u[i] < 4/6){
            dot[i] = 4
        } else if(u[i] < 5/6){
            dot[i] = 5
        } else if(u[i] < 6/6){
            dot[i] = 6
        } 
    }
    
    ### 1 =====
    case = dot < 2 # 1인지 아닌지 구하는 것
    sum(case) # 1의 개수  = n*(1/6)
    sum(case)/n  # p = 1/6 = 0.167
    
    plot(table(dot), main = paste0("n = ",n),
         type = "h", col = "darkgreen", lwd = 5)
}


### 주사위 관련 나만의 코드 ====
### 반복문으로 만들수 있는걸 만들어봄. 
par(mfrow = c(2,2), mar = c(3, 5, 2, 2))
# mar 은 상하좌우의 마진(여백)을 나타낸 것임. 
trial = c(30, 50, 100, 500)

for(n in trial){
    u = runif(n, 0, 1)
    
    dot = numeric(n)
    case = numeric(n)
    final = matrix(NA, nr = 6, nc = 2)
    
    for(i in 1:n){
        if(u[i] < 1/6){
            dot[i] = 1
        } else if(u[i] < 2/6){
            dot[i] = 2
        } else if(u[i] < 3/6){
            dot[i] = 3
        } else if(u[i] < 4/6){
            dot[i] = 4
        } else if(u[i] < 5/6){
            dot[i] = 5
        } else if(u[i] < 6/6){
            dot[i] = 6
        }    
    }
    
    for(k in 1:length(unique(dot))){
        for(y in 1:length(dot)){
            if(dot[y] == k){
                case[k] = case[k] + 1 
            }   
        }
    }
    
    cat("시행횟수는", n, "\n")
    for(x in 1:length(unique(dot))){
        cat("주사위",x,
            "의 눈의 경우의 수는", case[x], 
            "확률은",case[x]/n,"\n")
    }
    
    plot(table(dot), main = paste0("n = ",n),
         type = "h", col = "darkgreen", lwd = 5)
}

## 자유투 =====

### 자유투를 던졌을 때 연속 2번이상 성공할 확률 ====
n = 1000
k = 0

for(i in 1:n){
    u = runif(5, 0, 1)
    shoot = as.numeric(u <= 0.2)
    

    if(sum(shoot) >= 2){
        k = k + 1
    }
}
k/n

x1 = choose(5,0)*(0.2)^0*(0.8)^5
x2 = choose(5,1)*(0.2)^1*(0.8)^5
1 - (x1 + x2)



### 2 ====
n = 1000
gathering = c(NA) ; gathering2 = numeric(n) 
# gathering2는 잘못된 방식으로 구하는 걸 보여주는 변수

for(i in 1:n){
    u = runif(100, 0, 1)
    shoot = as.numeric(u <= 0.2)
    
    for(j in 1:98){
        if(shoot[j]*shoot[j+1]*shoot[j+2] == 1){
            break
        }
    }
    
    # 잘못된 코드
    for(k in 1:98){
        if(shoot[k] == shoot[k+1] 
           & shoot[k+1] == shoot[k+2]){
            break
        }
    }
    gathering[i] = j+2
    gathering2[i] = k+2
}
mean(gathering)
mean(gathering2)

## 뷔퐁의 바늘실험 ====
needle_experiment = function(n, l, d){
    set.seed(100)
    k = 0
    
    for(i in 1:n){
        x = (d/2)*runif(1) 
        # d/2 
        # 바늘 가운데에서 가장 가까운 거리의 평행선
        # d/2 보다 클수는 없어서 
        # runif(1)
        theta = runif(1, 0, pi)
        
        if(x <= (l/2)*sin(theta)){
            k = k + 1
        }
    }
    prob = k/n
    pi.hat = 2*l/(prob*d)
    return(c(prob = prob, pi.hat = pi.hat))
}

needle_experiment(50000, 10, 20)


### 연습 ====

needle_experiment = function(n, l, d){
    k = 0
    set.seed(100)
    
    for(i in 1:n){
         x = (d/2)*runif(1)
         theta = runif(1, 0, pi)
         
         if(x <= (l/2)*sin(theta)){
             k = k + 1
         }
    }
    prob = k/n
    pi.hat = 2*l/(prob*d)
    return(c(prob = prob, pi.hat = pi.hat))
}

needle_experiment(50000, 15, 20)

중심극한정리를 사용한 정규분포

CLT_norm = function(x_bar_n, sample_m, mu, sig){
    xbar = as.numeric(x_bar_n)
    
    for(i in 1:x_bar_n){
        no = rnorm(sample_m, mu, sig)
        xbar[i] = mean(no)
    }
    
    result_mean = mean(xbar)
    result_var = var(xbar)
    ori_var= sig^2/sample_m
    return(c(result_mean = result_mean,
             result_var = result_var,
             ori_var = ori_var))
    print(h)
}


CLT_norm(10000, 100, 5, 2)

이항분포

n0 = 30; p = 0.1; mu = n0*p; var = n0*p*(1-p)

m = 1000 # 자료 set의 개수(xbar의 개수)
n = 100 # 난수 개수 (표본의 개수)

xbar = c()
for(i in 1:m){
    x = rbinom(n, n0, p) #이항분포에서 추출
    xbar[i] = mean(x)
}

xbar_mu = mean(xbar) ; mu
xbar_var = var(xbar) ; var/n

# histogram
hist(xbar, breaks = "fd", prob = T)

# theoretical curve ; N(mu, sqrt(var/n))
curve(dnorm(x, mu, sqrt(var/n)), add = T)

포아송분포

lamb = 5
var = lamb

m = 1000 # 자료 set의 개수 (xbar의 개수) 
n = 100 # 난수 개수 (표본개수)

xbar = c()
for(i in 1:m){
    x = rpois(n, lambda = lamb)
    xbar[i] = mean(x)
}
xbar_mu = mean(xbar) ; lamb
xbar_var = var(xbar) ; var/n

hist(xbar, breaks = "fd", prob = T)
curve(dnorm(x, lamb, sqrt(var/n)), add = T)

이항분포의 CLT를 n을 바꿔가며 확인

### n바꾸어서 CLT 확인 ====
p = 0.5 ; q = 1-p

par(mfrow = c(2,2))
for(n in c(10, 100, 1000, 10000)){
    
    p_hat = c()
    for(i in 1:1000){
        num = rbinom(n, 1, p)
        p_hat[i] = mean(num)
    } # for i
    
    CLT = (p_hat - p) / sqrt((p*q)/n)
    
    hist(CLT, probability = T,
         ylim = c(0, 0.5), xlim = c(-3, 3),
         main = paste0("n = ", n))
    
    curve(dnorm(x, 0, 1),
          xlim = c(-3, 3), ylim = c(0, 0.5),
          col = "tomato", lwd = 2,
          main = "X ~ N(0,1)", add = T)
} # for n