진수는 숫자를 표현하는 방식이다. 기본적으로 **몇 개의 숫자를 쓸 수 있느냐(=기수)**로 나뉜다. 아래는 대표적인 4가지 진수야:

🌱 2진수(Binary, Base2)

• 사용 숫자: 0, 1
• 예시: 1011, 110, 0001
• 용도: 컴퓨터 내부에서 사용하는 기본 숫자 표현

예시 변환:

• 1011(2) = 1×2³ + 0×2² + 1×2¹ + 1×2⁰ = 8 + 0 + 2 + 1 = 11(10)

🌱 8진수 (Octal, Base8)

• 사용 숫자: 0 ~ 7
• 예시: 75, 0123, 177
• 자리수:
  • 1의 자리 ... 0 ~ 7 (8종류의 수)
  • 2의 자리 ... 0 ~ 77 (64종류의 수)
  • 3의 자리 ... 0 ~ 777 (512종류의 수)
• 용도: 예전 컴퓨터 시스템에서 많이 씀 (예: Unix 파일 권한)

예시 변환:

• 75(8) = 7×8¹ + 5×8⁰ = 56 + 5 = 61(10)
• 125(0) = 175(8) 125 ÷ 8 = 15 … 5 15 ÷ 8 = 1 … 7 1 ÷ 8 = 0 … 1 (끝) → 나머지를 역순으로 읽으면: 1 7 5

10진수 ↔ 8진수(Octal) 변환표 (10 ~ 255)

🌱 10진수 (Decimal, Base10)

• 사용 숫자: 0 ~ 9
• 예시: 42, 1234, 2025
• 용도: 우리가 일상에서 쓰는 숫자

🌱 16진수 (Hexadecimal, Base16)

• 사용 숫자: 0 ~ 9 + A(10), B(11), C(12), D(13), E(14), F(15)
• 예시: 2F, 0xA3, 1B4
• 용도: 메모리 주소, 색상 코드, 낮은 수준 프로그래밍 등

예시 변환:

• 2F(16) = 2×16¹ + 15×16⁰ = 32 + 15 = 47(10)
• 125(0) = 7D(16) 125 ÷ 16 = 7 … 13 → D 7 ÷ 16 = 0 … 7 (끝) → 나머지를 역순으로 읽으면: 7 D

10진수 ↔ 16진수(Hex) 변환표 (10 ~ 255)

요약 비교

필요하면 진수 변환하는 방법도 구체적으로 설명해줄게.

• 실기 체험 환경: https://dataq.goorm.io/exam/3/%EC%B2%B4%ED%97%98%ED%95%98%EA%B8%B0/quiz/1

  help(), dir() 적극 활용 !!!!!!!

• help(): 도움말(docstring)을 출력

• dir(): 객체가 가지고 있는 속성과 메서드(함수) 목록 출력

import pandas as pd

#dir을 통해 사용 가능한 함수 확인
print(dir(pd))
print(dir(pd.DataFrame))

import sklearn
print(sklearn.__all__)

# 전처리 무엇을 할 수 있지?
import sklearn.preprocessing
print(sklearn.preprocessing.__all__)

🦋 제 1유형(10점, 문제 3개): 수행 순서와 답 계산

IQR(이상치)

데이터 중에서 너무 크거나 작은 값(이상치) 들을 걸러내기 위해 사용한다.

Q1 = df[col].quantile(0.25)   # 1사분위수 (하위 25%)
Q3 = df[col].quantile(0.75)   # 3사분위수 (상위 25%)
IQR = Q3 - Q1                 # IQR: 중간 50% 범위

# 이상치 기준 범위
하한 = Q1 - 1.5 * IQR
상한 = Q3 + 1.5 * IQR

• quantile(): 데이터의 분위수를 계산할 때 사용하는 함수 0.25 분위수(=1사분위수), 0.5 분위수(=중앙값), 0.75 분위수(=3사분위수)

  🦋 제 2유형(40점, 문제 1개):

  1. 데이터 유형 파악

▪️ .info() / .info

print(train.info())

▪️ .shape : 튜플 형태로 배열 정보 확인

print(X_train.shape)

2. 데이터 전처리

(1) 독립변수/종속변수 분리, train/test set 분리

• axis = 0: 아래로 내려가면서 계산 → 열(세로)을 따라 계산
• axis = 1: 옆으로 가면서 계산 → 행(가로)을 따라 계산 ⚠️ 행은 가로 = 행거는 가로

import pandas as pd

df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
})
print(df)
'''
   A  B
0  1  4
1  2  5
2  3  6
'''

print(df.sum(axis=0)) # → 각 열의 합
print(df.sum(axis=1)) # → 각 행의 합
'''
A     6
B    15

0     5
1     7
2     9
'''

(2) 결측치 처리: fillna()

# 환불금액에 결측치가 있다는 건 환불을 하지 않았다는 의미로 볼 수 있음
X_trian['환불금액'] = X_trian['환불금액'].fillna(0)
X_test['환불금액'] = X_test['환불금액'].fillna(0)

print(X_trian.isna().sum())
print(X_test.isna().sum())

(3) 수치형 변수 스케일링

Why? 강수량 값이 크다고 해서 중요하다는 뜻이 아니기 때문에 같은 스케일로 바꿔야한다.

• Min-Max Scaling(최소-최대 정규화) : 0~1 사이로 정규화 $$ X_{\text{scaled}} = \frac{X - X_{\text{min}}}{X_{\text{max}} - X_{\text{min}}} $$

  # 🔧 scikit-learn
  from sklearn.preprocessing import MinMaxScaler
  scaler = MinMaxScaler()
  num_columns = X_trian.select_dtypes(exclude='object').columns # 범주형 변수를 제외하고 수치형 변수만 가져옴
  X_trian[num_columns] = scaler.fit_transform(X_trian[num_columns]) # fit_transform(): 학습 → 적용
  X_test[num_columns] = scaler.transform(X_test[num_columns])       # transform(): 적용

  • 범위: 0 ~ 1 / -1 ~ 1
  • 민감도: 이상치에 민감
  • 사용처: 이미지, 딥러닝 등

• Standard Scaling(표준화, Z-score 정규화): 정규분포 기반 $$ X_{\text{scaled}} = \frac{X - \mu}{\sigma} $$

  (평균: μ, 표준편차: σ)

  # 🔧 scikit-lear
  from sklearn.preprocessing import StandardScaler
  scaler = StandardScaler()
  X_scaled = scaler.fit_transform(X)

  • 범위: 평균 0, 표준편차 1
  • 민감도: 상대적으로 안정적이며, 데이터가 정규분포에 가까울수록 효과적
  • 사용처: 회귀, PCA 등

(4) 범주형 변수(Object) 인코딩

why? "Sunny", "Rainy"가 같은 문자열은 컴퓨터가 이해하지 못하기 때문에 숫자를 부여할 필요가 있음.

• Label Encoding(라벨 인코딩):

  ['피자', '치킨', '콜라'] → [0, 1, 2]
  
  # 🔧 scikit-lear
  from sklearn.preprocessing import LabelEncoder
  le = LabelEncoder()
  X_trian['encoded'] = le.fit_transform(X_trian['food'])
  X_test['encoded'] = le.fit_transform(X_test['food'])

  • 순서 없음
  • 트리 기반 모델(RandomForest, XGBoost 등)에 주로 사용됨
  • 각 범주에 숫자 ID 부여

• One-Hot Encoding(원-핫 인코딩):

  • fit → transform → DataFrame → concat

    '피자' → [1, 0, 0]
    '치킨' → [0, 1, 0]
    '콜라' → [0, 0, 1]
    

  pd.get_dummies(df['food'])

  🔧 scikit-lear

  from sklearn.preprocessing import OneHotEncoder ohe = OneHotEncoder(sparse_output=False) cat_cols = ['C1', 'C2', 'C3', 'C4']

  ohe.fit(X_trian[cat_cols])

  DataFrame = get_feature_names_out() : 열 이름 복원

  X_train_ohe = pd.DataFrame(ohe.transform(X_trian[cat_cols]), columns=ohe.get_feature_names_out(cat_cols), index=X_trian.index) X_test_ohe = pd.DataFrame(ohe.transform(X_test[cat_cols]), columns=ohe.get_feature_names_out(cat_cols), index=X_test.index)

  기존 범주형 변수 제거하고 인코딩된 것 추가

  X_trian = pd.concat([X_trian.drop(columns=cat_cols), X_train_ohe], axis=1) X_test = pd.concat([X_test.drop(columns=cat_cols), X_test_ohe], axis=1)

  - 각 범주를 이진 벡터로 변환
  - 선형 모델(**Linear Regression**, Logistic 등)에 주로 사용됨
  - **범주마다 새로운 열 생성**
  

3. 데이터 분리: train_test_split()

• 전체 데이터셋을 훈련(train)과 검증(validation)으로 나누어:
  • 모델 학습은 X_trian, y_train으로 진행하고,
  • 학습한 모델의 성능을 검증용 데이터 X_val, y_val에서 평가

from sklearn.model_selection import train_test_split
X_trian, X_val, y_train, y_val = train_test_split(X_trian, y, test_size=0.2)
print(X_trian.shape, X_val.shape, y_train.shape, y_val.shape)

• train_test_split(X_trian, y, test_size=0.2):
  • X_trian: 독립 변수 데이터 (특징 변수)
  • y: 종속 변수 (목표값, 예: 지하철 이용자 수)
  • test_size=0.2: 전체 데이터 중 20%를 검증용(validation)으로 사용하겠다는 의미 ➡️ 즉, 80%는 훈련용, 20%는 검증용

4. 모델 학습 및 검증

▪️ 분류(RandomForestClassifier)

from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier()
model.fit(X_train, y_train) # 모델 학습
y_val_pred = model.predict(X_val)

• 다중 분류: LabelEncoder → A B C D E → 0 1 2 3 4 → inverser_transform → A B C D E

▪️ 회귀(RandomForestRegressor)

from sklearn.ensemble import RandomForestRegressor
model = RandomForestRegressor()
model.fit(X_trian, y_train)
y_val_pred = model.predict(X_val)

로지스틱 / 다중 선형 회귀 모델

import statsmodels.api as sm
X = sm.add_constant(X) # 상수항 추가

model = 
print(f"회귀계수: {model.params[]}")

• 로지스틱: sm.Logit(y, X).fit()
• 다중 선형: sm.OLS(y, X).fit()

🆚 차이

5. 평가

▪️ 분류: roc_auc_score, accuracy_score

• ROC 곡선 아래 면적(ROC Auc Score):
  • ROC 곡선(Receiver Operating Characteristic curve)은 참 양성 비율(TPR)과 거짓 양성 비율(FPR)의 변화를 나타내는 곡선으로, 분류기가 얼마나 잘 구분하는지(클래스 간 분리도)를 수치로 나타냄.
  • 최대 1.0으로, 1에 가까울수록 성능이 좋음.
• 정확도(Accuracy Score):
  • 맞게 예측한 샘플의 비율
  • 최대 1.0으로, 1에 가까울수록 성능이 좋음.

$$ \text{Accuracy} = \frac{\text{정확히 맞춘 샘플 수}}{\text{전체 샘플 수}} $$

from sklearn.metrics import roc_auc_score, accuracy_score
auc_score = roc_auc_score(y_val, y_val_pred)
acc = accuracy_score(y_val, y_val_pred)
print(f'auc_score: {auc_score}, acc: {acc}')

▪️ 회귀: rmse, r2_score

• RSEM: 예측값과 실제값 사이 오차의 평균적 크기를 나타냄 값이 낮을 수록 안정적
• R²(결정계수): 최대 1.0으로, 1에 가까울수록 성능이 좋음

from sklearn.metrics import root_mean_squared_error, r2_score
rmse = root_mean_squared_error(y_val, y_val_pred)
r2 = r2_score(y_val, y_val_pred)
print(rmse, r2)

6. 결과 저장

y_pred = model.predict(X_test)
result = pd.DataFrame(y_pred, columns=['pred'])
result.to_csv('result.csv', index=False)

7. 생성 결과 확인

result = pd.read_csv('result.csv')
print(result)

🦋 제 3유형(15점, 문제 2개(3문항)): 통계적 가설 검정

▪️ 상관계수: df.corr()

correlations = df.corr(numeric_only=True)['Traget'].drop('Traget') # 자기자신 제외

# 가장 높은 상관계수와 변수 이름
max_corr_var = correlations.abs().idxmax()
max_corr_value = correlations[max_corr_var]

print(f"📌 Target과 가장 선형관계가 큰 변수: {max_corr_var}")
print(f"🔢 상관계수: {max_corr_value:.3f}")

▪️ F-검정(F-test): 두 집단의 분산이 같은가

$$ F = \frac{s_1^2}{s_2^2} $$

• $s_1^2$ : 분산이 더 큰 쪽 (분모가 작게 되면 F 값이 커져서 유의성이 높아짐)
• $s_2^2$ : 분산이 더 작은 쪽

👉 이 값은 F분포를 따름 (자유도는 각 집단의 표본 수 – 1)

• 귀무가설(H₀) 두 집단의 분산은 같다: σ₁² = σ₂²
• 대립가설(H₁) 두 집단의 분산은 다르다: σ₁² ≠ σ₂²

var1 = group1.var()
var2 = group2.var()

# 데이터의 개수 -1 = 자유도
dof_1 = len(group1) -1
dof_2 = len(group2) -1
print(dof_1, dof_2) # 51 63 → group2: 분자, group1: 분모

f_stat = var2/var1
print(round(f_stat,3))

▪️ 분산 추정량(Sample Variance)

$$ s^2 = \frac{1}{n - 1} \sum (x_i - \bar{x})^2 $$

• $n$: 표본의 크기
• $x_i$: i번째 데이터 값
• $\bar{x}$: 표본 평균

▪️ 합동 분산 추정량 (Pooled Variance) : 등분산일 때 가능

$$ s_p^2 = \frac{(n_1 - 1)s_1^2 + (n_2 - 1)s_2^2}{n_1 + n_2 - 2} $$

• $s_1^2$, $s_2^2$: 두 집단의 표본 분산
• $n_1$, $n_2$: 각 집단의 표본 수

var1 = group1.var()
var2 = group2.var()
n1 = len(group1)
n2 = len(group2)

pooled_var = ((n1-1)*var1 + (n2-1)*var2) / (n1+n2-2)
print(round(pooled_var, 3)) 

▪️ t-검정(t-test)

$$ t = \frac{\bar{x}_1 - \bar{x}_2}{s_p \cdot \sqrt{\frac{1}{n_1} + \frac{1}{n_2}}} $$

mean1 = group1.mean()
mean2 = group2.mean()

t_stat = (mean1 - mean2) / np.sqrt(pooled_var * (1/n1 + 1/n2))

• 독립표본 → ttest_ind()
• 대응표본 → ttest_rel()
• 원샘플 → ttest_1samp()
• 한표본 →

▪️ p-value(유의확률)

• $p < 0.05$: 유의수준 5% → Significant(유의함)
• $p \geq 0.05$: Not Significant
• model.pvalues.max()

from scipy import stats 

ttest_result = stats.ttest_ind(group1, group2, equal_var=True)

▪️ 오즈비(Odds Ratio):

어떤 사건이 발생할 확률과 발생하지 않을 확률의 비율을 비교하는 값이다.

import numpy as np
coef = model.params['age']
# 오즈비 (odds ratio) = exp(회귀계수)
print(np.exp(coef))

"오즈비가 몇 배로 변화하는가?" → 오즈비는 계수의 지수함수: $$ \text{오즈비} = e^{\beta} $$

5단위로 증가하면: $$ \text{변화한 오즈비} = e^{\beta \times 5} $$

• odds_ratio > 1: 확률이 증가
• odds_ratio < 1: 확률이 감소
• odds_ratio ≈ 1: 영향 거의 없음

▪️ 잔차 이탈도(residual deviance): .deviance

residual_deviance = -2 * model.llf
                  = model.deviance

▪️ 로짓 우도값(Log-Likelihood of the model: .llf

print(model.llf)

선형 회귀 모델

회귀 계수(Regression Coefficient)

회귀 계수는 각 독립변수가 종속변수에 미치는 영향력의 크기를 나타낸다.

$$ \text{PIQ} = \beta_0 + \beta_1 \cdot \text{Brain} + \beta_2 \cdot \text{Height} $$

• β₀: 상수항 (절편)
• β₁: Brain의 회귀 계수
• β₂: Height의 회귀 계수

의미:

• β₁ = 1.2이면 → Brain 값이 1 단위 증가할 때, PIQ는 평균적으로 1.2 증가.
• β₂ = -3.5이면 → Height가 1 증가하면 PIQ는 평균적으로 3.5 감소.

상수항(constant or intercept) 추가

📌 상수항이 없으면:

모델이 (0, 0)을 반드시 지나야 한다는 제약이 생긴다. 즉, $$ \text{PIQ} = \beta_1 \cdot \text{Brain} + \beta_2 \cdot \text{Height} $$ → 독립변수가 모두 0일 때 종속변수도 무조건 0이어야 함.

📌 상수항을 추가하면:

$$ \text{PIQ} = \beta_0 + \beta_1 \cdot \text{Brain} + \beta_2 \cdot \text{Height} $$

→ 데이터에 더 잘 맞는 유연한 모델을 만들 수 있고, 실제 데이터 분포에도 더 적합함.

• statsmodels나 scikit-learn에서 회귀 분석할 때, 반드시 상수항을 포함시키는 게 일반적.
• statsmodels는 기본적으로 상수항을 포함하지 않기 때문에, sm.add_constant(X)로 명시적으로 추가해줘야 함.

df['컬럼명'] vs df.컬럼명

둘 다 컬럼의 값을 반환한다.

📌 예시: 이런 경우는 df['컬럼명']만 가능

df['Credit Limit']        # O (공백 있음)
df['123Column']           # O (숫자로 시작)
df['class']               # O ('class'는 파이썬 예약어)

df.Credit Limit           # ❌ 오류: 공백 있음
df.123Column              # ❌ 오류: 숫자로 시작
df.class                  # ❌ 오류: 예약어 충돌

✅ 결론

🔸 Filtering Data

데이터 불러오기

https://github.com/justmarkham/DAT8/blob/master/data/chipotle.tsv
import pandas as pd

data_url = 'https://raw.githubusercontent.com/Datamanim/pandas/main/chipo.csv'
df = pd.read_csv(data_url)

.loc[조건]

# 식당데이터 : 
print('🍕 quantity 값이 3인 데이터 상위 5개 출력:')
print(df.loc[df['quantity']==3].head())

• df['quantity']==3 : quantity라는 열의 값이 3과 같은 비교하여 True/False 중에 반환.
• df.loc[조건] : .loc[]는 조건에 맞는 행들을 선택, quantity == 3인 행들만 선택
• .head() : 상위 5개 행만 보여주는 함수. .head(3)이면 상위 3개, .head(10)이면 10개.

  🍕 quantity 값이 3인 데이터 상위 5개 출력:
     order_id  quantity          item_name                                 choice_description item_price
  409       178         3       Chicken Bowl  [[Fresh Tomato Salsa (Mild), Tomatillo-Green C...    $32.94 
  445       193         3               Bowl  [Braised Carnitas, Pinto Beans, [Sour Cream, C...    $22.20 
  689       284         3  Canned Soft Drink                                        [Diet Coke]     $3.75 
  818       338         3      Bottled Water                                                NaN     $3.27 
  850       350         3  Canned Soft Drink                                           [Sprite]     $3.75 

.reset_index(): 인덱스 재정렬

print('🍕 quantity 값이 3인 데이터 상위 5개를 출력히는데 인덱스를 0부터 시작하게 재정의:')
print(df.loc[df['quantity']==3].head().reset_index(drop=True))

• .reset_index() :
  • 기존의 인덱스를 새로운 열로 이동시킴
  • 새로운 0부터 시작하는 인덱스를 생성
• .reset_index(drop=True):
  • 기존 인덱스를 완전히 버림
  • 0부터 다시 매긴 새로운 인덱스만 사용
  • 👉 기존 인덱스를 열로 보존하지 않음

🍕 quantity 값이 3인 데이터 상위 5개를 출력히는데 인덱스를 0부터 시작하게 재정의:
   order_id  quantity          item_name                                 choice_description item_price
0       178         3       Chicken Bowl  [[Fresh Tomato Salsa (Mild), Tomatillo-Green C...    $32.94 
1       193         3               Bowl  [Braised Carnitas, Pinto Beans, [Sour Cream, C...    $22.20 
2       284         3  Canned Soft Drink                                        [Diet Coke]     $3.75 
3       338         3      Bottled Water                                                NaN     $3.27 
4       350         3  Canned Soft Drink                                           [Sprite]     $3.75 

새로운 데이터 프레임 정의

print('🆕 quantity, item_price의 컬럼으로 구성된 새로운 데이터 프레임을 정의:')
print(df[['quantity', 'item_price']])

🆕 quantity, item_price의 컬럼으로 구성된 새로운 데이터 프레임을 정의:
      quantity item_price
0            1     $2.39 
1            1     $3.39 
2            1     $3.39 
3            1     $2.39 
4            2    $16.98 
...        ...        ...
4617         1    $11.75 
4618         1    $11.75 
4619         1    $11.25 
4620         1     $8.75 
4621         1     $8.75 

[4622 rows x 2 columns]

❓ 왜 df['quantity', 'item_price'] 이렇게 쓰면 안되나요? 이건 Pandas 입장에선 튜플 하나를 인덱싱한 것처럼 해석된다. 띠라서 df[['quantity', 'item_price']]처럼 대괄호 2개를 작성해야만 컬럼 두 개를 선택하라는 의미로 해석된다.

.astype() : type 변경

print('💵 item_price에 $를 제거하고 float 타입으로 변경하여 item_price_float에 저장:')
df['item_price_float'] = df['item_price'].str.replace('$', '', regex=False).astype(float)
print(df['item_price_float'].head())

• .str.replace('$', '', regex=False) → $ 기호를 없앰
  • .str.replace(): Pandas는 기본적으로 pat을 정규표현식(Regex)으로 인식하여, regex=True가 기본값
  • $는 "문장의 끝"을 의미하는 메타문자로 regex=False를 작성해 문자의 의미를 없애줌
• .astype(float) → 문자열 "3.50" → 실수 3.50으로 변환

  💵 item_price에 $를 제거하고 float 타입으로 변경하여 item_price_float에 저장:
  0     2.39
  1     3.39
  2     3.39
  3     2.39
  4    16.98
  Name: item_price_float, dtype: float64

🧐

print('🍗 item_name이 "Chicken Salad Bowl"인 것과 item_price_float가 9 이하인 것을 찾아라:')
filtered_df = df.loc[(df.item_name == "Chicken Salad Bowl") & (df.item_price_float <= 9)]
print("☑️ 조건에 맞는 상위 5개: ")
print(filtered_df.head())
print('☑️ 전체 개수:', len(filtered_df))

🍗 item_name이 "Chicken Salad Bowl"인 것과 item_price_float가 9 이하인 것을 찾아라:
☑️ 조건에 맞는 상위 5개: 
     order_id  quantity           item_name                                 choice_description item_price  item_price_float
44         20         1  Chicken Salad Bowl  [Fresh Tomato Salsa, [Fajita Vegetables, Pinto...     $8.75               8.75
256       111         1  Chicken Salad Bowl  [Fresh Tomato Salsa, [Fajita Vegetables, Rice,...     $8.75               8.75
526       220         1  Chicken Salad Bowl  [Roasted Chili Corn Salsa, [Black Beans, Sour ...     $8.75               8.75
528       221         1  Chicken Salad Bowl  [Tomatillo Green Chili Salsa, [Fajita Vegetabl...     $8.75               8.75
529       221         1  Chicken Salad Bowl  [Tomatillo Green Chili Salsa, [Fajita Vegetabl...     $8.75               8.75
☑️ 전체 개수: 56

.sort_values(): 오름차순 정렬

print('💵 item_price_float를 오름차순으로 정리하고 index를 초기화:')
print(df.sort_values('item_price_float').reset_index(drop=True).head())

💵 item_price_float를 오름차순으로 정리하고 index를 초기화:
   order_id  quantity      item_name choice_description item_price  item_price_float
0       471         1  Bottled Water                NaN     $1.09               1.09
1       338         1    Canned Soda        [Coca Cola]     $1.09               1.09
2      1575         1    Canned Soda       [Dr. Pepper]     $1.09               1.09
3        47         1    Canned Soda       [Dr. Pepper]     $1.09               1.09
4      1014         1    Canned Soda        [Coca Cola]     $1.09               1.09

ascending=False: 내림차순

print('💵 item_price_float를 내림차순으로 정리하고 index를 초기화:')
print(df.sort_values('item_price_float', ascending=False).reset_index(drop=True).head())

💵 item_price_float를 내림차순으로 정리하고 index를 초기화:
   order_id  quantity                     item_name                                 choice_description item_price  item_price_float
0      1443        15  Chips and Fresh Tomato Salsa                                                NaN    $44.25              44.25
1      1398         3                 Carnitas Bowl  [Roasted Chili Corn Salsa, [Fajita Vegetables,...    $35.25              35.25
2       511         4               Chicken Burrito  [Fresh Tomato Salsa, [Fajita Vegetables, Rice,...    $35.00              35.00
3      1443         4               Chicken Burrito  [Fresh Tomato Salsa, [Rice, Black Beans, Chees...    $35.00              35.00
4      1443         3                Veggie Burrito  [Fresh Tomato Salsa, [Fajita Vegetables, Rice,...    $33.75              33.75

.str.contains(): 해당 문제열 포함 여부

print('🍪 item_name에 "Chips"가 포함되는 상위 5개 데이터 추출:')
print(df.loc[df.item_name.str.contains('Chips')].head())

• .str.contains('Chips') → 문자열 "Chips"가 포함되어 있는지 여부를 True/False로 반환
• str.contains('chips', case=False): 대소문자 무시
• str.contains('Chips', regex=False): 정규표현식 사용 안함

  🍪 item_name에 "Chips"가 포함되는 상위 5개 데이터 추출:
    order_id  quantity                              item_name choice_description item_price  item_price_float
  0          1         1           Chips and Fresh Tomato Salsa                NaN     $2.39               2.39
  3          1         1  Chips and Tomatillo-Green Chili Salsa                NaN     $2.39               2.39
  6          3         1                          Side of Chips                NaN     $1.69               1.69
  10         5         1                    Chips and Guacamole                NaN     $4.45               4.45
  14         7         1                    Chips and Guacamole                NaN     $4.45               4.45

🥗 둘 중 하나만 포함

print('🥗 item_name에 "Steak Salad" 또는 "Bowl"가 포함되는 데이터 추출:')
answer = df.loc[(df.item_name == 'Steak Salad') | (df.item_name == 'Bowl')]
print(answer)

      order_id  quantity  ... item_price item_price_float
445        193         3  ...    $22.20             22.20
664        276         1  ...     $8.99              8.99
673        279         1  ...     $7.40              7.40
752        311         1  ...     $8.99              8.99
893        369         1  ...     $8.99              8.99
3502      1406         1  ...     $8.69              8.69

[6 rows x 6 columns]

.drop_duplicates(''): 중복행 제거후 첫번째 케이스 출력

print('🥗 item_name에 "Steak Salad" 또는 "Bowl"가 포함되는 데이터 추출:')
print(answer.drop_duplicates('item_name'))

     order_id  quantity  ... item_price item_price_float
445       193         3  ...    $22.20             22.20
664       276         1  ...     $8.99              8.99

.drop_duplicates('', keep='last'): 중복행 제거후 마지막 케이스 출력

print('🥗 item_name에 "Steak Salad" 또는 "Bowl"가 포함되는 데이터 추출:')
print(answer.drop_duplicates('item_name', keep='last'))

      order_id  quantity  ... item_price item_price_float
673        279         1  ...     $7.40              7.40
3502      1406         1  ...     $8.69              8.69

df.iloc[:,::2] : 짝수열

print("😈 짝수번째 컬럼만 출력:")
print(df.iloc[:,::2].head())

• slicing[start : end : step]
  • ::2는 처음부터 끝까지 2칸씩 건너뛰기 (인덱스: 0, 2, 4, 6, ...)
• [:,::2]:
  • :: 행 위치, 모든 행 선택
  • ::2: 열 위치, 열 인덱스를 2칸씩 건너뛰며 선택
• df.iloc[::2, :]: 모든 열에서 행 인덱스를 2칸씩 건너뛰며 선택

  😈 짝수번째 컬럼만 출력:
   order_id                              item_name item_price
  0         1           Chips and Fresh Tomato Salsa     $2.39 
  1         1                                   Izze     $3.39 
  2         1                       Nantucket Nectar     $3.39 
  3         1  Chips and Tomatillo-Green Chili Salsa     $2.39 
  4         2                           Chicken Bowl    $16.98 

참고, https://www.datamanim.com/dataset/99_pandas/pandasMain.html#filtering-sorting

🔸 Pandas 선언

import pandas as pd

🔸 CSV 파일 읽어오기

# 파일 경로 지정
titanic_train = './titanic/train.csv'
titanic_test = './titanic/test.csv'

# CSV 파일 읽어오기
df_train = pd.read_csv(titanic_train)
df_test = pd.read_csv(titanic_test)

만약 데이터에 한글이 포함되어 있을 경우: encoding='euc-kr'

DataUrl = 'https://raw.githubusercontent.com/Datamanim/pandas/main/Jeju.csv'
df = pd.read_csv(DataUrl,encoding='euc-kr')

🔸 Data 구조 확인

type(): 데이터 로드

# 데이터 확인
print(type(df_train), type(df_test))

<class 'pandas.core.frame.DataFrame'>

.head(): 상위 행 5개 출력

print(df_train.head())  
print(df_test.head())

 PassengerId  Survived  Pclass                                               Name     Sex   Age  SibSp  Parch            Ticket     Fare Cabin Embarked
0            1         0       3                            Braund, Mr. Owen Harris    male  22.0      1      0         A/5 21171   7.2500   NaN        S
1            2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0      1      0          PC 17599  71.2833   C85        C
2            3         1       3                             Heikkinen, Miss. Laina  female  26.0      0      0  STON/O2. 3101282   7.9250   NaN        S
3            4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  35.0      1      0            113803  53.1000  C123        S
4            5         0       3                           Allen, Mr. William Henry    male  35.0      0      0            373450   8.0500   NaN        S
   PassengerId  Pclass                                          Name     Sex   Age  SibSp  Parch   Ticket     Fare Cabin Embarked
0          892       3                              Kelly, Mr. James    male  34.5      0      0   330911   7.8292   NaN        Q
1          893       3              Wilkes, Mrs. James (Ellen Needs)  female  47.0      1      0   363272   7.0000   NaN        S
2          894       2                     Myles, Mr. Thomas Francis    male  62.0      0      0   240276   9.6875   NaN        Q
3          895       3                              Wirz, Mr. Albert    male  27.0      0      0   315154   8.6625   NaN        S
4          896       3  Hirvonen, Mrs. Alexander (Helga E Lindqvist)  female  22.0      1      1  3101298  12.2875   NaN        S

.tail(): 하위 행 5개 출력

print(df_train.tail())
print(df_test.tail(2))

     PassengerId  Survived  Pclass                                      Name     Sex   Age  SibSp  Parch      Ticket   Fare Cabin Embarked
886          887         0       2                     Montvila, Rev. Juozas    male  27.0      0      0      211536  13.00   NaN        S
887          888         1       1              Graham, Miss. Margaret Edith  female  19.0      0      0      112053  30.00   B42        S
888          889         0       3  Johnston, Miss. Catherine Helen "Carrie"  female   NaN      1      2  W./C. 6607  23.45   NaN        S
889          890         1       1                     Behr, Mr. Karl Howell    male  26.0      0      0      111369  30.00  C148        C
890          891         0       3                       Dooley, Mr. Patrick    male  32.0      0      0      370376   7.75   NaN        Q
     PassengerId  Pclass                      Name   Sex  Age  SibSp  Parch  Ticket     Fare Cabin Embarked
416         1308       3       Ware, Mr. Frederick  male  NaN      0      0  359309   8.0500   NaN        S
417         1309       3  Peter, Master. Michael J  male  NaN      1      1    2668  22.3583   NaN        C

.shape: 행, 열 갯수 출력

print(f'🛳️ train(행,열): {df_train.shape}')
print(f'⚓️ test 행: {df_test.shape[0]}, test 열: {df_test.shape[1]}')

🛳️ train(행,열): (891, 12)
⚓️ test 행: 418, test 열: 11

.cloumns: 전체 컬럼명 확인

print(f'🛳️ Train columns:\n{df_train.columns}')
print(f'⚓️ Test columns:\n{df_test.columns}')

🛳️ Train columns:
Index(['PassengerId', 'Survived', 'Pclass', 'Name', 'Sex', 'Age', 'SibSp',
       'Parch', 'Ticket', 'Fare', 'Cabin', 'Embarked'],
      dtype='object')
⚓️ Test columns:
Index(['PassengerId', 'Pclass', 'Name', 'Sex', 'Age', 'SibSp', 'Parch',
       'Ticket', 'Fare', 'Cabin', 'Embarked'],
      dtype='object')

.index: 인덱스 구성 확인

print(f'🛳️ trian: {df_train.index}')
print(f'⚓️ test: {df_test.index}')

🛳️ trian: RangeIndex(start=0, stop=891, step=1)
⚓️ test: RangeIndex(start=0, stop=418, step=1

.info(): 각 열의 데이터 수, 데이터 타입 확인

print('🛳️ trian:')
print(df_train.info())

print('⚓️ test:')
print(df_test.info())

🛳️ trian:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  891 non-null    int64  
 1   Survived     891 non-null    int64  
 2   Pclass       891 non-null    int64  
 3   Name         891 non-null    object 
 4   Sex          891 non-null    object 
 5   Age          714 non-null    float64
 6   SibSp        891 non-null    int64  
 7   Parch        891 non-null    int64  
 8   Ticket       891 non-null    object 
 9   Fare         891 non-null    float64
 10  Cabin        204 non-null    object 
 11  Embarked     889 non-null    object 
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB
None

⚓️ test:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 418 entries, 0 to 417
Data columns (total 11 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  418 non-null    int64  
 1   Pclass       418 non-null    int64  
 2   Name         418 non-null    object 
 3   Sex          418 non-null    object 
 4   Age          332 non-null    float64
 5   SibSp        418 non-null    int64  
 6   Parch        418 non-null    int64  
 7   Ticket       418 non-null    object 
 8   Fare         417 non-null    float64
 9   Cabin        91 non-null     object 
 10  Embarked     418 non-null    object 
dtypes: float64(2), int64(4), object(5)
memory usage: 36.1+ KB
None

.dtype: 선택한 열의 데이터 타입(data type)을 반환

print(f'🛳️ train 4번쨰 행의 data type: {df_train.iloc[:,3].dtype}')
# df_train.columns
# Index(['PassengerId', 'Survived', 'Pclass', 'Name', ...])

🛳️ train 4번쨰 행의 data type: object

• df_train.iloc[:,3]: Name열을 선택
• .iloc: 인덱스로 행/열을 선택하는 함수
• [:,3]
  • : → 모든 행을 의미
  • 3 → 열 인덱스 3번 (네 번째 열)을 선택
• dtype('O'/'object') → 문자열
• dtype('int64') → 정수
• dtype('float64') → 실수

🔁 iloc vs loc

✅ 예제 데이터

import pandas as pd

data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
}
df = pd.DataFrame(data, index=[100, 101, 102])
print(df)

출력:

      Name  Age
100  Alice   25
101    Bob   30
102 Charlie   35

🔹 iloc 예시 (위치 기반)

df.iloc[0, 0]   # 0행 0열 → 'Alice'
df.iloc[2, 1]   # 2행 1열 → 35
df.iloc[:, 1]   # 전체 행, 1열 (Age 열) → [25, 30, 35]

🔹 loc 예시 (레이블 기반)

df.loc[100, 'Name']   # 인덱스 100 행, 'Name' 열 → 'Alice'
df.loc[102, 'Age']    # 인덱스 102 행, 'Age' 열 → 35
df.loc[:, 'Name']     # 전체 행, 'Name' 열 → ['Alice', 'Bob', 'Charlie']

수치형(exclude)/범주형(include) 변수

• .select_dtypes(exclude[include]=object).columns

  print('🛳️ train의 수치형 변수를 가진 행:')
  print(df_train.select_dtypes(exclude=object).columns)
  

print('⚓️ test의 범주형 변수를 가진 행:') print(df_test.select_dtypes(include=object).columns)

🛳️ train의 수치형 변수를 가진 행: Index(['PassengerId', 'Survived', 'Pclass', 'Age', 'SibSp', 'Parch', 'Fare'], dtype='object')

⚓️ test의 범주형 변수를 가진 행: Index(['Name', 'Sex', 'Ticket', 'Cabin', 'Embarked'], dtype='object')

---
### .isnull(): 결측치 파악
```python
print(f'🛳️ train 결측치 갯수: \n{df_train.isnull().sum()}')
print(f'⚓️ test 결측치 갯수: \n{df_test.isnull().sum()}')

🛳️ train 결측치 갯수: 
PassengerId      0
Survived         0
Pclass           0
Name             0
Sex              0
Age            177
SibSp            0
Parch            0
Ticket           0
Fare             0
Cabin          687
Embarked         2
dtype: int64

⚓️ test 결측치 갯수: 
PassengerId      0
Pclass           0
Name             0
Sex              0
Age             86
SibSp            0
Parch            0
Ticket           0
Fare             1
Cabin          327
Embarked         0
dtype: int64

.describe(): 수치형 변수의 분포(사분위, 평균, 표준편차, 최대 , 최소) 확인

print('🛳️ train describe:')
print(tabulate(df_train.describe(), headers='keys', tablefmt='pretty'))

print('⚓️ test describe:')
print(tabulate(df_test.describe(), headers='keys', tablefmt='pretty'))

🛳️ train describe:
+-------+-------------------+--------------------+--------------------+--------------------+--------------------+---------------------+--------------------+
|       |    PassengerId    |      Survived      |       Pclass       |        Age         |       SibSp        |        Parch        |        Fare        |
+-------+-------------------+--------------------+--------------------+--------------------+--------------------+---------------------+--------------------+
| count |       891.0       |       891.0        |       891.0        |       714.0        |       891.0        |        891.0        |       891.0        |
| mean  |       446.0       | 0.3838383838383838 | 2.308641975308642  | 29.69911764705882  | 0.5230078563411896 | 0.38159371492704824 | 32.204207968574636 |
|  std  | 257.3538420152301 | 0.4865924542648585 | 0.8360712409770513 | 14.526497332334044 | 1.1027434322934275 | 0.8060572211299559  |  49.6934285971809  |
|  min  |        1.0        |        0.0         |        1.0         |        0.42        |        0.0         |         0.0         |        0.0         |
|  25%  |       223.5       |        0.0         |        2.0         |       20.125       |        0.0         |         0.0         |       7.9104       |
|  50%  |       446.0       |        0.0         |        3.0         |        28.0        |        0.0         |         0.0         |      14.4542       |
|  75%  |       668.5       |        1.0         |        3.0         |        38.0        |        1.0         |         0.0         |        31.0        |
|  max  |       891.0       |        1.0         |        3.0         |        80.0        |        8.0         |         6.0         |      512.3292      |
+-------+-------------------+--------------------+--------------------+--------------------+--------------------+---------------------+--------------------+


⚓️ test describe:
+-------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+
|       |    PassengerId     |       Pclass       |        Age         |       SibSp        |       Parch        |        Fare        |
+-------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+
| count |       418.0        |       418.0        |       332.0        |       418.0        |       418.0        |       417.0        |
| mean  |       1100.5       | 2.2655502392344498 | 30.272590361445783 | 0.4473684210526316 | 0.3923444976076555 | 35.627188489208635 |
|  std  | 120.81045760473994 | 0.8418375519640519 | 14.18120923562442  | 0.8967595611217125 | 0.9814288785371684 | 55.90757617997383  |
|  min  |       892.0        |        1.0         |        0.17        |        0.0         |        0.0         |        0.0         |
|  25%  |       996.25       |        1.0         |        21.0        |        0.0         |        0.0         |       7.8958       |
|  50%  |       1100.5       |        3.0         |        27.0        |        0.0         |        0.0         |      14.4542       |
|  75%  |      1204.75       |        3.0         |        39.0        |        1.0         |        0.0         |        31.5        |
|  max  |       1309.0       |        3.0         |        76.0        |        8.0         |        9.0         |      512.3292      |
+-------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+

🧐 Name 컬럼에 해당하는 값들을 출력

print('🛳️ Names:')
print(df_train['Name'])

🛳️ Names:
0                                Braund, Mr. Owen Harris
1      Cumings, Mrs. John Bradley (Florence Briggs Th...
2                                 Heikkinen, Miss. Laina
3           Futrelle, Mrs. Jacques Heath (Lily May Peel)
4                               Allen, Mr. William Henry
                             ...                        
886                                Montvila, Rev. Juozas
887                         Graham, Miss. Margaret Edith
888             Johnston, Miss. Catherine Helen "Carrie"
889                                Behr, Mr. Karl Howell
890                                  Dooley, Mr. Patrick
Name: Name, Length: 891, dtype: object

.quantile(): 4분위 범위(IQR)

print(f'🛳️ Age IQR: {df_train['Age'].quantile(0.75) - df_train['Age'].quantile(0.25)}')

🛳️ Age IQR: 17.875

.nunique() / .unique() :유일값 확인

• .nunique(): 유일값 갯수
• .unique(): 유일값에 해당하는 것 모두 출력

  print(f'🛳️ Cabin 유일값 갯수: {df_train.Cabin.nunique()}')
  print(f'🛳️ Cabin 유일값: {df_train.Cabin.unique()}')

  🛳️ Cabin 유일값 갯수: 147
  

🛳️ Cabin 유일값: [nan 'C85' 'C123' 'E46' 'G6' 'C103' 'D56' 'A6' 'C23 C25 C27' 'B78' 'D33' 'B30' 'C52' 'B28' 'C83' 'F33' 'F G73' 'E31' 'A5' 'D10 D12' 'D26' 'C110' 'B58 B60' 'E101' 'F E69' 'D47' 'B86' 'F2' 'C2' 'E33' 'B19' 'A7' 'C49' 'F4' 'A32' 'B4' 'B80' 'A31' 'D36' 'D15' 'C93' 'C78' 'D35' 'C87' 'B77' 'E67' 'B94' 'C125' 'C99' 'C118' 'D7' 'A19' 'B49' 'D' 'C22 C26' 'C106' 'C65' 'E36' 'C54' 'B57 B59 B63 B66' 'C7' 'E34' 'C32' 'B18' 'C124' 'C91' 'E40' 'T' 'C128' 'D37' 'B35' 'E50' 'C82' 'B96 B98' 'E10' 'E44' 'A34' 'C104' 'C111' 'C92' 'E38' 'D21' 'E12' 'E63' 'A14' 'B37' 'C30' 'D20' 'B79' 'E25' 'D46' 'B73' 'C95' 'B38' 'B39' 'B22' 'C86' 'C70' 'A16' 'C101' 'C68' 'A10' 'E68' 'B41' 'A20' 'D19' 'D50' 'D9' 'A23' 'B50' 'A26' 'D48' 'E58' 'C126' 'B71' 'B51 B53 B55' 'D49' 'B5' 'B20' 'F G63' 'C62 C64' 'E24' 'C90' 'C45' 'E8' 'B101' 'D45' 'C46' 'D30' 'E121' 'D11' 'E77' 'F38' 'B3' 'D6' 'B82 B84' 'D17' 'A36' 'B102' 'B69' 'E49' 'C47' 'D28' 'E17' 'A24' 'C50' 'B42' 'C148']

```

참고, https://www.datamanim.com/dataset/99_pandas/pandasMain.html#getting-knowing-data

Pandas는 Python에서 데이터를 쉽게 다루고 분석할 수 있도록 도와주는 오픈 소스 라이브러리로 주로 표 형식의 데이터를 다룰 때 사용한다.

📦 Pandas의 핵심 기능

• 데이터프레임(DataFrame)과 시리즈(Series)라는 두 가지 주요 자료구조 제공
• 엑셀처럼 표 형태의 데이터 처리 가능 (행과 열로 구성)
• 데이터 정렬, 필터링, 그룹화, 결합, 통계 등 다양한 작업 지원
• CSV, Excel, SQL, JSON 등의 다양한 파일 포맷 입출력 지원

💡 예시 코드

import pandas as pd

# 간단한 데이터프레임 만들기
data = {'이름': ['철수', '영희', '민수'],
        '나이': [23, 25, 21]}

df = pd.DataFrame(data)

print(df)

출력:

   이름  나이
0  철수   23
1  영희   25
2  민수   21

🔧 Pandas가 주로 쓰이는 곳

• 데이터 분석 (EDA)
• 머신러닝 전처리
• 보고서 및 통계 처리
• 시간 시계열 분석
• 대용량 데이터 처리

📝 2025년 1회차 기출, 1️⃣1️⃣ ~ 2️⃣0️⃣

11. C Lang. - 이중 포인터, malloc

#include <stdio.h>
#include <stdlib.h>

void set(int** arr, int* data, int rows, int cols) {
    for (int i = 0; i < rows * cols; ++i) {
    arr[((i + 1) / rows) % rows][(i + 1) % cols] = data[i];
    }
}

int main() {
    int rows = 3, cols = 3, sum = 0, i;
    int data[] = {5, 2, 7, 4, 1, 8, 3, 6, 9};
    int** arr;

    arr = (int**) malloc(sizeof(int*) * rows);
    for (i = 0; i < rows; i++) {
        arr[i] = (int*) malloc(sizeof(int) * cols);
    }

    set(arr, data, rows, cols);

    for (i = 0; i < rows * cols; i++) {
        sum += arr[i / cols][i % cols] * (i % 2 == 0 ? 1 : -1);
    }

    for(i=0; i<rows; i++) {
        free(arr[i]);
    }
    free(arr);

    printf("%d", sum);
    return 0;
}

🖍️ 13

• data 배열에 있는 값을 2차원 배열 arr에 특정 방식으로 저장 (set 함수)
• 저장된 배열 값을 홀수 인덱스에서는 음수, 짝수 인덱스에서는 양수로 합산
• 최종적으로 sum을 출력

  🧩 2차원 배열을 동적으로 할당:

  arr = (int**) malloc(sizeof(int*) * rows);

• arr은 int 포인터의 포인터, 즉 int** arr을 int* 배열로 만들고 싶음
• sizeof(int*) * rows: int* 타입을 rows개 만큼 메모리 할당 즉, 행(row) 개수만큼 포인터 공간을 확보

  arr
  │
  ├───► arr[0] → ?
  ├───► arr[1] → ?
  └───► arr[2] → ?

  for (i = 0; i < rows; i++) {
    arr[i] = (int*) malloc(sizeof(int) * cols);
  }

• arr[i]는 각 행에 해당하는 포인터
• sizeof(int) * cols: 열(col) 수만큼 정수 배열을 만듦 즉, 각 행에 실제 데이터를 저장할 공간을 할당

  arr
  │
  ├───► arr[0] → [ int ][ int ][ int ] 
  ├───► arr[1] → [ int ][ int ][ int ] 
  └───► arr[2] → [ int ][ int ][ int ] 

  🧩 set() 함수

  void set(int** arr, int* data, int rows, int cols) {
    for (int i = 0; i < rows * cols; ++i) {
        arr[((i + 1) / rows) % rows][(i + 1) % cols] = data[i];
    }
  }

• 행 인덱스: ((i + 1) / rows) % rows
• 열 인덱스: (i + 1) % cols 즉, i가 0부터 8까지 순회하면서, data[i] 값을 위의 인덱스 계산으로 arr에 넣음

  🧩 최종 arr 상태:

  arr = {
  {9, 5, 2},
  {7, 4, 1},
  {8, 3, 6}
  };

  🧩 sum 계산

  for (i = 0; i < rows * cols; i++) {
    sum += arr[i / cols][i % cols] * (i % 2 == 0 ? 1 : -1);
  }

  2차원 배열을 순서대로 탐색하면서:
• 짝수 인덱스 (i % 2 == 0) → 더함
• 홀수 인덱스 → 뺌

  ➡︎ 9 - 5 + 2 - 7 + 4 - 1 + 8 - 3 + 6 = 13

12. 결합도

① 다른 모듈 내부에 있는 변수나 기능을 다른 모듈에서 사용하는 경우의 결합도 ② 모듈 간의 인터페이스로 배열이나 오브젝트, 자료구조 등이 전달되는 경우의 결합도 ③ 파라미터가 아닌 모듈 밖에 선언되어 있는 전역 변수를 참조하고 전역 변수를 갱신하는 식으로 상호작용하는 경우의 결합도

🖍️ ① 내용 결합도 ② 스템프 결합도 ③ 공통 결합도

13. Java Lang. - OOP 개념

상속(Inheritance), 메서드 오버라이딩(Method Overriding), 정적 변수(Static Variable), 변수 숨김(Variable Shadowing)

class parent{
    static int total = 0;
    int v = 1;

    public parent(){
        total += (++v);
        show();
    }
    public void show(){
        total += total;
    }
}

class child extends parent{
    int v = 10;

    public child(){
        v += 2;
        total += v++;
        show(); 
    }
    @Override
    public void show(){
        total += total*2;
    }
}

class Main {
    public static void main(String[] args) {
        new child();
        System.out.println(parent.total);
    }
}

🖍️ 54

🩵 코드 시작:

new child();

1️⃣ 먼저 parent 생성자가 실행

int v = 1;
++v;                // v는 2가 됨
total += v;         // total = 0 + 2 = 2
show();             // 여기서 child의 show()가 호출됨

⚠️ 중요 포인트 show()는 parent 클래스의 메서드처럼 보이지만, child 클래스에서 오버라이딩했기 때문에, 실제로는 child의 show()가 실행됨

// child의 show() 실행
total += total * 2;  // 2 + (2 * 2) = 6

• total = 6

  2️⃣ child 생성자가 실행

  int v = 10;     // child의 v (부모 v와는 다른 변수)
  v += 2;         // v는 12
  total += v++;   // total = 6 + 12 = 18, v는 13이 됨
  show();         // 다시 child의 show() 실행

  total += total * 2;  // 18 + (18 * 2) = 54

  🔚 최종 결과

  System.out.println(parent.total);  // 결과: 54

• 동적 바인딩으로 인해 부모 생성자에서도 자식의 메서드가 호출됨
• static 변수 덕분에 값이 누적되어 최종적으로 54가 출력됨

14. 디자인 패턴

• Wrapper라고도 불림
• 다른 클래스가 이용할 수 있도록 인터페이스 변환해주는 패턴

🖍️ adapter

15. 구문 커버리지(Statement Coverage)

정확하지 않음

int main() {
    int a = 0;
    while (조건문) {
        if (B[a] < 0)
            B[a] = -B[a];
        a++;
    }
    return(1);
}

🖍️

순서: ➊→➋→➌→➍→➎→➋→➏

흐름도 구성 노드

[Start] --> [a = 0]
           |
           v
    [➊ while (조건문)]    <------------------------
         /       \                                 |
       No         Yes                                 |
       |           |                                 |
 [➋ return 1]     v                                 |
               [➌ if (조건문)]                    |
                 /      \                        |
              No         Yes                    |
               |          |                        |
               |          v                        |
               |      [➍ B[a] = -B[a]]                 |
                \       /                        |
                    |                            |
                 [➎ a++]  -----------------------
                     |
              [➏ return 1] 

16. Java Lang. - 재귀 함수

public class Main {
    static int comp(int[] a, int st, int end) {
        if (st >= end) return 0;
        int mid = (st + end) / 2;
        return a[mid] + Math.max(comp(a, st, mid), comp(a, mid + 1, end));
    }
    public static void main(String[] args) {
        int[] values = {3, 5, 8, 12, 17};
        System.out.println(comp(values, 0, values.length - 1));
    }
}

🖍️ 20

🧩 main 함수

public static void main(String[] args) {
    int[] values = {3, 5, 8, 12, 17};
    System.out.println(comp(values, 0, values.length - 1));
}

• comp 함수는 values 배열을 0부터 values.length - 1 (즉, 0부터 4까지)까지의 범위로 분할하여 실행
• comp 함수는 재귀적으로 배열을 나누고, 각 부분에서 가장 큰 값을 구해 반환

  🧩 comp 함수

  static int comp(int[] a, int st, int end) {
    if (st >= end) return 0;
    int mid = (st + end) / 2;
    return a[mid] + Math.max(comp(a, st, mid), comp(a, mid + 1, end));
  }

  comp 함수는 배열 a와 인덱스 st(start)와 end(end)를 인자로 받아서 부분 배열의 합을 구하고, 그 중에서 최대값을 반환하는 함수
• 재귀 종료 조건: st >= end이면 0을 반환, 이 조건은 배열의 크기가 1 이하일 때 재귀가 종료
• 분할: 배열을 두 부분으로 나눔, mid는 배열의 중간 인덱스
• 부분합 계산: comp(a, st, mid)는 st부터 mid까지의 부분 배열을 처리하고, comp(a, mid + 1, end)는 mid + 1부터 end까지의 부분 배열을 처리
• 최대값 구하기: 두 부분의 결과를 비교한 후 더 큰 값을 선택하고, a[mid] 값을 더해 최종 결과를 계산

  ✅ comp(values, 0, 4) 실행 흐름 표

  

  comp(0,4) → 8+12
  ├── comp(0,2) → a[1]+3+0 = 8
  │   ├── comp(0,1) → a[0]+0+0 = 3
  │   │   ├── comp(0,0) → 0
  │   │   └── comp(1,1) → 0
  │   └── comp(2,2) → 0
  ├── comp(3,4) → a[3]+0+0 = 12
  │   ├── comp(3,3) → 0
  │   └── comp(4,4) → 0

17. Python Lang. - 이진 트리

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

def build_tree(li):
    nodes = [TreeNode(i) for i in li]
    for i in range(1, len(li)):
        nodes[(i - 1) // 2].children.append(nodes[i])
    return nodes[0]

def calc(node, level=0):
    return node.value if level % 2 else 0 + sum(calc(n, level + 1) for n in node.children) if node else 0

li = [3, 5, 8, 12, 15, 18, 20]
root = build_tree(li)
print(calc(root))

🖍️ 13

🩵 클래스 TreeNode 정의

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

• TreeNode 클래스는 트리의 각 노드를 나타냄
• __init__(): 노드의 값을 설정, 자식 노드들을 담을 children 리스트를 초기화

  🩵 build_tree 함수

  def build_tree(li):
    nodes = [TreeNode(i) for i in li]
    for i in range(1, len(li)):
        nodes[(i - 1) // 2].children.append(nodes[i])
    return nodes[0]

• build_tree 함수는 입력 리스트 li를 이용해 트리를 만듦 먼저, li의 각 값에 대해 TreeNode 인스턴스를 만들어 nodes 리스트에 저장
• 이후 for 루프를 통해 각 노드의 부모 노드를 찾아서 자식으로 추가
  • nodes[(i - 1) // 2]는 현재 노드 i의 부모 노드를 가리킴
  • 예를 들어, i = 1일 때, (i - 1) // 2 = 0으로, 노드 1의 부모는 노드 0
• 마지막으로 트리의 루트 노드(nodes[0])를 반환

  🌳 결과 트리 구조

  nodes[0]: 3
  ├── nodes[1]: 5
  │   ├── nodes[3]: 12
  │   └── nodes[4]: 15
  └── nodes[2]: 8
    ├── nodes[5]: 18
    └── nodes[6]: 20

  🩵 calc 함수

  calc 함수는 트리의 각 노드를 깊이 우선 탐색(DFS) 방식으로 순회하며 계산한다.

  def calc(node, level=0):
    return node.value if level % 2 else 0 + sum(calc(n, level + 1) for n in node.children) if node else 0

• level=0: 루트(시작점)
• level: 현재 노드가 트리의 몇 번째 레벨인지를 나타냄

  🔍 핵심: 조건부 삼항 연산자

  return (
    node.value if level % 2           # 👉 레벨이 홀수면 자기 값 반환
    else 0 + sum(...)                 # 👉 짝수면 자기 값 무시하고 자식 노드들의 결과만 합침
    if node                           # 👉 node가 None이면 무조건 0 반환
    else 0
  )

• True = 1 / False = 0
• node.value: 현재 노드 값
• 기본적으로, 노드의 값은 깊이에 따라 다르게 처리됨
  • level % 2 == 1: 홀수, node.value + 자식들 합
  • level % 2 == 0: 짝수, 자신의 값은 무시 + 자식들 합
• sum(calc(n, level + 1) for n in node.children) 현재 노드의 모든 자식 노드들에 대해 calc()를 호출해서 합산, 재귀 호출
• node == None일 경우, 0을 반환

  nodes[0]: 3 → 무시
  ├── nodes[1]: 5 → 포함
  │   ├── nodes[3]: 12 → 무시
  │   └── nodes[4]: 15 → 무시
  └── nodes[2]: 8 → 포함
    ├── nodes[5]: 18 → 무시
    └── nodes[6]: 20 → 무시

  

  🩵 실행

  li = [3, 5, 8, 12, 15, 18, 20]
  root = build_tree(li)
  print(calc(root))

        3
       / \
      5   8
     / \  / \
    12 15 18 20

• 5 + 8 = 13

18. C Lang. - 연결리스트

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int value;
    struct Node *next;
} Node;

Node* createNode(Node* head, int value) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->value = value;
    new_node->next = head;
    return new_node;
}

Node* reconnect(Node* head, int disconnect_count) {
    Node *prev = NULL, *curr = head;

    while (curr && curr->value != disconnect_count) {
        prev = curr;
        curr = curr->next;
    }

    if (!curr || curr == head) return head;

    prev->next = curr->next;
    curr->next = head;
    head = curr;

    return head;
}

int main() {
    Node *head = NULL, *curr, *temp;
    for (int i = 1; i <= 5; i++)
        head = createNode(head, i);

    head = reconnect(head, 3);

    for (curr = head; curr != NULL; curr = curr->next)
        printf("%d", curr->value);

    // 메모리 해제
    curr = head;
    while (curr != NULL) {
        temp = curr;
        curr = curr->next;
        free(temp);
    }

    return 0;
}

🖍️ 35421

🧩 구조체 정의

typedef struct Node {
    int value;
    struct Node *next;
} Node;

• Node라는 이름의 구조체를 정의
• value: 노드가 가지고 있는 값 (int형).
• next: 다음 노드를 가리키는 포인터, 이 포인터를 통해 연결된 리스트를 구성

  🧩 새 노드 생성 함수

  Node* createNode(Node* head, int value) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->value = value;
    new_node->next = head;
    return new_node;
  }

  createNode() 함수는 새로운 노드를 생성하여 리스트의 맨 앞에 추가하는 함수
• malloc을 사용하여 새로운 Node를 동적으로 할당
• 할당된 새로운 노드의 value를 주어진 value로 설정
• 새로운 노드의 next는 현재의 head를 가리키도록 설정하여, 리스트의 맨 앞에 이 노드를 추가
• 함수는 생성된 new_node를 반환

  🧩 연결 리스트에서 특정 노드를 맨 앞으로 이동시키는 함수

  Node* reconnect(Node* head, int disconnect_count) {
    Node *prev = NULL, *curr = head;
    ...
  }

  reconnect 함수는 특정 값(disconnect_count)을 가진 노드를 리스트에서 찾아 맨 앞으로 이동시키는 함수
• prev: 현재 노드의 이전 노드를 가리키는 포인터
• curr: 현재 노드를 가리키는 포인터, 초기에는 head로 설정됨

  while (curr && curr->value != disconnect_count) {
      prev = curr;
      curr = curr->next;
  }

  while 루프를 통해 리스트를 탐색하여 disconnect_count 값과 일치하는 노드를 찾음
• prev는 항상 curr의 이전 노드를 추적
• curr는 현재 노드를 추적

  if (!curr || curr == head) return head;

• curr이 NULL이면 값을 찾지 못한 경우이고, curr == head이면 이미 맨 앞에 있는 경우
• 그런 경우에는 아무것도 하지 않고 head를 그대로 반환

  prev->next = curr->next;
  curr->next = head;
  head = curr;

• prev->next = curr->next: prev 노드의 next가 curr의 next를 가리키도록 하여 curr 노드를 리스트에서 분리
• curr->next = head: curr 노드를 리스트의 맨 앞에 추가하기 위해 curr->next를 기존 head로 설정
• head = curr: head를 curr로 변경하여 리스트의 첫 번째 노드를 curr로 설정

  head
  ↓
  [5] → [4] → [3] → [2] → [1] → NULL
  ↑      ↑
  prev   curr
  head
  ↓
  [5] → [4] → [3] → [2] → [1] → NULL
               ↑      ↑
             prev    curr
  • prev->next = curr->next → 4 → 2
  • curr->next = head → 3 → 5
  • head = curr → 새로운 head는 3

  🧩 main 함수

  int main() {
    Node *head = NULL, *curr, *temp;
    for (int i = 1; i <= 5; i++)
        head = createNode(head, i);
    ...
  }

• Node *head = NULL: 리스트의 헤드를 NULL로 초기화(빈 리스트)
• for (int i = 1; i <= 5; i++): 1부터 5까지 숫자를 가진 노드들을 생성하여 연결 리스트를 만듦
• createNode 함수를 사용하여 각 숫자에 대한 노드를 리스트의 맨 앞에 추가 결과적으로 head는 5 -> 4 -> 3 -> 2 -> 1로 초기화됨

  head = reconnect(head, 3);

• 3을 리스트에서 찾아서 맨 앞에 이동시킴
• 결과적으로 리스트는 3 -> 5 -> 4 -> 2 -> 1

  for (curr = head; curr != NULL; curr = curr->next)
   printf("%d", curr->value);

• 리스트의 모든 값을 출력하는 루프
• head부터 시작하여 각 노드를 출력

  🧩 메모리 해제

  curr = head;
  while (curr != NULL) {
    temp = curr;
    curr = curr->next;
    free(temp);
  }

  동적으로 할당한 메모리를 해제하는 코드
• curr는 리스트의 현재 노드를 가리키고, temp는 메모리 해제를 위한 임시 포인터
• curr를 리스트를 따라 이동시키면서, 각 노드의 메모리를 free 함수로 해제
• free(temp)로 curr가 가리키는 노드를 해제한 후, curr을 다음 노드로 이동시킴

19. C Lang. - 16진수

#include <stdio.h>

typedef struct student {
    char* name;
    unsigned int score[3];
} Student;

int dec(int enc) {
    return enc & 0xA5;
}

int sum(Student* p) {
    return dec(p->score[0]) + dec(p->score[1]) + dec(p->score[2]);
}

int main() {
    Student s[2] = { "Kim", {0xF0, 0xF5, 0xDB}, "Lee", {0xED, 0xD3, 0xF2} };
    Student* p = s;
    int result = 0;

    for (int i = 0; i < 2; i++) {
        result += sum(&s[i]);
    }
    printf("%d", result);
    return 0;
}

🖍️ 908

🧩 구조체 정의

typedef struct student {
    char* name;
    int score[3];
} Student;

• Student 구조체는 학생의 이름과 점수 3개를 저장
• score[3] 배열은 3개의 정수 점수를 저장 다만, 이 점수는 인코딩된 형태

  🧩 디코딩 함수

  int dec(int enc) {
    return enc & 0xA5;
  }

• & 연산자는 비트 AND 연산
• 0xA5는 16진수로 10100101
• 즉, 인코딩된 점수에서 특정 비트만 남겨서 "디코딩"하는 역할

  Kim:
  0xF0(11110000)` & 0xA5(10100101) = 0xA0(10100000) = 160
  0xF5(11110101) & 0xA5 = 0xA5 = 165
  0xDB & 0xA5 = 0x81 = 129 
  → Kim의 총합: 160 + 165 + 129 = 454
  Lee:
  0xED & 0xA5 = 0xA5 = 165 
  0xD3 & 0xA5 = 0x81 = 129 
  0xF2 & 0xA5 = 0xA0 = 160
  → Lee의 총합: 165 + 129 + 160 = 454

  🧩 합산 함수

  int sum(Student* p) {
    return dec(p->score[0]) + dec(p->score[1]) + dec(p->score[2]);
  }

• 특정 학생 포인터 p의 세 점수를 디코딩해서 더함

  🧩 main 함수

  for (int i = 0; i < 2; i++) {
        result += sum(&s[i]);
    }
    printf("%d", result);

• result = sum[0] + sum[1] = 454 + 454 = 908

20. Java Lang. - 재귀 함수, Overloading

public class Main {
    public static void main(String[] args) {
    System.out.println(calc("5"));
    }

    static int calc(int value) {
        if (value <= 1) return value;
        return calc(value - 1) + calc(value - 2);
    }

    static int calc(String str) {
        int value = Integer.valueOf(str);
        if (value <= 1) return value;
        return calc(value - 1) + calc(value - 3);
    }
}

🖍️ 4

🩵 main()

public class Mian {
    public static void main(String[] args) {
        System.out.println(calc("5"));
    }

• main() 함수에서 "5"라는 문자열을 calc() 함수에 넘김
• 문자열이므로 호출되는 건 calc(String str)

  🩵 메서드 오버로딩 (Overloading)

  static int calc(String str) {
    int value = Integer.valueOf(str);
    if (value <= 1) return value;
    return calc(value - 1) + calc(value - 3);
  }

• Integer.valueOf(str); : 문자열을 정수로 변환
• 재귀적으로 calc(int)를 호출! (value - 1, value - 3)
• ⚠️ 주의: 여기서 호출되는 calc(value - 1) + calc(value - 3)은 int 버전의 calc()

  🔍 동작 순서 분석

  "5" → calc(String) 호출됨
  value = 5
  calc(5 - 1) + calc(5 - 3) = calc(4) + calc(2)

  📌 calc(4) - static int calc(int value)

  calc(4 - 1) + calc(4 - 2)
  = calc(3) + calc(2)
  = (calc(2) + calc(1)) + (calc(1) + calc(0))
  = ((calc(1) + calc(0)) + 1) + (1 + 0)
  = ((1 + 0) + 1) + (1 + 0)
  = (1 + 1) + 1 
  = 2 + 1 = 3

  📌 calc(2) - static int calc(int value)

  calc(2 - 1) + calc(2 - 2)
  calc(1) + calc(0) 
  = 1 + 0 = 1

  🩵 최종 결과

  calc("5") = calc(4) + calc(2) = 3 + 1 = 4

📝 2025년 1회차 기출, 1️⃣ ~ 🔟

1. 소프트웨어 보안

• 케빈 미트닉이 사용했던 공격 방법이다.
• ( )은/는 '세션을 가로채다'라는 의미로, 사용자가 인증을 마친 후 유지되고 있는 세션 ID를 탈취하거나 위조하여 마치 정상 사용자처럼 접근하는 방식이다.
• TCP ( )은/는 TCP 연결의 시퀀스 번호를 예측하거나 가로채어 통신 흐름에 불법적으로 끼어드는 방식으로 이루어진다. 이를 통해 공격자는 피해자의 세션을 탈취하거나 조작할 수 있다.
• ( )은/는 세션 관리 취약점을 이용한 공격 기법이다.

🖍️ 세션 하이재킹

2. DB 무결성 제약 조건

🖍️ ① 도메인 무결성 ② 개체 무결성 ③ 참조 무결성

3. 오류 감지 기법

( )은/는 영어 3글자 약자로 이루어진 오류 감지 기법으로, 연속된 비트 오류를 감지하는데 효과적이며, 주로 데이터를 전송이나 저장 시 무결성을 확인하는데 사용된다. 다항식 기반의 계산을 통해 전송된 데이터에 오류가 있는지를 수신 측에서 판별할 수 있다.

🖍️ CRC

4. 소프트웨어 보안

( )은/는 사회공학적 기법을 활용한 악성 소프트웨어의 한 유형이다. 사용자를 위헙하거나 공포심을 유발하여 특정 행동을 하도록 유도하는 악성 소프트웨어이다. 주로 가짜 바이러스 경고나 시스템 문제를 표시하여 사용자가 돈을 지불하거나 특정 소프트웨어를 설치하도록 속이는 방식으로 작동한다. [보기] 셔블웨어, 애드웨어, 스캐어웨어, 안티 스파이웨어, ...

🖍️ 스캐어웨어

5. Java Lang. - try-catch~finally

public class Main {
    public static void main(String[] args) {
        try{
            int a=5,b=0;
            System.out.print(a/b);
        }
        catch(ArithmeticException e){
            System.out.print("출력1");
        }
        catch(ArrayIndexOutOfBoundsException e) {
            System.out.print("출력2");
        }
        catch(NumberFormatException e) {
            System.out.print("출력3");
        }
        catch(Exception e){
            System.out.print("출력4");
        }
        finally{
            System.out.print("출력5");
        }
    }
}

🖍️ 출력1출력5

int a=5,b=0;
            System.out.print(a/b);

a / b → 5 / 0을 계산하려는 순간 ➤ 런타임 에러 ArithmeticException 발생! ➤ System.out.print()는 호출조차 안 됨! ➤ try 블록이 중단되고 바로 해당 catch로 이동함

🔹 catch 블록

catch (ArithmeticException e) {
    System.out.print("출력1");
}

• 예외 타입이 정확히 맞음 → 이 블록 실행됨
• 출력: 출력1

  다른 catch들은 무시되고,

  🔹 finally 블록

  finally {
    System.out.print("출력5");
  }

• finally는 예외가 발생하든 말든 무조건 실행됨
• 출력: 출력5

➕

• ArithmeticException: 0으로 나누기 같은 산술 계산

  int x = 10 / 0;  // ArithmeticException 발생

• ArrayIndexOutOfBoundsException: 배열 범위 초과 인덱스 접근

  int[] arr = {1, 2, 3};
  int x = arr[5];  // 인덱스 5는 없음 → 예외 발생

• NumberFormatException: "abc" 같은 문자열 → 숫자 변환 시

  String s = "hello";
  int x = Integer.parseInt(s);  // "hello"는 숫자가 아님 → 예외 발생

• Exception: 모든 예외의 최상위 클래스(일반 예외 포괄)
  • 위의 세 가지 예외들도 Exception을 상속받음
  • 특정 예외를 명시하지 않고, 모든 예외를 통틀어 잡고 싶을 때 사용

    try {
    // 어떤 예외가 날지 모를 때
    } catch(Exception e) {
    // 모든 예외를 처리
    }

6. 프로토콜

① IP 네트워크상에서 IP 주소를 물리 주소(MAC 주소)로 변환하는 프로토콜 ② 물리적 주소(MAC 주소)를 IP 주소로 변환하는 프로토콜

🖍️ ① ARP ② RARP

7. SQL

[emp]

[sal]

[SQL]
SELECT name, incentive FROM emp, sal WHERE emp.id = sal.id and incentive >= 500;

🖍️

// CREATE
CREATE TABLE emp
(   id       NUMBER NOT NULL,
    name     VARCHAR(10) NOT NULL);
CREATE TABLE sal
(   id        NUMBER NOT NULL,
    incentive NUMBER NOT NULL);
// INSERT
INSERT INTO emp (id, name)
VALUES 
    (1, '강감찬'),
    (2, '김유신'),
    (3, '이순신');
INSERT INTO sal (id, incentive)
VALUES 
    (1, 300),
    (2, 200),
    (3, 1000),
    (4, 500);

8. 관계형 데이터베이스의 용어

① 릴레이션에서 속성(차수)의 개수를 의미: ( ) ② 릴레이션에서 튜플의 개수를 의미: ( ) ③ 한 릴레이션(테이블)의 속성이 다른 테이블의 기본 키를 참조할 때, 참조하는 키: ( ) key ④ 특정 속성에 대해 입력될 수 있는 값의 유형이나 범위를 의미하며, 무결성을 보장하기 위한 기준: ( )

[보기]
ㄱ domain ㄴ primary ㄷ degree ㄹ candidate
ㅁ cardinality ㅂ attribute ㅅ foreign

🖍️ ① ㄷ degree, ② ㅁ cardinality, ③ ㅅ foreign, ④ ㄱ domain

9. 서브넷 마스크

IP: 192.168.35.10 서브넷 마스크: 255.255.252.0

[보기]
ㄱ 192.168.32.xxx ㄴ 192.168.34.xxx ㄷ 192.168.35.xxx ㄹ 192.168.32.xxx ㅁ 192.168.35.xxx

🖍️ ㄱ,ㄴ,ㄷ,ㄹ,ㅁ 252 = 11111100 35 = 00100011

• 네트워크 주소 = 192.168.32.000
• 브로드캐스트 주소 = 192.168.35.255
• ∴ 사용 가능한 IP 주소 범위: 192.168.32.1 ~ 192.168.35.254

10. C Lang. - ASCII 코드

#include <stdio.h>
char Data[5] = {'B', 'A', 'D', 'E'};
char c;

int main(){
    int i, temp, temp2;
    c = 'C';
    printf("%d\n", Data[3]-Data[1]);

    for(i=0;i<5;++i){
        if(Data[i]>c)
            break;
    }

    temp = Data[i];
    Data[i] = c;
    i++;

    for(;i<5;++i){
        temp2 = Data[i];
        Data[i] = temp;
        temp = temp2;
    }

    for(i=0;i<5;i++){
        printf("%c", Data[i]);
    }

    return 0;
}

🖍️ ** 4 BACDE**

💚 1. 출력: Data[3]-Data[1]

printf("%d\n", Data[3]-Data[1]);

• Data[3] = 'E',Data[1] = 'A'
• 'E' - 'A' = 69 - 65 = 4
• 출력: 4

  💚 2. 삽입 위치 찾기

  for(i=0; i<5; ++i){
    if(Data[i] > c)
        break;
  }

• 문자 'C'보다 큰 값을 찾을 때까지 반복
• 비교 순서: Data[0] = 'B' → 'B' < 'C' → 계속 Data[1] = 'A' → 'A' < 'C' → 계속 Data[2] = 'D' → 'D' > 'C' → break! → i == 2 에서 멈춤 ⇒ 'C'는 인덱스 2에 삽입될 예정

  💚 3. 배열에 'C' 삽입

  temp = Data[i];
  Data[i] = c;
  i++;
  for(; i<5; ++i){
    temp2 = Data[i];
    Data[i] = temp;
    temp = temp2;
  }

• i = 2
• Data[2] = 'D'를 temp에 저장하고 'C'로 대체
• 이후 한 칸씩 뒤로 밀면서 값 shift

  💚 4. 최종 출력

  for(i=0; i<5; i++){
    printf("%c", Data[i]);
  }

  → 출력 결과: BACDE

JSON_EXTRACT(json_column, '$.key')

JSON 형태로 저장된 데이터에서 할 때 사용하는 함수이다.

• 예를 들어 아래처럼 생긴 JSON이 있다고 해보자:

  {
  "price": 100,
  "qty": 3
  }

• 이 JSON이 json_data라는 컬럼에 저장돼 있다면:

  SELECT JSON_EXTRACT(json_data, '$.price') 
  FROM your_table;
  // 100

💡 SUM(JSON_EXTRACT(...))?

추출한 값들을 전부 더하는 함수이다.

SELECT SUM(JSON_EXTRACT(json_data, '$.price')) AS total_price
FROM your_table;

→ 각 행의 JSON에서 price 값을 뽑아서 전부 더한 total_price를 구하게 된다.

⚠️ 참고

JSON_EXTRACT는 JSON 값을 그대로 반환해서, 숫자를 뽑아도 '"100"' 이런 식으로 문자열처럼 나온다. 그래서 합계를 정확히 구하려면 CAST 또는 ->> 같은 방식으로 숫자로 변환해주는 게 좋다.

SELECT SUM(CAST(JSON_EXTRACT(json_data, '$.price') AS UNSIGNED)) AS total_price
FROM your_table;

// MySQL 5.7+
SELECT SUM(json_data->>'$.price') AS total_price
FROM your_table;

Java Lang.

클래스, 생성자, 멤버 변수, 메서드, for문, 연산 등

✅ Q1.

class Main {
    public static void main(String[] args) {
        Counter c = new Counter(3);
        int result = c.increase();
        System.out.println(c.val + result);
    }
}

class Counter {
    int val;

    public Counter(int val) {
        this.val = val;
    }

    public int increase() {
        for (int i = 0; i < 2; i++) {
            val += i;
        }
        return val;
    }
}

🖍️ 8

Counter c = new Counter(3); // val = 3
int result = c.increase();  // val += 0, val += 1 => val = 4
System.out.println(c.val + result); // 4 + 4 = 8

✅ Q2.

class Main {
    public static void main(String[] args) {
        A a = new A(1);
        a.n = 4;
        System.out.println(a.fun());
    }
}

class A {
    int n;

    public A(int n) {
        this.n = n;
    }

    public int fun() {
        int r = 0;
        for (int i = 1; i < n; i++) {
            r += i * 2;
        }
        return r;
    }
}

🖍️ 12

A a = new A(1);
a.n = 4;
--------------------------
i from 1 to 3 → r += i * 2  
i = 1 → r = 2  
i = 2 → r = 6  
i = 3 → r = 12

✅ Q3.

class Main {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String str3 = "hello world";
        String str4 = str3.replace('e', 'a');

        System.out.println(str1.equals(str2));
        System.out.println(str3.indexOf("world"));
        System.out.println(str4);
        System.out.println(str4.substring(0,3));
        System.out.println(str2.charAt(0));
    }
}

🖍️ true 6 hallo world hal h

System.out.println(str3.indexOf("world"));
System.out.println(str4.substring(0,3));

• indexOf("world"): "world"라는 문자열이 처음 등장하는 인덱스 위치 반환
• substring(0, 3): 인덱스 0부터 시작해서 3 직전까지(즉, 0, 1, 2 인덱스) 자름. "hallo world" → 인덱스 0부터 2까지는 "hal"

21년 기출

3회차

🖍️ 정보 기술 3A

• Authentication: 시스템을 접근하기 전에 접근 시도하는 사용자의 신원을 검증
• Authorization: 검증된 사용자에게 어떤 수준의 권한과 서비스를 허용
• Accounting: 사용자의 자원(시간,정보,위치 등)에 대한 사용 정보를 수집

🖍️ 데이터 제어어(DCL) 중 GRANT

데이터베이스 사용자에게 사용 권한을 부여하는데 사용하는 명령어이다.

🖍️ ARP 스푸핑

근거리 통신망 하에서 ARP 메시지를 이용하여 상대방의 데이터 패킷을 중간에서 가로채는 중간자 공격 기법이다. 이 공격은 데이터 링크 상의 프로토콜인 ARP를 이용하기 때문에 근거리상의 통신에서만 사용할 수 있는 공격이다.

🖍️ 제어(control) 결합도

어떤 모듈이 다른 모듈의 내부 논리 조직을 제어하기 위한 목적으로 제어 신호를 이용하여 통신하는 경우의 결합도이다. 하위 모듈에서 상위 모듈로 제어 신호가 이동하여 상위 모듈에게 처리 명령을 부여하는 권리 전도 현상이 발생할 수 있다.

🖍️ OSI 7 Layer

• 데이터링크 계층: 물리계층을 통해 송수신되는 정보의 오류와 흐름을 관리하여 안전한 정보의 전달을 수행할 수 있도록 도와주는 역할
• 네트워크 계층: 데이터를 목적지까지 가장 안전하고 빠르게 전달하는 기능
• 표현 계층: 수신자에서 데이터의 압축을 풀수 있는 방식으로 된 데이터 압축

🖍️ 객체지향

• Aggregation(집약관계): 클래스들 사이의 전체 또는 부분 같은 관계를 나타내는 것
• Generalization(일반화관계): 한 클래스가 다른 클래스를 포함하는 상위 개념일 때 IS-A관계라하며, 일반화 관계로 모델링함
• Accociation(연관관계): 2개 이상 사물이 서로 관련된 관계
• Dependency(의존관계): 연관 관계와 같이 한 클래스가 다른 클래스에서 제공하는 기능을 사용할 때 표시
• Realization(실체화관계): 인터페이스를 구현받아 추상 메소드를 오버라이딩 함
• Composition(합성관계): 부분 객체가 전체 객체에 속하는 관계

🖍️ Cause Effect Graph (원인 결과 그래프)

입력 자료 간의 관계와 출력에 영향을 미치는 상황을 체계적으로 분석 후 효용성이 높은 테스트 케이스를 선정해서 테스트하는 기법이다.

🖍️ DES

이것은 미국 NBS (National Bureau of Standards, 현재 NIST)에서 국가 표준으로 정한 암호 알고리즘으로, 64비트 평문을 64비트 암호문으로 암화하는 대칭키 암호 알고리즘이다. 키는 7비트마다 오류검출을 위한 정보가 1비트씩 들어가기 때문에 실질적으로는 56비트이다. 현재는 취약하여 사용되지 않는다.

🖍️ 클래스 다이어그램

이 다이어그램은 문제 해결을 위한 도메인 구조를 나타내어 보이지 않는 도메인 안의 개념과 같은 추상적인 개념을 기술하기 위해 나타낸 것이다. 또한 소프트웨어의 설계 혹은 완성된 소프트웨어의 구현 설명을 목적으로 사용할 수 있다. 이 다이어그램은 속성(attribute)과 메서드(method)를 포함한다.

🖍️ 인덱스

2회차

🖍️ 애드혹 네트워크(Ad-hoc Network)

🖍️ 트랜잭션의 특성: 원자성

모두 반영되거나 아니면 전혀 반영되지 않아야 하는 특성이다.

🖍️ 로킹

병행제어기법 중, 접근한 데이터에 대한 연산을 모두 마칠때까지 상호배제하는 기법이다.

🖍️ 럼바우 데이터 모델링

• Function Modeling: 입력값이 출력값일 때 - 자료 흐름도(DFD)
• Dynamic Modeling: 시간에 따라 변하는 것 - 상태 변화도(DFD)
• Information Modeling: 구조 - ER다이어그램(ERD)

1회차

🖍️ RARP (Reverse Address Resolution Protocol)

물리 네트워크(MAC) 주소에 해당하는 IP 주소를 알려주는 프로토콜로 역순 주소 결정 프로토콜이다.

🖍️ WSDL

웹 서비스명, 제공 위치, 메세지 포맷, 프로토콜 정보 등 웹 서비스에 대한 상세 정보가 기술된 XML 형식으로 구성된 언어이다.

🖍️ IPC

공유메모리, 소켓, 세마포어, 메세지 큐 등 프로세스 간 통신하는 기술이다.

🖍️ 연산, 구조, 제약조건

데이터 모델 구성요소 3가지:

• 개체 데이터 모델에서는 ( A ) 을/를 이용하여 실제 데이터를 처리하는 작업에 대한 명세를 나타냄
• 논리 데이터 모델에서는 ( B ) 을/를 어떻게 나타낼 것인지 표현
• ( C ) 은/는 데이터 무결성 유지를 위한 데이터베이스의 보편적 방법으로 릴레이션의 특정 칼럼에 설정하는 제약을 의미하며, 개체무결성과 참조 무결성 등이 있음

🖍️ DAC(임의적 접근 통제)

시스템 객체의 접근을 개인 또는 그룹의 식별자에 기반을 둔 방법, 어떤 종류의 접근 권한을 가진 사용자가 다른 사용자에 자산의 판탄에 따라 권한을 허용하는 접근제어 방식이다.

🖍️ 결합도 문제

• 내용 결합도 은/는 다른 모듈 내부에 있는 변수나 기능을 다른 모듈에서 사용하는 경우의 결합도
• 스탬프 결합도 은/는 모듈 간의 인터페이스로 배열이나 객체, 구조 등이 전달되는 경우의 결합도
• 공통 결합도 은/는 파라미터가 아닌 모듈 밖에 선언된 전역 변수를 참조하고 전역 변수를 갱신하는 식으로 상호작용하는 경우의 결합도

20년 기출

4회차

🖍️ 즉시갱신 회복 기법

데이터베이스의 회복(Recovery) 기법 중 Rollback 시 Redo, Undo가 모두 실행되는 트랜잭션 처리법으로 트랜잭션 수행 중 갱신 결과를 바로 DB에 반영하는 기법이다.

🖍️ 스니핑(Sniffing)

네트워크상에 존재하는 트래픽을 훔쳐보는 행위로, 주로 자신이 수신해야 하는 정보가 아닌 정보를 받도록 조작하는 행위이다.

🖍️ NAT(Network Address Translation)

IP 패킷에서 외부의 공인 IP주소와 포트 주소에 해당하는 내부 IP주소를 재기록하여 라우터를 통해 네트워크 트래픽을 주고받는 기술이다.

🖍️ 블록체인

분산 컴퓨팅 기술 기반의 데이터 위변조 방지 기술로 P2P방식을 기반으로 하여 소규모 데이터들이 연결되어 형성된 '블록'이라는 분산 데이터 저장 환경에 관리 대상 데이터를 저장함으로써 누구도 임의로 수정할 수 없고 누구나 변경의 결과를 열람할 수 있게끔 만드는 기술이다.

🖍️ 하둡(Hadoop)

오픈 소스 기반으로 한 분산 컴퓨팅 플랫폼으로, 일반 PC급 컴퓨터들로 가상화된 대형 스토리지를 형성하고 그 안에 보관된 거대한 데이터 세트를 병렬로 처리할 수 있도록 개발된 자바 소프트웨어 프레임워크로 구글, 야후 등에 적용한 기술이다.

🖍️ 프로세스 상태 전의도

🖍️ 샘플링 오라클

테스트 오라클 중 특정한 몇 개의 입력값에 대해서만 기대하는 결과를 제공해주는 오라클이다.

🖍️ 유닉스(UNIX)

데니스 리치와 켄톰슨 등이 함께 벨 연구소를 통해 만든 운영체제이며, 90% 이상 C언어로 구현되어 있고, 시스템 프로그램이 모듈화되어 있어서 다른 하드웨어 기종으로 쉽게 이식 가능하며 계층적 트리 구조를 가짐으로써 통합적인 파일 관리가 용이한 운영체제이다.

🖍️ 가용성(Availability)

정보 보안의 3요소 중 하나로, 인가된 사용자는 원할 때 정보에 접근이 가능해야 한다.

3회차

🖍️ ICMP

( )은/는 TCP/IP에서 신뢰성 없는 IP를 대신하여 송신측으로 네트워크의 IP 상태 및 에러 메시지를 전달해주는 프로토콜이다.

🖍️ 프로토콜

심리학자 톰 마릴은 컴퓨터가 메시지를 전달하고 메시지가 제대로 도착했는지 확인하며 도착하지 않았을 경우 메시지를 재전송하는 일련의 방법을 '기술적 은어'를 뜻하는 ( )이라는 용어로 정의했다.

🖍️ ÷

릴레이션 A, B가 있을 때 릴레이션 B 조건에 맞는 것들만 릴레이션 A에서 튜플을 꺼내 프로젝션하는 관계대수의 기호이다.

🖍️ 헝가리안 표기법(Hungarian Notation)

식별자 표기 시 접두어에 자료형을 붙이는 표기법이다.

🖍️ 데이터베이스에서 스키마(Schema)

데이터베이스의 전체적인 구조와 제약조건에 대한 명세로, 내부 스키마와 개념 스키마, 외부 스키마로 나뉜다.

🖍️ EAI 유형

• 포인트 투 포인트(Point-to-point)
• 허브 앤 스포크(Hub & Spoke)
• 메세지 버스(Message bus) 유형
• 하이브리드(Hybrid) 유형

🖍️ 생성자

해당 클래스의 객체가 생성될 때 자동으로 호출되는 특수한 종류의 메서드이다.

2회차

🖍️ 목표 복구 시간(RTO; Recovery Time Objective)

🖍️ IPSec

네트워크 계층(network layer, 3계층)인 인터넷 프로토콜(IP)에서 '암호화', '인증', '키 관리'를 통해 보완성을 제공해 주는 표준화된 기술이다.

🖍️ Observer

한 객체의 상태가 바뀌면 그 객체에 의존하는 다른 객체들한테 연락이 가고 자동으로 내용이 갱신되는 방식으로 일대다(one-to-many) 의존성을 가지는 패턴이다. 서로 상호작용을 하는 객체 사이에서는 가능하면 느슨하게 결합(Loose coupling)하는 디자인을 사용해야 한다.

🖍️ SOAP

( )은/는 HTTP 등의 프로토콜을 이용하여 XML 기반의 메시지를 교환하는 프로토콜로, Envelope-Header-Body 주요 3요소로 구성된다. ( )은/는 유사한 기능을 하는 RESTful로 대체될 수 있다.

🖍️ Linked Open Data

• 전세계 오픈된 정보를 하나로 묶는 방식
• Linked data와 Open data의 합성어
• URI(Uniform Resource Identifier)를 사용
• RESTful 방식으로 볼 수 있으며, 링크 기능이 강조된 시멘틱 웹에 속하는 기술

🖍️ 개념절 설계 → 논리적 설계 → 물리적 설계

DB 설계(모델링) 과정: 요구사항 분석 → 개념절 설계 → 논리적 설계 → 물리적 설계 → 구현

🖍️ 형상 관리

CVS, SVN, Clear Case 등이 있다.

1회차

🖍️ 구문, 의미, 타이밍

프로토콜을 구성하는 대표적인 세가지 요소

🖍️ 원자성, 일관성, 독립성, 지속성

데이터베이스 트랜잭션의 4가지 속성

🖍️ 랜드 어택(Land Attack)

패킷의 출발지 주소(Address)나 포트(Port)를 임의로 변경하여 출발지와 목적지 주소[포트]를 통일하게 함으로써, 공격 대상 컴퓨터의 실행 속도를 느리게 하거나 동작을 마비시켜 서비스 거부 상태에 빠지도록 하는 공격이다.

🖍️ 물리 계층

OSI 7계층에서 ( )는 전송에 필요한 두 장치 간의 실제 접속과 절단 등 기계적, 전기적, 기능적, 절차적 특성에 대한 규칙을 정의한다. 단위(PDU)는 '비트'를 사용한다.

🖍️ 처리량, 응답 시간, 경과 시간, 자원 사용률

애플리케이션 성능을 측정

Java Lang.

✅ 오버라이딩

class A {
    void print() {
        System.out.println("A");
    }
}

class B extends A {
    void print() {
        System.out.println("B");
    }
}

public class Main {
    public static void main(String[] args) {
        A obj = new B();
        obj.print();
    }
}

🖍️ B

• obj.print(); → B의 print()

✅ 오버로딩

class Calc {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calc c = new Calc();
        System.out.println(c.add(2, 3));
        System.out.println(c.add(2.5, 1.5));
    }
}

🖍️ 5 4.0

• c.add(2, 3) → int add(int a, int b){} → 5
• c.add(2.5, 1.5) → double add(double a, double b){} → 4.0

✅ equals() vs ==

public class Main {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
}

🖍️ false true

• s1 == s2 → false (다른 객체)
• s1.equals(s2) → true (내용 비교)

✅ 업캐스팅과 다형성

class Animal {
    void sound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.sound();
    }
}

🖍️ Bark

• Animal a = new Dog();
• a.sound(); → Dog의 오버라이딩된 메서드 호출됨 → "Bark"

✅ static 메서드 하이딩

class Parent {
    static void greet() {
        System.out.println("Hello from Parent");
    }
}

class Child extends Parent {
    static void greet() {
        System.out.println("Hello from Child");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Child();
        p.greet();
    }
}

🖍️ Hello from Parent

• Parent p = new Child();
• p.greet(); → static은 클래스 타입 기준 → "Hello from Parent"

✅ 추상 클래스와 구현

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    void draw() {
        System.out.println("Draw Circle");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Circle();
        s.draw();
    }
}

🖍️ Draw Circle

• Shape s = new Circle();
• s.draw(); → "Draw Circle"

❌ 생성자 실행 순서

class Super {
    Super() {
        System.out.println("Super constructor");
    }
}

class Sub extends Super {
    Sub() {
        System.out.println("Sub constructor");
    }
}

public class Main {
    public static void main(String[] args) {
        Sub obj = new Sub();
    }
}

🖍️ Super constructor Sub constructor

• Sub 객체 생성 시 → Super → Sub 순으로 호출됨

❌ instanceof 연산자

class Animal {}
class Cat extends Animal {}

public class Main {
    public static void main(String[] args) {
        Animal a = new Cat();
        System.out.println(a instanceof Animal);
        System.out.println(a instanceof Cat);
    }
}

🖍️ true true

• Animal a = new Cat();
• a instanceof Animal → true
• a instanceof Cat → true

✅ 변수 하이딩

class Parent {
    int x = 10;
}

class Child extends Parent {
    int x = 20;
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.x);
    }
}

🖍️ 10

• Parent p = new Child();
• p.x → 10 (Parent 기준으로 접근됨)

✅ 인터페이스와 다형성

interface Drawable {
    void draw();
}

class Rectangle implements Drawable {
    public void draw() {
        System.out.println("Drawing Rectangle");
    }
}

public class Main {
    public static void main(String[] args) {
        Drawable d = new Rectangle();
        d.draw();
    }
}

🖍️ Drawing Rectangle

instanceof

• instanceof 는 실제 객체 기준으로 판별한다(타입 일치 여부)
• instanceof null → 항상 false
• 인터페이스도 instanceof 가능
• 클래스끼리는 상속 관계가 아닌 경우 false

❌ 업캐스팅 후 instanceof

class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();
        System.out.println(a instanceof Dog);
        System.out.println(a instanceof Cat);
        System.out.println(a instanceof Animal);
    }
}

🖍️ true false true

• a는 실제로 Dog 객체 → instanceof Dog → true
• a는 Cat은 아님 → instanceof Cat → false
• Dog는 Animal을 상속 → instanceof Animal → true

❌ 인터페이스 instanceof

interface Eater {}
class Human implements Eater {}
class Robot {}  // Robot은 Object를 상속하고 있음

public class Main {
    public static void main(String[] args) {
        Object obj = new Human();
        System.out.println(obj instanceof Eater);
        System.out.println(obj instanceof Human);
        System.out.println(obj instanceof Robot);
    }
}

🖍️ true true false

• Human은 Eater 구현 → instanceof Eater → true
• obj는 Human이므로 instanceof Human → true
• Human은 Robot 아님 → false new Robot() instanceof Object // true Object obj = new Human(); → obj는 실제로 Human 객체 → Human과 Robot은 아무 관계 없음

❌ null 객체에 instanceof

class A {}
public class Main {
    public static void main(String[] args) {
        A a = null;
        System.out.println(a instanceof A);
    }
}

🖍️ false

• instanceof는 null이면 무조건 false
• 타입과 상관없음

다형성 & 타입 캐스팅 문제

✅ 업캐스팅과 메서드 호출

class Animal {
    void speak() {
        System.out.println("Animal speaks");
    }
}

class Cat extends Animal {
    void speak() {
        System.out.println("Meow");
    }

    void jump() {
        System.out.println("Cat jumps");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.speak();
        // a.jump();  // 컴파일 에러 발생 여부?
    }
}

🖍️ Meow

• Animal a = new Cat(); a.speak();: Cat의 오버라이딩된 메서드 호출
• a.jump();: a.jump() 는 업캐스팅된 참조로는 불가 → 컴파일 에러

✅ 다운캐스팅

class Parent {
    void show() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    void show() {
        System.out.println("Child");
    }

    void onlyChild() {
        System.out.println("Child specific method");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Child(); // 업캐스팅
        p.show();                // 오버라이딩된 Child.show()

        Child c = (Child) p;    // 다운캐스팅 (정상)
        c.onlyChild();            // Child의 전용 메서드
    }
}

🖍️ Child Child specific method

❌ 잘못된 다운캐스팅

class A {}
class B extends A {}
class C extends A {}

public class Main {
    public static void main(String[] args) {
        A obj = new C();  // 실제로는 C 타입
        B b = (B) obj;    // C는 B의 하위 클래스 아님 → ClassCastException 발생
        System.out.println("Cast success");
    }
}

🖍️ ❗ 런타임 에러 (ClassCastException) 발생

Exception in thread "main" java.lang.ClassCastException: C cannot be cast to B

✅ 다형성과 배열

class Vehicle {
    void run() {
        System.out.println("Vehicle runs");
    }
}

class Bike extends Vehicle {
    void run() {
        System.out.println("Bike runs fast");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle[] list = { new Vehicle(), new Bike() };
        for (Vehicle v : list) {
            v.run();
        }
    }
}

🖍️ Vehicle runs Bike runs fast

배열 선언:

Vehicle[] list = { new Vehicle(), new Bike() };

• list는 Vehicle 타입의 배열이지만, 그 안에는 Vehicle 객체와 업캐스팅된 Bike 객체가 있음.
• 즉, 내부적으로는 이렇게 저장돼 있음:

  list[0] → new Vehicle()
  list[1] → new Bike()  ← Bike가 Vehicle로 업캐스팅됨

  반복문 실행:

  for (Vehicle v : list) {
    v.run();
  }

• 첫 번째 반복: v = new Vehicle() → v.run() → Vehicle runs
• 두 번째 반복: v = new Bike() v는 Vehicle 타입으로 보이지만, 실제 객체는 Bike이므로 → 오버라이딩된 Bike.run()이 호출됨 → Bike runs fast

❌ instanceof를 활용한 안전한 캐스팅

class Animal {}
class Dog extends Animal {
    void bark() {
        System.out.println("Woof");
    }
}

class Cat extends Animal {}

public class Main {
    public static void main(String[] args) {
        Animal a = new Cat();

        if (a instanceof Dog) {
            Dog d = (Dog) a;
            d.bark();
        } else {
            System.out.println("Not a Dog");
        }
    }
}

🖍️ Not a Dog

• a는 Cat이므로 instanceof Dog→ false → else 블록 실행됨

✅ 정적 메서드(hiding) vs 인스턴스 메서드(오버라이딩)

class Base {
    static void greet() {
        System.out.println("Hello from Base");
    }

    void say() {
        System.out.println("Base says hi");
    }
}

class Derived extends Base {
    static void greet() {
        System.out.println("Hello from Derived");
    }

    void say() {
        System.out.println("Derived says hi");
    }
}

public class Main {
    public static void main(String[] args) {
        Base b = new Derived();
        b.greet(); 
        b.say();   
    }
}

🖍️ Hello from Base Derived says hi

Base b = new Derived();
b.greet();  // 정적 메서드 → 참조 변수 타입 기준 → Base.greet()
b.say();    // 인스턴스 메서드 → 실제 객체 기준 → Derived.say()

• greet()은 static → 오버라이딩 아님 → Base 기준
• say()는 오버라이딩 → Derived 기준

Python Lang.

❌ 딕셔너리 키와 in 연산자

d = {'a': 1, 'b': 2}
print('a' in d, 1 in d)

🖍️ True False

• 'a' in d → True (키 체크)
• 1 in d → False (값은 아님!)

✅ set의 중복 제거 + 정렬

s = set([3, 1, 2, 3, 2])
print(sorted(s))

🖍️ [1,2,3]

• set은 중복을 제거함

❌ 딕셔너리 값 기준 정렬 : lambda

d = {'apple': 3, 'banana': 1, 'cherry': 2}
print(sorted(d.items(), key=lambda x: x[1]))

🖍️ [('banana', 1), ('cherry', 2), ('apple', 3)]

• d.items() → [('apple', 3), ('banana', 1), ('cherry', 2)]
• 값 기준 정렬 → [('banana', 1), ('cherry', 2), ('apple', 3)]

❌ enumerate와 unpacking

lst = ['a', 'b', 'c']
for idx, val in enumerate(lst, start=1):
    if idx == 2:
        print(val)

🖍️ 'b'

• for idx, val in enumerate(lst, start=1): 구문에 의해 index는 1부터 시작
• idx=2일 때 val → 'b'

❌ set 연산

a = {1, 2, 3}
b = {3, 4, 5}
print(a & b, a | b)

🖍️ {3} {1, 2, 3, 4, 5}

• a & b → {3}
• a | b → {1, 2, 3, 4, 5}

❌ 딕셔너리 .get() 메서드

d = {'x': 10}
print(d.get('x'), d.get('y'), d.get('y', 'N/A'))

🖍️ 10 None 'N/A'

• d.get('x') → 10
• d.get('y') → None
• d.get('y', 'N/A') → 'N/A'

✅ lambda와 map

nums = [1, 2, 3]
result = list(map(lambda x: x * 2, nums))
print(result)

🖍️ [2, 4, 6]

✅ filter와 lambda

nums = [0, 1, 2, 3, 4]
result = list(filter(lambda x: x % 2 == 0, nums))
print(result)

🖍️ [0, 2, 4]

• 짝수만 출력

❌ set의 불변성

s = {1, 2, 3}
try:
    s.add([4, 5])
except Exception as e:
    print(type(e).__name__)

🖍️ TypeError

• 리스트는 hashable 아님 → TypeError
• 리스트는 set에 못 들어감

✅ sorted의 key 함수와 reverse

words = ["apple", "banana", "kiwi"]
print(sorted(words, key=lambda x: len(x), reverse=True))

🖍️ ["banana", "apple", "kiwi"]

• key=lambda x: len(x) → [5, 6, 4]
• sorted(words) → ["kiwi", "apple", "banana"]
• reverse=True → ["banana", "apple", "kiwi"]

C Lang.

✅ 구조체 포인터 체이닝

#include <stdio.h>

struct Node {
    int data;
    struct Node *next;
};

int main() {
    struct Node n3 = {30, NULL};
    struct Node n2 = {20, &n3};
    struct Node n1 = {10, &n2};

    struct Node *head = &n1;
    printf("%d\n", head->next->next->data);
    return 0;
}

🖍️ 30

• head->next->next->data -> n1 -> n2 -> n3.data

✅ 연결 리스트를 통한 합계 계산

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int value;
    struct Node *next;
};

int main() {
    struct Node *a = malloc(sizeof(struct Node));
    struct Node *b = malloc(sizeof(struct Node));
    struct Node *c = malloc(sizeof(struct Node));

    a->value = 5; a->next = b;
    b->value = 10; b->next = c;
    c->value = 15; c->next = NULL;

    struct Node *ptr = a;
    int sum = 0;
    while (ptr != NULL) {
        sum += ptr->value;
        ptr = ptr->next;
    }

    printf("%d\n", sum);
    return 0;
}

🖍️ 30

• sum = 5 + 10 + 15 = 30

❌ 구조체 포인터 비교

#include <stdio.h>

struct Item {
    int id;
    struct Item *link;
};

int main() {
    struct Item a = {1, NULL};
    struct Item b = {2, &a};
    struct Item c = {3, &b};

    struct Item *ptr = &c;

    if (ptr->link->link == NULL)
        printf("End\n");
    else
        printf("Not End\n");

    return 0;
}

🖍️ Not End

ptr = &c  
ptr->link = &b  
ptr->link->link = &a  
→ &a != NULL → "Not End"

❌ 문자열 필터링 (포인터 포함)

#include <stdio.h>
#include <string.h>

struct Word {
    char str[20];
    struct Word *next;
};

int main() {
    struct Word w1 = {"cat", NULL};
    struct Word w2 = {"apple", &w1};
    struct Word w3 = {"banana", &w2};

    struct Word *ptr = &w3;

    while (ptr != NULL) {
        if (strchr(ptr->str, 'a') != NULL && strlen(ptr->str) > 4)
            printf("%s\n", ptr->str);
        ptr = ptr->next;
    }

    return 0;
}

🖍️ banana apple

• strchr(ptr->str, 'a') != NULL: 문자열에 'a'가 포함
• strlen(ptr->str) > 4: 문자열의 길이 > 4
• "cat" : 문자열에 'a'는 포함되지만 문자열의 길이 4가 되지 않음 ∴ false
• "apple" : 문자열에 'a'가 포함되면서 동시에 문자열의 길이가 4가 넘음 ∴ true
• "banana": "apple"가 같은 이유 ∴ true

✅ 연결 구조에서 조건 필터 + 합산

#include <stdio.h>

struct Data {
    int num;
    struct Data *next;
};

int main() {
    struct Data d3 = {11, NULL};
    struct Data d2 = {6, &d3};
    struct Data d1 = {4, &d2};

    struct Data *cur = &d1;
    int sum = 0;

    while (cur) {
        if (cur->num % 2 == 0)
            sum += cur->num;
        cur = cur->next;
    }

    printf("%d\n", sum);
    return 0;
}

🖍️ 10

• 구조체 Data는 int num과 다음 노드를 가리키는 포인터 *next를 가지고 있어 → 단일 연결 리스트 구조
• d1 -> d2 -> d3 순서로 연결되어 있고, 값은 각각 4 → 6 → 11
• d1 % 2 = 4 % 2 == 0 -> sum += 4
• d2 % 2 = 6 % 2 == 0 -> sum = 4 + 6
• d3 % 2 = 11 % 2 != 0

❌ 이중 포인터를 이용한 값 변경

#include <stdio.h>

void update(int **pp) {
    **pp = 99;
}

int main() {
    int a = 5;
    int *p = &a;
    update(&p);
    printf("%d\n", a);
    return 0;
}

🖍️ 99

• int *p = &a; → 포인터 p는 a의 주소를 가리킴
• update(&p); → p의 주소를 전달 → 즉, pp는 int** → "포인터를 가리키는 포인터"
• *pp는 p, 즉 &a
• **pp는 *(&a) → 결국 a ∴ **pp = 99 → a = 99

✅ malloc과 구조체 배열 동적 생성

#include <stdio.h>
#include <stdlib.h>

struct Box {
    int size;
};

int main() {
    struct Box *arr = malloc(3 * sizeof(struct Box));
    arr[0].size = 10;
    arr[1].size = 20;
    arr[2].size = 30;

    int total = 0;
    for (int i = 0; i < 3; i++) {
        total += arr[i].size;
    }

    printf("%d\n", total);
    free(arr);
    return 0;
}

🖍️ 60 total = 10 + 20 + 30

✅ 구조체 내 포인터를 이용한 문자열 복사

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct Person {
    char *name;
};

int main() {
    struct Person p;
    p.name = malloc(20);

    strcpy(p.name, "Charlie");  // 문자열 복사
    printf("%s\n", p.name);
    free(p.name);
    return 0;
}

🖍️ Charlie

✅ 포인터를 이용한 연결 리스트 길이 구하기

#include <stdio.h>

struct Node {
    int val;
    struct Node *next;
};

int main() {
    struct Node n3 = {3, NULL};
    struct Node n2 = {2, &n3};
    struct Node n1 = {1, &n2};

    struct Node *ptr = &n1;
    int count = 0;

    while (ptr) {
        count++;
        ptr = ptr->next;
    }

    printf("%d\n", count);
    return 0;
}

🖍️ 3

• 노드 3개

✅ malloc + 연결 리스트 초기화 및 조건 검사

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct Animal {
    char name[20];
    struct Animal *next;
};

int main() {
    struct Animal *a = malloc(sizeof(struct Animal));
    struct Animal *b = malloc(sizeof(struct Animal));

    strcpy(a->name, "dog");
    a->next = b;

    strcpy(b->name, "cat");
    b->next = NULL;

    struct Animal *cur = a;
    while (cur != NULL) {
        if (strcmp(cur->name, "cat") == 0)
            printf("Meow\n");
        cur = cur->next;
    }

    free(a);
    free(b);
    return 0;
}

🖍️ Meow

• if (strcmp(cur->name, "cat") == 0)

• if (strcmp("dog", "cat") == 0)

• not 0 ∴ cur = cur->next;

• if (strcmp("cat", "cat") == 0) ∴ strcmp == 0

Python Lang.

✅ 리스트 슬라이싱 + 참조

a = [1, 2, 3, 4]
b = a[1:3]
b[0] = 99
print(a[1])

🖍️ 2

• b = a[1:3] → b = [2, 3]
• b[0] = 99 → b = [99, 3]

❌ 리스트 곱하기 vs 리스트 컴프리헨션

a = [[0] for _ in range(3)]
a[0][0] = 100
print(a)

🖍️ [[100], [100], [100]]

• a = [[0] for _ in range(3)] → a =[[0], [0], [0]] 각각 독립적인 리스트
• a[0][0] = 100 → [[100], [0], [0]] 👉 이건 [[0]] * 3 일 때 생기는 참조 공유 현상과 다름!

✅ 문자열 불변성

s = "hello"
t = s
s = s.upper()
print(t)

🖍️ hello

• t = hello
• s = HELLO

✅ set과 리스트 변환

a = list(set([1, 2, 2, 3]))
a.sort()
print(a)

🖍️ [1,2,3]

• a = list(set([1, 2, 2, 3])) set 중복 제거: {1, 2, 3} list 변환 후 정렬 → [1, 2, 3]

❌ bool 평가

print(bool([]), bool([0]), bool(0), bool(""), bool("0"))

🖍️ False, True, False, False, True

• bool([]) → False (빈 리스트)
• bool([0]) → True (리스트 안에 값이 있음)
• bool(0) → False
• bool("") → False (빈 문자열)
• bool("0") → True (길이 있음)

❌ 튜플 포함 리스트 변경

x = ([1, 2], 3)
x[0].append(4)
print(x)

🖍️ `([1, 2, 4], 3)

• 튜플은 불변이지만, 내부 리스트는 가변 x는 ([1, 2, 4], 3)이 됨

❌ 문자열 인덱싱 + 슬라이싱

s = "OpenAI"
print(s[1:-1:2])

🖍️ pn OpenAI 012345

• s[1:-1] → 'penA'
• [::2] → 'pn'

❌ 리스트 연산과 할당

a = [1, 2, 3]
b = a
a += [4]
print(b)

🖍️ [1, 2, 3, 4]

• b = [1, 2, 3]
• a += [4]는 리스트 제자리 수정 ∴ a = [1, 2, 3, 4]
• a와 b는 같은 객체 → b도 변경됨

✅ is 연산자

x = 256
y = 256
print(x is y)

🖍️ True

• 파이썬은 -5~256 범위의 정수는 캐싱됨
• x is y → True

✅ 문자열 곱하기와 슬라이싱

msg = "ab" * 3
print(msg[2:5])

🖍️ aba

• msg = "ababab" ababab 012345

Python Lang.

✅ 문자열 슬라이싱의 step

s = "PythonRocks"
print(s[::2])

🖍️ PhRk 해설: 인덱스 0, 2, 4, ...

✅ 문자열 음수 인덱스 슬라이싱

text = "abcdefghij"
print(text[-4:-1])

🖍️ ghi 해설: text[-4:-1] == text[6:9] => 'ghi'

✅ 리스트 vs 튜플

a = [1, 2, 3]
b = (1, 2, 3)
a[0] = 100
# b[0] = 100

print(a[0], b[0]) # 튜플은 변경 불가

🖍️ 100, 1

❌ 리스트 슬라이싱 복사

x = [1, 2, 3, 4]
y = x[:]
x[0] = 99
print(y[0])

🖍️ 1

• 리스트 슬라이싱([:])은 얕은 복사. 따라서 y는 x와 분리된 새 리스트임
• y는 복사본으로 영향 없음 ∴ y = [1, 2, 3, 4]
• x = [99, 2, 3, 4]

❌ 문자열 슬라이싱: reverse

word = "DataScience"
print(word[::-1][:4])

🖍️ ecne 해설:

• word[::-1] = 'ecneicSataD'
• word[:4] = 앞 4글자 = 'ecne'

❌ set

s = set("banana")
print(len(s))

🖍️ 3

• set은 중복되는 값을 제거함
• s = {'b', 'a', 'n'}

❌ 딕셔너리 키 타입

d = {}
d[1] = "int"
d[1.0] = "float"
print(d[1])

🖍️ float

• 1과 1.0은 같은 키로 간주됨 (== 비교 결과가 True, hash도 같음) 따라서 float으로 덮어씀

✅ 불변 튜플 + 가변 리스트

x = (1, 2, [3, 4])
x[2].append(5)
print(x)

🖍️ (1, 2, [3, 4, 5])

• x[2]= [3,4]

❌ 리스트 곱하기 복사 방식

a = [[0]] * 3
a[0][0] = 100
print(a)

🖍️ [[100], [100], [100]]

• [[0]] * 3: [[0]] 리스트 객체를 3번 반복해서 참조한 것 즉, 내부의 3개의 리스트는 모두 같은 객체를 참조함 (id 값 동일) a = [[0], [0], [0]]
• a[0][0] = 100: 이건 내부 리스트의 첫 번째 원소를 100으로 바꾸는 것 그런데 내부 리스트는 전부 같은 객체니까, 모든 리스트에 동시에 반영됨
• ❗ 왜 틀리기 쉬울까? *는 새로운 객체를 만드는 게 아니라 기존 객체에 대한 참조를 반복해! 그래서 내부 리스트들이 독립적이지 않음

❌ 문자열과 bool, int 변환

print(bool("False"), int("False" == "false"))

🖍️ True, 0 =>

• "False" == "false" → False → int(False) = 0

  🔍 코드 흐름 분석

• bool("False"):
  • 파이썬에서 빈 문자열("")은 False이고, 그 외 문자열은 모두 True
  • 결과는: True (비어 있지 않음)
• "False" == "false":
  • 대소문자 구분함 → "False"와 "false"는 다름
  • 결과는: False
• int(False):
  • False는 파이썬에서 정수 0으로 변환됨
  • True는 1, False는 0

Java Lang.

✅ 오버라이딩(재정의)과 업캐스팅

class Parent {
    void show() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    void show() {
        System.out.println("Child");
    }
}

public class Test1 {
    public static void main(String[] args) {
        Parent obj = new Child();
        obj.show();
    }
}

🖍️ Child 해설: Parent obj = new Child(); 상태에서 obj.show() 호출 → 오버라이딩된 Child의 show() 실행

✅ 오버로딩(서로 다른 인수)

class Overload {
    void print(int a) {
        System.out.println("int");
    }

    void print(double a) {
        System.out.println("double");
    }
}

public class Test2 {
    public static void main(String[] args) {
        Overload obj = new Overload();
        obj.print(10.5f);
    }
}

🖍️ double 해설: 10.5f은 float이지만 정확히 일치하는 메서드가 없고, 자동 형변환으로 double 버전 호출됨

❌ 메서드 하이딩 vs 오버라이딩

class A {
    static void hello() {
        System.out.println("Hello from A");
    }
}

class B extends A {
    static void hello() {
        System.out.println("Hello from B");
    }
}

public class Test3 {
    public static void main(String[] args) {
        A obj = new B();
        obj.hello();
    }
}

🖍️ Hello from A 해설: static 메서드는 인스턴스 타입이 아니라 참조 변수 타입 기준으로 호출됨 → A obj = new B(); 이므로 A.hello() 호출 🙌 틀린 이유: static은 오버라이딩이 아닌 하이딩이며, 동적 바인딩이 적용되지 않음

✅ equals() vs ==

public class Test4 {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");

        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
}

🖍️ false true 해설:

• == → 주소 비교 (false),
• equals() → 문자열 내용 비교 (true)

✅ 오버라이딩 vs 멤버 변수 숨기기

class Super {
    String name = "Super";

    String getName() {
        return name;
    }
}

class Sub extends Super {
    String name = "Sub";

    String getName() {
        return name;
    }
}

public class Test5 {
    public static void main(String[] args) {
        Super obj = new Sub();
        System.out.println(obj.name);
        System.out.println(obj.getName());
    }
}

🖍️ Super Sub 해설: obj.name은 변수 숨기기 때문에 Super 출력, getName()은 오버라이딩된 Sub 쪽 실행

❌ 오버로딩 해석 순서

class Demo {
    void process(Object o) {
        System.out.println("Object");
    }

    void process(String s) {
        System.out.println("String");
    }
}

public class Test6 {
    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.process(null);
    }
}

🖍️ String 해셜: 오버로딩은 가장 구체적인 타입 우선! null은 Object, String 모두에 해당하지만, String이 더 구체적이므로 선택됨 ❗ 틀린 이유: 오버로딩 해석 시 "더 구체적인 타입 우선" 이란 규칙을 놓침

✅ 업캐스팅과 오버라이딩 메서드 호출

class Animal {
    void speak() {
        System.out.println("Animal speaks");
    }
}

class Dog extends Animal {
    void speak() {
        System.out.println("Dog barks");
    }

    void wagTail() {
        System.out.println("Dog wags tail");
    }
}

public class Test7 {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.speak();
        // a.wagTail(); // 컴파일 에러
    }
}

🖍️ Dog barks 해설: Animal a = new Dog(); → a.speak() 호출 시 오버라이딩된 Dog의 speak() 호출됨

✅ equals 오버라이딩

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }

    public boolean equals(Object o) {
        if (o instanceof Person) {
            return this.name.equals(((Person) o).name);
        }
        return false;
    }
}

public class Test8 {
    public static void main(String[] args) {
        Person p1 = new Person("John");
        Person p2 = new Person("John");
        System.out.println(p1 == p2);      // Line A
        System.out.println(p1.equals(p2)); // Line B
    }
}

🖍️ false true

🔎 Line A: p1 == p2

• ==는 객체의 참조값을 비교해.
• p1과 p2는 new 키워드로 서로 다른 객체로 생성됐기 때문에 참조가 다름.
• 따라서 결과는: ✅ false

  🔎 Line B: p1.equals(p2)

• equals() 메서드를 오버라이딩 했기 때문에, 단순히 참조값이 아닌 내용 비교를 해.
• this.name.equals(((Person) o).name) → 즉 p1.name.equals(p2.name)
• 둘 다 "John"이니까 결과는: ✅ true

✅ 오버라이딩된 메서드와 생성자 순서

class Base {
    Base() {
        print();
    }

    void print() {
        System.out.println("Base");
    }
}

class Derived extends Base {
    int num = 10;

    void print() {
        System.out.println("Derived: " + num);
    }
}

public class Test9 {
    public static void main(String[] args) {
        new Derived();
    }
}

🖍️ Derived: 10 해설: Derived 생성자 호출 시, Base 생성자 내부에서 print() 호출 → Derived.print() 오버라이딩됨 → num은 이미 초기화된 상태 → 10

❌ final, static, 오버라이딩 혼합

class One {
    final void show() {
        System.out.println("One");
    }

    static void greet() {
        System.out.println("Static One");
    }
}

class Two extends One {
    // void show() {} // 컴파일 에러: final 메서드는 오버라이딩 불가

    static void greet() {
        System.out.println("Static Two");
    }
}

public class Test10 {
    public static void main(String[] args) {
        One o = new Two();
        o.show();
        o.greet();
    }
}

🖍️ One Static One 해설:

• show()는 final → 오버라이딩 불가 → One의 메서드 실행됨 (O)
• greet()는 static → 참조 타입 기준으로 호출 → One o = new Two(); → One.greet() 실행됨 → ❌ Static One이 맞는 출력

C Lang.

✅ 포인터 배열을 통한 문자열 길이 계산

#include <stdio.h>
#include <string.h>

int main() {
    char *arr[] = {"apple", "banana", "kiwi"};
    int total = 0;

    for (int i = 0; i < 3; i++) {
        total += strlen(*(arr + i));
    }

    printf("%d\n", total);
    return 0;
}

🖍️ 15 strlen(apple) = 5 strlen(banana) = 6 strlen(kiwi) = 4 total = 5 + 6 + 4 = 15

✅ 구조체 배열에서 최대값 찾기

#include <stdio.h>

struct Info {
    char name[20];
    int score;
};

int main() {
    struct Info students[3] = {
        {"Kim", 85},
        {"Lee", 92},
        {"Park", 87}
    };

    int max = students[0].score;
    char top[20];

    for (int i = 1; i < 3; i++) {
        if (students[i].score > max) {
            max = students[i].score;
            strcpy(top, students[i].name);
        }
    }

    printf("%s\n", top);
    return 0;
}

🖍️ Lee max = 92 -> int = 1 top = students[1].name = Lee

✅ 배열 포인터로 2차원 배열 순회

#include <stdio.h>

int main() {
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int (*p)[3] = arr;
    int sum = 0;

    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            sum += *(*(p + i) + j);
        }
    }

    printf("%d\n", sum);
    return 0;
}

🖍️ 21 int = 0 sum = 1 + 2 + 3 int = 1 sum = (1 + 2 + 3) + 4 + 5 + 6

✅ 구조체 + 포인터 연산 + 조건

#include <stdio.h>

struct Point {
    int x, y;
};

int main() {
    struct Point arr[] = {{1, 2}, {3, 4}, {5, 6}};
    struct Point *p = arr;
    int result = 0;

    for (int i = 0; i < 3; i++) {
        if ((p + i)->x % 2 == 1) {
            result += (p + i)->y;
        }
    }

    printf("%d\n", result);
    return 0;
}

🖍️ 12

• (p + 0)->x = 1, (p + 1)->x = 3, (p + 2)->x = 5
• if ((p + i)->x % 2 == 1)를 만족하는 i는 0, 3, 5
• result = 2 + 4 + 6 = 12

✅ 증감연산자와 포인터를 함께 사용

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30};
    int *p = arr;
    int a = *p++;
    int b = *p;
    printf("%d %d\n", a, b);
    return 0;
}

🖍️ 10 10

• p++는 후위 연산자 이므로 a에는 값 10이 저장 됌.
• b = *p 이므로 b도 10이 저장 됌.

✅ 구조체 포인터 배열 + 조건

#include <stdio.h>
#include <string.h>

struct Book {
    char title[20];
    int pages;
};

int main() {
    struct Book b1 = {"C Lang", 350};
    struct Book b2 = {"Data", 200};
    struct Book *books[] = {&b1, &b2};
    int total = 0;

    for (int i = 0; i < 2; i++) {
        if (books[i]->pages > 300)
            total += strlen(books[i]->title);
    }

    printf("%d\n", total);
    return 0;
}

🖍️ 6

• int = 0 books[0]->pages > 300 = 350 > 300 -> true total += strlen(books[0]->title); -> strlen("C Lang") ∴ total = 6 int = 1 books[1]->pages > 300 = 200 > 300 -> false

✅ 배열 포인터로 조건 탐색

#include <stdio.h>
#include <string.h>

int main() {
    char strs[2][10] = {"cat", "tiger"};
    char (*p)[10] = strs;
    int count = 0;

    for (int i = 0; i < 2; i++) {
        if (strchr(p[i], 't') != NULL) {
            count++;
        }
    }

    printf("%d\n", count);
    return 0;
}

🖍️ 2

• strchr() 함수는 string에서 문자의 첫 번째 표시를 찾으며, Null로 끝나는 string에서 작동.
• strchr(p[0], 't') : "cat"에서 "t"가 몇 번째에 있는지를 찾음 -> 2
• strchr(p[1], 't') : "tiger"에서 "t"가 몇 번째에 있는지를 찾음 -> 0

✅ 구조체 + 포인터 + 반복문 + 누적

#include <stdio.h>

struct Sensor {
    float temp;
};

int main() {
    struct Sensor sensors[4] = {{23.5}, {25.1}, {22.8}, {24.9}};
    struct Sensor *p = sensors;
    float sum = 0;

    for (int i = 0; i < 4; i++) {
        sum += (p + i)->temp;
    }

    printf("%.1f\n", sum);
    return 0;
}

🖍️ 96.3 sum = 23.5 + 25.1 + 22.8 + 24.9 = 96.3

✅ 문자열 함수 활용 조건문

#include <stdio.h>
#include <string.h>

int main() {
    char *list[] = {"apple", "apricot", "banana", "avocado"};
    int count = 0;

    for (int i = 0; i < 4; i++) {
        if (strncmp(list[i], "ap", 2) == 0)
            count++;
    }

    printf("%d\n", count);
    return 0;
}

🖍️ 2

• strncmp(list[i], "ap", 2) → 문자열 list[i]의 앞 2글자가 "ap"와 같은지 확인하는 조건 ∴ "apple", "apricot"

✅ 다차원 배열과 포인터

#include <stdio.h>

int main() {
    int arr[2][2] = {{1, 2}, {3, 4}};
    int *p = &arr[0][0];

    *(p + 2) += 5;
    printf("%d\n", arr[1][0]);
    return 0;
}

🖍️ 8

• *(p + 2) += 5 → arr[1][0] = 3 + 5 = 8

C Lang.

✅ 포인터와 배열

#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *ptr = arr;
    int sum = 0;

    for (int i = 0; i < 5; i++) {
        sum += *(ptr + i);  // 포인터로 배열 접근
    }

    printf("평균: %.2f\n", sum / 5.0);
    return 0;
}

• sum = 10 + 20 + 30 + 40 + 50 = 150
• sum / 5.0 = 30
• %.2f = 30.00

  🖍️ 평균: 30.00

✅ switch-case

#include <stdio.h>

int main() {
    double a = 12.0;
    double b = 4.0;
    char op = '*';  // 연산자: +, -, *, /

    switch (op) {
        case '+':
            printf("%.2f + %.2f = %.2f\n", a, b, a + b);
            break;

        case '-':
            printf("%.2f - %.2f = %.2f\n", a, b, a - b);

        case '*':
            printf("%.2f * %.2f = %.2f\n", a, b, a * b);

        case '/':
            if (b != 0)
                printf("%.2f / %.2f = %.2f\n", a, b, a / b);
            else
                printf("0으로 나눌 수 없습니다!\n");
            break;

        default:
            printf("잘못된 연산자입니다.\n");
    }

    return 0;
}

• break 제거 (fall-through 발생)
• switch-case는 위에서부터 차례대로 읽어 내려오며 해당하는 구문 실행 op=* 이기 때문에 아래 구문 실행

  case '*':
  printf("%.2f * %.2f = %.2f\n", a, b, a * b);

• case '*' 구문에는 break가 없기 때문에 case '/'도 실행

🖍️ 12.00 * 4.00 = 48.00 12.00 / 4.00 = 3.00

✅ 조건문 - 짝/홀

#include <stdio.h>

int main() {
    int arr[] = {3, 8, 12, 7, 6, 10, 1};
    int even[7]; // C에서는 크기 없는 배열은 선언 안됌
    int count = 0;

    int length = sizeof(arr) / sizeof(arr[0]);

    for(int i=0; i<length; i++){
        if(arr[i]%2 == 0){        // if(arr[i] % 2 != 0): 홀수만 출력
            even[count] = arr[i]; // count를 인덱스로 사용
            count ++;
        }
    } // 짝수 목록: 8 12 6 10 

    // 버블 정렬로 오름차순 정렬
    for (int i = 0; i < count - 1; i++) {
        for (int j = 0; j < count - i - 1; j++) {
            if (even[j] > even[j + 1]) {
                int temp = even[j];
                even[j] = even[j + 1];
                even[j + 1] = temp;
            }
        }
    } 

    printf("%d\n", count);
    printf("짝수 목록: ");
    for (int i = 0; i < count; i++) {
        printf("%d ", even[i]);
    }
    printf("\n");

    return 0;
}

• if(arr[i]%2 == 0): 짝수만
• if(arr[i] % 2 != 0): 홀수만

🖍️ 4 짝수 목록: 6 8 10 12

✅ 문자 배열에서 대문자만 출력

#include <stdio.h>

int main() {
    char str[] = "HeLLoWorLD";
    int length = sizeof(str)/ sizeof(str[0]);

    for(int i=0; i<length; i++){
        char ch = str[i];
        if (ch >= 'A' && ch <= 'Z'){
            printf("%c", ch);
        }
    }
    return 0;
}

🖍️ HLLWLD

✅ 구조체 아이템 접근

#include <stdio.h>

struct Product {
    char name[10];
    int price;
};

int main() {
    struct Product items[2] = {
        {"Pen", 500},
        {"Book", 1200}
    };
    int sum = 0;
    for (int i = 0; i < 2; i++) {
        sum += items[i].price;
    }
    printf("%d\n", sum);
    return 0;
}

• sum += items[i].price; 구조체 아이템 접근

🖍️ 1700

✅ 구조체 포인터

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main() {
    struct Point p = {3, 4};
    struct Point *ptr = &p;

    printf("%d\n", ptr->x + ptr->y);
    return 0;
}

🖍️ 7

✅ 구조체 초기화

#include <stdio.h>

struct Car {
    char name[10];
    int year;
    int price;
};

int main() {
    struct Car c = {"Sonata", 2020};
    printf("%d\n", c.price);
    return 0;
}

• 구조체 전역/로컬 선언 시 초기값은 0, 특히 main()에서 선언된 정적 지역 변수는 보장됨

🖍️ 0

✅ 구조체 포인터를 함수로 전달

#include <stdio.h>

struct Data {
    int x;
    int y;
};

void update(struct Data *d) {
    d->x += 5;
    d->y *= 2;
}

int main() {
    struct Data d = {2, 3};
    update(&d);
    printf("%d %d\n", d.x, d.y);
    return 0;
}

🖍️ 7 6

✅ 구조체 배열과 조건 판단

#include <stdio.h>

struct Score {
    char name[10];
    int score;
};

int main() {
    struct Score list[3] = {
        {"Kim", 85},
        {"Lee", 92},
        {"Park", 78}
    };
    int count = 0;

    for (int i = 0; i < 3; i++) {
        if (list[i].score >= 80) {
            count++;
        }
    }

    printf("%d\n", count);
    return 0;
}

🖍️ 2

✅ 구조체 리턴 함수

#include <stdio.h>

struct Point {
    int x, y;
};

struct Point move(struct Point p) {
    p.x += 10;
    p.y += 10;
    return p;
}

int main() {
    struct Point p = {1, 2};
    struct Point result = move(p);
    printf("%d %d\n", result.x, result.y);
    return 0;
}

🖍️ 11 12

✅ 중첩 구조체

#include <stdio.h>

struct Date {
    int year, month, day;
};

struct Person {
    char name[20];
    struct Date birth;
};

int main() {
    struct Person p = {"Jin", {1999, 12, 5}};
    printf("%d\n", p.birth.year);
    return 0;
}

🖍️ 1999

✅ 구조체 포인터 배열

#include <stdio.h>

struct Info {
    char name[10];
    int level;
};

int main() {
    struct Info a = {"Alice", 2};
    struct Info b = {"Bob", 3};
    struct Info* arr[2] = {&a, &b};

    printf("%s %d\n", arr[1]->name, arr[0]->level);
    return 0;
}

🖍️ Bob 2