정리정리

[Develop] Jekyll에서 Latex 사용하기

2020-09-13T00:00:00+09:00

Jekyll에서 Latex 사용하기

Data Science관련 포스팅을 작성하기 위해서는 수식 작성이 필수이다. 평소에 생각없이 markdown과 latex를 함께 사용하고, 별 문제 없다고 생각했는데 이전 포스팅에서 수식이 표현되지 않았다는 것을 알게되어 방법을 찾아보았다.

MathJax

Jekyll에서 latex를 사용하기 위해서는 MathJax를 이용한다.

1. _config.yml 설정

Jekyll 설정 (_config.yml)에서 사용할 markdown 렌딩 엔진을 kramdown으로 변경한다. 사실 default이기 때문에 크게 신경쓸 필요는 없다.

또한 highlighter를 rouge로 세팅한다. (역시 default)

# Conversion
markdown: kramdown
highlighter: rouge
lsi: false
excerpt_separator: "\n\n"
incremental: false

그리고 kramdown 세팅 역시 수정한다.

# Markdown Processing
kramdown:
  input: GFM
  math_engine: mathjax
  ...

2. page에서 MathJax support파일 생성

아래 경로에 파일을 만들어 아래와 같이 입력한다. mathjax의 설정과 라이브러리 로드를 한다.


```html

<script type="text/x-mathjax-config">
MathJax.Hub.Config({
    TeX: {
        equationNumbers: {
        autoNumber: "AMS"
        }
    },
    tex2jax: {
    inlineMath: [ ['$', '$'], ["\\(","\\)"]  ],
    displayMath: [ ['$$', '$$'], ["\\[","\\]"]  ],
    processEscapes: true,
    }
});
MathJax.Hub.Register.MessageHook("Math Processing Error",function (message) {
        alert("Math Processing Error: "+message[1]);
    });
MathJax.Hub.Register.MessageHook("TeX Jax - parse error",function (message) {
        alert("Math Processing Error: "+message[1]);
    });
</script>

<script type="text/javascript" async
    src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/MathJax.js?config=TeX-MML-AM_CHTML">
</script>

3. 실제 포스팅 페이지에서 로드하도록 수정

아래 경로의 header에 아래 내용을 복사하여 위에서 만든 support 파일을 include하도록 한다.


```html

<head>
    {% if page.use_math %}
        {% include mathjax_support.html %}
    {% endif %}
</head>

4. 실제 사용

포스팅 작성시 아래 구문을 통해 latex 수식을 작성할 수 있다.

latex 문법

$Y = X + b$

실제 포스팅 표현

$Y = X + b$

[LeetCode] 35. Search Insert Position

2020-03-10T00:00:00+09:00

[Medium] 35. Search Insert Position

https://leetcode.com/problems/search-insert-position/

Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.

You may assume no duplicates in the array.

Example 1

Input: [1,3,5,6], 5
Output: 2

Example 2

Input: [1,3,5,6], 2
Output: 1

문제 설명

단순히 Insert position을 구하는 문제로, 정렬된 배열에서 주어진 값이 어느 위치에 들어가야 하는지 찾는 문제다.

나의 풀이

O(N) 단순 배열을 for loop으로 순회하며, target보다 nums[i]의 값이 크거나 같을 경우 i를 리턴한다.

class Solution {
    public int searchInsert(int[] nums, int target) {
        int i;
        for(i = 0; i < nums.length; i++){
            if(target <= nums[i]){
                return i;
            }

        return i;
    }
}

베스트 풀이

아니나 다를까 이걸 더 효율화 한다고 사람들은 binary search를 통해 index를 찾는다. O(logN)의 시간 복잡도를 가진다.

public int searchInsert(int[] A, int target) {
    int low = 0, high = A.length-1;
    while(low<=high){
        int mid = (low+high)/2;
        if(A[mid] == target) return mid;
        else if(A[mid] > target) high = mid-1;
        else low = mid+1;
    }
    return low;
}

[LeetCode] 36. Valid Sudoku

2020-03-10T00:00:00+09:00

[Medium] 36. Valid Sudoku

https://leetcode.com/problems/valid-sudoku/

Determine if a 9x9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules:

Each row must contain the digits 1-9 without repetition.
Each column must contain the digits 1-9 without repetition.
Each of the 9 3x3 sub-boxes of the grid must contain the digits 1-9 without repetition.

Example 1

Input:
[
  ["5","3",".",".","7",".",".",".","."],
  ["6",".",".","1","9","5",".",".","."],
  [".","9","8",".",".",".",".","6","."],
  ["8",".",".",".","6",".",".",".","3"],
  ["4",".",".","8",".","3",".",".","1"],
  ["7",".",".",".","2",".",".",".","6"],
  [".","6",".",".",".",".","2","8","."],
  [".",".",".","4","1","9",".",".","5"],
  [".",".",".",".","8",".",".","7","9"]
]
Output: true

Example 2

Input:
[
  ["8","3",".",".","7",".",".",".","."],
  ["6",".",".","1","9","5",".",".","."],
  [".","9","8",".",".",".",".","6","."],
  ["8",".",".",".","6",".",".",".","3"],
  ["4",".",".","8",".","3",".",".","1"],
  ["7",".",".",".","2",".",".",".","6"],
  [".","6",".",".",".",".","2","8","."],
  [".",".",".","4","1","9",".",".","5"],
  [".",".",".",".","8",".",".","7","9"]
]
Output: false
Explanation: Same as Example 1, except with the 5 in the top left corner being 
    modified to 8. Since there are two 8's in the top left 3x3 sub-box, it is invalid.

문제 설명

스도쿠의 룰 3개를 통해 주어진 스도쿠 판이 valid한지 검증해야 한다.

나의 풀이

O(N^2) 주어진 값을 통해서만 검증하면 되기 때문에 row, col, sub-matrix을 위한 hashset을 만들고, 각 단계를 순회하며 hashset에 중복이 발생할 경우 false를 리턴한다.

이중 배열을 순회하기 때문에 최악의 경우 N^2가 소요된다. (이렇게 단순 순회도 N^2로 보는게 맞나??)

class Solution {
    public boolean isValidSudoku(char[][] board) {
        char[][] rows_valid = new char[9][9];
        char[][] cols_valid = new char[9][9];
        char[][] subs_valid = new char[9][9];

        for(int i = 0; i < 9; i++){
            for(int j = 0; j < 9; j++){
                rows_valid[i][j] = '.';
                cols_valid[i][j] = '.';
                subs_valid[i][j] = '.';
            }
        }

        for(int i = 0; i < 9; i++){
            for(int j = 0; j < 9; j++){
                // row
                char row_val = board[i][j];
                char col_val = board[j][i];
                char sub_val = board[(j/3) + (i/3)*3][(j%3) + (i%3)*3];

                if(row_val != '.'){
                    if(rows_valid[i][row_val-'0'-1] != '.') return  false;
                    else rows_valid[i][row_val-'0'-1] = 1;
                }
                if(col_val != '.'){
                    if(cols_valid[i][col_val-'0'-1] != '.') return false;
                    else cols_valid[i][col_val-'0'-1] = 1;
                }
                if(sub_val != '.'){
                    if(subs_valid[i][sub_val-'0'-1] != '.') return false;
                    else subs_valid[i][sub_val-'0'-1] = 1;
                }
            }
        }
        return true;
    }
}

베스트 풀이

베스트라기 보다는 신박한 풀이다. 시간복잡도는 동일해 보이나, 나의 코드보다 훨씬 간결하다. row, col, sub-matrix의 각 값을 하나의 string으로 encoding한다.

'4' in row 7 is encoded as "(4)7".
'4' in column 7 is encoded as "7(4)".
'4' in the top-right block is encoded as "0(4)2".

이후, hashset에 각 string이 들어가 있는지를 확인한다.

public boolean isValidSudoku(char[][] board) {
    Set seen = new HashSet();
    for (int i=0; i<9; ++i) {
        for (int j=0; j<9; ++j) {
            char number = board[i][j];
            if (number != '.')
                if (!seen.add(number + " in row " + i) ||
                    !seen.add(number + " in column " + j) ||
                    !seen.add(number + " in block " + i/3 + "-" + j/3))
                    return false;
        }
    }
    return true;
}

[LeetCode] 33. Search in Rotated Sorted Array

2020-03-03T00:00:00+09:00

[Medium] 33. Search in Rotated Sorted Array

https://leetcode.com/problems/search-in-rotated-sorted-array/

Example 1

Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4

Example 2

Input: nums = [4,5,6,7,0,1,2], target = 3
Output: -1

문제 설명

어느 시점을 기준으로 반전이 되어 있는 정렬된 리스트가 주어진다. 해당 리스트에서 찾고자 하는 값을 O(logn)으로 구해야 한다.

나의 풀이

O(logN)

O(logN)의 경우 Binary Search를 이용하면 풀 수 있다.
문제에서 제공하는 Rotated되는 시점을 잡기 위해 조건을 추가한다.
- target이 num[0]과 num[i] 사이에 있고 num[0] <= num[i]일 경우 : 0~i 범위에서 binary search를 수행한다.
- target이 num[0]과 num[i] 사이에 있고 num[0] > num[i]일 경우 : target이 num[i]보다 작기 때문에, rotated되는 위치를 찾아야 한다
- target이 num[i]보다 크고, num[0] > num[i]일 경우 : i~end 범위에서 binary search를 수행한다. 무식한 if문의 나열 후 Discuss에서 XOR을 이용해 깔끔하게 정리한 것을 보고 차용(?)했다. 무식하게 풀다

class Solution {
    public int search(int[] nums, int target) {
        int low = 0;
        int high = nums.length - 1;
        while (low < high){
            int mid = (low + high) / 2;
            if ((nums[0] > target) ^ (nums[0] > nums[mid]) ^ (target > nums[mid])){
                low = mid+1;
            }else{
                high = mid;
            }
        }
        return low == high && nums[low] == target ? low : -1;
    }
}

[LeetCode] 34. Find First and Last Position of Element in Sorted Array

2020-03-03T00:00:00+09:00

[Medium] 34. Find First and Last Position of Element in Sorted Array

https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/

Example 1

Input: nums = [5,7,7,8,8,10], target = 8
Output: [3,4]

Example 2

Input: nums = [5,7,7,8,8,10], target = 6
Output: [-1,-1]

문제 설명

33번 문제보다 훨씬 쉽다. 완전히 정렬된 배열이 주어지고, 찾는 값의 start index와 end index를 len 2인 배열로 반환한다. 없을 경우 -1을 채워 반환한다.

나의 풀이

O(logN)

O(logN)의 경우 Binary Search를 이용하면 풀 수 있다.
일단 값을 찾은 경우, 좌측, 우측으로 while로 이동하여 start와 end index를 구한다.
여러가지 제약조건을 넣어 코드가 지저분하지만 1ms의 속도를 가진다.
최악의 상황으로, 만일 모든 값이 동일한 배열이 주어질 경우, O(N)이기 때문에, 각 방향으로 binary search를 수행하는 방법이 더 적합해 보인다. O(2logN)

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] result = {-1, -1};
        int low = 0;
        int high = nums.length - 1;
        
        if(nums.length == 0){
            return result;
        }
        
        if(nums.length == 1 && nums[0] == target){
            result[0] = 0;
            result[1] = 0;
            return result;
        }

        while (low < high) {
            int mid = (low + high) / 2;
            if (nums[mid] == target) {
                int start = mid;
                int end = mid;
                while(start > 0 && nums[start-1] == target){
                    start--;
                }
                while(end < nums.length-1 && nums[end+1] == target){
                    end++;
                }
                result[0] = start;
                result[1] = end;
            }
            if (nums[mid] < target) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        
        if (nums[low] == target) {
            int start = low;
            int end = low;
            while(start > 0 && nums[start-1] == target){
                start--;
            }
            while(end < nums.length-1 && nums[end+1] == target){
                end++;
            }
            result[0] = start;
            result[1] = end;
        }


        return result;
    }
}

[LeetCode] 11. Container With Most Water

2020-02-11T00:00:00+09:00

[Medium] 11. Container With Most Water

https://leetcode.com/problems/container-with-most-water/

Example

Input:[1,8,6,2,5,4,8,3,7]
Output:49

문제 설명

가장 넒게 물을 담을 수 있는 2개의 포인트를 찾아야 한다.

나의 풀이 - 392ms

O(N^2) : 단순 이중 for loop를 이용해 최대 넓이를 구해 리턴했다.

public int maxArea(int[] height) {
        int max_result = 0;
        for(int i = 0; i < height.length-1; i++){
            int f_val = height[i];
            
            for(int j = i+1; j < height.length; j++){
                int s_val = height[j];
                int cont = 0;
                if(f_val < s_val){
                    cont = (j - i) * f_val;
                }else{
                    cont = (j - i) * s_val;
                }
                
                if(max_result < cont){
                    max_result =  cont;
                }
            }
        }
        return max_result;
    }

Best 풀이 - 2ms

O(N) : 양 쪽에 포인트를 둔 후에, 각 포인트 중 작은 값만 이동시키며 최대 값을 확인한다.

public int maxArea(int[] height) {
        int max_val = 0;
        int left = 0;
        int right = height.length - 1;
        
        while(left < right){
            max_val = Math.max(max_val, (right-left)*Math.min(height[left], height[right]));
            if(height[left] < height[right]){
                left++;
            }else{
                right--;
            }
        }
        return max_val;
    }

[LeetCode] 15. 3Sum

2020-02-11T00:00:00+09:00

[Medium] 11. Container With Most Water

https://leetcode.com/problems/3sum/

Example

Given array nums = [-1, 0, 1, 2, -1, -4],

A solution set is:
[
  [-1, 0, 1],
  [-1, -1, 2]
]

문제 설명

n개의 원소가 들어가 있는 배열이 들어 올 경우, 3개의 원소의 합 (a, b, c)이 0이 되는 조합들을 찾아 리턴한다.

나의 풀이

O(N)

X,Y,Z 세 개의 포인트를 둔다.
X를 고정한 후, 11번 문제과 동일하게 2 point 접근을 수행한다.
Y+Z == -X일 경우, 해당 원소를 리스트에 집어넣는다.

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<>();

        for(int i = 0; i < nums.length-2; i++){
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            int x = nums[i];
            int y_idx = i+1;
            int z_idx = nums.length - 1;
            while(y_idx < z_idx){
                if(nums[y_idx] + nums[z_idx] == -x){
                    res.add(Arrays.asList(x, nums[y_idx], nums[z_idx]));
                    y_idx++;
                    z_idx--;
                    while((y_idx < z_idx) && (nums[y_idx] == nums[y_idx-1])) y_idx++;
                    while((y_idx < z_idx) && nums[z_idx] == nums[z_idx+1]) z_idx--;
                }else if(nums[y_idx] + nums[z_idx] > -x){
                    z_idx--;
                }else{
                    y_idx++;
                }
            }
        }
        return res;
    }
}

[ALgorithm] Merge Sort

2020-02-08T00:00:00+09:00

대표적으로 O(logN)의 시간 복잡도를 가지는 소팅 알고리즘

방법

분할 정복(Devide & Conquer)을 이용하는 알고리즘이다. 주어진 배열을 원소가 하나 밖에 남지 않을 때 까지 1/2로 쪼갠 후에, 재귀를 이용해 돌아가며 원래 크기의 배율로 합칠 때 정렬을 수행한다.

Example

만일 아래와 같이 8개의 숫자로 이루어진 배열이 있을 경우 [5, 2, 7, 3, 8, 1, 10, 4]
하나의 배열을 둘로 쪼갠다. [5, 2, 7, 3] [8, 1, 10, 4]
이후 두 개의 배열을 다시 각각 둘로 쪼개고 [5, 2] [7, 3] [8, 1] [10, 4]
네 개의 배열을 다시 각각 둘로 쪼개면 한개씩의 배열이 만들어진다. [5] [2] [7] [3] [8] [1] [10] [4]
더 이상 쪼갤 수 없으므로 두 개씩 합치기를 시작한다. 합칠 때는 작은 수를 앞으로 한다. [2, 5] [3, 7] [1, 8] [4, 10]
다시 네 개의 배열을 두 개로 합친다. 합칠 배열의 각 값을 비교하여 작은 숫자를 먼저 넣으면 정렬된 배열이 만들어진다. [2, 3, 5, 7] [1, 4, 8, 10]
두 개의 배열을 하나로 합치면 최종적으로 정렬이 완료된 배열이 생긴다. [1, 2, 3, 4, 5, 7, 8, 10]

알고리즘의 특성

알거리즘은 Split과 Merge 단계로 나뉘어 구성이 된다
Split은 절반씩 분해해 나가기 때문에 O(logN)의 시간 복잡도를 가지며, Merge의 경우 모든 값을 비교해야 하기 때문에 O(N) 시간 복잡도를 가진다. 즉, 총 시간 복잡도는 O(NlogN)이 된다.
추가적인 공간을 가지고 해당 공간에 값을 담기 때문에, swap이 발생하지 않는다.

알고리즘의 구현

기본적으로 재귀를 이용하여 알고리즘을 구현한다.
배열을 더 이상 나눌 수 없을 때 까지 split한 후, merge를 수행하며, 이 때의 재귀 기저 조건은 배열의 크기가 1 (기본 배열에 따라 크기가 2보다 작을 때로 한다)일 때 이다.

    public static void MergeSort(int[] arr) {
    		sort(arr, 0, arr.length);
    	}
    	
    private static void sort(int[] arr, int low, int high) {
    	if(high - low < 2) {
    		return;
    	}
    	
    	int mid = (high + low) / 2;
    	sort(arr, 0, mid);
    	sort(arr, mid, high);
    	merge(arr, low, mid, high);
    }
    
    private static void merge(int[] arr, int low, int mid, int high) {
    	int[] temp = new int[high-low];
    	int idx = 0, l = low, h = mid;
    	
    	while(l < mid && h < high) {
    		if(arr[l] < arr[h]) {
    			temp[idx++] = arr[l++];
    		}else {
    			temp[idx++] = arr[h++];
    		}
    	}
    	
    	while(l < mid) {
    		temp[idx++] = arr[l++];
    	}
    	while(h < high) {
    		temp[idx++] = arr[h++];
    	}
    	
    	for(int i = low; i < high; i++) {
    		arr[i] = temp[i-low];
    	}
    }

    int[] arr = {5, 2, 7, 3, 8, 1, 10, 4};
    MergeSort(arr);
    
    for(int i = 0; i < arr.length; i++) {
    	System.out.print(arr[i] + " ");
    }

[1 2 3 4 5 7 8 10]

[ALgorithm] Quick Sort

2020-02-08T00:00:00+09:00

대표적으로 O(logN)의 시간 복잡도를 가지는 소팅 알고리즘

방법

분할 정복(Devide & Conquer)을 이용하는 알고리즘이다. 하나의 피봇(pivot)을 기준으로, 피봇 보다 작은 값들은 왼쪽에, 큰 값들을 왼쪽으로 옮기는 작업을 재귀로 수행한다. 병합 정렬(Merge Sort)의 경우 분할을 한 후에 병합이 시작되며 값의 비교가 시작되나, 퀵 정렬의 경우 분할 시점에 비교 연산이 수행되기 때문에 이론적으로는 병합 정렬보다 빠르게 동작할 수 있다. Python이나 Java의 리스트 정렬 알고리즘은 기본적으로 퀵 정렬을 사용한다.

Example

만일 아래와 같이 8개의 숫자로 이루어진 배열이 있을 경우 [5, 2, 7, 3, 1, 10, 4]
하나의 피봇을 정한다. 여기에서는 가운데 값인 3으로 정한다 [5, 2, 7] [3] [ 1, 10, 4] ^ ^ left index right index
피봇 3을 기준으로 left, right index가 교차 할 때 까지 옮기며 왼쪽이 피봇 보다 작고, 오른 쪽이 피봇 보다 클 경우 서로의 위치를 교환한다. [5, 2, 7] [3] [1, 10, 4] ^ ^ left right [1, 2, 7] [3] [5, 10, 4] ^ ^ left right [1, 2, 3] 7 [5, 10, 4]
이후 left와 right가 교차 할 경우 left의 값을 return하여, 이를 기준으로 분할 후 다시 비교를 시작한다. 여기서 왼쪽 배열은 이미 정렬이 되었으므로 더 진행되지 않는다. [1, 2, 3] [7, 5, 10, 4]
오른 쪽 배열 역시 동일하게 피보팅을 잡고 진행한다. [7, 5] [10] [4] [7, 5, 4] [10]
오른 쪽은 하나밖에 없으므로 정렬이 끝난다. 마지막 배열에 대해서 정렬을 수행한다. [7, 5, 4] [7] [5] [4] [4, 5, 7]
각 배열을 모두 보면 정렬이 완료되었다. [1, 2, 3, 4, 5, 7, 10]
알고리즘의 특성
피봇이 어느 값으로 선택되냐에 따라 O(N^2)의 시간 복잡도를 가질 수 있다. (최악의 경우)

알고리즘의 구현

기본적으로 재귀를 이용하여 알고리즘을 구현한다.

    void QuickSort(int[] arr){
    	sort(arr, 0, arr.length-1);
    }
    
    void sort(int[] arr, int left, int right) {
        if (left>= right) return;
    
        int mid = partition(arr, left, right);
        sort(arr, left, mid- 1);
        sort(arr, mid, right);
    }
    
    int partition(int[] arr, int left, int right){
    	int pivot = arr[(left+right) / 2];
    	while(left <= right){
    		while(arr[left] < pivot) left++;
    		while(arr[right] > pivot) right--;
    		if(left <= rght){
    			swap(arr, left, right);
    			left++;
    			right--;
    		}
    	}
    	return left;
    }
    
    void swap(int[] arr, int left, int right){
    	int temp = arr[left];
    	arr[left] = arr[right];
    	arr[right] = temp;
    }

    int[] arr = {5, 2, 7, 3, 1, 10, 4};
    QuickSort(arr);
    
    for(int i = 0; i < arr.length; i++) {
    	System.out.print(arr[i] + " ");
    }

[1 2 3 4 5 7 10]

[Statistical Study]MIT Notebook-chapter 9.3

2020-02-08T00:00:00+09:00

MIT Notebook-chapter 9.3

First Part Inference for one way count data Chi-Square test using the multinoial distribution

단측 count data의 추정을 위해 다항(multinomial) 분포를 이용한 카이제곱 검증

다항분포는 범주형 자료의 확률모형을 나타내는 예로서 이 모형을 이용하여 카이제곱검정의 통계량을 만들 수 있다

다항(Multinomial) 분포의 예시 - 아이스크림 맛의 선호도

해당 검증을 위해 아래와 같은 조건이 있다

Cell은 1, 2, …, c로 넘버링이 되어 있다
셀의 확률은 아래와 같다 $p_1, p_2, ..., p_c, Where \sum_{i}p_i=n$
셀의 개수는 아래와 같다 $n_1, n_2, ..., n_c, Where \sum_{i}n_i = n$
다항 분포의 확률 $P(N_1 = n_1, N_2 = n_2, ...) = \frac{n!}{n_1!n_2!...n_c!}p_1^{n_1}p_2^{n_2}...p^{n_c}$

우리는 아래와 같은 검증을 진행하려 한다. 과거와 현재의 마켓쉐어가 같을까?

$H_0 : p_1 = p_{10}, p_2 = p_{20}, ..., p_c = p_{c0}$ $H_1: p_i \neq p_{i0}$

우선 검증 평균 $X^2$를 설정하자. → 멘델의 적중률 검정을 따른다.

여기서 $e_i$는 $X_i$의 평균이라고 볼 수 있다.

\[e_i = np_{i0} \leftarrow expected \;cell\;counts\;when\; H_0\; is\; true\] \[X^2 = \sum_{i=1}^{c}\frac{(n_i-e_i)^2}{e_i} = \sum_{i}\frac{(observed_i-expected_i)^2}{expected_i}\]

$X^2$를 관찰된 개수가 기대count와 얼마나 다른지 차이라고 생각해야 한다.
$X^2$가 크다는 것은 → 관찰된 것이 기대보다 많이 다르다는 것을 의미한다, 이말은, 뭔가 잘못되었고 귀무가설이 채택되기 때문에 안된다.

카이제곱 분포(Chi-square distribution)란?

확률변수 Z1,Z2,⋯,Zn이 독립이고 표준정규분포를 따른다고 하자. 확률변수

\[Y=Z_1^2 + Z_2^2 + ... + Z_n^2\]

를 자유도 n인 카이제곱분포라고 한다.

다시 돌아가, 위에 수식을 보자.

\[X^2 = \sum_{i=1}^{c}\frac{(n_i-e_i)^2}{e_i} = \sum_{i}\frac{(observed_i-expected_i)^2}{expected_i}\]

n이 커진다면, 위에서 설명한 카이제곱 분포에 근접헤 가는 것을 알 수 있다. 결국, 우리가 구한 $X^2$가 자유도 $c-1$인 원래 카이제곱 분포값보다 클 경우, 우리는 귀무가설을 기각할 수 있다.

중요한 포인트 : $e_i >= 1이거나 e의 4/5이상이 >=5이어야 카이제곱 분포를 모사할 수 있음$