제가 방향 제시 드리는건, 결국 데이터를 어떻게 가공하냐가 성능에 제일 중요한 지표라는 점이고.

예를 들어서 아래 그래프를 보시면 파란색(4번 쇼핑몰의 판매량) , 빨간색(10번 쇼핑몰의 판매량) 입니다.

Y 축은 판매금액(판매량) 이라고 보시면 될거 같고, X 축은 Date 라고 보시면 될거같아요.

실제로 이 팀은 시계열 데이터를 다루는데 4번 쇼핑몰 매출이 있었다가 400일 이후엔 아예 없어진 부분과

10번 쇼핑몰에는 그전에는 매출이 하나도 없었다가 400일 기준으로 매출이 생긴 걸 고려해서

생각해낸 Insight가 특정 제품을 판매하는 쇼핑몰이 4번 쇼핑몰에서 10번 쇼핑몰로 바뀌었다.

라는 가설을 세워서 두 쇼핑몰을 합쳐서 하나의 쇼핑몰로 생각해 데이터 프레임을 만들었어요.

데이터 전처리 방법은 다양해요. 지금 적은 거 외에도 더 있을걸요? (찾아보시길)

결측치 처리 → 0 값을 제거할 수도 있고, 최빈값, 평균값 등등으로 값을 바꿀 수도 있어요

이상치 처리 → 튀는 값들을 제거하거나. 결측치처리와 비슷하게 값을 처리하는 방법

파생 변수 생성 → 제가 앞서 말씀드린 것처럼 저희 데이터의 ‘영업 일자’ 칼럼을 활용해서 1번 DF에 독립변수를 추가해서 2번처럼 만드는 거예요. ex) 공휴일, 요일 칼럼 추가

데이터 프레임을 다루기 힘드시면 gpt한테 코드 짜달라고 하고 결과만 보시고 여러분들의 생각만 넣으면 됩니다. ex) 나 이 데이터 셋으로 월별 매출량 보고 싶어, 일별 매출량 보고 싶어, 매출 수량이 0 인 게 얼마나 있는지 확인하고 싶어

해보진 않았지만 아마 단계별로 설명 잘해줄 거예요.

이번 해커톤으로 치면,

각 업장별 일별 매출량을 그래프로 한눈에 볼 수 있고요.

제일 좋은 방법은 저렇게 시각화해서 자기가 생각하는 인사이트를 찾는 게 중요할 거 같아요.

시간별로 한눈에 보기 편하니까?

화이팅입니다.

아 그리고 너무 힘드시면, 굳이 코드로 안 만들어와도 돼요.

그냥 생각하는 거 이렇게 가공해서 이런 칼럼 만들면 어때요?

• Insight 가 젤 중요해요 ..

1. 유저이름 설정

   git config --global user.name "name"

2. 유저 이메일 설정

   git config --global user.email "email" //

   GitHub 가입시 사용한 이메일로

3. 정보 확인하기

   git config --list

GitHub에 처음 코드 입력

1. 초기화

   git init

2. 추가할 파일 더하기

   git add .

   .(점) 은 모든파일을 의미, 선택적으로 하려면 add 뒤에 파일명 붙여주면됨.

3. 상태 확인

   git status

4. 히스토리 만들기

   git commit -m "message"

   -m 은 메시지를 뜻함, ""안에 히스토리 이름 주면됨.

5. GitHub repository 랑 내 로컬 프로젝트랑 연결

   git remote add origin "https://github.com/"

   GitHub에서 복사해서 붙여넣기하면됨.

6. 잘 연결됐는지 확인

   git remote -v

   내가 연결한 주소값이 잘 뜨면 성공!

7. GitHub로 올리기

   git push origin master

   master 자리에는 branch 이름이 들어가면 됨.

GitHub에 계속 업데이트

1. 추가할 파일 더하기

   git add .

2. 히스토리 만들기

   git commit -m "commit"

3. GitHub로 올리기

   git push origin master

내 컴퓨터에 소스코드를 업데이트 하고 싶으면 이 세개의 스텝만 계속 반복하면 됨.

GitHub로 팀프로젝트 하기

1. Github에서 소스코드 다운로드

   git clone 주소 폴더이름

2. Github에서 내 브랜치(branch)만들기

   git checkout -b 브렌치이름

3. 내 브랜치에 소스코드 업데이트하기

   git add . git commit -m "commit" git push origin 브렌치이름

4. 마스터 브랜치에 소스 가져오기(pull)

   git pull origin master

5. 브랜치끼리 이동하는 법

   git checkout 브렌치이름

이렇게 쉬운데 이전에는 어려워 보여서 그냥 따로 정리하고 그랬었는데.. 미리미리 좀 하는법을 익혀둘 걸... 내 잔디.. 지금부터라도 1일 1 커밋 실천해봐야겠다.

• 난방 부하 단계를 예측해주세요!

• 예측할 값(y): Heat_Load (Very Low, Low, Medium, High, Very High)

• 평가: f1-macro

• data: train.csv, test.csv

• 제출 형식: result.csv파일을 아래와 같은 형식으로 제출

  pred
  Very Low
  Low
  High
  ...
  Very High

답안 제출 참고

• pd.read_csv('result.csv') 로 제출 코드 확인

  # 데이터 불러오기
  import pandas as pd
  train = pd.read_csv("")
  test = pd.read_csv("")
  

데이터 크기 확인

train.shape, test.shape

train 샘플 확인

train.head(2)

test 샘플 확인

test.head(1)

type 확인

train.info()

train['Roof'].value_counts()

기초통계 train(object)

train.describe(include='O')

기초통계 test(object)

test.describe(include='O')

결측치 확인(train)

train.isnull().sum()

결측치 확인(test)

test.isnull().sum().sum()

target 확인

train['Heat_Load'].value_counts()

target컬럼 처리

target = train.pop('Heat_Load')

원핫 인코딩(판다스)

print(train.shape, test.shape) train = pd.get_dummies(train) test = pd.get_dummies(test) print(train.shape, test.shape)

from sklearn.model_selection import train_test_split X_tr, X_val, y_tr, y_val = train_test_split(train, target, test_size=0.2, random_state=0) X_tr.shape, X_val.shape, y_tr.shape, y_val.shape

평가 함수

from sklearn.metrics import f1_score

랜덤포레스트

from sklearn.ensemble import RandomForestClassifier rf = RandomForestClassifier(random_state=0) rf.fit(X_tr, y_tr) pred = rf.predict(X_val)

f1_score(y_val, pred, average='macro')

LightGBM

import lightgbm as lgb lg = lgb.LGBMClassifier(random_state=0, verbose=-1) lg.fit(X_tr, y_tr) pred = lg.predict(X_val)

f1_score(y_val, pred, average='macro')

test 예측

pred = rf.predict(test) submit = pd.DataFrame({ 'pred':pred }) submit.to_csv('result.csv', index=False)

pd.read_csv("result.csv") ```

import pandas as pd
df = pd.read_csv()
df.head(2)

1. datetime

df['출동시간'] = pd.to_datetime(df['출동시간']) df['도착시간'] = pd.to_datetime(df['도착시간']) df.info()

2. 도착 - 출동 (분)

df['diff'] = df['도착시간'] - df['출동시간'] df['diff'] = df['diff'].dt.total_seconds() / 60 df.head(2)

3. 소방서별 차이 평균

result = df.groupby('소방서')['diff'].mean()

4. 차이가 가장 큰 값

result.sort_values(ascending = False)[0]

2. 학교에서 교사 한 명당 맡은 학생 수가 가장 많은 학교를 찾고, 그 학교의 전체 교사 수를 구하시오. (정수 출력)
```python
import pandas as pd
df = pd.read_csv()
df.head(2)

# 1. 전체 학생수
df['전체'] = df.iloc[:, 2:].sum(axis=1)
df.head(2)

# 2. 교사 한 명당 맡은 학생 수 (전체/교사)
df['전체/교사'] = df['전체']/df['교사수']
df.head(2)

# 3. 전체 / 교사가 가장 큰 값을 가진 학교의 교사수
df['전체/교사'].idxmax()

print(int(df.loc[7, '교사수']))

3. 연도별로 총 범죄 건수(범죄유형의 총합)의 월평균 값을 구한 후 그 값이 가장 큰 연도를 찾아, 해당 연도의 총 범죄 건수의 월평균 값을 출력하시오. (반올림하여 정수로 출력)

   import pandas as pd
   df = pd.read_csv()
   df.head(2)
   

1. 총 범죄 건수

df['총범죄'] = df.iloc[:,1:-1].sum(axis=1) df.head(2)

2. 연도

df['연도'] = df['날짜'].str[:4] df.head(2)

3. 연도별 그룹핑(총범죄).sum()

result = df.groupby("연도")['총범죄'].sum()/12

4. 가장 큰 값

print(round(result.max())) ```

[가격 예측] 중고 자동차

• 자동차 가격을 예측해주세요!

• 예측할 값(y): price
• 평가: RMSE (Root Mean Squared Error)
• data: train.csv, test.csv
• 제출 형식: result.csv파일을 아래와 같은 형식(수치형)으로 제출

  pred
  11000
  20500
  19610
  ...
  11995

답안 제출 참고

• pd.read_csv('result.csv') 로 제출 코드 확인

# 데이터 불러오기
import pandas as pd

train = pd.read_csv("")
test = pd.read_csv("")

# 데이터 크기 확인
train.shape, test.shape

# 샘플 확인 (시험환경에서는 display 대신 print 활용)
display(train.head(3))
display(test.head(3))

train.info()

# 기초 통계값 확인
train.describe()
test.describe()

train.describe(include='O')
test.describe(include='O')

test['transmission'].value_counts()
train['price'].hist()

display(train.isnull().sum())
display(test.isnull().sum())

y_train = train.pop("price")

cols = ['year', 'mileage', 'tax', 'mpg', 'engineSize']
train = train[cols]
test = test[cols]

from sklearn.model_selection import train_test_split
X_tr, X_val, y_tr, y_val = train_test_split(train, y_train, test_size=0.2, random_state=2022)
X_tr.shape, X_val.shape, y_tr.shape, y_val.shape

from sklearn.ensemble import RandomForestRegressor
rf = RandomForestRegressor()
rf.fit(X_tr, y_tr)
pred = rf.predict(X_val)

from sklearn.metrics import mean_squared_error
def rmse(y_true, y_pred):
    return mean_squared_error(y_true, y_pred)**0.5

    rmse(y_val, pred)


pred = rf.predict(test)
result = pd.DataFrame({
    'pred':pred
})
result.to_csv("result.csv", index=False)
pd.read_csv('result.csv')

import pandas as pd
df = pd.read_csv()
# your code
cond1 = (df['종량제봉투종류'] == '규격봉투') & (df['종량제봉투용도'] == '음식물쓰레기')
df = df[cond1]
cond2 = df['2ℓ가격'] == 0
df = df[~cond2]
print(int(round(df['2ℓ가격'].mean(),0)))

2. bmi를 계산하고, 수치가 정상인 사람 수와 위험체중인 사람 수의 차이를 절대값으로 구하시오 (정수로 출력)

• bmi(체질량지수): 몸무게(kg) / 키(m)의 제곱 단위
  • Height: cm
  • Weight: kg

• 저체중: BMI 18.5미만
• 정상체중: BMI 18.5이상 ~ 23미만
• 과체중 또는 위험체중: BMI 23 이상 ~ 25미만
• 비만체중: 25이상

  import pandas as pd
  df = pd.read_csv()
  # your code
  df
  df['bmi'] = df['Weight'] / ((df['Height']/100) ** 2)
  cond1 = sum((df['bmi'] >= 18.5) & (df['bmi'] < 23))
  cond2 = sum((df['bmi'] >= 23) & (df['bmi'] < 25))
  answer = abs(cond1 - cond2)
  print(int(answer))

• 3. 순전입학생(순전입 학생 = 전입 학생 - 전출 학생)이 가장 많은 학교의 전체학생수를 정수로 출력하시오*

  import pandas as pd
  df = pd.read_csv()
  # your code
  df['순전입 학생'] = df['전입학생수(계)'] - df['전출학생수(계)']
  df = df.sort_values('순전입 학생', ascending = False)['전체학생수(계)']
  print(int(df.iloc[0]))

import pandas as pd
df = pd.read_csv()
# print("1사분위: ",df['age'].quantile(0.25))
# print("3사분위: ",df['age'].quantile(0.75))

result = abs(df['age'].quantile(0.25) - df['age'].quantile(0.75))
# print("절대값 차이: ",result)

print(int(result))

1-2.(loves반응+wows반응)/(reactions반응) 비율이 0.4보다 크고 0.5보다 작으면서, status_type=='video'인 데이터의 갯수

import pandas as pd
df = pd.read_csv()
cond1 = (df['loves'] + df['wows'])/ df['reactions'] > 0.4
cond2 = (df['loves'] + df['wows'])/ df['reactions'] < 0.5
cond3 = df['type'] == 'video'

print(len(df[cond1 & cond2 & cond3]))

1-3. date_added가 2018년 1월 이면서 country가 United Kingdom 단독 제작인 데이터의 갯수

import pandas as pd
df = pd.read_csv()

cond1 = df['country'] == "United Kingdom"

df['date_added'] = pd.to_datetime(df['date_added'])
df['year'] = df['date_added'].dt.year
df['month'] = df['date_added'].dt.month


cond2 = df['year'] == 2018
cond3 = df['month'] == 1

print(len(df[cond1 & cond2 & cond3]))

• 자동차 회사는 새로운 전략을 수립하기 위해 4개의 시장으로 세분화했습니다.
• 기존 고객 분류 자료를 바탕으로 신규 고객이 어떤 분류에 속할지 예측해주세요!

• 예측할 값(y): "Segmentation" (1,2,3,4)
• 평가: Macro f1-score
• data: train.csv, test.csv
• 제출 형식:

  ID,Segmentation
  458989,1
  458994,2
  459000,3
  459003,4

답안 제출 참고

• 아래 코드 예측변수와 수험번호를 개인별로 변경하여 활용
• pd.DataFrame({'ID': test.ID, 'Segmentation': pred}).to_csv('003000000.csv', index=False)

노트북 구분

• basic: 수치형 데이터만 활용 -> 학습 및 test데이터 예측
• intermediate: 범주형 데이터도 활용 -> 학습 및 test데이터 예측
• advanced: 학습 및 교차 검증(모델 평가) -> 하이퍼파라미터 튜닝 -> test데이터 예측

  # 라이브러리 불러오기
  import pandas as pd
  

데이터 불러오기

train = pd.read_csv() test = pd.read_csv()

#target = 'Segmentation' print(train.shape, test.shape) train.info()

train.head()

test.describe(include = 'O')

train['Segmentation'].value_counts()

전처리 및 인코딩 및 스케일링

#one-hot

from sklearn.preprocessing import LabelEncoder cols = train.select_dtypes(include = 'object').columns le = LabelEncoder() for col in cols: train[col] = le.fit_transform(train[col]) test[col] = le.transform(test[col])

print(train.shape, test.shape) target = train.pop('Segmentation') train.drop('ID', axis = 1 , inplace = True) test_id = test.pop('ID') print(train.shape, test.shape)

범주형 수치형 분할

train_oh = train.select_dtypes(include = 'object')

train_sc = train.select_dtypes(exclude = 'object')

test_oh = test.select_dtypes(include = 'object')

test_sc = test.select_dtypes(exclude = 'object')

#train.select_dtypes(exclude = 'object').columns #스케일링 minmax

cols =['Age', 'Work_Experience', 'Family_Size']

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()

train_sc[cols] = scaler.fit_transform(train_sc[cols])

test_sc[cols] = scaler.transform(test_sc[cols])

train_oh = pd.get_dummies(train_oh)

test_oh = pd.get_dummies(test_oh)

train = pd.concat([train_oh, train_sc], axis = 1)

test = pd.concat([test_oh, test_sc], axis = 1)

print(train.shape, test.shape)

모델링

from sklearn.model_selection import train_test_split X_tr, X_val, y_tr, y_val = train_test_split(train, target, test_size = 0.2, random_state = 2022) print(X_tr.shape, X_val.shape, y_tr.shape, y_val.shape)

분류 랜덤포레스트, 로지스틱회귀

from sklearn.metrics import accuracy_score

#랜덤포레스트 from sklearn.ensemble import RandomForestClassifier rf = RandomForestClassifier(random_state = 2022, max_depth = 7, n_estimators = 1000) rf.fit(X_tr, y_tr) rf_pred = rf.predict(X_val) print(accuracy_score(y_val, rf_pred))

0.5393848462115529

#로지스틱회귀 from sklearn.linear_model import LogisticRegression lo = LogisticRegression() lo.fit(X_tr, y_tr) lo_pred = lo.predict(X_val) print(accuracy_score(y_val, lo_pred))

pred= rf.predict(test) answer = pd.DataFrame({'ID' : test_id, 'Segmentation' : pred}).to_csv("result.csv", index = False) ```

# 여기에 답안코드를 작성하세요.

import tensorflow as tf from tensorflow import keras from tensorflow.keras.models import Sequential, load_model from tensorflow.keras.layers import Dense, Dropout from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

try: model = Sequential()

model.add(Dense(64, activation='relu', input_shape=(X_train.shape[1],)))
model.add(Dropout(0.2))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(16, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])

es = EarlyStopping(monitor='val_loss', patience=4, mode='min', verbose=1)
mc = ModelCheckpoint('best_model.keras', monitor='val_loss', save_best_only=True, verbose=1)


history = model.fit(X_train, y_train, 
                    batch_size=10, 
                    epochs=10, 
                    callbacks=[es, mc],
                    validation_data=(X_test, y_test), 
                    verbose=1)

except ModuleNotFoundError: print("필요한 모듈이 설치되어 있지 않습니다.")

<br>
<font color=blue>9-2. y_train, y_test를 원핫 인코딩 후 다중 분류하는 딥러닝 모델을 만드세요. 9-1과 동일한 가이드 적용</font>

```python
# 여기에 답안코드를 작성하세요.

from keras.utils import to_categorical
y_train_ohe = to_categorical(y_train)
y_test_ohe = to_categorical(y_test)



model = Sequential()
model.add(Dense(64,activation='relu',input_shape=(X_train.shape[1],)))
model.add(Dropout(0.2))
model.add(Dense(32,activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(16,activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(2,activation='softmax'))

model.compile(optimizer='adam', loss='categorical_crossentropy',metrics=['acc'])

history = model.fit(X_train, y_train_ohe, batch_size=10, epochs=10, callbacks=[es,mc], validation_data=(X_test, y_test_ohe), verbose=1)

model.save('voc_model.keras')

# 여기에 답안코드를 작성하세요.

plt.figure(figsize=(10,5))
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('Model Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend(['Train','Validation'], loc='lower right')

통신 서비스 이용 고객의 이탈 여부 예측 문제

[미션 안내]

• 고객 관련 데이터를 분석한 후 고객의 서비스 중단 또는 경쟁업체로의 이탈 여부를 예측하는 머신러닝, 딥러닝 모델을 만들고 결과를 예측하세요.

[미션 안내]

• 고객 관련 데이터를 분석한 후 고객의 서비스 중단 또는 경쟁업체로의 이탈 여부를 예측하는 머신러닝, 딥러닝 모델을 만들고 결과를 예측하세요.

1. scikit-learn 패키지는 머신러닝 교육을 위한 최고의 파이썬 패키지입니다.

scikit-learn를 별칭(alias) sk로 임포트하는 코드를 작성하고 실행하세요.

# 여기에 답안코드를 작성하세요.
import sklearn as sk

2. Pandas를 사용할 수 있도록 별칭(alias)을 pd로 해서 불러오세요.

# 여기에 답안코드를 작성하세요.
import pandas as pd

3. 모델링을 위해 분석 및 처리할 데이터 파일을 읽어오려고 합니다.

Pandas함수로 데이터 파일을 읽어 데이터프레임 변수명 df에 할당하는 코드를 작성하세요.

• churn_data.csv 파일을 읽어 데이터 프레임 변수명 df에 할당하세요.

# 여기에 답안코드를 작성하세요.
df = pd.read_csv("churn_data.csv")
df

4. df에서 불필요한 customerID 컬럼을 삭제하고 df1에 저장하세요.

# 여기에 답안코드를 작성하세요.

df1 = df.drop('customerID', axis=1)

5. df1의 TotalCharges 컬럼의 타입을 float로 변경하세요.

• TotalCharge의 컬럼 타입을 확인하는 코드를 작성하세요.
• ' ' 값을 0으로 변환하고 컬럼 타입을 float로 변경하세요.
• 전처리 후 데이터를 df2에 저장하세요.

  # 여기에 답안코드를 작성하세요.
  

df1['TotalCharges'].dtype df1['TotalCharges'].replace([' '], ['0'], inplace=True) df1['TotalCharges'] = df1['TotalCharges'].astype(float) df2=df1.copy()

### 6. df2에서 churn 컬럼의 데이터별 개수를 확인하는 코드를 작성하고 df2를 df3에 저장하세요.
### df2의 churn 컬럼의 Yes, No를 각각 1, 0으로 변환한 후 df3의 churn컬럼에 저장하세요.
```python
# 여기에 답안코드를 작성하세요.

df2['Churn'].value_counts()
df3 = df2.copy()
df3['Churn'] = df2['Churn'].replace(['Yes', 'No'], [1, 0])

7. df3의 모든 컬럼에 대해 결측치를 확인하는 코드를 작성하고 결측치를 처리하세요.

• df3을 df4에 저장하세요.
• df4의 결측치가 40% 이상인 컬럼은 컬럼을 삭제하세요.
• df4의 결측치가 40% 미만인 컬럼은 결측치가 있는 row를 삭제하세요.

  # 여기에 답안코드를 작성하세요.
  

print(df3.isnull().sum()) df4 = df3.copy() df4.drop('DeviceProtection', axis=1, inplace=True) df4.dropna(inplace=True) df4.info()

### 8. df4에서 SeniorCitizen 컬럼을 bar 차트로 확인해보고 불균형을 확인해보세요. 
### SeniorCitizen 컬럼은 불균형이 심하므로 삭제하세요.

```python
# 여기에 답안코드를 작성하세요.
df4['SeniorCitizen'].value_counts().plot(kind='bar')
df4.drop('SeniorCitizen', axis=1, inplace=True)
df4.info()

9. df4에서 다음의 가이드에 따라 데이터를 시각화 해보세요.

• tenure (서비스 사용기간)에 대해 히스토그램으로 시각화 하세요.
• tenure를 x 값으로 churn을 hue 값으로 사용하여 kdeplot으로 시각화 하고 '서비스 사용기간이 길어질 수록 이탈이 적다'에 대해 'O'인지 'X'인지 출력하세요.
• 'tenure','MonthlyCharges','TotalCharges' 컬럼간의 상관관계를 확인하여 heatmap으로 시각화하고 가장 높은 상관계수 값을 출력하세요.

  # 여기에 답안코드를 작성하세요.
  

import seaborn as sns import matplotlib.pyplot as plt sns.histplot(data=df4, x='tenure') plt.show()

sns.kdeplot(data=df4, x='tenure', hue='Churn') plt.show() print('O')

sns.heatmap(df4[['tenure','MonthlyCharges','TotalCharges']].corr(), annot=True) print(0.83)

### 10. df4에서 컬럼의 데이터 타입이 object인 컬럼들을 원-핫 인코딩하세요.
* 컬럼의 데이터 타입이 object인 컬럼들을 object_cols 변수에 저장하세요.
* object_cols 변수의 컬럼들을 원-핫 인코딩하세요.
* 전처리된 데이터를 df5에 저장하세요.
```ptyhon
# 여기에 답안코드를 작성하세요.

object_cols = df4.select_dtypes('object').columns.values
df5 = pd.get_dummies(data=df4, columns=object_cols)

11. df5에 대해 Scikit-learn의 train_test_split 함수로 훈련, 검증 데이터를 분리하세요.

• 입력 : X, y (y에는 churn을 저장하고 X에는 churn을 제외한 나머지를 저장하세요)
• Train : Test 비율 = 8:2
• y Class 비율에 맞게 나누는 옵션을 추가하세요.
• random_state=42 로 설정하세요.
• 결과 : X_train, X_valid, y_train, y_valid에 저장하세요.

  # 여기에 답안코드를 작성하세요.
  from sklearn.model_selection import train_test_split
  

X = df5.drop('Churn', axis=1).values y = df5['Churn'].values

X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)

### 12. MinMaxScaler 함수를 'scaler'로 정의하고 데이터를 정규화하세요.

```python
# 여기에 답안코드를 작성하세요.

from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)

13. 고객 이탈 여부를 예측하는 머신러닝 모델을 만들려고 합니다.

아래 가이드에 따라 모델링하고 학습을 진행하세요.

• LogisticRegression 모델 정의하고 학습시키세요.
• KNN으로 모델을 정의하고 학습시키세요. (n_neighbors=5)
• Decision Tree로 모델을 정의하고 학습시키세요. (max_depth=10, random_state=42)
• RandomForest로 모델을 정의하고 학습시키세요. (n_estimators=3, random_state=42)
• XGBoost로 모델을 정의하고 학습시키세요. (n_estimators=3, random_state=42)
• Light GBM으로 모델을 정의하고 학습시키세요. (n_estimators=3, random_state=42)
• 각각 다른 셀에 답안코드를 작성하세요.

  # 여기에 답안코드를 작성하세요.
  

from sklearn.linear_model import LogisticRegression lg = LogisticRegression() lg.fit(X_train, y_train)

from sklearn.neighbors import KNeighborsClassifier knn = KNeighborsClassifier(n_neighbors=5) knn.fit(X_train, y_train)

from sklearn.tree import DecisionTreeClassifier dt = DecisionTreeClassifier(max_depth=10, random_state=42) dt.fit(X_train, y_train)

from sklearn.ensemble import RandomForestClassifier rfc = RandomForestClassifier(n_estimators=3, random_state=42) rfc.fit(X_train, y_train)

!pip install xgboost from xgboost import XGBClassifier xgb = XGBClassifier(n_estimators=3, random_state=42)
xgb.fit(X_train, y_train)

!pip install lightgbm from lightgbm import LGBMClassifier lgbm = LGBMClassifier(n_estimators=3, random_state=42)
lgbm.fit(X_train, y_train)

### 14. 바로 위 Light GBM 모델의 성능을 평가하려고 합니다. 
### y값을 예측하여 confusion matrix를 구하고 heatmap 그래프로 시각화하세요. 
### 그리고 Scikit-learn의 classification_report를 활용하여 성능을 출력하세요.
```python
# 여기에 답안코드를 작성하세요.

from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report

y_pred = lgbm.predict(X_valid)
cm = confusion_matrix(y_valid, y_pred)
sns.heatmap(cm, annot=True)

print(classification_report(y_valid, y_pred, zero_division=1))

다음 문항을 풀기 전에 아래 코드를 실행하세요.

import tensorflow as tf
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.layers import Dense, Activation, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras.utils import to_categorical

tf.random.set_seed(1)

15. 고객 이탈여부를 예측하는 딥러닝 모델을 만들려고 합니다.

아래 가이드에 따라 모델링하고 학습을 진행하세요.

• Tensoflow framework를 사용하여 딥러닝 모델을 만드세요.
• 히든레이어(hidden layer) 2개이상으로 모델을 구성하세요.
• dropout 비율 0.2로 Dropout 레이어 1개를 추가해 주세요.
• 하이퍼파라미터 epochs: 30, batch_size: 16으로 설정해주세요.
• 각 에포크마다 loss와 metrics 평가하기 위한 데이터로 X_valid, y_valid 사용하세요.
• 학습정보는 history 변수에 저장해주세요

  # 여기에 답안코드를 작성하세요.
  

model = Sequential() model.add(Dense(64, activation='relu', input_shape=(X_train.shape[1],))) model.add(Dropout(0.2)) model.add(Dense(32, activation='relu')) model.add(Dense(16, activation='relu')) model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

es = EarlyStopping(monitor='val_loss', patience=5)

checkpoint_path = 'best_model.keras' mc = ModelCheckpoint(checkpoint_path, monitor='val_loss', verbose=1, save_best_only=True)

history = model.fit(X_train, y_train, epochs=30, batch_size=16, validation_data = (X_valid, y_valid), callbacks=[es, mc] )

### 16. 위 딥러닝 모델의 성능을 평가하려고 합니다.
### Matplotlib 라이브러리 활용해서 학습 accuracy와 검증 accuracy를 그래프로 표시하세요.
* 1개의 그래프에 학습 accuracy와 검증 accuracy 2가지를 모두 표시하세요.
* 위 2가지 각각의 범례를 'acc', 'val_acc'로 표시하세요.
* 그래프의 타이틀은 'Accuracy'로 표시하세요.
* X축에는 'Epochs'라고 표시하고 Y축에는 'Acc'라고 표시하세요.

```python
# 여기에 답안코드를 작성하세요.
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Acc')
plt.legend(['acc', 'val_acc'])
plt.show()

Address1(주소1)에 대해 countplot그래프로 만들고 아래 가이드에 따라 답하세요.

• Seaborn을 활용하세요.
• 첫번째, Address1(주소1)에 대해서 분포를 보여주는 countplot그래프 그리세요.
• 두번째, 지역명이 없는 '-'에 해당되는 row(행)을 삭제하세요.

  # 여기에 답안코드를 작성하세요.
  !pip install seaborn
  import seaborn as sns
  import matplotlib.pyplot as plt
  sns.countplot(x = 'Address1', data = df)
  plt.show()
  

df.drop(df[df['Address1'] == '-'].index, inplace = True)

### 5. 실주행시간과 평균시속의 분포를 같이 확인하려고 합니다.
### Time_Driving(실주행시간)과 Speed_Per_Hour(평균시속)을 jointplot 그래프로 만드세요.
* Seaborn을 활용하세요.
* X축에는 Time_Driving(실주행시간)을 표시하고 Y축에는 Speed_Per_Hour(평균시속)을 표시하세요.

```python
# 여기에 답안코드를 작성하세요.
sns.jointplot(x = "Time_Driving", y = "Speed_Per_Hour", data = df)
plt.show()

6. 위의 jointplot 그래프에서 시속 300이 넘는 이상치를 발견할 수 있습니다.

jointplot 그래프에서 발견한 이상치 1개를 삭제하세요.

• 대상 데이터프레임: df
• jointplot 그래프를 보고 시속 300 이상되는 이상치를 찾아 해당 행(Row)을 삭제하세요.
• 전처리 반영 후에 새로운 데이터프레임 변수명 df_temp에 저장하세요.

# 여기에 답안코드를 작성하세요.
df_temp = df.drop(df[df['Speed_Per_Hour'] > 300].index)

7. 모델링 성능을 제대로 얻기 위해서 결측치 처리는 필수입니다.

아래 가이드를 따라 결측치 처리하세요.

• 대상 데이터프레임: df_temp
• 결측치를 확인하는 코드를 작성하세요.
• 결측치가 있는 행(raw)를 삭제 하세요.
• 전처리 반영된 결과를 새로운 데이터프레임 변수명 df_na에 저장하세요.

  # 여기에 답안코드를 작성하세요.
  print(df_temp.isnull().sum())
  df_na = df_temp.dropna()
  df_na.isnull().sum()

  8. 모델링 성능을 제대로 얻기 위해서 불필요한 변수는 삭제해야 합니다.

  아래 가이드를 따라 불필요 데이터를 삭제 처리하세요.

• 대상 데이터프레임: df_na
• 'Time_Departure', 'Time_Arrival' 2개 컬럼을 삭제하세요.
• 전처리 반영된 결과를 새로운 데이터프레임 변수명 df_del에 저장하세요.

  # 여기에 답안코드를 작성하세요.
  df_del = df_na.drop(columns = ['Time_Departure', 'Time_Arrival'])

  9. 원-핫 인코딩(One-hot encoding)은 범주형 변수를 1과 0의 이진형 벡터로 변환하기 위하여 사용하는 방법입니다.

  원-핫 인코딩으로 아래 조건에 해당하는 컬럼 데이터를 변환하세요.

• 대상 데이터프레임: df_del
• 원-핫 인코딩 대상: object 타입의 전체 컬럼
• 활용 함수: pandas의 get_dummies
• 해당 전처리가 반영된 결과를 데이터프레임 변수 df_preset에 저장해 주세요.

# 여기에 답안코드를 작성하세요.
df_del.info()
oh_cols = ['Address1', 'Address2']
df_preset = pd.get_dummies(df_del, columns = oh_cols, drop_first = True)

10. 훈련과 검증 각각에 사용할 데이터셋을 분리하려고 합니다.

Time_Driving(실주행시간) 컬럼을 label값 y로, 나머지 컬럼을 feature값 X로 할당한 후 훈련데이터셋과 검증데이터셋으로 분리하세요.

• 대상 데이터프레임: df_preset
• 훈련 데이터셋 label: y_train, 훈련 데이터셋 Feature: X_train
• 검증 데이터셋 label: y_valid, 검증 데이터셋 Feature: X_valid
• 훈련 데이터셋과 검증데이터셋 비율은 80:20
• random_state: 42
• Scikit-learn의 train_test_split 함수를 활용하세요.

# 여기에 답안코드를 작성하세요.
from sklearn.model_selection import train_test_split
x = df_preset.drop(columns = ['Time_Driving'])
y = df_preset['Time_Driving']
X_train, X_valid, y_train, y_valid = train_test_split(x, y, test_size = 0.2, random_state = 42)

11. Time_Driving(실주행시간)을 예측하는 머신러닝 모델을 만들려고 합니다.

의사결정나무(decision tree)는 여러 가지 규칙을 순차적으로 적용하면서 독립 변수 공간을 분할하는 모형으로

분류(classification)와 회귀 분석(regression)에 모두 사용될 수 있습니다.

의사결정나무(decision tree)로 학습을 진행하세요.

• 트리의 최대 깊이: 5로 설정
• 노드를 분할하기 위한 최소한의 샘플 데이터수(min_samples_split): 3로 설정
• random_state: 120로 설정

  # 여기에 답안코드를 작성하세요.
  from sklearn.tree import DecisionTreeRegressor
  tree = DecisionTreeRegressor(max_depth = 5, min_samples_split = 3, random_state=120)
  tree.fit(X_train, y_train)

  12. 위 의사결정나무(decision tree) 모델의 성능을 평가하려고 합니다.

  예측 결과의 mae(Mean Absolute Error)를 구하세요.

• 성능 평가는 검증 데이터셋을 활용하세요.
• 11번 문제에서 만든 의사결정나무(decision tree) 모델로 y값을 예측(predict)하여 y_pred에 저장하세요.
• 검증 정답(y_valid)과 예측값(y_pred)의 mae(Mean Absolute Error)를 구하고 dt_mae 변수에 저장하세요.

  # 여기에 답안코드를 작성하세요.
  from sklearn.metrics import  mean_absolute_error
  y_pred = tree.predict(X_valid)
  dt_mae = mean_absolute_error(y_valid, y_pred)
  print(dt_mae)

  13. Time_Driving(실주행시간)을 예측하는 딥러닝 모델을 만들려고 합니다.

  아래 가이드에 따라 모델링하고 학습을 진행하세요.

• Tensoflow framework를 사용하여 딥러닝 모델을 만드세요.
• 히든레이어(hidden layer) 2개이상으로 모델을 구성하세요.
• dropout 비율 0.2로 Dropout 레이어 1개를 추가해 주세요.
• 손실함수는 MSE(Mean Squared Error)를 사용하세요.
• 하이퍼파라미터 epochs: 30, batch_size: 16으로 설정해주세요.
• 각 에포크마다 loss와 metrics 평가하기 위한 데이터로 X_valid, y_valid 사용하세요.
• 학습정보는 history 변수에 저장해주세요

  # 여기에 답안코드를 작성하세요.
  model = Sequential()
  model.add(Dense(64, activation='relu', input_shape=(87,))) #input_shape = (X_train.shape[1], 
  model.add(Dropout(0.2))
  model.add(Dense(32, activation='relu'))
  model.add(Dense(16, activation='relu'))
  model.add(Dense(1))
  

model.compile(loss='mse', optimizer='adam', metrics=['mae', 'mse'])

es = EarlyStopping(monitor='val_loss', patience=5)

checkpoint_path = 'best_model.keras' # 파일 경 로를 수정 mc = ModelCheckpoint(checkpoint_path, monitor='val_loss', verbose=1, save_best_only=True)

history = model.fit(X_train, y_train, epochs=30, batch_size=16, validation_data=(X_valid, y_valid), callbacks=[es, mc] )

### 14. 위 딥러닝 모델의 성능을 평가하려고 합니다.
### Matplotlib 라이브러리 활용해서 학습 mse와 검증 mse를 그래프로 표시하세요.
* 1개의 그래프에 학습 mae과 검증 mse 2가지를 모두 표시하세요.
* 위 2가지 각각의 범례를 'mae', 'mse'로 표시하세요.
* 그래프의 타이틀은 'Model MSE'로 표시하세요.
* X축에는 'Epochs'라고 표시하고 Y축에는 'MSE'라고 표시하세요.

```python
# 여기에 답안코드를 작성하세요.
plt.plot(history.history["mae"], label="mae")
plt.plot(history.history["mse"], label="mse")
plt.title("Model MSE")
plt.xlabel("Epochs")
plt.ylabel("MSE")
plt.legend()
plt.show()

dfs 로 순열 문제만 풀다가 그래프 들어가니까 방식의 차이때문에 재귀함수에 대해서 제대로 이해했는지에 대한 의문이 들기시작한다 .. 구분 잘하고 더 공부해보자

풀이

리스트배열 연결 노드들을 입력하고, dfs를 통해 start 노드가 연결되어 있는 노드들을 다 방문하고, 아직 방문이 안된 노드가 있으면 for문을 통해 다시 도는데 그때마다 answer값을 추가해주면 된다.

package study;

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class B_11724 {
    static boolean [] visited;
    static ArrayList<Integer> [] arr;
    static int N, M;
    static int answer = 0;;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        arr = new ArrayList[N+1];
        visited = new boolean[N+1];
        for (int i = 1; i < N+1; i++) {
            arr[i] = new ArrayList<Integer>();
        }
        int a,b;
        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            a = Integer.parseInt(st.nextToken());
            b = Integer.parseInt(st.nextToken());
            arr[a].add(b);
            arr[b].add(a);
        }

        for (int i = 1; i <= N; i++) {
            if (!visited[i]){
                dfs(i);
                answer++;
            }
        }
        System.out.println(answer);
    }
    public static void dfs(int start){
        visited[start] = true;
        for(int i : arr[start]){
            if (!visited[i]){
                dfs(i);
            }
        }
    }
}

풀이

노드 경로를 그대로 출력하는 느낌이라 따로 어려운 건 없어 보이고, 일반 dfs 같은 경우에는 시작에 depth 에 따른 종료 조건이 있어야하는데 이 문제는 그것과 다르게 시작 노드를 방문하고 부터 시작해야 한다는 점만 조심하면 될 것 같다.

package study;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class B_1260 {
    static int N, M, V;
    static boolean [] visited;
    static boolean [][] arr;
    static StringBuilder sb = new StringBuilder();
    static Queue<Integer> q = new LinkedList<>();
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        V = Integer.parseInt(st.nextToken());
        arr = new boolean[N+1][N+1];
        visited = new boolean[N+1];
        int a, b;
        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            a = Integer.parseInt(st.nextToken());
            b = Integer.parseInt(st.nextToken());
            arr[a][b] = arr[b][a] = true;
        }
        dfs(V);
        sb.append("\n");
        visited = new boolean[N+1];
        bfs(V);
        System.out.println(sb);
    }
    public static void dfs(int start){
        visited[start] = true;
        sb.append(start).append(" ");
        for (int i = 1; i < N+1; i++) {
            if (!visited[i] && arr[start][i]){
                dfs(i);
            }
        }
    }
    public static void bfs(int start){
        q.add(start);
        visited[start] = true;
        while (!q.isEmpty()){
            start = q.poll();
            sb.append(start).append(" ");

            for (int i = 1; i < N+1; i++) {
                if (arr[start][i] && !visited[i]){
                    q.add(i);
                    visited[i] = true;
                }
            }
        }
    }
}

ArrayList 는 String 으로 sort 해도, Integer sort 처럼 정렬이 되는 사실을 알게되었다.

조건을 어떻게 넣어야하는지 몰라서 찾아보고 문제를 풀었지만, 조금만 더 생각해보면 간단하게 풀 수있는 문제라고 생각한다. 머리 좀 쓰자 ..

package study;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class B_2529 {
    static boolean  [] visited;
    static int K;
    static String [] str;
    static ArrayList <String> arr;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in);
        K = Integer.parseInt(br.readLine());
        arr = new ArrayList<>();
        str = new String[K];
        answer = new int [K+1];
        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 0; i < K; i++) {
            str[i] = st.nextToken();
        }
        for (int i = 0; i < 10; i++) {
            visited = new boolean[10];
            visited[i] = true;
            dfs(i, 0, i+ "");
            visited[i] = false;
        }
        Collections.sort(arr);
        System.out.println(arr.getLast());
        System.out.println(arr.getFirst());

    }
    public static void dfs(int start, int depth, String a){
        if (a.length() == K+1){
            arr.add(a);
            return;
        }
        for (int i = 0; i < 10; i++) {
            if (!visited[i]){
                if (str[depth].equals("<")){
                    if (start < i){
                        visited[i] = true;
                        dfs(i, depth + 1, a+i);
                        visited[i] = false;
                    }
                }
                else {
                    if (start > i){
                        visited[i] = true;
                        dfs(i, depth + 1, a+i);
                        visited[i] = false;
                    }
                }
            }
        }
    }
}

ps - 제가 쓰는 개발툴이 업데이트가 좀 빨라서 getLast, getFirst 함수를 사용해서 최댓값, 최솟값을 출력했는데 System.out.println(arr.get(arr.size()-1)); System.out.println(arr.get(0)); 으로 작성하시면 백준에서 통과 됩니다.

▷ 한번에 제대로 일하는 꼼꼼함을

▷ 계획을 제대로 실현하는 책임감을

▷ 생각던 것보다 더 잘할 수 있는 능력을

▷ 내 안에서 혼자하는 생각을 명쾌하게 설명하고 전달하는 현명함을

결국 모든 것은 다 잘될 것이라는 근거없는 자신감은 일을 망칠 뿐이고 제대로 해야 중간도 갈까말까라는 마음으로 겸손하게 임하기

import java.lang.Math;
class Solution {
    public long solution(long n) {
        long answer = 0;
        double sqrt = Math. sqrt(n);
        if(sqrt % 1 == 0){
            answer = (long) Math.pow(sqrt + 1, 2);
        }else answer = -1;
        return answer;
    }
}

Math 함수 정리하기 백준으로 문제를 풀다보면, 인텔리제이로 문제를 풀었어서 자동완성 덕에 import 또는 전체 문장을 일일이 적지 않았었는데.. 프로그래머스로 문제를 풀다보니 length() 괄호 이런거 하나로 오류가 발생하기도 한다. 이게 프로그래머스의 장점인거 같기는한듯 ?

Math 함수를 사용하려면

import java.lang.Math;

기억하고 이번 문제에서 사용한 함수만 정리해보자면 Math.sqrt() : 제곱근 구하는 함수 Math.pow() : 제곱을 구하는 함수 그 외에도 max min 정도 문제를 풀다가 새로운 함수를 알게되면 다시 정리하러 오겠습니다.

일단 팰린드롬 인지 아닌지의 여부를 알아야하고, 팰린드롬일때 최대 길이가 몇인지를 알아야한다.

package SWEA_24_05_09;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

public class D3_19003 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine());
        for (int test_case = 1; test_case <= T; test_case++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int N = Integer.parseInt(st.nextToken());
            int M = Integer.parseInt(st.nextToken());
            int result = 0;
            boolean check = false;
            Set <String> set = new HashSet<>();
            for (int i = 0; i < N; i++) {
                String str = br.readLine();
                if (set.contains(str)){ 
                    result += M * 2;
                }else {
                    if (!check && pal(str)){
                        check = true;
                        result += M;
                    }else {
                        StringBuilder sb = new StringBuilder(str);
                        set.add(sb.reverse().toString());
                    }
                }
            }
            System.out.println("#" + test_case + " " + result);
        }
    }
    static boolean pal(String str){
        for (int i = 0; i < str.length()/2; i++) {
            if (str.charAt(i) != str.charAt(str.length()-1 -i)){
                return false;
            }
        }
        return true;
    }

}

check = 팰린드롬인지 여부를 확인하는 용도 문자열을 입력받고 , 이미 set에 있는 문자열이라면 그냥 result 값에 문자열길이를 2배해서 넣고, pal 함수를 통해 그 자체가 팰린드롬인게 확인이 되었다면, 문자열길이만큼만 더해준다. 만약 그게 아니라면 StringBuilder 의 reverse 함수를 통해 뒤집은 문자열을 set 에 넣어준다 그래야 다음 문자열과 비교했을때 같다면 이라는 조건으로 넘어가기 때문

위의 문제와 출력값을 보면 엄청 번거로운 코딩을 해야한다 ..

1. 문자를 입력받고 그 문자에 해당하는 숫자를 반환
2. 반환 받은 숫자를 6자리 이진수를 일렬로 나열
3. 나열한 이진수를 8자리씩 끊음.
4. 8자리씩 십진수로 변환
5. 십진수를 아스키코드로 변환

하지만 ? 자바에는 인코딩/디코딩 시에 사용할 수 있는 라이브러리인 java.util.Base64 가 있다.

package SWEA_24_04_29;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Base64;

public class D2_1928 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine());

        for (int test_case = 1; test_case <= T; test_case++) {
            String str = br.readLine();
            String result = new String(Base64.getDecoder().decode(str));
            System.out.println("#" + test_case + " " + result);
        }
    }
}

Base64.getDecoder().decode(str) 입력받은 str을 디코딩한 문자열을 가져와서 result에 저장

package SWEA_24_04_29;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Base64;

public class D2_1928 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine());

        for (int test_case = 1; test_case <= T; test_case++) {
            String str = br.readLine();
            String result = new String(Base64.getEncoder().encode(str.getBytes()));
            System.out.println("#" + test_case + " " + result);
        }
    }
}

반대로 인코딩한 문자열을 가져와서 result 로 출력도 가능한걸 확인했다. 디코딩/인코딩 = Base64 기억하자

문제내용은 1~N*N 까지 달팽이 모양으로 숫자를 증가해서 2차원 배열에 집어넣는 문제

규칙은 1부터 보면, 배열 크기까지 오른쪽으로 이동 (j 값 1 증가) -> 아래로 이동 (i 값 1 증가) -> 왼쪽으로 이동 (j 값 1 감소) -> 위쪽으로 이동 ( i 값 1 감소) 이게 핵심이라고 생각한다.

이동방향으로 생각하면 우 하 좌 상 int [] di = {0, 1, 0, -1} int [] dj = {1, 0, -1, 0}

package SWEA_24_04_26;

import java.util.Scanner;

public class D2_1954Ref {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        for (int test_case = 1; test_case <= T ; test_case++) {
            int N = sc.nextInt();
            int [][] arr = new int[N][N];
            int [] di = {0, 1, 0, -1};
            int [] dj = {1, 0, -1, 0};
            int i = 0; int j = 0; int dr = 0;
            int count = 1;
            arr[i][j] = count;
            count += 1;
            while (count <= N*N){
                int si = i + di[dr];
                int sj = j + dj[dr];
                if (0 <= si && si< N && 0<= sj && sj <N && arr[si][sj] == 0){
                    i = si;
                    j = sj;
                    arr[i][j] = count;
                    count += 1;
                }else dr = (dr+1) % 4;
            }
            System.out.println("#" + test_case);
            for (int k = 0; k < N; k++) {
                for (int l = 0; l < N; l++) {
                    System.out.print(arr[k][l]);
                    System.out.print(" ");
                }
                System.out.println(" ");
            }
        }
    }
}

if 문을 보면 들어갈 i 와 j 가 범위 안에 들어가 있어야 하고, 들어갈 칸이 값이 없을때 count 값을 추가하고 그게 아니라면, 방향전환을 해야하기 때문에 dr 값 수정

며칠 있다가 다시 풀어볼 예정이다. 내가 지금 코드를 암기를 한건지 이해를 한건지 나도 잘 모르겠다.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        Queue<Integer> que = new LinkedList<>();
        int last = 0;
        int N = Integer.parseInt(br.readLine());
        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            String str = st.nextToken();
            switch (str){
                case "push":
                    last = Integer.parseInt(st.nextToken());
                    que.add(last);
                    break;
                case "pop":
                    if (que.isEmpty()){
                        sb.append(-1).append('\n');
                    }
                    else sb.append(que.poll()).append('\n');
                    break;
                case "size":
                    sb.append(que.size()).append('\n');
                    break;
                case "empty":
                    if (que.isEmpty()) sb.append(1).append('\n');
                    else sb.append(0).append('\n');
                    break;
                case "front":
                    if (que.isEmpty()){
                        sb.append(-1).append('\n');
                    }
                    else sb.append(que.peek()).append('\n');
                    break;
                case "back":
                    if (que.isEmpty()){
                        sb.append(-1).append('\n');
                    }
                    else sb.append(last).append('\n');
                    break;


            }
        }
        System.out.println(sb);
    }
}

직접 Queue 를 구현해보기도 했음 스택을 공부하고 나니까 훨씬 이해가 쉬워지는 느낌 first 값 last 값 만 기억하면 쉬웠던거 같다.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static int[] queue = new int[10001];
    public static int first = 0;
    public static int last = 0;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        int N = Integer.parseInt(br.readLine());
        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            String str = st.nextToken();
            switch (str) {
                case "push":
                    push(Integer.parseInt(st.nextToken()));
                    break;
                case "pop":
                    sb.append(pop()).append('\n');
                    break;
                case "size":
                    sb.append(size()).append('\n');
                    break;
                case "empty":
                    sb.append(empty()).append('\n');
                    break;
                case "front":
                    sb.append(front()).append('\n');
                    break;
                case "back":
                    sb.append(back()).append('\n');
                    break;
            }

        }
        System.out.println(sb);

    }

    public static void push(int item) {
        queue[last] = item;
        last++;
    }

    public static int pop() {
        if (last - first == 0) {
            return -1;
        } else {
            int value = queue[first];
            first++;
            return value;
        }
    }

    public static int size() {
        return last - first;
    }

    public static int empty() {
        if (last - first == 0) {
            return 1;
        } else return 0;
    }

    public static int front() {
        if (last - first == 0) {
            return -1;
        } else {
            int F = queue[first];
            return F;
        }
    }

    public static int back() {
        if (last - first == 0) {
            return -1;
        } else {
            int B = queue[last - 1];
            return B;
        }
    }
}