import java.util.ArrayList;

// 30. 간단한 유니온 파인드 알고리즘 구현하기
public class Solution30 {

    private static int[] parent;

    private static int findRootNode(int x) {
        if (parent[x] == x) {
            return x;
        }
        parent[x] = findRootNode(parent[x]);
        return parent[x];
    }

    private static void union(int x, int y) {
        int root1 = findRootNode(x);
        int root2 = findRootNode(y);
        parent[root2] = root1;
    }

    public static Boolean[] solution(int k, int[][] operations) {

        parent = new int[k];

        for (int i = 0; i < k; i++) {
            parent[i] = i;
        }

        ArrayList<Boolean> answer = new ArrayList<>();

        for (int[] op : operations) {
            if (op[0] == 0) {
                union(op[1], op[2]);
            }
            else {
                answer.add(findRootNode(op[1]) == findRootNode(op[2]));
            }
        }

        return answer.toArray(new Boolean[0]);
    }
}

chmod +x scan-secrets.sh
./scan-secrets.sh

# gitleaks 설치
brew install gitleaks  # 또는 apt install gitleaks

# 각 레포에서 실행
git clone git@github.com:dev-minimalism/kr-canslim-notifier.git
cd kr-canslim-notifier
gitleaks detect --source . --verbose

# 전체 히스토리 포함
gitleaks detect --source . --verbose --log-opts="--all"

pip install truffleHog
truffleHog git git@github.com:dev-minimalism/kr-canslim-notifier.git --since_commit HEAD~100

sdk list java

// 클래스, 상속, 캡슐화, 다형성
public class Animal {
    private String name;
    
    public void makeSound() {
        System.out.println("Some sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

// 상태 변경과 제어 흐름을 명시적으로 작성
public static int factorial(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;  // 상태 변경
    }
    return result;
}

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class FunctionalExample {
    public static void main(String[] args) {
        // 1. 람다 표현식과 고차 함수
        Function<Integer, Integer> square = x -> x * x;
        Function<Integer, Integer> addOne = x -> x + 1;
        
        // 함수 합성
        Function<Integer, Integer> squareThenAdd = square.andThen(addOne);
        System.out.println(squareThenAdd.apply(3)); // 10
        
        // 2. 불변성과 순수 함수
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> doubled = numbers.stream()
            .map(n -> n * 2)  // 원본을 변경하지 않음
            .collect(Collectors.toList());
        
        // 3. 함수를 파라미터로 전달
        calculate(10, 5, (a, b) -> a + b); // 15
        calculate(10, 5, (a, b) -> a * b); // 50
    }
    
    static void calculate(int x, int y, BinaryOperator<Integer> operation) {
        System.out.println(operation.apply(x, y));
    }
}

// 타입 파라미터를 사용한 일반화
public class Box<T> {
    private T content;
    
    public void set(T content) {
        this.content = content;
    }
    
    public T get() {
        return content;
    }
}

// 제네릭 메서드
public static <T extends Comparable<T>> T findMax(List<T> list) {
    return list.stream()
        .max(Comparable::compareTo)
        .orElse(null);
}

import java.util.concurrent.*;

public class ConcurrentExample {
    public static void main(String[] args) throws Exception {
        // CompletableFuture를 사용한 비동기 프로그래밍
        CompletableFuture<String> future1 = CompletableFuture
            .supplyAsync(() -> fetchDataFromAPI1());
            
        CompletableFuture<String> future2 = CompletableFuture
            .supplyAsync(() -> fetchDataFromAPI2());
            
        // 두 작업을 결합
        CompletableFuture<String> combined = future1
            .thenCombine(future2, (result1, result2) -> result1 + " " + result2);
            
        System.out.println(combined.get());
    }
}

// RxJava 또는 Project Reactor 사용 예제
Flux.just(1, 2, 3, 4, 5)
    .filter(n -> n % 2 == 0)
    .map(n -> n * 2)
    .subscribe(System.out::println);

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.*;

// OOP: 클래스와 인터페이스 정의
interface DataProcessor<T> {
    CompletableFuture<List<T>> process(List<T> data);
}

public class HybridExample implements DataProcessor<Integer> {
    private final ExecutorService executor = Executors.newFixedThreadPool(4);
    
    @Override
    public CompletableFuture<List<Integer>> process(List<Integer> data) {
        // 함수형 + 동시성 프로그래밍
        return CompletableFuture.supplyAsync(() -> 
            data.parallelStream()           // 병렬 처리
                .filter(n -> n > 0)         // 함수형: 필터링
                .map(this::complexCalculation)  // 메서드 참조
                .sorted()                    // 정렬
                .collect(Collectors.toList()),
            executor
        );
    }
    
    // 명령형 스타일의 복잡한 계산
    private Integer complexCalculation(Integer n) {
        int result = n;
        for (int i = 0; i < 3; i++) {
            result = result * 2 + 1;
        }
        return result;
    }
    
    public static void main(String[] args) throws Exception {
        HybridExample processor = new HybridExample();
        List<Integer> data = Arrays.asList(1, -2, 3, 4, -5, 6);
        
        // 비동기 처리 시작
        CompletableFuture<List<Integer>> future = processor.process(data);
        
        // 콜백 체인 (함수형)
        future.thenApply(result -> {
            System.out.println("처리 결과: " + result);
            return result;
        })
        .thenAccept(result -> {
            // 결과 활용
            int sum = result.stream().mapToInt(Integer::intValue).sum();
            System.out.println("합계: " + sum);
        })
        .get(); // 완료 대기
        
        processor.executor.shutdown();
    }
}