diff --git a/15/beom/Leetcode.md b/15/beom/Leetcode.md
new file mode 100644
index 0000000..4e03fdd
--- /dev/null
+++ b/15/beom/Leetcode.md
@@ -0,0 +1,276 @@
+# Sliding Window
+
+## 목차
+## 219. Contains Duplicate II
+## 643. Maximum Average Subarray I
+## 2269. Find the K-Beauty of a Number
+## 1876. Substrings of Size Three with Distinct Characters
+## 1763. Longest Nice Substring(틀림)
+
+
+
+
+
+# 219. Contains Duplicate II
+
+## 코딩테스트 대비 문제 풀기!
+
+[Leetcode 링크](https://leetcode.com/problems/contains-duplicate-ii/)
+
+## 문제 요약
+
+nums의 요소가 같으면서, 인덱스끼리의 차의 절대값이 k보다 작은 수가 있으면 true
+
+
+## 시간복잡도, 공간복잡도
+| time | space |
+|------|-------|
+| O(n) | O(n)  |
+
+
+## 내가 푼 코드
+```java
+class Solution {
+    public boolean containsNearbyDuplicate(int[] nums, int k) {
+
+        Map<Integer, Integer> map = new HashMap<>();
+
+        for(int end = 0;end < nums.length;end++){
+            if(map.containsKey(nums[end])){
+                if(Math.abs(map.get(nums[end]) - end) <= k){
+                    return true;
+                }
+            }
+            map.put(nums[end], end);
+        }
+        return false;
+    }
+}
+```
+
+## 다른 사람의 잘푼 코드
+```java
+	var containsNearbyDuplicate = function (nums, k) {
+
+		if (nums.length === 1) return false;
+		const obj = {};
+
+		for (let i = 0; i < nums.length; i++) {
+			if (obj[nums[i]] >= 0 && Math.abs(obj[nums[i]] - i) <= k) {
+				return true;
+			}
+			obj[nums[i]] = i;
+		}
+		return false;
+	};
+```
+
+
+# 643. Maximum Average Subarray I
+
+## 코딩테스트 대비 문제 풀기!
+
+[Leetcode 링크](https://leetcode.com/problems/maximum-average-subarray-i/submissions/)
+
+## 문제 요약
+
+nums에서 k개의 숫자의 평균이 가장 큰 것을 더하세요
+
+
+## 시간복잡도, 공간복잡도
+| time | space |
+|------|-------|
+| O(n) | O(1)  |
+
+
+## 내가 푼 코드
+```java
+class Solution {
+    public double findMaxAverage(int[] nums, int k) {
+        double sum = 0, max = 0;
+
+        for(int i = 0; i<k; i++){
+            sum += nums[i];
+        }
+
+        max = sum;
+
+        for(int i=k;i< nums.length;i++){
+            sum = sum + nums[i] - nums[i-k];
+            max = Math.max(sum, max);
+        }
+
+        return max/k;
+    }
+}
+```
+
+# 2269. Find the K-Beauty of a Number
+
+## 코딩테스트 대비 문제 풀기!
+
+[Leetcode 링크](https://leetcode.com/problems/find-the-k-beauty-of-a-number/submissions/)
+
+## 문제 요약
+
+num이 있고 길이를 의미하는 k가 있을 때 num 중 k만큼의 수로 num이 나누어 떨어지는 갯수를 구하시오
+
+## 시간복잡도, 공간복잡도
+| time | space |
+|------|-------|
+| O(n) | O(n)  |
+
+
+## 내가 푼 코드
+```java
+class Solution {
+    public int divisorSubstrings(int num, int k) {
+        int count = 0;
+
+        String strNum = String.valueOf(num);
+
+        for(int i=0;i<strNum.length() - k + 1;i++){
+            String str = strNum.substring(i,i+k);
+            if(Integer.parseInt(str) == 0){
+                continue;
+            }
+
+            if(num % Integer.parseInt(str) == 0){
+                count++;
+            }
+        }
+        return count;
+    }
+}
+
+```
+
+# 1876. Substrings of Size Three with Distinct Characters
+
+## 코딩테스트 대비 문제 풀기!
+
+[Leetcode 링크](https://leetcode.com/problems/substrings-of-size-three-with-distinct-characters/)
+
+## 문제 요약
+
+s에서 중복되지 않는 3개의 문자가 있는 경우를 카운트하세요!
+
+## 시간복잡도, 공간복잡도
+| time | space |
+|------|-------|
+| O(n) | O(1)  |
+
+
+## 내가 푼 코드
+```java
+class Solution {
+    public int countGoodSubstrings(String s) {
+        Set<Character> set = new HashSet<>();
+        int start = 0, end = 0;
+        int count = 0;
+
+        while (end < s.length()){
+            if(!set.contains(s.charAt(end))){
+                set.add(s.charAt(end));
+                end++;
+                if(set.size() == 3){
+                    count++;
+                    set.remove(s.charAt(start));
+                    start++;
+                }
+            }else{
+                set.remove(s.charAt(start));
+                start++;
+            }
+        }
+
+        return count;
+    }
+}
+
+```
+
+
+# 1763. Longest Nice Substring(틀림)
+
+## 코딩테스트 대비 문제 풀기!
+
+[Leetcode 링크](https://leetcode.com/problems/substrings-of-size-three-with-distinct-characters/)
+
+## 문제 요약
+
+정확한 이해는 못함..........
+
+문자의 대문자 소문자가 동시에 나왔을 때 더 긴 문자열 반환??
+
+## 시간복잡도, 공간복잡도
+| time | space |
+|------|-------|
+| O(n^2) | O(n)  |
+
+
+## 다른 사람의 풀이
+```java
+class Solution {
+    public String longestNiceSubstring(String s) {
+        Set<Character> set = new HashSet<>();
+
+        for(int i = 0;i<s.length();i++){
+            set.add(s.charAt(i));
+        }
+
+        for(int i=0;i<s.length();i++){
+            if(set.contains(Character.toUpperCase(s.charAt(i))) && set.contains(Character.toLowerCase(s.charAt(i)))){
+                continue;
+            }
+
+            String s1 = longestNiceSubstring(s.substring(0,i));
+            String s2 = longestNiceSubstring(s.substring(i+1));
+            return s1.length()>= s2.length() ? s1 : s2;
+        }
+
+        return s;
+    }
+}
+
+```
+
+
+# 1984. Minimum Difference Between Highest and Lowest of K Scores
+
+## 코딩테스트 대비 문제 풀기!
+
+[Leetcode 링크](https://leetcode.com/problems/minimum-difference-between-highest-and-lowest-of-k-scores/)
+
+## 문제 요약
+
+nums의 배열안에서 k의 공간이 있을 때 공간안의 최대값과 최소값의 차가 가장 작은 것을 반환
+
+## 시간복잡도, 공간복잡도
+| time | space |
+|------|-------|
+| O(n log n) | O(1)  |
+
+
+## 내가 푼 코드
+```java
+class Solution {
+    public int minimumDifference(int[] nums, int k) {
+        Arrays.sort(nums);
+        int min = 100000;
+        int start = 0, end = k-1;
+
+        if(nums.length == 1){
+            return 0;
+        }
+        while (end < nums.length){
+            min = Math.min(min, nums[end] - nums[start]);
+            start++;
+            end++;
+        }
+
+        return min;
+    }
+}
+
+```
\ No newline at end of file
diff --git a/15/beom/SlidingWindow.md b/15/beom/SlidingWindow.md
new file mode 100644
index 0000000..c488ab1
--- /dev/null
+++ b/15/beom/SlidingWindow.md
@@ -0,0 +1,74 @@
+# 투 포인터 & 슬라이딩 윈도우
+
+# 투 포인터
+
+## 정의
+투 포인터는 **연속되고 길이가 가변적인** 부분 배열들을 활용하여 특정 조건을 일치시키는 알고리즘이다.
+
+## 유형
+1. 2개의 포인터 변수 시작점이 배열의 시작점인 경우
+2. 정렬된 배열 안에서 2개의 포인터 변수가 각각 시작점과 끝점인 경우
+
+
+
+# 슬라이딩 윈도우
+
+## 정의
+슬라이딩 윈도우 알고리즘은 위도우 즉 일정한 범위를 가지고 있는 것을 유지하면서 이것을 이동 하는 것이다.
+
+## 예시
+2가지 긴 물자열이 주어지고 알파벳 2개만을 포함하는 가장 긴 문자열을 찾아보는 문제가 있다고 가정하자
+
+이 문제를 슬라이딩 알고리즘을 이용하여 풀면 다음과 같이 파란색으로 칠해진 영역이 위도우가 되고 이를 하나씩 밀게 되는 것이다.
+
+![예시](assets/1.png)
+
+그림의 Riggt를 하나씩 움직이면 되는데 Right가 C를 가리키면 다음 포함하는 문자열이 3개가 되므로 윈도우가 더이상 확장되지 않고 다음 윈도우로 움직인다.
+
+![예시2](assets/2.png)
+
+이런식으로 움직이게 된다. 마찬가지로 D로 움직이면 CD만 포함되게 된다.
+
+Max lenght를 값으로 가지면서 윈도우를 옮길 수 있는데 윈도우의 범위를 어떻게 기억할 것인가가 관건이다.
+
+대표적으로 Map을 활용한다.
+
+<알파벳, index>로 각 위치를 기억해두면 빠르게 알파벳의 시작 위치를 기억할 수 있다.
+
+Map의 size가 3이상이 되면 조건을 벗어나므로 가장 작은 인덱스를 제거하고 새로운 인덱스를 Map에 넣으면 된다.
+
+> 코드
+ ```java
+public int function(String s) {
+    int n = s.length();
+    if (n < 3) return n;
+    int lIdx = 0;
+    int rIdx = 0;
+    Map<Character, Integer> hashMap = new HashMap<>();
+    int maxx = 2;
+    while (rIdx < n) {
+        if (hashMap.size() < 3)
+            hashMap.put(s.charAt(rIdx), rIdx++);
+        if (hashMap.size() == 3) {
+            int minIdx = Collections.min(hashMap.values());
+            hashMap.remove(s.charAt(minIdx));
+            lIdx = minIdx + 1;
+        }
+        maxx = Math.max(maxx, rIdx - lIdx);
+    }
+    return maxx;
+}
+``` 
+
+# 투포인터와 슬라이딩 윈도우의 차이
+**부분 배열 길이의 변화 여부**
+
+즉, 투 포인터 알고리즘은 부분 배열의 길이가 가변적이지만 슬라이딩 윈도우 알고리즘은 부분 배열의 길이가 고정적이다.
+
+
+
+## 참고 문헌
+[참고문헌1](https://ramees.tistory.com/52)
+
+[참고문헌2](https://hanyeop.tistory.com/356)
+
diff --git a/15/beom/SlidingWindow.pptx b/15/beom/SlidingWindow.pptx
new file mode 100644
index 0000000..a6b4d4c
Binary files /dev/null and b/15/beom/SlidingWindow.pptx differ
diff --git a/15/beom/assets/1.png b/15/beom/assets/1.png
new file mode 100644
index 0000000..c51691f
Binary files /dev/null and b/15/beom/assets/1.png differ
diff --git a/15/beom/assets/2.png b/15/beom/assets/2.png
new file mode 100644
index 0000000..ec114b7
Binary files /dev/null and b/15/beom/assets/2.png differ