백준 온라인 저지가 2026년 4월 28일에 종료됐다.

코테가 점점 없어지나? (그럴리는 없음) 그럼 난 뭘 준비해야하지?

"GitHub 잔디..?"

그렇게 DevTier가 시작됐다. GitHub 로그인하면 잔디 데이터를 분석해서 티어를 뽑아주는 서비스다.

🚀 DevTier 링크

1. 전투력 점수는 어떻게 계산하나

핵심은 GitHub contribution 데이터를 숫자로 만드는 것이다. 단순히 잔디 개수만 세면 재미없으니까, 여러 지표를 조합해서 "전투력 점수"를 뽑는 공식을 만들었다.

score = 총잔디×1 + 현재스트릭×3 + 최대스트릭×2 + 잔디밀도(%)×100 + 피크강도×0.5 + log2(레포스타+1)×10

처음엔 감으로 잡고, AI한테 물어보면서 다듬었다.

티어는 롤처럼 브론즈부터 챌린저까지 티어별 4단계로 나눴다. 챌린저는 절대 상위 100명으로 고정했다. (나때는 브5 부터 있었음)

2. 기술 스택

• Next.js 16 App Router (Vercel 배포)
• Supabase (PostgreSQL + Auth)
• GitHub GraphQL API - contribution 데이터 수집
• SVG 동적 생성 - README에 꽂는 뱃지

뱃지가 핵심이다. GitHub README에 이런 식으로 박힌다.

<a href="https://devtier-brown.vercel.app/result/username">
  <img width="240" src="https://devtier-brown.vercel.app/api/badge/username" />
</a>

뱃지를 보고 클릭하는 사람이 생기면 자연스럽게 유입이 일어나는 구조다.

3. 한국 개발자 데이터를 어떻게 모았나

티어가 의미 있으려면 "전체 중 몇 퍼센트"라는 상대적인 기준이 있어야 한다. 그래서 한국 개발자 데이터를 직접 긁어오는 배치 스크립트를 만들었다.

npm run collect:users   # GitHub Search API로 한국 유저 수집
npm run collect:scores  # 전체 유저 점수 계산
npm run recalc:tiers    # 백분위·티어 전체 재산출

처음엔 이걸 Supabase Edge Function으로 돌리려고 했는데, 3,000명 점수 계산에 37분이 걸렸다. Edge Function 타임아웃에 계속 걸렸고, 중간에 끊기면 어디까지 됐는지도 몰랐다.

결국 로컬 스크립트로 바꾸고, GitHub Actions로 매주 월요일 새벽 3시에 자동 실행되도록 루틴화했다. rate limit 걸리면 스킵하지 않고 재시도 큐로 처리해서 빠진 유저 없이 돌아간다.

4. SVG 뱃지 삽질기

뱃지에 애니메이션을 넣고 싶었다. 티어별로 다른 느낌으로.

• 챌린저: 왕관 shimmer + border pulse
• 다이아: 젬 rotate-shimmer
• 플래티넘~브론즈: 메달 glow-pulse

근데 문제가 있었다. GitHub은 SVG를 camo 프록시를 통해 서빙하는데, 여기서 <animate> 태그를 전부 제거해버린다. 열심히 만든 SMIL 애니메이션이 README에서 싹 죽었다.

해결책은 CSS @keyframes로 전환하는 것이었다. camo 프록시는 CSS는 건드리지 않는다. 이걸로 갈아엎고 나서야 GitHub README에서도 애니메이션이 제대로 살았다.

5. 도전과제 시스템

점수·티어와 별개로 절대 마일스톤 시스템도 붙였다. Common / Rare / Epic / Legendary 4단계 희귀도로 나뉜다.

잔디 1,000개 달성하면 "잔디 컬렉터(Rare)", 최대 스트릭 365일이면 "불꽃 개발자(Legendary)" 같은 식이다. 특이한 패턴도 잡아낸다. 평소엔 안 하다가 폭발하는 스타일이면 "몰아치기 스타일", 밀도랑 스트릭 둘 다 높으면 "마라토너".

결과 페이지에서 잠긴 도전과제에는 현재 진행률도 표시된다. "42 / 100" 이런 식으로 보이면 괜히 더 커밋하고 싶어진다.

마무리

백준이 사라진 것은 꽤 충격이 크다. 하지만 다들 힘내자 화이팅. (코테를 변기에 넣고서 내려)

🚽 그래서 님 티어가? - DevTier

솔직히 좀 충격이었음 코테 준비했둔 사람 중에 백준 모르는 사람도 없고 (프로그래머스가 좀 더 예쁘긴 했음)

근데 확실히 요즘은 AI가 너무 잘되어있기도 해서 좀 분위기가 달라지긴 한 것 같음 (대 딸깍의 시대)

코테가 당장 없어지진 않겠지만 코테 포지션이 확실히 애매해진 듯

결국 남은건 프젝인데 그래서 그런가 요즘 확실히 깃헙 열심히 꾸미는 사람들이 많아진 듯 깃허브 관리 잘하는 사람들은 진짜 잘하더라

나도 깃헙 좀 꾸며보려고 대충 한국 개발자들 깃허브 긁어봤음 (딸깍)

요런느낌으로 리스트업하고 하나씩 둘러봄

내껀 아니고 찾다 나온 사람인데 밀도도 중요하긴 하지만 레포 스타가 15000개가 말도 안되긴하네..

뭐 어쨌든 모든 개발자분들 화이팅입니다

관심있으신분들은 편히 둘러보십셔

https://devtier-brown.vercel.app/

(돈없어서 버셀 배포)

굿-밤

• 변수가 두개 이상 범주로 분할되어 있고, 독립적인지 연관성이 있는지 검정
• 귀무가설(H0) : 서로 독립
• 대립가설(H1) : 연관성이 있다
• p-value < 0.05 이면 대립가설 채택

검정방법 순서

1. 패키지 추가 (from scipy.stats import chi2_contingency)
2. 데이터 table 변환 (범주형 - pd.crosstab / 수치형 - np.array)
3. chi2 검정 (chi2, p_val, dof(자유도), ex(기대치))

패키지

from scipy.stats import chi2_contingency
from statsmodels.formula.api import logit

독립성 검정

import pandas as pd

df = pd.read_csv("data/Titanic.csv")

#1번 문제
from scipy.stats import chi2_contingency

table = pd.crosstab(df.Gender, df.Survived)
chi2, p_val, dof, exp = chi2_contingency(table)

print(round(chi2, 3))     # 260.717
print(p_val)             # 매우 작으므로 대립가설 채택

로지스틱 회귀

from statsmodels.formula.api import logit
result1 = logit('Survived ~ Gender+SibSp+Parch+Fare', data=df).fit().summary()
print(result1)

오즈비 구하기

import numpy as np
result2 = logit('Survived ~ Gender+SibSp+Parch+Fare', data=df).fit().params
print(np.exp(result2))

상관계수

df.corr()

Shapiro-Wilk (정규분포)

from scipy import stats
statistic, p_val = stats.shapiro(data)

출처 - datamanim.com

stats 주요 모듈

01 T-test

• ttest_1samp (단일표본 t검정)
• ttest_ind (독립표본 t검정)
• ttest_rel (대응표본 t검정)

02 비모수 검정

• manwhitneyu (맨-휘트니 U검정-중위수, 윌콕슨 순위합 검정과 동일)
• ranksums (윌콕슨 순위합 검정 - 중위수)
• wilcoxon (윌콕슨 부호 순위합 검정)

03 정규성 검정

• anderson (Anderson-Darling, 데이터 수가 상대적으로 많을 때)
• kstest (Kolmogorov-smirnov, 데이터 수가 상대적으로 많을 때)
• mstats.normaltest
• shapiro (shapiro, 노말분포, 데이터 수가 상대적으로 적을 때)

04 등분산 검정

• bartlett
• fligner
• levene

05 카이제곱 검정

• chi2_contingency (카이제곱독립검정, 독립성 검정)
• chisquare (카이제곱검정, 적합도 검정)
• fisher_exact (피셔 정확 검정 - 빈도수가 5개 이하 셀의 수가 전체 셀의 20%이상일 경우)

06 ANOVA (일원분산분석)

• f_oneway

예시

#1 정규성 검정

01 다음 데이터의 정규성을 검증하라

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/normal1.csv')

from scipy.stats import shapiro
print(shapiro(df))

• 결과 ShapiroResult(statistic=0.9981444478034973, pvalue=0.34849318861961365)

• 통계랑이 1에 가까우므로 정규분포에 가까움

• p-value가 0.05보다 크므로 귀무가설 기각X -> 정규 분포를 따름

• 통계량이 1에 가깝더라도, p-value가 0.05보다 작으면 정규성X

02 다음 데이터를 log변환 후 정규성을 확인하라

import pandas as pd
import numpy as np
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/normal3.csv')

log_df = np.log1p(df)

from scipy.stats import shapiro
print(shapiro(log_df))

• 결과 ShapiroResult(statistic=0.9976889491081238, pvalue=0.17540602385997772)

• 0.05보다 크므로 정규성 O

• log변환 시 너무 작은 값이거나, 0, 음수를 포함하는 값들이 있을때 사용

03 다음 데이터의 정규성을 검증하라

import pandas as pd
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/normal6.csv')

from scipy.stats import shapiro
#shapiro(df)

from scipy.stats import anderson
anderson(df['data'].values)

• 결과 AndersonResult(statistic=0.8266993530405671, critical_values=array([0.576, 0.656, 0.786, 0.917, 1.091]), significance_level=array([15. , 10. , 5. , 2.5, 1. ]), fit_result= params: FitParams(loc=299.95980319533163, scale=5.031806887885131) success: True message: 'anderson successfully fit the distribution to the data.')

• 5000개 이상일 경우 shapiro 말고 anderson 사용

• 5% : 0.786 < 통계량 : 0.827 < 2.5% : 0.917

• 따라서 유의수준 5% 이하이므로, 정규성 X

#2 단일 표본 t검정(one-sample)

01 100명의 키 정보가 들어있는 데이터가 있다. 데이터가 정규성을 만족하는지 확인하라. 그리고 평균키는 165라 판단할 수 있는지 귀무가설과 대립가설을 설정한 후 유의수준 5%로 검정하라

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/height1.csv')

from scipy.stats import shapiro

shapiro(df)
# ShapiroResult(statistic=0.9872668981552124, pvalue=0.4558176100254059)
# 정규성 O -> 단일 표본 t 검정

from scipy.stats import ttest_1samp
ttest_1samp(df['height'], 165)

• 결과 TtestResult(statistic=3.2017884987150644, pvalue=0.0018367171548080209, df=99)

• p-value 0.05이하 이므로, 100명 키의 평균은 165가 아니다.

02 100명의 키 정보가 들어있는 데이터가 있다. 데이터가 정규성을 만족하는지 확인하라. 그리고 평균키는 165라 판단할 수 있는지 귀무가설과 대립가설을 설정한 후 유의수준 5%로 검정하라

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/height2.csv')

from scipy.stats import shapiro

shapiro(df) 
# ShapiroResult(statistic=0.9672006368637085, pvalue=0.013552471995353699)
# 정규성 X -> 비모수 검정 (윌콕슨)

from scipy.stats import wilcoxon

wilcoxon(df)

• 결과 WilcoxonResult(statistic=array([0.]), pvalue=array([3.87726172e-18]))

• p-value가 0.05보다 작으므로, 대립가설 채택

• 100명 키의 평균은 165가 아니다.

#3 등분산 검정

01 두 개 학급의 시험성적에 대한 데이터이다. 그룹간 등분산 검정을 시행하라.

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/scipy2.csv')

from scipy.stats import bartlett
from scipy.stats import fligner
from scipy.stats import levene

a = df[df['class'] == 'A'].score
b = df[df['class'] == 'B'].score

print(bartlett(a, b))
print(fligner(a, b, center = 'median'))
print(fligner(a, b, center = 'mean'))
print(levene(a, b, center = 'median'))
print(levene(a, b, center = 'mean'))

• 결과 BartlettResult(statistic=0.26035880448930865, pvalue=0.609873758447687) FlignerResult(statistic=0.7281251154135562, pvalue=0.39349158741002765) FlignerResult(statistic=0.8272211734319945, pvalue=0.36307728836821906) LeveneResult(statistic=0.3145466542912649, pvalue=0.5751662820554713) LeveneResult(statistic=0.5086970687685527, pvalue=0.4760514837800255)

• 0.05보다 크므로, 각 그룹은 등분산이다.

02 두 개 학급의 시험성적에 대한 데이터이다. 그룹간 등분산 검정을 시행하라.

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/scipy3.csv')
from scipy.stats import bartlett
from scipy.stats import fligner
from scipy.stats import levene

a = df[df['class'] =='A'].score
b = df[df['class'] =='B'].score

print(bartlett(a,b))
print(fligner(a,b,center='median')) #default
print(fligner(a,b,center='mean')) 

print(levene(a,b, center='median')) #default
print(levene(a,b,center='mean'))

• 결과 BartlettResult(statistic=1.5116783794562305, pvalue=0.2188831590902503) FlignerResult(statistic=4.960366756026232, pvalue=0.025934706256615564) FlignerResult(statistic=4.94724457924667, pvalue=0.026132286002684912) LeveneResult(statistic=4.307122424591436, pvalue=0.03848734007752694) LeveneResult(statistic=4.342327020297874, pvalue=0.0377066528874248)

• fligner, levene 는 bartlett에 비해 robust하다

• 정규분포를 따르지 않는다면 bartlett은 신뢰하기 어렵다

• 따라서 등분산 X

03 두 개 학급의 시험성적에 대한 데이터이다. 그룹간 등분산 검정을 시행하라.

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/scipy6.csv')

from scipy.stats import bartlett
from scipy.stats import fligner
from scipy.stats import levene

print(bartlett(df.A, df.B))
print(fligner(df.A, df.B))
print(levene(df.A, df.B))

• 결과 BartlettResult(statistic=2.3832178811043527, pvalue=0.12264468401745829) FlignerResult(statistic=5.124831619122788, pvalue=0.023585858890699054) LeveneResult(statistic=5.147914610463281, pvalue=0.023868975493455683)

04 두 개 학급의 시험성적에 대한 데이터이다. 그룹간 등분산 검정을 시행하라.

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/scipy5.csv')

print(bartlett(df.A, df.B.dropna()))
print(fligner(df.A, df.B.dropna()))
print(levene(df.A, df.B.dropna()))

• 결과 BartlettResult(statistic=3.024072692680794, pvalue=0.08203720607748438) FlignerResult(statistic=7.710320541528441, pvalue=0.005490600130793619) LeveneResult(statistic=8.008595918808284, pvalue=0.004851565077063284)

• nan 값이 포함될 경우 없애고 등분산 검정을 시행해야 한다

#4 독립 표본 검정(Independent) - 정규성에 따라 다름

01 두 개 학급의 시험성적에 대한 데이터이다. 두 학급의 시험 평균(비모수검정의 경우 중위값)은 동일하다 말할 수 있는지 확인하라.

import pandas as pd 
df1 = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/ind1.csv')
df2 = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/ind2.csv')

from scipy.stats import shapiro

print(shapiro(df1)) # 정규성 O
print(shapiro(df2)) # 정규성 O

from scipy.stats import levene
print(levene(df1['data'], df2['data'])) # 등분산 O

from scipy.stats import ttest_ind
print(ttest_ind(df1, df2, equal_var = True))

• 결과 ShapiroResult(statistic=0.9860946536064148, pvalue=0.379673033952713) ShapiroResult(statistic=0.990182638168335, pvalue=0.6793646216392517) LeveneResult(statistic=2.5337683795339547, pvalue=0.11302904824469093) TtestResult(statistic=array([2.76719074]), pvalue=array([0.00619015]), df=array([198.]))

• 대립가설 채택

• 각 그룹 평균은 동일하지 않다

02 두 개 학급의 시험성적에 대한 데이터이다. 두 학급의 시험 평균(비모수검정의 경우 중위값)은 동일하다 말할 수 있는지 확인하라.

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/scipy5.csv')

from scipy.stats import shapiro
print(shapiro(df.A))          # 정규성 X
print(shapiro(df.B.dropna())) # 정규성 X

from scipy.stats import mannwhitneyu, ranksums
print(mannwhitneyu(df.A, df.B.dropna()))  # 귀무가설 채택
print(ranksums(df.A, df.B.dropna()))      # 귀무가설 채택

• 결과 ShapiroResult(statistic=0.93753981590271, pvalue=6.175894240456614e-10) ShapiroResult(statistic=0.9639433026313782, pvalue=0.00013568344002123922) MannwhitneyuResult(statistic=27036.0, pvalue=0.9807458376150018) RanksumsResult(statistic=0.02446942170858557, pvalue=0.9804781743503561)

• 귀무가설 채택

• 평균은 같다

03 두개 그룹에 대한 수치형 데이터이다. 두 그룹은 평균이 동일하다 말할 수 있는가

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/ind3.csv')

from scipy.stats import shapiro
a = df[df['group'] == 'a'].data
b = df[df['group'] == 'b'].data
print(shapiro(a)) # 정규성 O
print(shapiro(b)) # 정규성 O

from scipy.stats import levene
print(levene(a, b))   # 등분산 X

from scipy.stats import ttest_ind
print(ttest_ind(a, b, equal_var = False))

• 결과 ShapiroResult(statistic=0.9834123253822327, pvalue=0.1473984718322754) ShapiroResult(statistic=0.9831852316856384, pvalue=0.4701973497867584) LeveneResult(statistic=6.185601018015722, pvalue=0.013750484571911342) TtestResult(statistic=-2.1949470315829265, pvalue=0.029512802991767898, df=171.25282465005142)

• 귀무가설 기각

• 평균 동일 X

04 두개 그룹에 대한 수치형 데이터이다. 두 그룹은 평균이 동일하다 말할 수 있는가

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/ind6.csv')

from scipy.stats import shapiro
print(shapiro(df.a)) # 정규성 O
print(shapiro(df.b.dropna())) # 정규성 O

from scipy.stats import levene
print(levene(df.a, df.b.dropna()))  # 등분산 X

from scipy.stats import ttest_ind
print(ttest_ind(df.a, df.b.dropna(), equal_var = False))

• 결과 ShapiroResult(statistic=0.9865895509719849, pvalue=0.28390026092529297) ShapiroResult(statistic=0.9854326844215393, pvalue=0.5937624573707581) LeveneResult(statistic=3.9862856894158347, pvalue=0.04731495612868527) TtestResult(statistic=0.0015963310698567184, pvalue=0.9987289046092704, df=122.72255248639058)

• 귀무가설 기각X

• 평균값은 동일

#5 대응 표본 t 검정 (paired)

01 특정 질병 집단의 투약 전후의 혈류량 변화를 나타낸 데이터이다. 투약 전후의 변화가 있는지 검정하라

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/rel2.csv')

from scipy.stats import shapiro

print(shapiro(df.before)) # 정규성 O
print(shapiro(df.after))  # 정규성 O

from scipy.stats import levene
print(levene(df.before, df.after))  # 등분산 O

from scipy.stats import ttest_rel
print(ttest_rel(df.before, df.after))

• 결과 ShapiroResult(statistic=0.9907895922660828, pvalue=0.6065835952758789) ShapiroResult(statistic=0.9916961193084717, pvalue=0.6923638582229614) LeveneResult(statistic=0.06427968690211128, pvalue=0.8000741651677987) TtestResult(statistic=-2.5535473487670677, pvalue=0.011926744724546513, df=119)

• p-value 0.05이내

• 대립가설 채택

• 평균은 같지 않다

02 특정 질병 집단의 투약 전후의 혈류량 변화를 나타낸 데이터이다. 투약 전후의 변화가 있는지 검정하라

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/rel3.csv')

from scipy.stats import shapiro
print(shapiro(df.before)) # 정규성 O
print(shapiro(df.after))  # 정규성 O

from scipy.stats import levene
print(levene(df.before, df.after))  # 등분산 O

from scipy.stats import ttest_rel
print(ttest_rel(df.before, df.after))

• 결과 ShapiroResult(statistic=0.9920631051063538, pvalue=0.7270199656486511) ShapiroResult(statistic=0.992019534111023, pvalue=0.7229290008544922) LeveneResult(statistic=1.3463330638203617, pvalue=0.24708279045237214) TtestResult(statistic=0.188900575991026, pvalue=0.8504925317234707, df=119)

• 귀무가설 채택

• 평균은 같다

03 특정 집단의 학습 전후 시험 성적 변화를 나타낸 데이터이다. 시험 전과 후에 차이가 있는지 검정하라.

import pandas as pd
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/rel1.csv')

from scipy.stats import shapiro

print(shapiro(df.before))   # 정규성 X
print(shapiro(df.after))    # 정규성 X

from scipy.stats import levene
print(levene(df.before, df.after))  # 등분산 O

from scipy.stats import wilcoxon
print(wilcoxon(df.before, df.after))

• 결과 ShapiroResult(statistic=0.9173730611801147, pvalue=0.0018974003614857793) ShapiroResult(statistic=0.9448966979980469, pvalue=0.021140215918421745) LeveneResult(statistic=0.14329522146179022, pvalue=0.7058456563194881) WilcoxonResult(statistic=437.0, pvalue=0.12098409484052809)

• p-value 0.05보다 높으므로, 귀무가설 채택

• 전 후 평균 일치

04 한 기계 부품의 rpm 수치를 두 가지 다른 상황에서 측정했다. (총 70세트) b상황이 a상황보다 rpm값이 높다고 말할 수 있는지 검정하라.

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/rel4.csv')

a = df[df['group'] == 'a'].rpm
b = df[df['group'] == 'b'].rpm

from scipy.stats import shapiro

print(shapiro(a))   # 정규성 O
print(shapiro(b))   # 정규성 O

from scipy.stats import levene
print(levene(a, b)) # 등분산 O

from scipy.stats import ttest_rel
print(ttest_rel(a, b, alternative = 'greater'))

• 결과 ShapiroResult(statistic=0.9907217025756836, pvalue=0.8884284496307373) ShapiroResult(statistic=0.984674870967865, pvalue=0.5505106449127197) LeveneResult(statistic=0.06716114122680159, pvalue=0.7959020864923277) TtestResult(statistic=-1.9018108294460812, pvalue=0.9693143365355352, df=69)

• a>b 가 대립가설, a<=b 가 귀무가설

• 0.05보다 크므로 귀무가설 채택

#6 카이제곱 검정 (교차분석)

01 144회 주사위를 던졌을 때, 각 눈금별로 나온 횟수를 나타낸다. 이 데이터는 주사위의 분포에서 나올 가능성이 있는지 검정하라

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/dice.csv')

from scipy.stats import chisquare

df['expected'] = (df['counts'].sum()/6).astype('int')
print(chisquare(df.counts, df.expected))

• 결과 Power_divergenceResult(statistic=2.333333333333333, pvalue=0.8013589222076911)

• 귀무가설 채택

• 각 주사위 눈금 발생 비율은 동일함

02 다음 데이터는 국민 기초체력을 조사한 데이터이다. 성별과 등급이 독립적인지 검정하라.

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/body/body.csv')

cdf = pd.crosstab(df['측정회원성별'], df['등급'])

from scipy.stats import chi2_contingency
chi2, p, dof, exp = chi2_contingency(cdf)
print(p)

• 결과

7.481892813401677e-26 -> 귀무가설 기각 -> 두 항목은 연관이 있다

03 성별에 따른 동아리 활동 참석 비율을 나타낸 데이터이다. 성별과 참석간에 관련이 있는지 검정하라.

import pandas as pd 
df = pd.read_csv('https://raw.githubusercontent.com/Datamanim/datarepo/main/scipy/fe2.csv',index_col=0)

cdf = df.iloc[:-1, :-1]

from scipy.stats import chi2_contingency
chi2, p, dof, exp = chi2_contingency(cdf)
print(p)  # 귀무가설 채택 -> 하지만 5보다 작은 셀이 20%가 넘어가므로 피셔의 정확검정을 사용해야함

from scipy.stats import fisher_exact
print(fisher_exact(cdf))

• 결과

0.07023259819117404 SignificanceResult(statistic=18.0, pvalue=0.03571428571428571) -> 대립가설 채택 -> 관련이 있다

문제 1

• alchol(음주수치) 상위 10번째 값으로 상위 1~10위의 범위의 값을 변경한 후 speeding(속도)가 7이상의 alchol(음주수치) 데이터들의 평균 산출

  data = df.sort_values(by = 'alcohol', ascending = False)
  ten = data.iloc[9, 2]
  data.iloc[:10, 2] = ten
  

result = data[(data['speeding'] >= 7)] result1 = result.alcohol.mean() result1

### 문제 2
- 데이터 첫번째 행부터 70% 까지의 데이터를 추출한 후 distance(거리)의 결측값을 distance(거리)의 중앙값으로 대체하고 결측값 전처리 전과 후의 표준편차를 비교

data_len = int(len(df)*0.7) df_1 = df[:data_len] df_2 = df_1.copy() df_2['distance'] = df_1['distance'].fillna(df_1.distance.median()) print(np.std(df_1['distance'])) print(np.std(df_2['distance']))

### 문제 3
- orbital_period열의 이상치를 IQR기법으로 제거하여 이상치들의 합을 계산

Q1 = df['orbital_period'].quantile(0.25) Q3 = df['orbital_period'].quantile(0.75) IQR = Q3 - Q1

result = df[(df['orbital_period'] > Q3+1.5IQR)|(df['orbital_period'] < Q1-1.5IQR)] result['orbital_period'].sum()

### 정리

df.iloc[3, 2] # df 데이터 프레임의 4행, 3열 추출 (인덱스 기준) .mean() # 평균 .median() # 중앙값 .mode() # 최빈값 .copy() # 데이터 프레임 복사 .var() # 분산 .std() # 표준편차 np.ceil() # 올림 np.floor() # 내림 np.trunc() # 버림 df['col1'].quantile(0.25)

df 데이터 프레임의 col1 기준 25%까지의 값을 추출

& # and 연산 | # or 연산 .dropna() # 결측치 제거 ```

1. 데이터 수집
2. 데이터 정규화 - 훈련 데이터, 테스트 데이터 정규화
3. 정답 데이터 지정 - 학습 데이터와 함께 해당 데이터 정답 지정
4. 모델 생성 - RandomForest 사용
5. 모델 훈련
6. 모델 예측
7. 정답 제출

종류

1. 분류 - 목표변수가 카테고리로 나뉘어지는 결과(성공, 실패)

• 성능평가 - accuracy_score, f1_score, roc_auc_score

2. 회귀 - 목표변수가 수치형

• 성능평가 - RMS, 결정계수

분류모델

1. .info() print

• 결측값 확인
• Object 변수 확인

2. 결측값 처리

train.fillna(train['환불금액'].mode()[0], inplace = True)
test.fillna(test['환불금액'].mode()[0], inplace = True)

• .info() 다시 print해서 결측값 처리 되었는지 체크

  3. Object 변수 라벨 인코딩

  from sklearn.preprocessing import LabelEncoder
  

le = labelEncoder() train['주구매상품'] = le.fit_transform(train['주구매상품']) train['주구매지점'] = le.fit_transform(train['주구매지점']) test['주구매상품'] = le.fit_transform(test['주구매상품']) test['주구매지점'] = le.fit_transform(test['주구매지점'])

- .info() 다시 print해서 정수형태로 변환되었는지 체크
#### 4. 데이터 분할
- 학습용 독립변수(X), 테스트용 독립변수(X), 학습용 종속변수(Y), 테스트용 종속변수(Y)
- 데이터를 분할해서 써야한다

from sklearn.model_selection import train_test_split

X = train.drop(columns = ['성별', '회원ID'] Y = train['성별']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 2024)

#### 5. 모델링

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators = 150, max_depth = 20, random_state = 2024)

#### 6. 모델학습

rfc.fit(X_train, y_train)

#### 7. 예측값 도출

pred1 = rfc.predict(X_test)

#### 8. 성능평가

from sklearn.metrics import roc_auc_score, accuracy_score roc = roc_auc_score(y_test, pred) acc = accuracy_score(y_test, pred)

- print 해서 roc, acc 지표 체크

#### 9. 테스트 데이터 예측

test_X = test.drop(columns = ['회원ID']) pred2 = rfc.predict(test_X)

#### 10. 결과 데이터 제출 및 확인

pd.DataFrame({'pred' : pred2}).to_csv('result.csv', index = False)

### 회귀모델
문제
1. 전체 데이터 목록 4,009행 중 3,800행을 학습용 데이터로 사용하고, 나머지를 테스트 데이터로 사용할 수 있도록 데이터를 슬라이싱한다.
2. 학습용 데이터를 활용하여 모델을 모델링하고, 테스트 데이터를 적용하여 목표변수를(price) 예측하고, 예측결과를 제출한다. (단, 제출 결과는 테스트 데이터의 개수인 209행이 될 수 있도록 한다.)
3. 모델 평가 지표는 RMSE로 한다.
4. 모델 예측 결과는 price 컬럼을 갖고, 예측 결과를 나타내며, index는 표시하지 않는다.
5. 예측 결과 파일명은 다음과 같이 하여 제출한다. (파일명 : result.csv)
#### 1. 데이터 확인

import pandas as pd

df = pd.read_csv('https://raw.githubusercontent.com/JEunJin/BigData_python/master/bigdata_csvfile/used_cars_price_data.csv') print(df.info()) print(df.head())

- info()를 통해 결측값을 확인하고, LabelEncoding할 항목 판별

#### 2. 결측값 처리 - 최빈값 대체

df['fuel_type'].fillna(df['fuel_type'].mode()[0], inplace = True) df['accident'].fillna(df['accident'].mode()[0], inplace = True) df['clean_title'].fillna(df['clean_title'].mode()[0], inplace = True)

- mode()[0] - 최빈값은 여러개일 수 있음

#### 3. 라벨 인코딩

from sklearn.preprocessing import LabelEncoder le = LabelEncoder()

df['brand'] = le.fit_transform(df['brand']) df['model'] = le.fit_transform(df['model']) df['milage'] = le.fit_transform(df['milage']) df['fuel_type'] = le.fit_transform(df['fuel_type']) df['engine'] = le.fit_transform(df['engine']) df['transmission'] = le.fit_transform(df['transmission']) df['ext_col'] = le.fit_transform(df['ext_col']) df['int_col'] = le.fit_transform(df['int_col']) df['accident'] = le.fit_transform(df['accident']) df['clean_title'] = le.fit_transform(df['clean_title']) df['price'] = le.fit_transform(df['price'])

#### 4. 데이터 분할
1) train-test 분할

트레인 3800, 테스트 209

train = df.iloc[:3800, :] test = df.iloc[-209:, :]

2) 독립-종속 (X-y) 분할

from sklearn.model_selection import train_test_split

X = train.drop(columns = ['price']) y = train['price']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 10)

#### 5. 모델링

from sklearn.ensemble import RandomForestRegressor

rfr = RandomForestRegressor(n_estimators = 120, max_depth = 15, random_state = 10) rfr.fit(X_train, y_train) pred1 = rfr.predict(X_test)

- random_state 는 동일하게 설정해야함

#### 6. 성능평가

from sklearn.metrics import mean_squared_error import numpy as np

mse = mean_squared_error(y_test, pred1) rmse = np.sqrt(mse) print(rmse)

#### 7. 최종 결과 예측

test_X_data = test.drop(columns = ['price']) pred2 = rfr.predict(test_X_data)

#### 8. CSV 파일 저장

pd.DataFrame({'price' : pred2}).to_csv('result.csv', index = False) result = pd.read_csv('result.csv')

#### 9. 추가
- 원-핫 인코딩 : 순서가 없는 범주형 변수
- 라벨 인코딩 : 순서가 있는 범주형 변수

pd.get_dummies(df, columns = ['col1', 'col2']

import pandas as pd

02 csv 파일 불러오기

import pandas as pd
test_csv = pd.read_csv("CSV 파일경로")

03 col(열) 추출하기

import pandas as pd
test_csv = pd.read_csv("CSV 파일경로")

test_csv[['col1', 'col2', 'col3']]

• 원하는 col에 대해서 전부 추출 가능

04 특정 조건 검색

import pandas as pd
test_csv = pd.read_csv("CSV 파일경로")

test_csv[['col1', 'col2', 'col3']][test_csv['col2']=='hello']

• col2가 hello인 행의 col1, col2, col3만 추출해서 출력
• 비교연산자 전부 사용 가능(>, ==, < 등)

05 비교연산자 종류

==    // 똑같으면 True, 다르면 False
<    // 오른쪽이 크면 True, 아니면 False
>    // 왼쪽이 크면 True, 아니면 False
<=    // 오른쪽이 크거나 같으면 True, 아니면 False
>=    // 왼쪽이 크거나 같으면 True, 아니면 False
!=    // 다르면 True, 같으면 False

1) Pandas 비교 연산 종류

test_csv['col1'].between(1, 10)    // col1의 1~10 사이인 row 선택 
test_csv['col1'].isin([1, 2])    // col1이 1, 2인 row 선택
test_csv['col1'].isnull()        // col1이 numm인 row 선택
test_csv['col1'].apply(lamda)    // lamda 함수를 활용해 row 선택

• between은 시작과 끝 값을 포함

  2) not 연산 예시

  test_csv[['col1', 'col2', 'col3']][~file['col2'].between(1, 10)]

• col2가 1~10사이가 아닌 row 선택

  3) 모든 col을 전부 선택하고 싶을 때

  test_csv[:][test_csv['col2'].between(1, 10)]
  test_csv[test_csv['col2'].between(1, 10)]

• 두개 다 가능

4) not 연산 적용 예시

test_csv[:][~test_csv['col2'].between(1, 10)]
test_csv[~test_csv['col2'].between(1, 10)]

06 한글 데이터 인코딩

test_csv = pd.read_csv("CSV 파일경로", encoding = "euckr")

• EUCKR : Extended Unix Code KR

07 lambda 함수를 활용한 선택

test_csv[['col1', 'col2', 'col3']][file['col2'].apply(lambda x : x[0] == 'A')]

• col2의 0번 인덱스가 A인 row 선택

08 데이터 정렬

test_csv[['col1', 'col2', 'col3']].sort_values( by ='col2',  ascending=True)

• ascending = True - 오름차순 정렬
• ascending = Flase - 내림차순 정렬

09 데이터 프레임 구조 확인

test_csv.info()

1) Dtype (Data Type)

• int64 - 정수
• object - 문자
• float64 - 실수

10 데이터 타입 변환 (문자-날짜)

test_csv['date'] = pd.to_datetime(csv_test['date'])

1) 날짜형 데이터 선택

test_csv[['col1', 'col2', 'date']][test_csv['date'] == '1999-12-09']

• between()을 사용하면 구간 단위 선택도 가능

11 데이터 중복 제거

test_csv['col2'].unique()

• 대괄호 2개 -> Data frame
• 대괄호 1개 -> Series (unique()는 Series 함수)

12 문자 함수

1) .upper(), .lower()

test_csv['name'].str.upper()
test_csv['name'].str.lower()

• Series에서는 upper(), lower()등이 사용 불가 하므로 str로 바꿔준 뒤 써야함
• upper() : 전체 문자열을 대문자로 변환
• lower() : 전체 문자열을 소문자로 변환

2) .capitalize() - 첫번째 철자 대문자로 변환

test_csv.col1.str.capitalize()

3) .slice(start = , stop = ) - 문자열 자르기

test_csv.col1.str.slice(start = 0, stop = 3)

• 0번째 부터 2번째 까지 자르기
• .apply(lambda = )를 사용해서 체크할 수도 있지만 .slice()로 잘라서 체크도 가능

4) .len() - 문자열 길이

test_csv['col1_len'] = test_csv.col1.str.len()

• 이런식으로 새로운 col 추가도 가능

5) .lstrip(), .rstrip(), .strip() - 공백 제거

test_csv.col1.str.strip()

6) .replace() - 문자 대체

test_csv.col1.str.replace('a', 'b')

• a를 b로 대체

  7) .find() - 특정 문자 위치 인덱스

  test_csv[['col1', 'col2']][test_csv.col2.str.find('a') != -1]

• 없으면 -1 출력

13 pd.concat()

pd.concat([test_csv.col1, test_csv.col2], axis = 1)

• axis = 1 - 옆으로 붙이기
• axis = 0 - 아래로 붙이기

  test_csv.col2.str.lower()

• 이런식의 접근도 가능

14 데이터 형 변환

test_csv['co1'] = test_csv['co1'].astype(str)

• col1을 str type으로 변환

15 re - 데이터 전처리 모듈

1) re.sub

test_csv['col1_mask'] = test_csv.col1.apply( lambda x : re.sub('[0-2]', '*', x))

• 0~2의 문자를 * 로 바꿈

16 각종 연산

1) max(), min() - 최대, 최소 선택

test_csv['col1'].max().reset_index()
test_csv['col1'].max().reset_index()

2) groupby, reset_index() - col로 묶기

test_csv.groupby('col1')['col2'].max().reset_index()

• job별로 묶은 뒤 money col의 max를 출력

  3) groupby() 2개로 하기

  test_csv.groupby(['col1', 'col2'])['col3'].sum().reset_index()

  4) sum(), mean() - 합, 평균값

  test_csv['col1'].sum().reset_index()
  test_csv['col1'].mean().reset_index()

  5) count() - 개수 세기

  test_csv.groupby('col1')['col2'].count().reset_index()

• 결측치가 없는 columns을 사용해야 한다

  17 col 이름 변경

  test_csv.columns = ['이름', '나이']

• 차례로 변경

18 DateTime

1) Date Time으로 변환

test_csv['col1'] = pd.to_datetime(test_csv['col1'])

2) 정보 추출

test_csv.col1.dt.year    // 년도
test_csv.col1.dt.month    // 월
test_csv.col1.dt.day    // 일

19 Rank()

test_csv['순위'] = test_csv['col1'].rank(method = 'dense', ascending = False).astype(int)
test_csv[['col1', 'col2', '순위']].sort_values(by = '순위', ascending = True)

• dense 설정 : 1등 -> 공동 2등 -> 3등
• dense 설정X : 1등 -> 공동 2등 -> 4등

20 qcut()

cuts = 5
test_csv['grade'] = pd.qcut(test_csv.순위, q = cuts, labels=range(1, cuts+1))

• cuts : 몇개로 나눌 건지 선택

21 round() - 반올림

round(3.14)    // 3이 나옴

22 .fillna() - 결측지 대체

test_csv['col1'].fillna(mean_value, inplace = True)

23 그룹별 가로 출력

test_csv.groupby('col1')['col2'].apply(list).reset_index(name = 'test_name')

24 행 이동

test_csv['col1'] = test_csv['col2'].shift(1).fillna(0).astype(int)

25 pivot() - 데이터 회전

result = test_csv.pivot_table(columns='num', values = 'col1', aggfunc = 'sum')

• index = 'col2' : 세로로 구분 열 추가

26 merge - join함수

result = pd.merge(test_csv1, test_csv2, on = 'col1', how = 'inner')

• on은 동일한 col을 선택
• inner : equi join
• outer : full outer joint
• right : 우측 테이블 데이터
• left : 좌측 테이블 데이터

27 .drop_duplicates() - 중복제거

pd.concat([x1, x2], axis = 0).drop_duplicates()

수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.

1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ... 2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ... 3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...

1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성해주세요.

• 제한사항 시험은 최대 10,000 문제로 구성되어있습니다. 문제의 정답은 1, 2, 3, 4, 5중 하나입니다. 가장 높은 점수를 받은 사람이 여럿일 경우, return하는 값을 오름차순 정렬해주세요.

  2. 풀이

  1차 시도 (성공)

  def solution(answers):
    first_std = 0
    second_std = 0
    third_std = 0
    f_std_list = [1, 2, 3, 4, 5] * 8
    s_std_list = [2, 1, 2, 3, 2, 4, 2, 5] * 5
    t_std_list = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5] * 4
    answer = []
    idx = 0
    for i in range(0, len(answers)):
        if (i % 40 == 0) and (i != 0) :
            idx += 1
        if f_std_list[i-(idx*40)] == answers[i]:
            first_std += 1
        if s_std_list[i-(idx*40)] == answers[i]:
            second_std += 1        
        if t_std_list[i-(idx*40)] == answers[i]:
            third_std += 1        
  
    if first_std > second_std :
        if first_std > third_std:
            answer.append(1)
        elif first_std <third_std:
            answer.append(3)
        else:
            answer.append(1)
            answer.append(3)
    elif first_std < second_std:
        if second_std > third_std:
            answer.append(2)
        elif second_std <third_std:
            answer.append(3)
        else:
            answer.append(2)
            answer.append(3)
    else :
        if first_std > third_std:
            answer.append(1)
            answer.append(2)
        elif first_std < third_std:
            answer.append(3)
        else:
            answer.append(1)
            answer.append(2)
            answer.append(3)
    return answer

• 너무 복잡하게 푼 것 같다...

  3. Lv.up

  4. Ref.

  def solution(answers):
    pattern1 = [1,2,3,4,5]
    pattern2 = [2,1,2,3,2,4,2,5]
    pattern3 = [3,3,1,1,2,2,4,4,5,5]
    score = [0, 0, 0]
    result = []
  
    for idx, answer in enumerate(answers):
        if answer == pattern1[idx%len(pattern1)]:
            score[0] += 1
        if answer == pattern2[idx%len(pattern2)]:
            score[1] += 1
        if answer == pattern3[idx%len(pattern3)]:
            score[2] += 1
  
    for idx, s in enumerate(score):
        if s == max(score):
            result.append(idx+1)
  
    return result

  • 이해가 좀 어렵지만... 그래도 대충은 알것 같다..

• 일단 1번 문제부터 말렸다.. 뭐가 문제였는지는 모르겠다.
• 총 세문제가 나왔는데.. 솔직히 말해서 실력이 많이 부족했다는 걸 느꼈다!
• 앞으로 공부해야할 부분들이 많이 보였다.
• 세문제중 두번째 문제만 해결하고 나머지 두 문제는 건드리지 못했다..
• 화이팅합시다..!

배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다.

예를 들어 array가 [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3이라면

array의 2번째부터 5번째까지 자르면 [5, 2, 6, 3]입니다. 1에서 나온 배열을 정렬하면 [2, 3, 5, 6]입니다. 2에서 나온 배열의 3번째 숫자는 5입니다. 배열 array, [i, j, k]를 원소로 가진 2차원 배열 commands가 매개변수로 주어질 때, commands의 모든 원소에 대해 앞서 설명한 연산을 적용했을 때 나온 결과를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

• 제한사항 array의 길이는 1 이상 100 이하입니다. array의 각 원소는 1 이상 100 이하입니다. commands의 길이는 1 이상 50 이하입니다. commands의 각 원소는 길이가 3입니다.

  2. 풀이

  1차 시도 (성공)

  def solution(array, commands):
    answer = []
    cut = []
    for i in range(0, len(commands)):
        cut = array[commands[i][0]-1:commands[i][1]]
        cut.sort()
        answer.append(cut[commands[i][2]-1])
    return answer

  3. Lv.up

  4. Ref.

  def solution(array, commands):
    return list(map(lambda x:sorted(array[x[0]-1:x[1]])[x[2]-1], commands))

• 람다식을 사용해서 한줄로 정리했다.

이중 우선순위 큐는 다음 연산을 할 수 있는 자료구조를 말합니다. 이중 우선순위 큐가 할 연산 operations가 매개변수로 주어질 때, 모든 연산을 처리한 후 큐가 비어있으면 [0,0] 비어있지 않으면 [최댓값, 최솟값]을 return 하도록 solution 함수를 구현해주세요.

• 제한사항 operations는 길이가 1 이상 1,000,000 이하인 문자열 배열입니다. operations의 원소는 큐가 수행할 연산을 나타냅니다. 원소는 “명령어 데이터” 형식으로 주어집니다.- 최댓값/최솟값을 삭제하는 연산에서 최댓값/최솟값이 둘 이상인 경우, 하나만 삭제합니다. 빈 큐에 데이터를 삭제하라는 연산이 주어질 경우, 해당 연산은 무시합니다.

2. 풀이

1차 시도(성공)

import heapq

def solution(operations):
    answer = []
    min_heap = []
    max_heap = []

    for i in operations:
        if i[0] == 'I':
            heapq.heappush(min_heap, int(i[2:]))
            heapq.heappush(max_heap, -int(i[2:]))
        elif i == "D 1":
            if len(max_heap) != 0:
                min_heap = list(min_heap)
                min_heap.remove(-heapq.heappop(max_heap))
                heapq.heapify(min_heap)
            else :
                continue
        elif i == "D -1":
            if len(min_heap) != 0:
                max_heap = list(max_heap)
                max_heap.remove(-heapq.heappop(min_heap))
                heapq.heapify(max_heap)
            else :
                continue

    if len(max_heap) == 0:
        answer = [0, 0]
    else:
        answer.append(-heapq.heappop(max_heap))
        answer.append(heapq.heappop(min_heap))
    return answer

• 최대, 최소를 처리하기 위해 힙을 2개 사용하였다.

  3. Lv.up

  4. Ref.

  from heapq import heappush, heappop
  

def solution(arguments): max_heap = [] min_heap = [] for arg in arguments: if arg == "D 1": if max_heap != []: heappop(max_heap) if max_heap == [] or -max_heap[0] < min_heap[0]: min_heap = [] max_heap = [] elif arg == "D -1": if min_heap != []: heappop(min_heap) if min_heap == [] or -max_heap[0] < min_heap[0]: max_heap = [] min_heap = [] else: num = int(arg[2:]) heappush(max_heap, -num) heappush(min_heap, num) if min_heap == []: return [0, 0] return [-heappop(max_heap), heappop(min_heap)]

- 똑같은 알고리즘으로 구성한 것 같다!

매운 것을 좋아하는 Leo는 모든 음식의 스코빌 지수를 K 이상으로 만들고 싶습니다. 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 Leo는 스코빌 지수가 가장 낮은 두 개의 음식을 아래와 같이 특별한 방법으로 섞어 새로운 음식을 만듭니다.

• 섞은 음식의 스코빌 지수 = 가장 맵지 않은 음식의 스코빌 지수 + (두 번째로 맵지 않은 음식의 스코빌 지수 * 2)

Leo는 모든 음식의 스코빌 지수가 K 이상이 될 때까지 반복하여 섞습니다. Leo가 가진 음식의 스코빌 지수를 담은 배열 scoville과 원하는 스코빌 지수 K가 주어질 때, 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 섞어야 하는 최소 횟수를 return 하도록 solution 함수를 작성해주세요.

• 제한사항 scoville의 길이는 2 이상 1,000,000 이하입니다. K는 0 이상 1,000,000,000 이하입니다. scoville의 원소는 각각 0 이상 1,000,000 이하입니다. 모든 음식의 스코빌 지수를 K 이상으로 만들 수 없는 경우에는 -1을 return 합니다.

  2. 풀이

  1차 시도(실패)

  import heapq
  

def solution(scoville, K): answer = 0 heapq.heapify(scoville) for i in range(len(scoville)): if len(scoville) == 1: answer = -1 break if scoville[0] >= K: flag = 0 break food1 = heapq.heappop(scoville) food2 = heapq.heappop(scoville) mix_food = food1 + (food2*2) heapq.heappush(scoville, mix_food) answer += 1

return answer

- heap 사용해서 풀었으나.. 자꾸 2-3개 케이스에서만 오류가 뜬다.. 뭐가 문제인지 모르겠다..

#### 2차 시도 (성공)

import heapq

def solution(scoville, K): answer = 0 heapq.heapify(scoville) while len(scoville) >= 2: if scoville[0] >= K: break food1 = heapq.heappop(scoville) food2 = heapq.heappop(scoville) mix_food = food1 + (food2*2) heapq.heappush(scoville, mix_food) answer += 1

if len(scoville) == 1 and scoville[0] < K:
    answer = -1

return answer

- -1이 되는 경우의 수를 밖으로 빼주고, while문을 통해 list가 0으로 들어올 수 있을 만한 case를 분류해주었더니 성공했다!
### 3. Lv.up
1. 힙 사용

import heapq list = [1, 2, 3, 4, 5] heapq.heapify(list)

2. max heap 사용

import heapq list = [1, 2, 3, 4, 5] heap = [-num for num in list] heap.heapify(heap) max_val = -heapq.heappop(heap)

### 4. Ref.

import heapq as hq

def solution(scoville, K):

hq.heapify(scoville)
answer = 0
while True:
    first = hq.heappop(scoville)
    if first >= K:
        break
    if len(scoville) == 0:
        return -1
    second = hq.heappop(scoville)
    hq.heappush(scoville, first + second*2)
    answer += 1  

return answer

- 그냥 while True해도 되는구나.. 이걸보니 내가 해결해주지못한건 처음에list값에 아무것도 안들어왔을 때 이구나 라는 걸 알 수 있다. 

• 우선순위가 가장 높은 데이터를 가장 먼저 삭제하는 자료구조.

구현방법

1. List 이용

• insert time : O(1)
• delete time : O(N)

  2. Heap 이용

• insert time : O(logN)
• delete time : O(logN)

Heap

• max heap, min heap 으로 나뉨
• 완전 이진 트리 (왼쪽에서 오른쪽으로 데이터 insert)

Python 라이브러리 사용

import heapq

def heap(res):
    h = []
    result = []

    for value in res:
        heapq.heappush(h, value)
    for i in range(len(h)):
        result.append(heap.heappop(h))
    return result

• 파이썬의 기본 heap 은 min heap
• max heap은 - 붙어야 함

네오는 평소 프로도가 비상금을 숨겨놓는 장소를 알려줄 비밀지도를 손에 넣었다. 그런데 이 비밀지도는 숫자로 암호화되어 있어 위치를 확인하기 위해서는 암호를 해독해야 한다. 다행히 지도 암호를 해독할 방법을 적어놓은 메모도 함께 발견했다.

1. 지도는 한 변의 길이가 n인 정사각형 배열 형태로, 각 칸은 "공백"(" ") 또는 "벽"("#") 두 종류로 이루어져 있다.
2. 전체 지도는 두 장의 지도를 겹쳐서 얻을 수 있다. 각각 "지도 1"과 "지도 2"라고 하자. 지도 1 또는 지도 2 중 어느 하나라도 벽인 부분은 전체 지도에서도 벽이다. 지도 1과 지도 2에서 모두 공백인 부분은 전체 지도에서도 공백이다.
3. "지도 1"과 "지도 2"는 각각 정수 배열로 암호화되어 있다.
4. 암호화된 배열은 지도의 각 가로줄에서 벽 부분을 1, 공백 부분을 0으로 부호화했을 때 얻어지는 이진수에 해당하는 값의 배열이다. 네오가 프로도의 비상금을 손에 넣을 수 있도록, 비밀지도의 암호를 해독하는 작업을 도와줄 프로그램을 작성하라.

• 입력형식 입력으로 지도의 한 변 크기 n 과 2개의 정수 배열 arr1, arr2가 들어온다. 1 ≦ n ≦ 16 arr1, arr2는 길이 n인 정수 배열로 주어진다. 정수 배열의 각 원소 x를 이진수로 변환했을 때의 길이는 n 이하이다. 즉, 0 ≦ x ≦ 2n - 1을 만족한다.

• 출력형식 원래의 비밀지도를 해독하여 '#', 공백으로 구성된 문자열 배열로 출력하라.

  2. 풀이

  1차 시도(성공)

  def solution(n, arr1, arr2):
    answer = []
    bin_arr1 = 0
    bin_arr2 = 0
    bin_arr = 0
    line_str = ""
    for i in range(0, n):
        for j in range(0, n):
            bin_arr1 = arr1[i] % 2
            bin_arr2 = arr2[i] % 2
            arr1[i] = arr1[i] // 2
            arr2[i] = arr2[i] // 2
            if bin_arr1 + bin_arr2 == 0:
                line_str = ' '+line_str
            else :
                line_str = '#'+line_str
            bin_arr1 = 0
            bin_arr2 = 0
        answer.append(line_str)
        line_str = ''
  
    return answer

• 역시 실전 코테 문제들은 다 빡구현... 쉽지 않다..

  3. Lv.up

1. 2진수 변환

   bin(x)

4. Ref.

def solution(n, arr1, arr2):
    answer = []
    for i,j in zip(arr1,arr2):
        a12 = str(bin(i|j)[2:])
        a12=a12.rjust(n,'0')
        a12=a12.replace('1','#')
        a12=a12.replace('0',' ')
        answer.append(a12)
    return answer

• 와... rjust() 오른쪽 정렬해서 출력하는 함수가 있었구나.. 진짜 어지럽다.
• str로 바꿔서 그냥 replace했네... 대단하다..

네오와 프로도가 숫자놀이를 하고 있습니다. 네오가 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면 프로도는 원래 숫자를 찾는 게임입니다.

다음은 숫자의 일부 자릿수를 영단어로 바꾸는 예시입니다.

1478 → "one4seveneight" 234567 → "23four5six7" 10203 → "1zerotwozero3" 이렇게 숫자의 일부 자릿수가 영단어로 바뀌어졌거나, 혹은 바뀌지 않고 그대로인 문자열 s가 매개변수로 주어집니다. s가 의미하는 원래 숫자를 return 하도록 solution 함수를 완성해주세요.

참고로 각 숫자에 대응되는 영단어는 다음 표와 같습니다.

• 제한사항 1 ≤ s의 길이 ≤ 50 s가 "zero" 또는 "0"으로 시작하는 경우는 주어지지 않습니다. return 값이 1 이상 2,000,000,000 이하의 정수가 되는 올바른 입력만 s로 주어집니다.

2. 풀이

1차 시도(성공)

def solution(s):
    answer = ""
    all_len = len(s)
    for i in range(0, all_len):
        if all_len == 0:
            break
        if s.startswith('ze'):
            answer += '0'
            s = s[4:]
            all_len -= 4
        elif s.startswith('on'):
            answer += '1'
            s = s[3:]
            all_len -= 3
        elif s.startswith('tw'):
            answer += '2'
            s = s[3:]
            all_len -= 3
        elif s.startswith('th'):
            answer += '3'
            s = s[5:]
            all_len -= 5
        elif s.startswith('fo'):
            answer += '4'
            s = s[4:]
            all_len -= 4
        elif s.startswith('fi'):
            answer += '5'
            s = s[4:]
            all_len -= 4
        elif s.startswith('si'):
            answer += '6'
            s = s[3:]
            all_len -= 3
        elif s.startswith('se'):
            answer += '7'
            s = s[5:]
            all_len -= 5
        elif s.startswith('ei'):
            answer += '8'
            s = s[5:]
            all_len -= 5
        elif s.startswith('ni'):
            answer += '9'
            s = s[4:]
            all_len -= 4
        else  :
            answer += str(s[0])
            s = s[1:]
            all_len -= 1

    ans_int = int(answer)
    return ans_int

3. Lv.up

4. Ref.

num_dic = {"zero":"0", "one":"1", "two":"2", "three":"3", "four":"4", "five":"5", "six":"6", "seven":"7", "eight":"8", "nine":"9"}

def solution(s):
    answer = s
    for key, value in num_dic.items():
        answer = answer.replace(key, value)
    return int(answer)

• 와.. 해시 만들어서 replace 썼네.. 이런 생각들은 참 대단하다..

• 본인은 비전공자로 시험을 치뤘다.
• 정확히 하자면 완전 비전공자는 아님.(로봇공학 전공)
• 문제는 일단 알고리즘 두문제랑 CS 10문제가 나왔다.
• 본인은 CS를 거의 모르기에 대충 찍어 넘기고, 알고리즘 풀이를 진행했다.
• 첫번째문제 하다가, 30분정도 지나서 막히길래 CS 먼저 풀고 나니 1시간정도가 남았었다. 그렇게 진입한 두번째 문제.
• 내용 이해가 조금 어려웠지만..(내가 능지가 부족한가..) 이해하고 나니 구현은 쉬웠던 문제였다.
• 다만 예외 처리 할게 좀 많아서 시간이 좀 걸렸다.
• 그래서 대충 내 능지 선에서... 두번째 문제는 예외처리까지 다 한것 같다.. 아마..?
• 몰라... 코딩 어려워...
• 다행히...... 합격....!
• 다른 후기 찾아보니 2차는 거의 다풀어야 붙는다고 하니까 의욕이 점점 떨어진다.. 시간상 프로그래머스 1, 2단계 문제도 다 못풀고 들어갈 것같은데.. 일단 그래도 다행인건 나같은 비전공자도 코드 짤 수 있도록 알고리즘 공부가 필요한 요소는 많이 없었다!
• 거의 그냥 구현..? 아님 다른 쉬운 알고리즘 방법이 있었을 수도... 쨋든...! 2차 고생합시다..!

숫자로 이루어진 문자열 t와 p가 주어질 때, t에서 p와 길이가 같은 부분문자열 중에서, 이 부분문자열이 나타내는 수가 p가 나타내는 수보다 작거나 같은 것이 나오는 횟수를 return하는 함수 solution을 완성하세요.

예를 들어, t="3141592"이고 p="271" 인 경우, t의 길이가 3인 부분 문자열은 314, 141, 415, 159, 592입니다. 이 문자열이 나타내는 수 중 271보다 작거나 같은 수는 141, 159 2개 입니다.

• 제한사항 1 ≤ p의 길이 ≤ 18 p의 길이 ≤ t의 길이 ≤ 10,000 t와 p는 숫자로만 이루어진 문자열이며, 0으로 시작하지 않습니다

  2. 풀이

  1차 시도(성공)

  def solution(t, p):
    answer = 0
    cut_len = len(p)
    answer_list = []
    for i in range(0, len(t) - len(p)+1):
        if int(t[i:i+cut_len]) <= int(p):
            answer_list.append(int(t[i:i+cut_len]))
    answer = len(answer_list)
    return answer

• 단순 구현...

  3. Lv.up

  4. Ref.

  def solution(t, p):
    answer = 0
  
    for i in range(len(t) - len(p) + 1):
        if int(p) >= int(t[i:i+len(p)]):
            answer += 1
  
    return answer

• 조금더 간단하게 구현했지면 결국 똑같음

명함 지갑을 만드는 회사에서 지갑의 크기를 정하려고 합니다. 다양한 모양과 크기의 명함들을 모두 수납할 수 있으면서, 작아서 들고 다니기 편한 지갑을 만들어야 합니다. 이러한 요건을 만족하는 지갑을 만들기 위해 디자인팀은 모든 명함의 가로 길이와 세로 길이를 조사했습니다.

아래 표는 4가지 명함의 가로 길이와 세로 길이를 나타냅니다. 가장 긴 가로 길이와 세로 길이가 각각 80, 70이기 때문에 80(가로) x 70(세로) 크기의 지갑을 만들면 모든 명함들을 수납할 수 있습니다. 하지만 2번 명함을 가로로 눕혀 수납한다면 80(가로) x 50(세로) 크기의 지갑으로 모든 명함들을 수납할 수 있습니다. 이때의 지갑 크기는 4000(=80 x 50)입니다.

모든 명함의 가로 길이와 세로 길이를 나타내는 2차원 배열 sizes가 매개변수로 주어집니다. 모든 명함을 수납할 수 있는 가장 작은 지갑을 만들 때, 지갑의 크기를 return 하도록 solution 함수를 완성해주세요.

• 제한사항 sizes의 길이는 1 이상 10,000 이하입니다. sizes의 원소는 [w, h] 형식입니다. w는 명함의 가로 길이를 나타냅니다. h는 명함의 세로 길이를 나타냅니다. w와 h는 1 이상 1,000 이하인 자연수입니다.

  2. 풀이

  1차 시도(성공)

  def solution(sizes):
    max_arr = []
    min_arr = []
    answer = 0
    for i in range(0, len(sizes)):
        if sizes[i][0] >= sizes[i][1]:
            max_arr.append(sizes[i][0])
            min_arr.append(sizes[i][1])
        else:
            max_arr.append(sizes[i][1])
            min_arr.append(sizes[i][0])
    answer = max(max_arr) * max(min_arr)
    return answer

• 가벼운 구현 문제

  3. Lv.up

  4. Ref.

  def solution(sizes):
    return max(max(x) for x in sizes) * max(min(x) for x in sizes)

• 한줄..

어떤 문장의 각 알파벳을 일정한 거리만큼 밀어서 다른 알파벳으로 바꾸는 암호화 방식을 시저 암호라고 합니다. 예를 들어 "AB"는 1만큼 밀면 "BC"가 되고, 3만큼 밀면 "DE"가 됩니다. "z"는 1만큼 밀면 "a"가 됩니다. 문자열 s와 거리 n을 입력받아 s를 n만큼 민 암호문을 만드는 함수, solution을 완성해 보세요.

• 제한사항 공백은 아무리 밀어도 공백입니다. s는 알파벳 소문자, 대문자, 공백으로만 이루어져 있습니다. s의 길이는 8000이하입니다. n은 1 이상, 25이하인 자연수입니다.

  2. 풀이

  1차 시도(실패)

  def solution(s, n):
    answer = ''
    # ASCII 저장할 변수
    tmp = 0
    for i in range(0, len(s)):
        # 공백일때
        if s[i] == ' ':
            answer += ' '
            continue
        # 소문자 일때
        if s[i].islower:
            tmp = ord(s[i]) + n
            # z를 넘어가면 a로 돌리기
            if tmp > 122:
                tmp -= 26
            answer += chr(tmp)
        elif s[i].isupper:
            tmp = ord([i]) + n
            # Z를 넘어가면 A로 돌리기
            if tmp > 90:
                tmp -= 26
            answer += chr(tmp)
    return answer

• 테스트 케이스 일부에서 계속 실패가 뜬다.

  2차 시도 (성공)

  def solution(s, n):
    answer = ''
    # ASCII 저장할 변수
    tmp = 0
    for i in range(0, len(s)):
        # 공백일때
        if s[i] == ' ':
            answer += ' '
            continue
        # 소문자 일때
        if s[i].islower():
            tmp = ord(s[i]) + n
            # z를 넘어가면 a로 돌리기
            if tmp > 122:
                tmp -= 26
            answer += chr(tmp)
        elif s[i].isupper():
            tmp = ord(s[i]) + n
            # Z를 넘어가면 A로 돌리기
            if tmp > 90:
                tmp -= 26
            answer += chr(tmp)
    return answer

• 억장 무너지네. islower()이렇게 선언해야한다.
• ()이거 꼭 있어야한다.
• 근데 왜 에러가 안떴지?

  3. Lv.up

1. 문자 to ASCII ord('A')
2. ASCII to 문자 chr(45)

4. Ref.

def caesar(s, n):
    s = list(s)
    for i in range(len(s)):
        if s[i].isupper():
            s[i]=chr((ord(s[i])-ord('A')+ n)%26+ord('A'))
        elif s[i].islower():
            s[i]=chr((ord(s[i])-ord('a')+ n)%26+ord('a'))

    return "".join(s)

• 내가 고민했던 부분도 추가되어있다. 만약 반복횟수가 여러번일때의 예외처리를 해놓았다.
• 내가 고민만하고 구현은 안한 이유는 제한사항에서 n을 25로 제한했기 때문이다.

한국중학교에 다니는 학생들은 각자 정수 번호를 갖고 있습니다. 이 학교 학생 3명의 정수 번호를 더했을 때 0이 되면 3명의 학생은 삼총사라고 합니다. 예를 들어, 5명의 학생이 있고, 각각의 정수 번호가 순서대로 -2, 3, 0, 2, -5일 때, 첫 번째, 세 번째, 네 번째 학생의 정수 번호를 더하면 0이므로 세 학생은 삼총사입니다. 또한, 두 번째, 네 번째, 다섯 번째 학생의 정수 번호를 더해도 0이므로 세 학생도 삼총사입니다. 따라서 이 경우 한국중학교에서는 두 가지 방법으로 삼총사를 만들 수 있습니다.

한국중학교 학생들의 번호를 나타내는 정수 배열 number가 매개변수로 주어질 때, 학생들 중 삼총사를 만들 수 있는 방법의 수를 return 하도록 solution 함수를 완성하세요.

• 제한사항 3 ≤ number의 길이 ≤ 13

• 1,000 ≤ number의 각 원소 ≤ 1,000 서로 다른 학생의 정수 번호가 같을 수 있습니다.

  2. 풀이

  1차 시도(실패)

• for문 하나로 해보려고했으나, 실패함

• 쉬운 문제니까 3중 for문,,?

  2차 시도(성공)

  def solution(number):
    answer = 0
  
    for i in range(0, len(number)-2):
        for j in range(i+1, len(number)-1):
            for k in range(j+1, len(number)):
                if number[i] + number[j] + number[k] == 0:
                    answer += 1
    return answer

• 시간제한이 없는 간단한 문제였다.

• 허무하다

  3. Lv.up

  4. Ref.

  def solution (number) :
    from itertools import combinations
    cnt = 0
    for i in combinations(number,3) :
        if sum(i) == 0 :
            cnt += 1
    return cnt

• 와,, combinations가 있다니.... 참... 허무하다... 알아두자

S사에서는 각 부서에 필요한 물품을 지원해 주기 위해 부서별로 물품을 구매하는데 필요한 금액을 조사했습니다. 그러나, 전체 예산이 정해져 있기 때문에 모든 부서의 물품을 구매해 줄 수는 없습니다. 그래서 최대한 많은 부서의 물품을 구매해 줄 수 있도록 하려고 합니다.

물품을 구매해 줄 때는 각 부서가 신청한 금액만큼을 모두 지원해 줘야 합니다. 예를 들어 1,000원을 신청한 부서에는 정확히 1,000원을 지원해야 하며, 1,000원보다 적은 금액을 지원해 줄 수는 없습니다.

부서별로 신청한 금액이 들어있는 배열 d와 예산 budget이 매개변수로 주어질 때, 최대 몇 개의 부서에 물품을 지원할 수 있는지 return 하도록 solution 함수를 완성해주세요.

• 제한사항 d는 부서별로 신청한 금액이 들어있는 배열이며, 길이(전체 부서의 개수)는 1 이상 100 이하입니다. d의 각 원소는 부서별로 신청한 금액을 나타내며, 부서별 신청 금액은 1 이상 100,000 이하의 자연수입니다. budget은 예산을 나타내며, 1 이상 10,000,000 이하의 자연수입니다.

  2. 풀이

  1차 시도(성공)

  def solution(d, budget):
    d.sort()
    answer = 0
    summ = 0
    # sort한 d를 for로 돈다
    for i in range(0, len(d)):
        # summ에 d를 더한다
        summ += d[i]
        # 만약 더했는데, budget보다 넘어가면 그 개수로 반복문을 탈출한다.
        if summ > budget:
            answer = i
            break
        # 더했는데 안넘어가면 개수를 answer에 넣고 반복문을 계손 돈다.
        else :
            answer = i+1
    return answer

• 큰 기교없이 구현으로 풀어낸 문제이다.
• 생각을 정리하기위해 주석을 적으면서 진행했다.

  3. Lv.up

  4. Ref.

  def solution(d, budget):
    d.sort()
    while budget < sum(d):
        d.pop()
    return len(d)

• d에서 원소를 제거한 후 sum으로 budget과 비교했다.
• sort해서 작은 수부터 카운트 하자는 건 내가 짠 생각과 똑같지만 이후에 활용도에서 차이가 났다.