개발 공부 기록

12/5 (화) D3.js로 그래프 자료구조 시각화하기 TIL

깊은바다거북 — Tue, 5 Dec 2023 15:04:50 +0900

다음과 같이 생긴 노드-간선 그래프를 그리려고 한다.

간선 데이터가 edges = [[1,2],[2,3],[3,4],[1,4],[1,5]] 와 같은 식으로 주어진다고 할 때, 그래프(Graph) 자료구조를 시각화하는 HTML, JS, CSS 코드는 다음과 같다(D3.js 라이브러리 활용):

<!DOCTYPE html>
<html>

<head>
	<title>Graph Visualization</title>
	<script src="https://d3js.org/d3.v3.min.js"></script>
	<style>
		.link {
			stroke: #999;
			stroke-opacity: 0.6;
		}

		.node {
			fill: #ccc;
			stroke: #fff;
			stroke-width: 1.5px;
		}
	</style>
</head>

<body>
	<script>
		// 간선 데이터
		var edges = [
			{ source: 1, target: 2 },
			{ source: 2, target: 3 },
			{ source: 3, target: 4 },
			{ source: 1, target: 4 },
			{ source: 1, target: 5 }
		];

		// 노드 데이터 생성
		var nodes = {};
		edges.forEach(function (edge) {
			edge.source = nodes[edge.source] || (nodes[edge.source] = { id: edge.source });
			edge.target = nodes[edge.target] || (nodes[edge.target] = { id: edge.target });
		});

		// SVG 요소의 크기
		var width = 800, height = 600;

		// D3.js force layout 설정
		var force = d3.layout.force()
			.nodes(d3.values(nodes))
			.links(edges)
			.size([width, height])
			.linkDistance(150)
			.charge(-800)
			.on("tick", tick)
			.start();

		// SVG 요소 추가
		var svg = d3.select("body").append("svg")
			.attr("width", width)
			.attr("height", height);

		// 간선을 SVG 선으로 표현
		var link = svg.selectAll(".link")
			.data(force.links())
			.enter().append("line")
			.attr("class", "link");

		// 노드를 SVG 원으로 표현
		var node = svg.selectAll(".node")
			.data(force.nodes())
			.enter().append("g")
			.attr("class", "node");

		node.append("circle")
			.attr("r", 20);  // 원의 반지름

		// 노드에 번호 표시
		node.append("text")
			.attr("dx", -4)
			.attr("dy", ".35em")
			.style("fill", "black")  // 글자 색을 검정색으로 설정
			.text(function (d) { return d.id; });

		// 애니메이션을 위한 tick 함수
		function tick() {
			link.attr("x1", function (d) { return d.source.x; })
				.attr("y1", function (d) { return d.source.y; })
				.attr("x2", function (d) { return d.target.x; })
				.attr("y2", function (d) { return d.target.y; });

			node.attr("transform", function (d) { return "translate(" + d.x + "," + d.y + ")"; });
		}
	</script>
	<h1>Hello</h1>
</body>

</html>

codePen에서 보기:
https://codepen.io/soa6318/pen/qBgLaxP

출처: LeetCode #684. Redundant Connection 와 Edge Copilot

Uploaded by N2T

11/14 (화) 대소문자를 모두 가지는 최장 부분 문자열 구하기 TIL

깊은바다거북 — Tue, 14 Nov 2023 17:44:21 +0900

공부한 것

LeetCode #1763. Longest Nice Substring
Longest Nice Substring - LeetCode
Can you solve this real interview question? Longest Nice Substring - A string s is nice if, for every letter of the alphabet that s contains, it appears both in uppercase and lowercase. For example, "abABB" is nice because 'A' and 'a' appear, and 'B' and 'b' appear. However, "abA" is not because 'b' appears, but 'B' does not. Given a string s, return the longest substring of s that is nice. If there are multiple, return the substring of the earliest occurrence. If there are none, return an empty string. Example 1: Input: s = "YazaAay" Output: "aAa" Explanation: "aAa" is a nice string because 'A/a' is the only letter of the alphabet in s, and both 'A' and 'a' appear. "aAa" is the longest nice substring. Example 2: Input: s = "Bb" Output: "Bb" Explanation: "Bb" is a nice string because both 'B' and 'b' appear. The whole string is a substring. Example 3: Input: s = "c" Output: "" Explanation: There are no nice substrings. Constraints: * 1 <= s.length <= 100 * s consists of uppercase and lowercase English letters.
https://leetcode.com/problems/longest-nice-substring/description/
- Divide and Conquer(분할 정복법)를 이해하기에 아주 좋은 다이어그램이 있어 가져와보았다:
  출처: https://leetcode.com/problems/longest-nice-substring/solutions/2237699/javascript-brute-force-and-divide-and-conquer-with-illustrations/
- 해답 코드:
```
// Divide and Conquer 풀이: 
function longestNiceSubstring2(s: string): string {
	// 탈출 조건: s의 길이가 0 혹은 1인 경우, 대-소문자 짝이 있을 수 없으므로 (최장 부분 문자열은)빈 문자열 반환.
	if (s.length < 2)
		return '';

	let arr = [...s];
	let set = new Set(arr);

	for (let i = 0; i < arr.length; i++) {
		const c = arr[i];
		// 현재 문자 c의 대소문자 버전이 모두 현재 부분 문자열 s에 존재하면: 현재 부분 문자열 s의 다음 문자 검사를 계속한다(=s를 둘로 쪼개지 않는다).  
		if (set.has(c.toUpperCase()) && set.has(c.toLowerCase()))
			continue;

		// 현재 문자 c의 대소문자가 현재 부분 문자열 s에 들어있지 않으면: 현재 문자 c를 기준으로 반절을 가른 부분 문자열 각각에서 최장 부분 문자열을 추출한다. s의 길이가 < 2에 도달할 때까지 반복하게 됨.
		const sub1: string = longestNiceSubstring2(s.substring(0, i));
		const sub2: string = longestNiceSubstring2(s.substring(i + 1));

		// 두 (최장)부분 문자열 중 길이가 더 긴 쪽을 반환한다.
		return sub1.length >= sub2.length ? sub1 : sub2;
	}

	return s;
}
```

Uploaded by N2T

11/3 (금) 합이 가장 큰 부분 배열 TIL

깊은바다거북 — Fri, 3 Nov 2023 20:31:55 +0900

공부한 것

LeetCode #53. Maximum Subarray
Maximum Subarray - LeetCode
Can you solve this real interview question? Maximum Subarray - Given an integer array nums, find the subarray with the largest sum, and return its sum. Example 1: Input: nums = [-2,1,-3,4,-1,2,1,-5,4] Output: 6 Explanation: The subarray [4,-1,2,1] has the largest sum 6. Example 2: Input: nums = [1] Output: 1 Explanation: The subarray [1] has the largest sum 1. Example 3: Input: nums = [5,4,-1,7,8] Output: 23 Explanation: The subarray [5,4,-1,7,8] has the largest sum 23. Constraints: * 1 <= nums.length <= 105 * -104 <= nums[i] <= 104 Follow up: If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.
https://leetcode.com/problems/maximum-subarray/description/
- 가장 신기하고 간결하다고 생각된 풀이를 첨부한다.
- 해답 코드:
```
// Time complexity: O(N)
// Space complexity: O(1) 
function maxSubArray3(nums: number[]): number {
	let localSum = 0;
	let maxSum = -Infinity;

	for (const num of nums) {
		// 지금 수와 지금 수를 부분 합계에 더한 값 중 더 큰 쪽을 새로운 부분 합계로 삼는다. 
		localSum = Math.max(num, localSum + num);
		// 만약 새로운 부분 합계가 최고 합계보다 더 크면 최고 합계를 업데이트한다. 
		if (localSum > maxSum) {
			maxSum = localSum;
		}
	}

	return maxSum;
}
```

Uploaded by N2T

11/2 (목) 쿼리를 포함하기 위한 최소 인터벌 TIL

깊은바다거북 — Thu, 2 Nov 2023 17:49:06 +0900

공부한 것

LeetCode #1851. Minimum Interval to Include Each Query

Minimum Interval to Include Each Query - LeetCode

https://leetcode.com/problems/minimum-interval-to-include-each-query/description/?source=submission-noac

최소 힙을 사용하니 걸리는 시간이 대폭 줄어들었다. ‘최소값’이라는 키워드가 나왔을 때 최소 힙을 떠올렸어야 했는데.

해답 코드:

function minInterval3(intervals: number[][], queries: number[]): number[] {
	const sortedQueries = queries.map((q, i) => [q, i]).sort((a, b) => a[0] - b[0]);
	intervals.sort((a, b) => a[0] - b[0]);

	const heap = new MinHeap();
	const result = new Array(queries.length);

	let i = 0; 

	for (const [query, index] of sortedQueries) {
		while (i < intervals.length && intervals[i][0] <= query) {
			const [start, end] = intervals[i];
			heap.insert([end - start + 1, end]);
			i++;
		}

		while (heap.size && query > heap.min[1]) {
			heap.remove();
		}

		result[index] = heap.size ? heap.min[0] : -1;
	}
	
	return result;
}


class MinHeap {
	private heap: [number, number][] = [];

	get min() {
		return this.heap[0];
	}

	get size() {
		return this.heap.length;
	}

	insert(val: [number, number]) {
		this.heap.push(val);
		this.bubbleUp(this.size - 1);
	}

	remove() {
		if (!this.size) return;

		this.swap(0, this.size - 1);
		const min = this.heap.pop();
		this.bubbleDown(0);
		return min;
	}

	// 현재 index 자리의 노드를 min heap 규칙에 맞도록 끌어올린다.
	private bubbleUp(index: number) {
		// 지금 자리가 루트(root)에 도달하거나, 부모의 size값 이상이 될 때까지 반복 
		while (index > 0) {
			const parentIndex = Math.floor((index - 1) / 2);

			// 지금 자리의 size값이 부모 자리의 size값보다 작을 때만 자리 교체
			if (this.heap[index][0] < this.heap[parentIndex][0]) {
				this.swap(index, parentIndex);
				index = parentIndex;
			} else {
				break;
			}
		}
	}

	// 현재 index 자리의 노드를 min heap 규칙에 맞도록 끌어내린다.
	private bubbleDown(index: number) {
		// 지금 자리가 힙의 끝에 도달하거나, 두 자식의 size값 미만이 될 때까지 반복
		while (index < this.size) {
			const leftChildIndex = index * 2 + 1;
			const rightChildIndex = index * 2 + 2;
			let smallest = index;

			if (leftChildIndex < this.size && this.heap[leftChildIndex][0] < this.heap[smallest][0])
				smallest = leftChildIndex;
			
			if (rightChildIndex < this.size && this.heap[rightChildIndex][0] < this.heap[smallest][0])
				smallest = rightChildIndex;

			if (index === smallest) break;

			this.swap(index, smallest);
			index = smallest;
		}
	}

	private swap(i: number, j: number) {
		[this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
	}
}

Uploaded by N2T

10/28 (토) (완료)인터벌이 안 겹치도록 삭제해야 하는 최소 인터벌 개수 TIL

깊은바다거북 — Sat, 28 Oct 2023 10:48:27 +0900

공부한 것

LeetCode #435. Non-overlapping Intervals
Non-overlapping Intervals - LeetCode
Can you solve this real interview question? Non-overlapping Intervals - Given an array of intervals intervals where intervals[i] = [starti, endi], return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping. Example 1: Input: intervals = [[1,2],[2,3],[3,4],[1,3]] Output: 1 Explanation: [1,3] can be removed and the rest of the intervals are non-overlapping. Example 2: Input: intervals = [[1,2],[1,2],[1,2]] Output: 2 Explanation: You need to remove two [1,2] to make the rest of the intervals non-overlapping. Example 3: Input: intervals = [[1,2],[2,3]] Output: 0 Explanation: You don't need to remove any of the intervals since they're already non-overlapping. Constraints: * 1 <= intervals.length <= 105 * intervals[i].length == 2 * -5 * 104 <= starti < endi <= 5 * 104
https://leetcode.com/problems/non-overlapping-intervals/description/
- 방법 2(포기): 시작점 기준으로 오름차순 정렬한 후에, 인접한 두 인터벌이 겹치면 둘 중 길이가 더 긴 쪽을 삭제하는 식으로 전체 인터벌을 순회하는 방법. 두 인터벌이 겹치는데 두 길이가 같으면 둘 중 더 뒤쪽에 있는 인터벌을 삭제한다. ⇒ 다음 경우와 같이 이미 삭제하고 지나친 인터벌이 나중에 필요해지는 경우가 생긴다.
- 방법 3(성공): 끝점 기준으로 오름차순 정렬하고 첫 인터벌을 선택한 후, 그 다음부터 '이전 인터벌의 끝'과 겹치지 않는 가장 가까운 인터벌을 찾아 선택하기를 반복한다. 마지막에는 총 인터벌 개수에서 선택한 인터벌 수를 뺀 값을 반환하면 된다.
  - 방법 3 코드:
```
// Time Complexity: O(n log n)
// Space Complexity: O(log n) 
function eraseOverlapIntervals(intervals: number[][]): number {
	if (intervals.length === 1) return 0;

	intervals.sort((a, b) => a[1] - b[1]);
	let end = intervals[0][1]; // 정렬 후 첫 인터벌은 선택하고 시작
	let count = 1; // result[]에 넣는 대신 숫자로 셈(=제거하지 않는 인터벌의 수 = '선택'한 인터벌의 수)

	for (let i = 1; i < intervals.length; i++) {
		const currentStart = intervals[i][0];

		// 현재 인터벌이 이전 인터벌과 겹치지 안으면 현재 인터벌을 (제거하지 않는 것으로) '선택'한다. 
		if (currentStart >= end) {
			// '선택': count를 1 늘이고 end를 업데이트함
			count++;
			end = intervals[i][1]; 
		}
	}

	// 전체 인터벌에서 제거하지 않는 총 인터벌 수를 빼 반환한다. 
	return intervals.length - count;
}
```

Uploaded by N2T

10/27 (금) 인터벌이 안 겹치도록 삭제해야 하는 최소 인터벌 개수 TIL

깊은바다거북 — Fri, 27 Oct 2023 19:26:27 +0900

공부한 것

LeetCode #435. Non-overlapping Intervals
Non-overlapping Intervals - LeetCode
Can you solve this real interview question? Non-overlapping Intervals - Given an array of intervals intervals where intervals[i] = [starti, endi], return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping. Example 1: Input: intervals = [[1,2],[2,3],[3,4],[1,3]] Output: 1 Explanation: [1,3] can be removed and the rest of the intervals are non-overlapping. Example 2: Input: intervals = [[1,2],[1,2],[1,2]] Output: 2 Explanation: You need to remove two [1,2] to make the rest of the intervals non-overlapping. Example 3: Input: intervals = [[1,2],[2,3]] Output: 0 Explanation: You don't need to remove any of the intervals since they're already non-overlapping. Constraints: * 1 <= intervals.length <= 105 * intervals[i].length == 2 * -5 * 104 <= starti < endi <= 5 * 104
https://leetcode.com/problems/non-overlapping-intervals/description/
- 방법 1(포기): 인터벌이 어떤 인터벌과 겹치는지 인터벌 각각에 대하여 ‘겹침 목록’을 만든다. 예를 들어 인덱스 0번 인터벌이 1번, 2번, 10번 인덱스의 인터벌과 겹친다면 0과 set(1, 2, 10)을 묶어두는 자료구조를 사용한다. 그 후 가장 겹침이 많은 인터벌을 삭제하고, 연관된 다른 인터벌들에서도 이 인덱스 번호를 전부 삭제한다. 그 다음으로 겹침 수가 많은 인터벌을 삭제하고 연관된 목록에서도 이 인덱스를 삭제하기를 반복해서, 모든 인터벌의 겹침 수가 0이 되면 반복을 중지한다. 남은 인터벌의 개수를 전체 개수에서 뺀 수가 제거한 인터벌의 수가 되며, 이 것을 반환한다.
- 방법 2(진행중): 시작점 기준으로 오름차순 정렬한 후에, 인접한 두 인터벌이 겹치면 둘 중 길이가 더 긴 쪽을 삭제하는 식으로 전체 인터벌을 순회하는 방법. 두 인터벌이 겹치는데 두 길이가 같으면 둘 중 더 뒤쪽에 있는 인터벌을 삭제한다. ⇒ 규칙에 뭔가 허점이 있지 않을까 했는데 아니나 다를까 에러 케이스에 걸려 파악 중이다.
  - 코드
```
function eraseOverlapIntervals(intervals: number[][]): number {
	// 0. 인터벌이 하나 뿐이면 삭제할 것 없음. 0을 조기 리턴.
	if (intervals.length === 1) return 0;

	// 1. 정렬
	intervals.sort((a, b) => a[0] - b[0]);

	// 2. 순회
	const result = [intervals[0]];
	for (let i = 1; i < intervals.length; i++) {
		let pre = result[result.length - 1];
		let post = intervals[i];

		if (pre[1] > post[0]) { // 두 인터벌이 겹침
			// pre가 변경되어야 하는 경우: pre 간격이 더 길 때
			// (post가 '빠져야' 하는 경우라면 그냥 result에 안 넣으면 되므로 아무 조치 x)
			if (pre[1] - pre[0] > post[1] - post[0]) {
				// pre를 삭제하고 post를 넣는다. 
				result.pop();
				result.push(post);
			}	
		}
		else { // 두 인터벌이 겹치지 않음
			// 지금 post 넣기
			result.push(post);
		}
	}

	// 3. 반환
	return intervals.length - result.length;
};
```

Uploaded by N2T

10/26 (목) 겹치는 인터벌 합치기 TIL

깊은바다거북 — Thu, 26 Oct 2023 14:22:21 +0900

공부한 것

LeetCode #56. Merge Interval

LeetCode - The World's Leading Online Programming Learning Platform

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

https://leetcode.com/problems/merge-intervals/submissions/

어제는 이미 정렬된 인터벌들에 새 인터벌을 하나 끼우는 방식으로, 전체를 한 번만 순회하기 때문에 시간 복잡도는 $O(n)$ 이면 되었다.

오늘은 정렬되지 않은 전체 인터벌을 겹치는 것끼리 병합하는 문제로, 먼저 정렬 후 전체를 한 번 순회해야 하기 때문에 시간 복잡도가 $O(n log n)$ 이다.

방법 1: 반환할 인터벌들을 새 배열 result에 넣는 방법

// Time Complexity: O(n log n)
// Space Complexity: O(n) 
function merge1(intervals: number[][]): number[][] {
	if (intervals.length === 1) return intervals;
	
	// 1. start 기준으로 오름차순 정렬하기: O(N logN)
	intervals.sort((a, b) => a[0] - b[0]);
	const result = [intervals[0]];

	// 2. 어느 두 연이은 인터벌 중 앞의 end가 뒤의 start보다 크거나 같으면 병합한다: O(N)
	for (let i = 1; i < intervals.length; i++) {
		const pre = result[result.length - 1];
		const post = intervals[i];
		if (pre[1] >= post[0]) { // 병합하기
			pre[1] = Math.max(pre[1], post[1]);
		} else { // 새 인터벌 등장. result에 넣기
			result.push(post);
		}
	}

	return result;
};

방법 2: result 배열을 사용하지 않는 방법

// 새 result 배열 없이 해보기:
// Time Complexity: O(n log n)
// Space Complexity: O(log n) (in-place sorting을 하므로)
function merge(intervals: number[][]): number[][] {
	if (intervals.length === 1) return intervals;	
	
	// 1. start 기준으로 오름차순 정렬하기: O(N logN)
	intervals.sort((a, b) => a[0] - b[0]);

	// 2. 어느 두 연이은 인터벌 중 앞의 end가 뒤의 start보다 크거나 같으면 병합한다: O(N)
	let pre = intervals[0];
	for (let i = 1; i < intervals.length; i++) {
		const post = intervals[i];
		if (pre[1] >= post[0]) { // 병합하기
			pre[1] = Math.max(pre[1], post[1]);
			delete intervals[i]; // delete post;는 안 됨 주의
		} else { // 새 인터벌 등장. pre를 새 인터벌로 옮긴다.
			pre = post;			
		}
	}

	return intervals.filter(x => true);
};

결과: 방법 1과 방법 2에서 유의미한 메모리 차이는 발생하지 않음.

Uploaded by N2T

10/25 (수) (완료)인터벌 끼워넣기 TIL

깊은바다거북 — Wed, 25 Oct 2023 22:04:31 +0900

공부한 것

LeetCode #57. Insert Interval

Insert Interval - LeetCode

Can you solve this real interview question? Insert Interval - You are given an array of non-overlapping intervals intervals where intervals[i] = [starti, endi] represent the start and the end of the ith interval and intervals is sorted in ascending order by starti. You are also given an interval newInterval = [start, end] that represents the start and end of another interval. Insert newInterval into intervals such that intervals is still sorted in ascending order by starti and intervals still does not have any overlapping intervals (merge overlapping intervals if necessary). Return intervals after the insertion. Example 1: Input: intervals = [[1,3],[6,9]], newInterval = [2,5] Output: [[1,5],[6,9]] Example 2: Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8] Output: [[1,2],[3,10],[12,16]] Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10]. Constraints: * 0 <= intervals.length <= 104 * intervals[i].length == 2 * 0 <= starti <= endi <= 105 * intervals is sorted by starti in ascending order. * newInterval.length == 2 * 0 <= start <= end <= 105

https://leetcode.com/problems/insert-interval/description/

방법 2(통과): 반환할 새 배열을 만들고, 통합된 새 시작점과 새 끝점을 구하여 이 사이의 점 들을 제외한 나머지 점들을 옮겨담아 반환하는 방식. 방법 1보다 확실히 빨라졌다. 다만 메모리 사용이 조금 많음.

방법3(통과): 시간, 공간, 가독성 모두 좋은데 가독성이 가장 발군인 풀이법. 방법1이나 방법2와 아이디어가 같은데 math.Max()와 math.Min()을 활용해 새 인터벌의 시점과 끝점을 점점 양옆으로 확장해나가는 방식을 사용한 것이 눈에 띈다.

방법 2 풀이 코드:

/* 대략적인 아이디어: 
	 새롭게 배열을 만든다. 통합된 시작점 전의 점까지를 넣고, 통합된 시작점을 넣고, 이후 점들은 건너뜀. 이후 통합된 끝점와 그 이후의 점들을 넣고서 두 짝씩 묶는다. 틀림없이 두 짝이 맞게 되며, 반환한다. 
*/ 
function insert2(intervals: number[][], newInterval: number[]): number[][] {
	// 0. 
	if (!intervals.length) return [newInterval];

	// 편하게 하기 위해 intervals를 평면화시킴([[1,3],[6,9]] => [1,3,6,9])
	const dots = intervals.flatMap((interval) => interval);

	const result = [];
	const [newStart, newEnd] = newInterval;
	let newStartFound = false, newEndFound = false;
	let i = 0; 
	
	// newStart이 나타나는 지점 찾기
	for (; i < dots.length; i++) {
		if (dots[i] >= newStart) {
			if (dots[i] !== newStart && i % 2 === 0) { // 간격 '외'임
				result.push(newStart);
			} else { // 간격 '내'임. 
				if (dots[i] === newStart && i % 2 === 0) { // 지금 i를 '시작점'으로 삼고 이후 나타나는 점들을 건너뛴다. 
					// = i번째 점은 넣어줌.
					result.push(dots[i]);
				} else { // i 이전 점을 '시작점'으로 삼는다
					// = i부터 건너뜀	
				}
			}
			newStartFound = true;
			break;
		}
		// newStart이 나타나기 전까지는 점들을 다 넣어준다. 
		else {
			result.push(dots[i]);
		}
	}

	// newEnd가 나타나는 지점 찾기
	for (; i < dots.length; i++) {
		if (dots[i] >= newEnd) {
			if (dots[i] !== newEnd && i % 2 === 0) { // 간격 '외'임
				result.push(newEnd);
			} else {
				if (dots[i] === newEnd && i % 2 === 0) { // i 다음 점을 '끝점'으로 삼는다 = i까지 건너뛴다
					i++;
				} else { // i를 '끝점'으로 삼는다 = 점 i는 추가한다.
					// result.push(dots[i]);
				}
			}
			newEndFound = true;
			break;
			// FIXME: break하기 전에 점이 겹치지 않았으면 i--를 해줘야 함.
			// 		=> i++를 넣어주고, result.push(dots[i])를 주석 처리해준 후, 루프 바깥에서 result.push(...dots.slice(i+1))을 slice(i)로 바꿔줌으로써 달성함. 
		}
		// newEnd가 나타나기 전까지는 점들을 다 건너뛴다.
	}

	// newEnd 이후 점들을 다 넣어주기
	result.push(...dots.slice(i));
	
	// dots의 끝점에 도달할때까지 newStart이나 newEnd를 찾을 수 없는 경우
	if (!newStartFound)
		// 제일 마지막에 newIntervals의 두 점을 넣어준다
		result.push(newStart, newEnd);
	else if (!newEndFound)
		// 끝점 newEnd만 추가해준다. 
		result.push(newEnd);
	
	// 최종 점들을 두 짝씩 묶어서 반환하기
	const newIntervals = []
	for (let i = 0; i < result.length; i += 2) {
		newIntervals.push([result[i], result[i + 1]]);
	}
	return newIntervals;
}

방법 3 풀이 코드:

// 전과 같은 아이디어이나 가독성이 좋은: 
function insert4(intervals: number[][], newInterval: number[]): number[][] {
	const newIntervals = [];
	const m = intervals.length;
	let i = 0;

	while (i < m && intervals[i][1] < newInterval[0]) {
		newIntervals.push(intervals[i]);
		i++;
	}
	
	while (i < m && intervals[i][0] <= newInterval[1]) {
		newInterval[0] = Math.min(intervals[i][0], newInterval[0]);
		newInterval[1] = Math.max(intervals[i][1], newInterval[1]);
		i++;
	}

	newIntervals.push(newInterval);

	while (i < m) {
		newIntervals.push(intervals[i]);
		i++;
	}

	return newIntervals;
}

결과:

풀이 1과 비교:

Uploaded by N2T

10/24 (화) 인터벌 끼워넣기 TIL

깊은바다거북 — Tue, 24 Oct 2023 21:02:34 +0900

공부한 것

LeetCode #57. Insert Interval

Insert Interval - LeetCode

https://leetcode.com/problems/insert-interval/description/

방법 1: 생각의 흐름대로 로직을 구성하여 답을 내놓음 ⇒ intervals 목록을 필요할 때마다 반복해서 순회하기 때문에 테스트에 통과는 하지만 시간 효율이 좋지 못함. 리팩토링 필요.

방법 1 풀이 코드:

/* 대략적인 아이디어: 
	^ 1. 새로 들어오는 인터벌의 시작과 끝을 재정립하기
				1) 새 인터벌의 시점: 
					만약 기존의 인터벌의 간격 이내라면(시작과 끝 포함), 그 인터벌의 시작지점으로 새 인터벌의 시작을 옮긴다. 새 인터벌의 시점이 어떤 인터벌에도 속하지 않는다면 그대로 둔다. 
				2) 새 인터벌의 종점: 
					만약 어떤 인터벌의 중간 지점이거나 시작지점과 만난다면 그 인터벌의 끝을 새로운 종점으로 설정한다. 만약 어떤 인터벌의 끝과 만나거나 어떤 인터벌과도 접하지 않는다면, 그대로 둔다. 
	^ 2. 수정한 '새 인터벌'의 시점과 종점을 기존 목록과 비교하기
				1) 기존 목록의 종점이 새 것의 종점보다 작은 동안 루프를 돈다:
					시점이 새 것의 시점과 같거나 큰 경우 그 인터벌을 삭제 대상으로 포함.
	^ 3. 찾은 '삭제 대상' 지우기 및 수정한 '새 인터벌' 삽입
				어떻게 하면 더 효과적으로 처리할 수 있을까
*/
function insert2(intervals: number[][], newInterval: number[]): number[][] {
	if (intervals.length === 0) return [newInterval];
	
	// 1-1. 새 인터벌의 시점 수정하기
	let [newStart, newEnd] = newInterval;
	let i = 0;
	for (; i < intervals.length; i++) {
		let [start, end] = intervals[i];
		if (newStart >= start && newStart <= end) {
			// 기존 인터벌의 간격 이내일 때, 시점 수정
			newStart = start;
			break;
		}
	}
	// 1-2. 새 인터벌의 종점 수정하기
	for (; i < intervals.length; i++) { // 새 인터벌이 '시작'한 부분부터 검사 시작
		let [start, end] = intervals[i];
		if (newEnd >= start && newEnd <= end) {
		// 기존 인터벌의 시점과 같거나 간격 내일 때(종점 미포함)(종점 포함해도 상관없음)
			newEnd = end;
			break;
		}
	}
	// 1-3. 새 인터벌의 시작점은 기존 인터벌에 포함되지 않지만 종점은 포함되어 있을 때: 새 인터벌의 시점은 그대로 두고 종점만 그 지점으로 옮긴다
	for (let i = 0; i < intervals.length; i++) {
		let [start, end] = intervals[i];
		if (newEnd >= start && newEnd <= end) {
			newEnd = end;
			break;
		}
	}
	// 2. 수정한 '새 인터벌'의 시점과 종점을 기존 목록과 비교하기
	let j = 0; 
	let [start, end] = intervals[j];
	let hasReplaced = false;

	// 기존 인터벌의 종점이 새것과 같은 것을 발견할 때까지
	while (end <= newEnd && j < intervals.length) {
		if (start >= newStart) {
			// 처음 '삭제 대상'을 발견한 자리에 수정한 '새 인터벌'을 덮어씌운다.
			if (!hasReplaced) {
				intervals[j] = [newStart, newEnd];
				hasReplaced = true;
			} 
			// 이후 발견하는 '삭제 대상'들은 그냥 삭제한다.
			else 
				delete intervals[j];
			// 이후 .filter(x=>true)로 반환
		}
		[start, end] = intervals[++j] ?? [null, null];
	}

	intervals = intervals.filter(x => true)

	// 3. '대체할' 기존 인터벌을 찾지 못했어도 넣어야 한다.
	if (!hasReplaced) {
		for (let j = 0; j < intervals.length; j++) {
			if (newStart < intervals[j][0]) {
				intervals = [...intervals.slice(0, j), [newStart, newEnd], ...intervals.slice(j)];
				hasReplaced = true;
				break;
			}
		}
	}
	if (!hasReplaced)
		intervals.push([newStart, newEnd]);

	return intervals;
};

Uploaded by N2T

10/23 (월) (완료)스트림에서 중위값 찾기 TIL

깊은바다거북 — Mon, 23 Oct 2023 22:35:05 +0900

공부한 것

LeetCode #295. Find Median from Data Stream

Find Median from Data Stream - LeetCode

Can you solve this real interview question? Find Median from Data Stream - The median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value, and the median is the mean of the two middle values. * For example, for arr = [2,3,4], the median is 3. * For example, for arr = [2,3], the median is (2 + 3) / 2 = 2.5. Implement the MedianFinder class: * MedianFinder() initializes the MedianFinder object. * void addNum(int num) adds the integer num from the data stream to the data structure. * double findMedian() returns the median of all elements so far. Answers within 10-5 of the actual answer will be accepted. Example 1: Input ["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"] [[], [1], [2], [], [3], []] Output [null, null, null, 1.5, null, 2.0] Explanation MedianFinder medianFinder = new MedianFinder(); medianFinder.addNum(1); // arr = [1] medianFinder.addNum(2); // arr = [1, 2] medianFinder.findMedian(); // return 1.5 (i.e., (1 + 2) / 2) medianFinder.addNum(3); // arr[1, 2, 3] medianFinder.findMedian(); // return 2.0 Constraints: * -105 <= num <= 105 * There will be at least one element in the data structure before calling findMedian. * At most 5 * 104 calls will be made to addNum and findMedian. Follow up: * If all integer numbers from the stream are in the range [0, 100], how would you optimize your solution? * If 99% of all integer numbers from the stream are in the range [0, 100], how would you optimize your solution?

https://leetcode.com/problems/find-median-from-data-stream/

방법 1: 이진 트리로 스트림 데이터(숫자들)를 넣은 후 중위 순회를 반 진행하여 중위값을 반환하기 ⇒ 시간 초과로 해답이 통과하지 못함.

방법 2: 최대 힙에 더 작은 수를, 최소 힙에 더 큰 수들을 나누어 담은 후 각 힙에서 O(1) 시간으로 얻을 수 있는 최대값과 최소값으로 중위값을 구하기 ⇒ 통과함

방법 2 풀이 코드:

최대 힙과 최소 힙을 따로 구현하였다. leetcode에서 직접 풀 때는 디폴트로 제공되는 priority queue나 queue를 사용할 수도 있다(참고: “언어별 환경(사용 가능한 라이브러리 구성)에 대하여”)

최소 힙 코드:

class MinHeap {
    private heap: number[];

    constructor() {
        this.heap = [];
    }

    //^ 삽입한 요소를 힙 구조에 맞게 위치 조정(heapify) - Bubble up
    // Time complexity: O(log N)
    // Space complexity: O(1)
    private bubbleUp() {
        // 마지막 요소에서 시작. 부모와 교체할 때마다 그 위치로 index 값이 조정됨. 그렇게 업데이트되는 바뀌는 위치가 root 노드에 도달하기까지 아래 루프를 반복한다.
        let index = this.heap.length - 1;
        while (index > 0) {
            // 해당 요소의 부모 노드 위치를 계산해서 그 값을 parent로 지정한다. heap은 왼쪽부터 꽉꽉 채워서 차례로 들어가는 반 완전 이진 트리(?)로 본다. 
            const element = this.heap[index];
            const parentIndex = Math.floor((index - 1) / 2);
            const parent = this.heap[parentIndex];

            // 새로 삽입한 요소와 부모 노드를 비교하여 위치를 조정:
            // 만약 지금 요소가 부모보다 크거나 같으면 전체 루프를 멈춘다. 
            if (element >= parent) break;

            // 만약 부모보다 값이 작으면 자리를 바꾼다.
            this.heap[index] = parent;
            this.heap[parentIndex] = element;

            // (부모와 바꿔서) 새롭게 위치한 자리를 새로운 index로 삼는다. 
            index = parentIndex;
            
            // 자신보다 작은 부모를 만나거나 루트에 도달하기까지 과정을 반복한다.
        }
    }

    //^ 추출한 요소를 힙 구조에 맞게 위치 조정(heapify) - Bubble Down
    // Time complexity: O(log N)
    // Space complexity: O(1)
    private bubbleDown() {
        // 앞의 요소부터 시작한다.
        let index = 0;
        const element = this.heap[index];

        // 무한 루프를 돌면서
        while (true) {
            // 현재 요소의 두 자식 위치를 구한다.
            const leftChildIndex = index * 2 + 1;
            const rightChildIndex = index * 2 + 2;
            let leftChild, rightChild;
            let swapTarget = null;

            // 각 자식마다, 자식의 위치가 실제 존재하는 노드라면(=heap의 길이 내라면) 그 값을 leftChild, rightChild에 저장한다. 또 각 자식이 현재 요소보다 작으면 자리를 바꿔야 하므로, 바꿀 타겟이 되는 위치 변수 swapTarget에 자식의 위치를 따로 저장한다. 
            if (leftChildIndex < this.heap.length) {
                leftChild = this.heap[leftChildIndex];
                if (leftChild < element) {
                    swapTarget = leftChildIndex;
                }
            }

            // 그래서 만약 "왼 자식은 그대로 두고 오른 자식만 바꿔야 하든지", "왼 자식도 바꿔야 하는데 오른 자식이 왼보다 더 작다면(더 작은 쪽을 위로 올려야 하므로)" 오른 자식을 바꿀 대상 swapTarget으로 삼는다. 
            if (rightChildIndex < this.heap.length) {
                rightChild = this.heap[rightChildIndex];
                if ((!swapTarget && rightChild < element) ||
                    (swapTarget && rightChild < leftChild)) {
                    swapTarget = rightChildIndex;
                }
            }
            
            // 교체할 대상이 없다면 현재 루프를 break한다. 루프 전체에서 break하는 부분이 여기뿐으로, 두 자식 중 더이상 바꿀 대상이 없는 경우에만 무한 루프를 멈추게 된다. 
            if (!swapTarget) break;

            // 교체할 대상이 있다면 현재 노드와 교체한다. 
            this.heap[index] = this.heap[swapTarget];
            this.heap[swapTarget] = element;

            // 다시 '현재 요소'의 위치를 바꾼 타겟 위치로 지정하고 루프를 계속한다. 
            index = swapTarget;
        }
    }

    //^ 요소를 삽입
    // Time & Space complexity: bubbleUp()과 동일
    insert(value: number) {
        // heap배열의 마지막에 요소를 삽입하고, 알맞은 위치로 찾아가도록 this.bubbleUp() 활용
        this.heap.push(value);
        this.bubbleUp();
    }

    //^ 최소 요소 추출
    // Time & Space complexity: bubbleDown()과 동일
    popMin() {
        // 제일 앞의 요소가 반환 대상이다.(아직 안뽑음)
        const min = this.heap[0];
        // 제일 뒤의 요소를 뽑고서(?) 만약 heap이 비게 됐다면 이게 곧 반환할 최소값이라는 소리이므로 그대로 반환한다. 
        const end = this.heap.pop();

        // 만약 heap 길이가 아직 0이 아니면 뽑은 수를 제일 앞 자리로 덮어씌워준다. 그리고 거기서부터 bubbleDown해서 제자리를 찾도록 한다.
        if (this.heap.length > 0) {
            this.heap[0] = end;
            this.bubbleDown();
        }

        return min;
    }

    //^ 힙의 길이를 반환
    getLength() {
        return this.heap.length;
    }

    //^ 최소값을 반환(추출 없이)
    getMin() {
        return this.heap[0];
    }
}

최대 힙 코드:

// MinHeap과 거의 비슷하므로 주석은 생략한다.
class MaxHeap {
	private heap: number[]

	constructor() {
		this.heap = [];
	}

	//^ heap의 맨 끝 요소를 제자리로 끌어올리기
	private bubbleUp() {
		// 부모와 비교하여 더 클 때만 자리를 교체한다.
		let index = this.heap.length - 1;

		while (index > 0) {
			let element = this.heap[index];
			let parentIndex = Math.floor((index - 1) / 2);
			let parent = this.heap[parentIndex];
			
			if (element <= parent) break;
			
			this.heap[parentIndex] = element;
			this.heap[index] = parent;
			
			index = parentIndex;
		}
	}
	
	//^ heap의 맨 앞 요소를 제자리로 끌어내리기
	private bubbleDown() {
		// 존재하는 자식 중 나보다 더 큰 최대 자식과 자리를 교체한다. 
		let index = 0;
		const element = this.heap[index];
		
		while (true) {
			let leftChildIndex = index * 2 + 1;
			let rightChildIndex = index * 2 + 2;
			let leftChild, rightChild;
			let swapTarget = null;

			if (leftChildIndex < this.heap.length) {
				leftChild = this.heap[leftChildIndex];
				if (element < leftChild) {
					swapTarget = leftChildIndex;
				}
			}
			if (rightChildIndex < this.heap.length) {
				rightChild = this.heap[rightChildIndex];
				if ((swapTarget === null && element < rightChild) ||
					(swapTarget !== null && leftChild < rightChild)) {
					swapTarget = rightChildIndex;
				}
			}

			if (swapTarget === null) break;

			this.heap[index] = this.heap[swapTarget];
			this.heap[swapTarget] = element;

			index = swapTarget;
		}

	}

	//^ 요소를 삽입
	insert(num: number) {
		this.heap.push(num);
		this.bubbleUp();
	}

	//^ 최대 요소 추출
	popMax() {
		const max = this.heap[0];
		const end = this.heap.pop();
		if (this.heap.length > 0) {
			this.heap[0] = end;
			this.bubbleDown();
		}
		return max;
	}

	getLength() {
		return this.heap.length;
    }
    
    getMax() {
        return this.heap[0];
    }
}

/* 
 ^ 필요 자료 구조: Min heap과 Max heap
 ^ addNum의 로직: 
    1. 추가하려는 수가 현재 min heap의 .getMin()과 같거나 더 크면 min heap에 넣고, 더 작으면 max heap에 넣는다. 
    2. 새 수를 추가하고서 두 힙의 길이가 2 이상 차이 나면, 더 긴 쪽에서 .pop()하여 반대쪽에 넣어준다.
    3. 처음엔(두 힙 모두 길이가 0이면) min heap에 넣어준다. 
	  => O(2 log N)

 ^ findMedian의 로직: 
    1. finMdeian()이 불린 시점에서 두 힙의 길이가 같으면 각각의 min과 max를 get()하여 평균을, 둘의 길이가 다르면 더 긴 쪽에서 get()한 값을 반환한다. 
    => O(1)
*/
class MedianFinder {
    minHeap: MinHeap
    maxHeap: MaxHeap
    constructor() {
        this.minHeap = new MinHeap();
        this.maxHeap = new MaxHeap();
    }

    addNum(num: number) {
        if (num < this.minHeap.getMin())
            this.maxHeap.insert(num);
        else
            this.minHeap.insert(num);
        // initially(when both lengths are 0), the number goes to the min heap naturally. 

        const minLength = this.minHeap.getLength();
        const maxLength = this.maxHeap.getLength();
        if (minLength - maxLength >= 2) { // min heap에서 뽑아서 max heap으로
            const popped = this.minHeap.popMin();
            this.maxHeap.insert(popped);
        }
        if (maxLength - minLength >= 2) { // max heap에서 뽑아서 min heap으로
            const popped = this.maxHeap.popMax();
            this.minHeap.insert(popped);
        }
    }

    findMedian(): number {
        const minLength = this.minHeap.getLength();
        const maxLength = this.maxHeap.getLength();
        const min = this.minHeap.getMin();
        const max = this.maxHeap.getMax();
        if (minLength === maxLength)
            return (min + max) / 2;
        return (minLength > maxLength) ? min : max;
    }
}

Uploaded by N2T