📌# 1단계 본문: 배열 생성 및 초기화

1. 배열이란?

*배열(Array)은 **같은 타입의 여러 값을 하나로 묶어서 저장하는 그릇입니다.
예를 들어, 1부터 45까지의 숫자를 하나의 배열에 순서대로 저장할 수 있습니다.
변수는 하나의 값만 저장할 수 있지만,
배열은 여러 개의 값을 연속해서 저장할 수 있습니다.

배열의 특징 요약

같은 타입의 데이터만 저장할 수 있습니다.
*인덱스(Index)로 **위치를 표시합니다.
- 인덱스는 0부터 시작합니다.
- 예: 첫 번째 값 → 배열[0], 두 번째 값 → 배열[1]
크기가 고정되어 있으며, 한 번 생성하면 크기를 변경할 수 없습니다.

🔹 비유: 우체국 사서함

배열은 여러 개의 우체국 사서함과 같으며,
*각 칸에는 번호(인덱스)**가 적혀 있습니다.
*1번 칸, 2번 칸, 3번 칸…처럼 **순서대로 번호가 붙어 있음

2. 배열 생성하기

1부터 45까지의 숫자를 저장할 배열을 생성합니다.
6개의 로또 번호를 저장할 배열도 생성합니다.

int[] balls = new int[45]; // 1~45 숫자를 저장할 배열
int[] lotto = new int[6];  // 섞인 번호 중 6개 저장

balls[] 배열에는 1부터 45까지의 숫자가 순서대로 저장됩니다.
lotto[] 배열에는 섞인 번호 중 6개가 저장됩니다.
배열 생성 방법:
- 타입[] 배열이름 = new 타입[크기];
- int[] balls = new int[45];는
  - int 타입의 45개 공간을 가진 배열을 만듭니다.
  - 각 공간에는 기본값인 0이 들어갑니다.

🔹 비유: 번호표 통 만들기

balls[]는 1부터 45까지의 번호표가 들어있는 통
lotto[]는 뽑힌 번호표 6개를 넣는 바구니

3. 배열 초기화하기

balls[] 배열에 1부터 45까지의 숫자를 순서대로 넣습니다.
배열에 값을 넣는 것을 배열 초기화라고 합니다.

for (int i = 0; i < balls.length; i++) {
    balls[i] = i + 1;
}

i는 0부터 44까지 반복하며,
balls[i]에 i + 1 값을 넣습니다.
- balls[0] = 1
- balls[1] = 2
- …
- balls[44] = 45

🔹 비유: 번호표 만들기

45개의 빈 번호표에 1번부터 45번까지 번호를 적는 과정
*첫 번째 번호표(0번 칸)에는 **1번을 적고,
*두 번째 번호표(1번 칸)에는 **2번을 적음
*마지막 번호표(44번 칸)에는 **45번을 적음

4. 배열 초기화의 전체 흐름

balls[] 배열을 생성합니다. (int[] balls = new int[45];)
for 문을 사용하여 balls[] 배열을 초기화합니다.
1부터 45까지의 숫자가 순서대로 저장됩니다.

전체 코드

int[] balls = new int[45];
for (int i = 0; i < balls.length; i++) {
    balls[i] = i + 1;
}

balls[] 배열에는 1부터 45까지의 숫자가 순서대로 저장됩니다.
각 칸에는 번호표가 차례대로 들어갑니다.

🔹 비유: 번호표 통 준비하기

비어 있는 통(balls[])에 1번부터 45번까지 번호표를 차례대로 넣음
첫 번째 칸에는 1번 번호표가,
두 번째 칸에는 2번 번호표가 들어감
마지막 칸에는 45번 번호표가 들어감

5. 기술 면접 대비 요약

배열(Array): 같은 타입의 여러 값을 순서대로 저장
배열 생성 방법:
- 타입[] 배열이름 = new 타입[크기];
- 예: int[] balls = new int[45];
배열 초기화:
- for 문을 사용하여 순서대로 값 넣기
- 예: balls[i] = i + 1;
인덱스는 0부터 시작하며,
- balls[0] = 1, balls[1] = 2, …, balls[44] = 45
1부터 45까지 배열 초기화는 로또 번호 생성의 첫 단계
배열 초기화의 성능 최적화:
- for 문은 가장 빠르고 효율적인 초기화 방법
- 메모리 사용량을 최소화하고 속도도 빠름

📝 한눈에 보는 요약

배열(Array): 같은 타입의 여러 값을 순서대로 저장
배열 생성: int[] balls = new int[45];
배열 초기화: balls[i] = i + 1;
배열의 인덱스는 0부터 시작
for 문을 사용하여 순서대로 값을 넣음
로또 번호 생성의 첫 단계는 1부터 45까지 배열 초기화

🔀 2단계 본문: 배열 섞기 (랜덤 셔플)

1. 배열 섞기(랜덤 셔플)의 필요성

로또 번호는 무작위(Random)로 섞여야 합니다.
1부터 45까지의 숫자가 순서대로 있으면
- 예: 1, 2, 3, 4, 5, 6
공정한 추첨이 아니므로
숫자의 순서를 랜덤하게 섞어야 로또 번호가 공정하게 뽑힙니다.

배열 섞기의 목적 요약

공정한 추첨을 위해 순서를 무작위(Random)로 변경
중복 없이 1부터 45까지의 숫자를 무작위로 섞음
섞인 숫자 중 앞 6개를 선택하여 로또 번호로 사용

🔹 비유: 공 뒤섞기

1번부터 45번까지 적힌 공이 순서대로 있는 상태
공정하게 추첨하기 위해 공을 무작위로 섞어야 함
공을 충분히 섞은 후 앞쪽에서 6개를 뽑음

2. 랜덤 섞기 알고리즘 (Swap 방식)

랜덤한 위치의 숫자 2개를 교환(Swap)하면서 배열을 섞습니다.
1000번 반복하여 배열이 충분히 섞이도록 합니다.

랜덤 섞기 코드 분석

for (int i = 0; i < 1000; i++) {
    int f = (int)(Math.random() * 45);
    int t = (int)(Math.random() * 45);
    int tmp = balls[f];
    balls[f] = balls[t];
    balls[t] = tmp;
}

설명

랜덤 인덱스 생성
```
 int f = (int)(Math.random() * 45);
 int t = (int)(Math.random() * 45);
```
- Math.random()은 0.0 이상 1.0 미만의 실수를 생성합니다.
- Math.random() * 45는 0 이상 45 미만의 실수가 됩니다.
- (int)로 정수형 변환하면 0부터 44 사이의 랜덤한 정수가 나옵니다.
- *랜덤하게 뽑은 두 위치(f와 t)의 값을 **서로 교환(Swap) 합니다.

두 위치의 값을 교환(Swap)
```
 int tmp = balls[f];
 balls[f] = balls[t];
 balls[t] = tmp;
```
- *임시 변수(tmp)를 사용하여 **두 위치의 값을 교환(Swap) 합니다.
- 예: balls[3]과 balls[7]을 교환할 때
  - tmp에 balls[3] 값을 저장
  - balls[3]에 balls[7] 값을 넣음
  - balls[7]에 tmp 값을 넣음
- 두 위치의 값이 바뀌면서 배열이 무작위로 섞임

🔹 비유: 카드 섞기

랜덤하게 뽑은 두 장의 카드를 위치를 바꿈
이 작업을 여러 번 반복하면서 카드 순서가 무작위가 됨
1000번 반복하면서 충분히 섞이도록 함

3. 1000번 반복의 의미

1000번 반복은 배열이 충분히 섞이도록 보장하기 위함입니다.
랜덤한 위치에서 두 숫자를 Swap하면서
배열이 점점 무작위 상태로 변합니다.
하지만, 반복 횟수는 경험적인 값이며,
배열 크기(45)에 비해 비효율적일 수 있습니다.
더 효율적인 알고리즘인 Fisher-Yates 알고리즘을 사용하는 것이 좋습니다.

4. 랜덤 셔플의 비효율성 및 개선점

비효율적인 점

랜덤하게 두 위치를 선택하고 교환하는 방식은
중복된 위치가 여러 번 선택될 수 있음
예: balls[3]과 balls[3]을 Swap하면 변화가 없음
랜덤 인덱스를 중복 없이 선택하는 것이 효율적입니다.

개선점: Fisher-Yates 알고리즘

Fisher-Yates 알고리즘은 가장 효율적인 랜덤 셔플 알고리즘입니다.
뒤에서부터 앞으로 이동하면서
이전 위치 중 하나를 무작위로 선택하여 교환합니다.
한 번 선택된 위치는 다시 선택되지 않음 → 중복 방지
O(N) 시간 복잡도로 현재 방식(O(N * 1000))보다 빠름

Fisher-Yates 알고리즘 예시

for (int i = balls.length - 1; i > 0; i--) {
    int j = (int)(Math.random() * (i + 1));
    int tmp = balls[i];
    balls[i] = balls[j];
    balls[j] = tmp;
}

뒤에서부터 앞으로 이동하며
*이전 위치 중 랜덤한 곳(j)과 **교환
한 번 선택된 위치는 다시 선택되지 않음
중복 없이 랜덤하게 섞임

5. 기술 면접 대비 요약

랜덤 셔플(Random Shuffle): 배열의 순서를 무작위로 변경
Swap 알고리즘: 랜덤한 위치 2개를 선택하여 값을 교환
1000번 반복하여 배열을 충분히 섞음
비효율적인 점:
- 중복된 위치가 여러 번 선택될 수 있음
- 배열 크기에 비해 반복 횟수가 너무 많음
개선점:
- Fisher-Yates 알고리즘 사용
- 중복 없이 랜덤하게 섞음
- O(N) 시간 복잡도로 현재 방식(O(N * 1000))보다 빠름
기술 면접 대비 포인트:
- 랜덤 알고리즘의 효율성 비교
- Swap 알고리즘과 Fisher-Yates 알고리즘의 차이점
- O(N) vs O(N * 1000) 시간 복잡도 설명

📝 한눈에 보는 요약

랜덤 셔플(Random Shuffle): 배열을 무작위로 섞음
현재 방식: 랜덤한 위치 2개를 선택하여 값을 교환 (Swap)
문제점: 중복된 위치가 여러 번 선택될 수 있음
개선 방법: Fisher-Yates 알고리즘
- 뒤에서부터 앞으로 이동하며 중복 없이 랜덤하게 섞음
- O(N) 시간 복잡도로 현재 방식보다 훨씬 빠름

🎟️ 3단계 본문: 로또 번호 6개 선택하기

1. 로또 번호 선택의 기본 개념

1부터 45까지의 숫자가 랜덤하게 섞인 배열에서
앞쪽 6개의 숫자를 로또 번호로 선택합니다.
중복 없이 6개의 숫자가 선택됩니다.
섞는 과정에서 중복이 제거되므로,
중복 검사 코드가 필요하지 않습니다.

왜 앞쪽 6개를 선택할까?

랜덤하게 섞은 배열에서 앞쪽 6개를 선택하면
이미 무작위 상태이기 때문에 공정한 추첨이 가능합니다.
뒤쪽 숫자를 선택해도 결과는 동일하지만,
앞쪽 6개를 선택하는 것이 직관적입니다.

🔹 비유: 공 뽑기 통에서 앞쪽 공 6개 뽑기

섞은 공에서 앞쪽에 있는 6개를 순서대로 뽑음
공은 중복 없이 6개가 선택됨
뒤쪽 공을 뽑아도 결과는 같지만,
앞쪽 공부터 뽑는 것이 더 자연스러움

2. 배열에서 6개의 번호 선택하기

랜덤하게 섞인 balls[] 배열에서
앞 6개를 lotto[] 배열에 저장합니다.

코드 분석

for (int i = 0; i < lotto.length; i++) {
    lotto[i] = balls[i];
}

설명

6번 반복하기
- lotto.length는 6입니다.
- 6번 반복하면서 lotto[0]부터 lotto[5]까지 값을 넣습니다.
앞쪽 6개의 숫자 선택하기
- balls[0], balls[1], …, balls[5]→ 랜덤하게 섞인 배열에서 앞 6개를 선택
- balls 배열은 이미 무작위로 섞였으므로앞쪽 숫자 6개가 랜덤하게 선택됩니다.
lotto[] 배열에 저장하기
- lotto[0] = balls[0]
- lotto[1] = balls[1]
- …
- lotto[5] = balls[5]

예시

// balls[] 배열 (랜덤하게 섞인 상태)
balls = [33, 7, 22, 1, 19, 44, 10, ... , 15]

// lotto[] 배열 (앞 6개 선택 후)
lotto = [33, 7, 22, 1, 19, 44]

섞인 배열의 앞 6개가 로또 번호로 선택됩니다.
중복 없이 6개의 숫자가 선택됩니다.

🔹 비유: 앞쪽에서 6개 공 뽑기

섞은 공에서 앞쪽에 있는 6개를 순서대로 뽑음
공은 중복 없이 6개가 선택됨

3. 중복 검사 없이 번호 선택하기

중복된 번호가 없는 이유는
- 배열을 섞는 과정에서 중복 없이 무작위로 섞였기 때문입니다.
배열에 같은 숫자가 두 번 들어가지 않으므로
중복 검사 없이 6개의 숫자를 선택할 수 있습니다.

중복 검사 없이 가능한 이유 정리

배열 초기화 단계
- 1부터 45까지의 숫자가 중복 없이 배열에 저장됨
- balls[] = [1, 2, 3, ... , 45]
배열 섞기 단계
- 배열을 랜덤하게 섞음
- 하지만 숫자는 그대로 존재하므로 중복 없음
앞쪽 6개 선택
- 중복 없이 무작위로 섞인 배열에서
- 앞 6개를 선택하므로 중복이 있을 수 없음

🔹 비유: 번호표 순서만 섞기

1번부터 45번까지 적힌 번호표가 순서만 바뀜
번호표 자체는 중복되지 않음
앞쪽 6개를 선택해도 중복될 수 없음

4. 다른 방법과의 비교

현재 방식: 배열 섞기 → 앞 6개 선택

장점:
- 배열을 섞는 과정에서 중복이 제거됨
- 중복 검사 코드가 필요 없음
- 코드가 간결하고 이해하기 쉬움
단점:
- 배열을 섞는 과정이 비효율적 (Swap 방식 → O(N * 1000))
- Fisher-Yates 알고리즘 사용 시 더 효율적

다른 방법: Set 자료구조 사용하기

Set은 중복을 허용하지 않는 자료구조입니다.
Set에 랜덤한 숫자를 넣고,
6개가 될 때까지 반복하면 중복 없는 번호를 얻을 수 있습니다.

Set<Integer> lotto = new HashSet<>();
while (lotto.size() < 6) {
    lotto.add((int)(Math.random() * 45) + 1);
}

장점:
- 중복 검사 없이 6개의 숫자를 선택할 수 있음
- 간결한 코드로 중복을 방지
단점:
- Set은 순서가 없어서 정렬이 필요
- 중복이 발생하면 랜덤 생성이 반복되어 성능 저하 가능

5. 기술 면접 대비 요약

랜덤하게 섞인 배열에서 앞 6개를 선택
중복 검사 없이 6개의 숫자를 선택할 수 있음
배열 섞는 과정에서 중복 없이 무작위로 섞임
배열의 순서를 바꾸기만 하므로 중복될 수 없음
비교 방법:
- 현재 방식: 배열 섞기 → 앞 6개 선택 (코드가 간결)
- Set 사용 방식: 중복 없는 자료구조(Set) 활용 (랜덤 생성 반복 시 성능 저하)
기술 면접 대비 포인트:
- 중복 검사 없이 랜덤하게 숫자 선택하는 방법 설명
- 배열 섞기 방식과 Set 사용 방식의 장단점 비교
- 코드의 가독성 vs 성능 최적화의 균형점 설명

📝 한눈에 보는 요약

랜덤하게 섞은 배열에서 앞 6개 선택
중복 없이 무작위 선택 가능
Set 사용 방법과 비교 (각각의 장단점 설명 가능)
코드가 간결하고 직관적이며 성능도 우수

🔢 4단계 본문: 번호 정렬 (버블 정렬)

1. 번호 정렬의 필요성

로또 번호는 오름차순으로 정렬해서 결과를 발표합니다.
예: 3, 7, 22, 33, 44, 45
선택된 6개의 숫자는 랜덤 순서로 섞여 있으므로
숫자가 작은 것부터 차례대로 정렬해야 정상적인 로또 번호가 됩니다.

왜 오름차순으로 정렬할까?

로또 결과 발표는 항상 오름차순으로 합니다.
예: 3, 7, 22, 33, 44, 45
정렬하지 않으면
- 예: 44, 33, 3, 22, 45, 7
숫자가 뒤죽박죽 섞여있어서 확인하기 어렵습니다.
오름차순 정렬을 하면 보기 쉽고 결과 확인이 간편합니다.

🔹 비유: 숫자 순서대로 정렬하기

크기가 다른 공을 작은 공부터 큰 공까지 순서대로 줄 세우기
숫자가 뒤죽박죽 섞여있으면 확인하기 어렵지만,
작은 것부터 순서대로 배열하면 한눈에 확인 가능

2. 버블 정렬 (Bubble Sort) 사용

버블 정렬은 서로 이웃한 숫자끼리 비교하면서
큰 숫자를 오른쪽으로 이동시키는 정렬 알고리즘입니다.
작은 숫자는 왼쪽으로 밀려나며 정렬됩니다.
마치 거품(Bubble)이 위로 올라가는 모양과 비슷해서
*버블 정렬(Bubble Sort)**이라고 불립니다.

버블 정렬의 특징 요약

서로 이웃한 숫자끼리 비교하여 큰 숫자를 오른쪽으로 이동
한 번의 순회가 끝나면 가장 큰 숫자가 맨 오른쪽에 정렬됨
이 과정을 반복하면서 모든 숫자가 오름차순으로 정렬
시간 복잡도: O(N²) (비효율적)
장점: 구현이 쉽고 직관적
단점: 정렬 속도가 느림 (큰 배열에서는 비효율적)

🔹 비유: 물방울이 위로 올라가는 모양

큰 숫자가 거품처럼 위(오른쪽)으로 올라가고,
작은 숫자는 밑(왼쪽)으로 내려가며 정렬됨

3. 버블 정렬 코드 분석

for (int i = 0; i < lotto.length; i++) {
    boolean sortable = true;
    for (int j = 0; j < lotto.length - 1 - i; j++) {
        if (lotto[j] > lotto[j + 1]) {
            int tmp = lotto[j];
            lotto[j] = lotto[j + 1];
            lotto[j + 1] = tmp;
            sortable = false;
        }
    }
    if (sortable) break;
}

설명

두 개씩 비교하여 큰 숫자를 오른쪽으로 이동
- lotto[j]와 lotto[j + 1]을 비교하여
  - 왼쪽 숫자가 더 크면 → 서로 교환(Swap)
  - 왼쪽 숫자가 더 작으면 → 아무 일도 안 함
한 번의 순회가 끝나면
- 가장 큰 숫자가 맨 오른쪽에 위치
- 가장 오른쪽 숫자는 정렬이 끝난 상태
반복하며 정렬
- 6개의 숫자를 5번 비교하면서 정렬 완료
- 이웃한 숫자끼리 비교하면서 큰 숫자를 오른쪽으로 이동
- 가장 큰 숫자가 정렬되면 다음 큰 숫자를 정렬
sortable 플래그로 성능 최적화
- 이미 정렬된 상태라면 더 이상 반복하지 않음
- 비교와 Swap이 발생하지 않으면 → sortable = true
- sortable이 true라면 → break로 반복문 종료
- 불필요한 반복을 생략해서 성능 향상

예시: 버블 정렬 과정

// 초기 상태
lotto = [33, 7, 22, 1, 19, 44]

// 1회전 후 (가장 큰 숫자 44가 맨 오른쪽으로 이동)
lotto = [7, 22, 1, 19, 33, 44]

// 2회전 후 (33이 오른쪽으로 이동)
lotto = [7, 1, 19, 22, 33, 44]

// 3회전 후 (22가 오른쪽으로 이동)
lotto = [1, 7, 19, 22, 33, 44]

1회전마다 가장 큰 숫자가 오른쪽으로 이동
최종 상태: [1, 7, 19, 22, 33, 44] (오름차순 정렬)

🔹 비유: 물방울이 위로 올라가는 모양

가장 큰 숫자가 거품처럼 오른쪽으로 이동하며
작은 숫자는 왼쪽에 남음
이동을 반복하며 모든 숫자가 정렬됨

4. 비효율성 및 개선점

버블 정렬의 비효율성

시간 복잡도: O(N²)
비교 횟수와 교환 횟수가 많음
정렬 속도가 매우 느림
큰 배열에서는 비효율적

개선점: Arrays.sort() 사용하기

자바에서 제공하는 Arrays.sort() 메서드는
Dual-Pivot Quick Sort 알고리즘을 사용합니다.
시간 복잡도: O(N log N) → 버블 정렬보다 훨씬 빠름
lotto[] 배열을 오름차순으로 정렬하려면 다음과 같이 사용합니다:

Arrays.sort(lotto);

간단한 코드로 빠르고 효율적인 정렬이 가능합니다.
버블 정렬 대신 Arrays.sort()를 사용하는 것이 성능에 유리합니다.

5. 기술 면접 대비 요약

버블 정렬(Bubble Sort): 이웃한 숫자끼리 비교하며 정렬
큰 숫자를 오른쪽으로 이동하며 작은 숫자는 왼쪽으로 밀림
시간 복잡도: O(N²) (비효율적)
sortable 플래그로 성능 최적화 (이미 정렬된 경우 반복문 종료)
개선점:
- Arrays.sort() 사용 (O(N log N))
- Dual-Pivot Quick Sort 알고리즘으로 훨씬 빠름
기술 면접 대비 포인트:
- 버블 정렬의 원리와 단점 설명
- 시간 복잡도 비교: O(N²) vs O(N log N)
- Arrays.sort() 사용법과 장점!

🔊 5단계 본문: 번호 출력하기

1. 번호 출력을 하는 이유

정렬된 로또 번호 6개를 사용자가 확인할 수 있도록 출력합니다.
예: 1, 7, 19, 22, 33, 44
결과를 화면에 보여주기 위해 *System.out.println()을 사용합니다.
번호 사이에 ,를 붙여서 연속적으로 출력합니다.

왜 `,`로 구분해서 출력할까?

6개의 숫자를 연속적으로 출력하면 보기 불편합니다.
- 예: 1719223344
숫자, 숫자, 숫자, ... 형식으로 출력하면
한눈에 번호를 확인할 수 있습니다.
- 예: 1, 7, 19, 22, 33, 44

🔹 비유: 전화번호 출력하기

전화번호를 숫자만 연속적으로 쓰면 알아보기 힘듦
- 예: 01012345678
중간에 를 넣어서 숫자를 구분하면 보기 쉬움
- 예: 010-1234-5678

2. 번호 출력 코드 분석

System.out.printf("최종정렬 : ");
for (int a : lotto)
    System.out.printf(a + ",");

설명

System.out.printf()로 결과 문자열 출력
- printf()는 형식화된 문자열을 출력합니다.
- "최종정렬 : " 부분은 문자열 그대로 출력됩니다.
- 예: 최종정렬 :
향상된 for문 사용하기
```
 for (int a : lotto)
```
- 향상된 for문은 배열의 모든 요소를 하나씩 꺼내서 반복합니다.
- lotto[] 배열에 있는 6개의 숫자를 왼쪽부터 순서대로 꺼냅니다.
- a에는 현재 꺼낸 숫자가 저장됩니다.
  - 첫 번째 반복: a = lotto[0]
  - 두 번째 반복: a = lotto[1]
  - …
  - 여섯 번째 반복: a = lotto[5]
숫자와 ,를 함께 출력하기
```
 System.out.printf(a + ",");
```
- 숫자(a)와 ,를 문자열로 이어붙여서 출력합니다.
- 예: 1, 7, 19, 22, 33, 44,
- 모든 숫자 뒤에 ,가 붙음
  - 예: 1, 7, 19, 22, 33, 44, (마지막에도 ,가 있음)
- 마지막 ,는 제거하지 않음

예시: 출력 결과

최종정렬 : 1, 7, 19, 22, 33, 44,

오름차순으로 정렬된 6개의 숫자가 연속적으로 출력됩니다.
모든 숫자 뒤에 ,가 붙어서 출력됩니다.
마지막에도 ,가 붙음 (문법 오류는 아니지만, 가독성이 떨어짐)

3. 개선점: 마지막 `,` 제거하기

문제점

현재 방식은 모든 숫자 뒤에 ,가 붙음
- 예: 1, 7, 19, 22, 33, 44,
마지막 ,는 불필요하며 보기 불편함

개선 방법 1: `if`문으로 마지막 `,` 제거

System.out.printf("최종정렬 : ");
for (int i = 0; i < lotto.length; i++) {
    System.out.printf(lotto[i] + (i < lotto.length - 1 ? "," : ""));
}

i < lotto.length - 1일 때만 ,를 붙임
마지막 숫자는 i가 lotto.length - 1*이므로 **false가 되어 ,가 붙지 않음
출력 예: 최종정렬 : 1, 7, 19, 22, 33, 44

개선 방법 2: `String.join()` 사용하기 (Java 8 이상)

String result = String.join(",", Arrays.stream(lotto)
                                       .mapToObj(String::valueOf)
                                       .toArray(String[]::new));
System.out.printf("최종정렬 : " + result);

Arrays.stream(lotto)로 배열을 스트림(Stream)으로 변환
.mapToObj(String::valueOf)로 정수를 문자열로 변환
.toArray(String[]::new)로 문자열 배열로 변환
String.join()으로 각 숫자 사이에 ,를 넣어서 하나의 문자열로 연결
출력 예: 최종정렬 : 1, 7, 19, 22, 33, 44
가독성이 높고 코드가 간결함

4. 기술 면접 대비 요약

정렬된 로또 번호를 오름차순으로 출력
번호 사이에 ,를 넣어서 연속적으로 출력
향상된 for문으로 배열의 모든 요소를 왼쪽부터 순서대로 꺼냄
문제점:
- 마지막 ,가 불필요하게 출력
개선점:
- if문으로 마지막 , 제거
- String.join() 사용 (Java 8 이상)
- 가독성이 높고 코드가 간결함
기술 면접 대비 포인트:
- 향상된 for문과 printf() 사용법 설명
- 마지막 , 문제 해결 방법 설명
- Java 8의 String.join() 사용법 및 Stream API 설명

📝 한눈에 보는 요약

오름차순으로 정렬된 번호 6개 출력
번호 사이에 ,를 넣어서 연속 출력
향상된 for문으로 배열의 모든 요소를 순서대로 출력
마지막 , 문제 해결:
- if문 사용 또는 String.join() 사용 (Java 8 이상)
가독성과 코드 간결성 향상

⚙️ 6단계 본문: 성능 최적화 및 개선점

1. 성능 최적화가 필요한 이유

로또 번호 생성 코드는 랜덤 셔플, 번호 선택, 정렬, 출력의 과정을 거칩니다.
성능 최적화를 하면 코드 실행 속도가 빨라지고 자원 사용이 효율적이 됩니다.
특히, 랜덤 셔플과 정렬 과정이 비효율적이어서 최적화가 필요합니다.

왜 성능 최적화가 필요할까?

로또 번호는 중복 없이 랜덤하게 생성되어야 하므로
랜덤 셔플과 정렬 과정이 포함됩니다.
하지만, 현재 방식은 불필요한 연산이 많아서 느리고 비효율적입니다.
효율적인 알고리즘을 사용하면 속도가 빨라지고 자원을 절약할 수 있습니다.

🔹 비유: 공 뽑기 통을 더 효율적으로 섞기

현재 방식은 공 45개를 1000번 흔드는 것과 같음
더 효율적인 방법으로 최소한의 움직임으로 공을 섞고 정렬하면
에너지도 절약되고 시간도 절약됨

2. 랜덤 셔플의 문제점 및 개선점

현재 방식의 문제점: Swap 방식

for (int i = 0; i < 1000; i++) {
    int f = (int)(Math.random() * 45);
    int t = (int)(Math.random() * 45);
    int tmp = balls[f];
    balls[f] = balls[t];
    balls[t] = tmp;
}

랜덤하게 뽑은 두 위치의 값을 교환(Swap) 하여 배열을 섞습니다.
1000번 반복하여 배열이 충분히 섞이도록 합니다.

비효율적인 점

중복된 위치가 여러 번 선택될 수 있음
- 예: balls[3]과 balls[3]을 Swap하면 변화가 없음
- 같은 위치를 여러 번 선택하면 불필요한 연산 발생
45개의 숫자를 1000번 Swap → 불필요한 연산이 너무 많음
시간 복잡도: O(N * 1000) (비효율적)
배열 크기에 비해 Swap 횟수가 너무 많음

개선점: Fisher-Yates 알고리즘

Fisher-Yates 알고리즘은 가장 효율적인 랜덤 셔플 알고리즘입니다.
뒤에서부터 앞으로 이동하면서
이전 위치 중 하나를 무작위로 선택하여 교환합니다.
한 번 선택된 위치는 다시 선택되지 않음 → 중복 방지
O(N) 시간 복잡도로 현재 방식(O(N * 1000))보다 훨씬 빠름

Fisher-Yates 알고리즘 코드

for (int i = balls.length - 1; i > 0; i--) {
    int j = (int)(Math.random() * (i + 1));
    int tmp = balls[i];
    balls[i] = balls[j];
    balls[j] = tmp;
}

설명

뒤에서부터 앞으로 이동하면서
- i는 배열의 마지막 인덱스부터 앞쪽으로 이동합니다.
- *현재 위치(i)에서 **이전 위치 중 하나(j)를 랜덤하게 선택합니다.
랜덤하게 선택된 위치와 교환
- j는 0부터 i까지의 랜덤한 인덱스입니다.
- balls[i]와 balls[j]의 값을 교환(Swap) 합니다.
한 번 선택된 위치는 다시 선택되지 않음
- *현재 위치(i)는 **이전 위치 중 하나와 교환하고,
- 다음 반복에서는 현재 위치(i)가 제외됩니다.
- 중복 없이 랜덤하게 섞임

🔹 비유: 카드 섞기

맨 뒤 카드부터 앞으로 이동하며 앞쪽 카드 중 하나와 교환
앞쪽에 있는 카드는 다시 선택되지 않음
중복 없이 랜덤하게 섞임

Fisher-Yates 알고리즘의 장점

중복 없이 랜덤하게 섞임
45개의 숫자를 45번만 Swap → 불필요한 연산 없음
시간 복잡도: O(N) (현재 방식보다 훨씬 빠름)
랜덤 셔플 문제 해결의 최적화된 알고리즘

3. 정렬의 문제점 및 개선점

현재 방식의 문제점: 버블 정렬

for (int i = 0; i < lotto.length; i++) {
    boolean sortable = true;
    for (int j = 0; j < lotto.length - 1 - i; j++) {
        if (lotto[j] > lotto[j + 1]) {
            int tmp = lotto[j];
            lotto[j] = lotto[j + 1];
            lotto[j + 1] = tmp;
            sortable = false;
        }
    }
    if (sortable) break;
}

버블 정렬은 이웃한 숫자끼리 비교하면서 큰 숫자를 오른쪽으로 이동
시간 복잡도: O(N²) (비효율적)
배열의 크기가 커질수록 비교 횟수와 Swap 횟수가 급격히 증가

개선점: Arrays.sort() 사용하기

자바에서 제공하는 Arrays.sort() 메서드는
Dual-Pivot Quick Sort 알고리즘을 사용합니다.
시간 복잡도: O(N log N) → 버블 정렬보다 훨씬 빠름

Arrays.sort(lotto);

간단한 코드로 빠르고 효율적인 정렬이 가능합니다.
버블 정렬 대신 Arrays.sort()를 사용하는 것이 성능에 유리합니다.

4. 기술 면접 대비 요약

랜덤 셔플 최적화:
- 현재 방식: Swap 방식 (O(N * 1000), 비효율적)
- 개선점: Fisher-Yates 알고리즘 (O(N), 중복 없이 랜덤하게 섞음)
정렬 최적화:
- 현재 방식: 버블 정렬 (O(N²), 비효율적)
- 개선점: Arrays.sort() 사용 (O(N log N), 빠르고 효율적)
기술 면접 대비 포인트:
- 랜덤 셔플과 정렬 알고리즘의 성능 비교
- 시간 복잡도 분석: O(N²), O(N log N), O(N)
- Fisher-Yates 알고리즘과 Arrays.sort()의 원리 설명

🎓 7단계 본문: 기술 면접 대비 포인트 및 총정리

1. 기술 면접 대비의 중요성

로또 번호 생성 코드를 통해
- 자료구조(Array)
- 랜덤 알고리즘(Random Shuffle)
- 정렬 알고리즘(Sorting)
- 성능 최적화(Optimization)
이 네 가지 개념을 종합적으로 설명할 수 있습니다.

왜 기술 면접 대비가 필요할까?

기술 면접에서는 문제 해결 능력과 코드 최적화 능력을 평가합니다.
로또 번호 생성 코드를 설명하면서
- 자료구조와 알고리즘을 이해하고 있는지
- 성능 최적화를 어떻게 하는지
- 시간 복잡도와 공간 복잡도를 분석할 수 있는지
이 세 가지를 모두 설명할 수 있습니다.

🔹 비유: 요리 대회 참가 준비

요리 대회에서는 요리 실력뿐만 아니라
- 재료의 배합(자료구조)
- 조리 순서(알고리즘)
- 조리 시간 단축(성능 최적화)
이 모든 것을 종합적으로 평가합니다.
로또 번호 생성 코드는 개발 역량을 종합적으로 보여줄 수 있는 예제입니다.

2. 주요 개념 및 질문 포인트

1) 배열(Array)와 자료구조

*배열(Array)은 **같은 타입의 여러 값을 하나로 묶어서 저장합니다.
로또 번호 생성 코드에서는
- balls[] 배열에 1부터 45까지의 숫자를 저장합니다.
- lotto[] 배열에 선택된 6개의 번호를 저장합니다.

면접 질문 포인트

배열(Array)의 특징은 무엇인가요?
- 같은 타입의 데이터만 저장할 수 있음
- 인덱스는 0부터 시작
- 크기가 고정되어 있으며 한 번 생성하면 크기를 변경할 수 없음
배열(Array)와 ArrayList의 차이점은 무엇인가요?
- Array는 크기가 고정되고 초기화 시 크기를 지정해야 함
- ArrayList는 크기가 가변적으로 동적으로 크기 변경 가능
- ArrayList는 내부적으로 배열을 사용하지만,
  - 자동으로 크기가 조정되고 다양한 메서드를 제공

2) 랜덤 셔플(Random Shuffle)과 랜덤 알고리즘

랜덤 셔플은 배열의 순서를 무작위로 변경합니다.
현재 방식은 Swap 방식을 사용하지만,
Fisher-Yates 알고리즘이 더 효율적입니다.

면접 질문 포인트

현재 방식의 문제점과 개선점은 무엇인가요?
- 문제점:
  - 랜덤한 위치를 1000번 Swap → 불필요한 연산이 많음
  - 중복된 위치가 여러 번 선택될 수 있음
  - 시간 복잡도: O(N * 1000) (비효율적)
- 개선점:
  - Fisher-Yates 알고리즘 사용
  - 중복 없이 랜덤하게 섞임
  - O(N) 시간 복잡도로 현재 방식보다 훨씬 빠름
Fisher-Yates 알고리즘의 원리는 무엇인가요?
- 뒤에서부터 앞으로 이동하면서
- 이전 위치 중 하나를 무작위로 선택하여 교환
- 한 번 선택된 위치는 다시 선택되지 않음
- 중복 없이 랜덤하게 섞임

3) 정렬(Sorting) 알고리즘

*버블 정렬(Bubble Sort)은 **이웃한 숫자끼리 비교하면서
큰 숫자를 오른쪽으로 이동하며 오름차순으로 정렬합니다.
하지만, 시간 복잡도 O(N²)로 비효율적입니다.
Arrays.sort() 메서드를 사용하면 O(N log N)으로 더 빠르게 정렬할 수 있습니다.

면접 질문 포인트

버블 정렬의 문제점과 개선점은 무엇인가요?
- 문제점:
  - O(N²) 시간 복잡도
  - 비교 횟수와 교환 횟수가 많음
  - 배열의 크기가 커질수록 성능 저하
- 개선점:
  - Arrays.sort() 메서드 사용
  - Dual-Pivot Quick Sort 알고리즘으로 O(N log N)
  - 빠르고 효율적인 정렬
버블 정렬과 Quick Sort의 차이점은 무엇인가요?
- 버블 정렬(Bubble Sort)
  - 이웃한 숫자끼리 비교
  - 큰 숫자를 오른쪽으로 이동
  - 시간 복잡도: O(N²)
  - 구현이 쉽지만 비효율적
- Quick Sort (Dual-Pivot Quick Sort)
  - 기준(Pivot)을 정하고 좌우로 분할
  - 분할한 부분 배열을 재귀적으로 정렬
  - 시간 복잡도: O(N log N)
  - 빠르고 효율적인 정렬

4) 성능 최적화 및 시간 복잡도 분석

성능 최적화는 코드 실행 속도를 높이고 자원 사용을 절약합니다.
랜덤 셔플과 정렬 알고리즘에서 성능 최적화를 했습니다.

면접 질문 포인트

시간 복잡도란 무엇인가요?
- *입력 크기(N)가 커질수록 **연산 횟수가 증가하는 정도를 나타냅니다.
- Big-O 표기법으로 표현합니다.
- 예: O(N), O(N log N), O(N²), O(N³)
로또 번호 생성 코드의 시간 복잡도를 설명해보세요.
- 랜덤 셔플 (Fisher-Yates 알고리즘): O(N)
- 정렬 (Arrays.sort()): O(N log N)
- 전체 시간 복잡도: O(N log N)

5. 기술 면접 대비 총정리

배열과 자료구조: Array와 ArrayList의 차이점 설명
랜덤 셔플 알고리즘: 현재 방식 vs Fisher-Yates 알고리즘
정렬 알고리즘: 버블 정렬 vs Quick Sort (Arrays.sort())
시간 복잡도 분석: O(N), O(N log N), O(N²) 설명
성능 최적화 방법: 불필요한 연산 제거 및 효율적인 알고리즘 사용

** 📌# 1단계 본문: 배열 생성 및 초기화**

1. 배열이란?

배열의 특징 요약

2. 배열 생성하기

3. 배열 초기화하기

4. 배열 초기화의 전체 흐름

전체 코드

5. 기술 면접 대비 요약

📝 한눈에 보는 요약

🔀 2단계 본문: 배열 섞기 (랜덤 셔플)

1. 배열 섞기(랜덤 셔플)의 필요성

배열 섞기의 목적 요약

2. 랜덤 섞기 알고리즘 (Swap 방식)

랜덤 섞기 코드 분석

설명

3. 1000번 반복의 의미

4. 랜덤 셔플의 비효율성 및 개선점

비효율적인 점

개선점: Fisher-Yates 알고리즘

Fisher-Yates 알고리즘 예시

5. 기술 면접 대비 요약

📝 한눈에 보는 요약

🎟️ 3단계 본문: 로또 번호 6개 선택하기

1. 로또 번호 선택의 기본 개념

왜 앞쪽 6개를 선택할까?

2. 배열에서 6개의 번호 선택하기

코드 분석

설명

예시

3. 중복 검사 없이 번호 선택하기

중복 검사 없이 가능한 이유 정리

4. 다른 방법과의 비교

현재 방식: 배열 섞기 → 앞 6개 선택

다른 방법: Set 자료구조 사용하기

5. 기술 면접 대비 요약

📝 한눈에 보는 요약

🔢 4단계 본문: 번호 정렬 (버블 정렬)

1. 번호 정렬의 필요성

왜 오름차순으로 정렬할까?

2. 버블 정렬 (Bubble Sort) 사용

버블 정렬의 특징 요약

3. 버블 정렬 코드 분석

설명

예시: 버블 정렬 과정

4. 비효율성 및 개선점

버블 정렬의 비효율성

개선점: Arrays.sort() 사용하기

5. 기술 면접 대비 요약

🔊 5단계 본문: 번호 출력하기

1. 번호 출력을 하는 이유

왜 ,로 구분해서 출력할까?

2. 번호 출력 코드 분석

설명

예시: 출력 결과

3. 개선점: 마지막 , 제거하기

문제점

개선 방법 1: if문으로 마지막 , 제거

개선 방법 2: String.join() 사용하기 (Java 8 이상)

4. 기술 면접 대비 요약

📝 한눈에 보는 요약

⚙️ 6단계 본문: 성능 최적화 및 개선점

1. 성능 최적화가 필요한 이유

왜 성능 최적화가 필요할까?

2. 랜덤 셔플의 문제점 및 개선점

현재 방식의 문제점: Swap 방식

비효율적인 점

개선점: Fisher-Yates 알고리즘

Fisher-Yates 알고리즘 코드

설명

Fisher-Yates 알고리즘의 장점

3. 정렬의 문제점 및 개선점

현재 방식의 문제점: 버블 정렬

개선점: Arrays.sort() 사용하기

4. 기술 면접 대비 요약

🎓 7단계 본문: 기술 면접 대비 포인트 및 총정리

1. 기술 면접 대비의 중요성

왜 기술 면접 대비가 필요할까?

2. 주요 개념 및 질문 포인트

1) 배열(Array)와 자료구조

면접 질문 포인트

📌# 1단계 본문: 배열 생성 및 초기화

왜 `,`로 구분해서 출력할까?

3. 개선점: 마지막 `,` 제거하기

개선 방법 1: `if`문으로 마지막 `,` 제거

개선 방법 2: `String.join()` 사용하기 (Java 8 이상)