코딩가딩가딩

블로그 이사

코딩뽀시래기 — Sat, 19 Oct 2024 21:33:49 +0900

티스토리 글 작성이 좀 불편해서 더 안 쓰게 되는 느낌이라 Velog로 이사를 가야겠다...

옮기면서 기존에 좀 이상하게 작성했던 내용들도 정리를 해야지

https://velog.io/@jung0115

jung0115 (jmi) / 작성글 - velog

I want to be a developer ✨

velog.io

[백준/JavaScript] 거짓말(1043)

코딩뽀시래기 — Sat, 17 Aug 2024 23:01:12 +0900

문제

https://www.acmicpc.net/problem/1043

지민이는 파티에 가서 이야기 하는 것을 좋아한다. 파티에 갈 때마다, 지민이는 지민이가 가장 좋아하는 이야기를 한다. 지민이는 그 이야기를 말할 때, 있는 그대로 진실로 말하거나 엄청나게 과장해서 말한다. 당연히 과장해서 이야기하는 것이 훨씬 더 재미있기 때문에, 되도록이면 과장해서 이야기하려고 한다. 하지만, 지민이는 거짓말쟁이로 알려지기는 싫어한다. 문제는 몇몇 사람들은 그 이야기의 진실을 안다는 것이다. 따라서 이런 사람들이 파티에 왔을 때는, 지민이는 진실을 이야기할 수 밖에 없다. 당연히, 어떤 사람이 어떤 파티에서는 진실을 듣고, 또다른 파티에서는 과장된 이야기를 들었을 때도 지민이는 거짓말쟁이로 알려지게 된다. 지민이는 이런 일을 모두 피해야 한다.

사람의 수 N이 주어진다. 그리고 그 이야기의 진실을 아는 사람이 주어진다. 그리고 각 파티에 오는 사람들의 번호가 주어진다. 지민이는 모든 파티에 참가해야 한다. 이때, 지민이가 거짓말쟁이로 알려지지 않으면서, 과장된 이야기를 할 수 있는 파티 개수의 최댓값을 구하는 프로그램을 작성하시오.

[ 입력 ]

첫째 줄에 사람의 수 N과 파티의 수 M이 주어진다.

둘째 줄에는 이야기의 진실을 아는 사람의 수와 번호가 주어진다. 진실을 아는 사람의 수가 먼저 주어지고 그 개수만큼 사람들의 번호가 주어진다. 사람들의 번호는 1부터 N까지의 수로 주어진다.

셋째 줄부터 M개의 줄에는 각 파티마다 오는 사람의 수와 번호가 같은 방식으로 주어진다.

N, M은 50 이하의 자연수이고, 진실을 아는 사람의 수는 0 이상 50 이하의 정수, 각 파티마다 오는 사람의 수는 1 이상 50 이하의 정수이다.

[ 출력 ]

첫째 줄에 문제의 정답을 출력한다.

풀이

// 백준 - 거짓말(1043)
let N, M;
let knowTrue;
let partyGraph;
let visited;

const find = (x) => {
  if (parent[x] === x) return x;
  return parent[x] = find(parent[x]);
}

const union = (x, y) => {
  x = find(x);
  y = find(y);
  if (x !== y) {
    parent[y] = x;
  }
}

const solution = ( input ) => {
  [ N, M ] = input.shift().split(' ').map((o) => parseInt(o));
  parent = Array(N + 1).fill(0).map((_, idx) => idx);

  let trueInfo = input.shift().split(" ").map(Number);
  let trueCount = trueInfo[0];
  let truePeople = trueInfo.slice(1);

  let parties = [];
  
  for (let i = 0; i < M; i++) {
    let line = input[i].split(' ').map(Number);
    let partySize = line[0];
    let partyMembers = line.slice(1);
    parties.push(partyMembers);

    for (let j = 1; j < partySize; j++) {
      union(partyMembers[0], partyMembers[j]);
    }
  }

  // 진실을 아는 사람들끼리도 합치기
  let trueRoot = truePeople[0];
  for (let i = 1; i < trueCount; i++) {
    union(trueRoot, truePeople[i]);
  }

  // 과장된 이야기를 할 수 있는 파티의 수를 센다
  let answer = 0;
  for (let i = 0; i < M; i++) {
    let party = parties[i];
    let possible = true;

    for (let j = 0; j < party.length; j++) {
      if (find(party[j]) === find(trueRoot)) {
        possible = false;
        break;
      }
    }

    if (possible) answer++;
  }

  console.log(answer);;
}

const checkParent = ( person ) => {
  for(let i = 1; i <= N; i++) {
    if(!visited[i] & partyGraph[person][i]) {
      visited[i] = true;

      if(knowTrue[i]) return true;
      if(checkParent(i)) return true;
    }
  }

  return false;
}

/*
테스트용: __dirname + '/input.txt'
제출용: '/dev/stdin'
*/
const fs = require('fs');
const input = fs.readFileSync('/dev/stdin').toString().split('\n');

solution(input);

[백준/JavaScript] 프렉탈 평면(1030)

코딩뽀시래기 — Thu, 1 Aug 2024 01:36:10 +0900

문제

https://www.acmicpc.net/problem/1030

프렉탈 평면은 다음과 같이 커진다. 시간 0에서 프렉탈은 흰색 정사각형 하나이다. 단위 시간(1)이 진행될 때마다 N×N개의 크기가 동일한 단위 정사각형으로 나누어진다. 만약 나누어진 정사각형이 흰색이라면 가운데 K×K 정사각형이 검정색으로 채워진다. N과 K는 둘 다 홀수이거나, 둘 다 짝수이다.

예를 들어, N=3, K=1이라면, 시간 1에 3×3 정사각형이 된다. 가운데 정사각형은 검정색이고, 나머지는 흰색이 된다. 시간 2때 9×9 정사각형이 되고, 17개는 검정이고, 나머지는 흰색이다.

s, N, K, R1, R2, C1, C2가 주어질 때, 시간 s일 때, R1행 C1열부터 R2행 C2열까지의 모습을 출력하는 프로그램을 작성하시오.

풀이

분할정복 문제

// 백준 - 프렉탈 평면(1030)
let s, N, K, R1, R2, C1, C2;
let answer;
const solution = ( input ) => {
  [ s, N, K, R1, R2, C1, C2 ] = input.shift().split(' ').map((o) => parseInt(o));
  answer = new Array(51).fill(0);
  for(let i = 0; i < 51; i++) {
    answer[i] = new Array(51).fill(0);
  }
  
  fractal(0, 0, Math.pow(N, s), false);

  for(let i = 0; i <= R2 - R1; i++) {
    let printLine = ""
    for(let j = 0; j <= C2 - C1; j++) {
      printLine += answer[i][j].toString();
    }
    console.log(printLine);
  }
}

const fractal = ( x, y, size, isBlack ) => {
  if(x > C2 || x + size <= C1 || y > R2 || y + size <= R1) return; // 범위 벗어나면 패스

  // 분할 끝
  if(size == 1) {
    answer[y - R1][x - C1] = isBlack ? 1 : 0;
    return;
  }

  let nextSize = size / N;
  let black = [(N - K) / 2, N - (N - K) / 2];
  for(let i = 0; i < N; i++) {
    let nextY = y + nextSize * i;
    for(let j = 0; j < N; j++) {
      let nextX = x + nextSize * j;
      fractal(nextX, nextY, nextSize, isBlack || (i >= black[0] && i < black[1])&& (j >= black[0] && j < black[1]));
    }
  }
}

/*
테스트용: __dirname + '/input.txt'
제출용: '/dev/stdin'
*/
const fs = require('fs');
const input = fs.readFileSync('/dev/stdin').toString().split('\n');

solution(input);

[SWEA/Java] 1251. [S/W 문제해결 응용] 4일차 - 하나로

코딩뽀시래기 — Thu, 1 Aug 2024 00:28:58 +0900

문제 링크

삼성 SW Expert Academy - 트리 | 1251. [S/W 문제해결 응용] 4일차 - 하나로

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

ps. 이번 문제는 해당 사이트에 가입해야 문제를 볼 수 있습니다

✔️ 소요된 시간

3시간

✨ 수도 코드

이 문제는 Minimum Spanning Tree를 구하는 문제였습니다

✅ Minimum Spanning Tree란?

그래프에서 간선의 수를 가장 적게, 즉 n개의 정점을 가지는 그래프에서 n-1개의 간선을 선택해서 만든 트리가 Spanning Tree입니다
그리고 이때 간선의 가중치를 고려하여 최소 비용의 Spanning Tree를 선택하는 것이 MST(Minimum Spanning Tree)입니다

⭐️ 링크를 참고하면 이해에 도움이 될 것 같습니다!

이 문제에서는 섬이 노드이고, 해저터널이 간선, 환경부담금이 가중치라고 생각할 수 있습니다. 모든 섬 사이가 간선으로 연결되어있는 그래프가 있다고 생각하고, 해당 그래프에서 n-1의 간선을 선택하여 MST를 만들면 최소한의 환경부담금으로 모든 섬을 해저터널로 연결이 가능합니다!

환경부담금은 (해저터널로 연결하는 섬 사이의 거리)^2 * E(환경 부담 세율)인데, 저는 계산을 최소화하기 위해서 (해저터널로 연결하는 섬 사이의 거리)^2를 가중치로 설정하고, 최종 누적 가중치에 E(환경 부담 세율)를 곱해주었습니다

private static class Edge implements Comparable<Edge> {
    int island1, island2;
    Long cost; // 비용 = 환경 부담금 (* E는 마지막에)

    Edge(int island1, int island2, Long cost) {
      this.island1 = island1;
      this.island2 = island2;
      this.cost = cost;
    }
}

ArrayList<Edge> edges = new ArrayList<>();
for(int i = 0; i < N; i++) {
  for(int j = i + 1; j < N; j++) {
    Long distanceX = island[i][0] - island[j][0];
    Long distanceY = island[i][1] - island[j][1];
    Long cost = (distanceX * distanceX) + (distanceY * distanceY);

    edges.add(new Edge(i, j, cost));
  }
}

간선(해저터널)로 연결된 노드(섬)과 가중치를 저장하는 class Edge를 정의해두고, 모든 간선에 대해 가중치를 구해서 ArrayList에 넣어주었습니다

이때, 가중치를 최소로 해야하므로 해당 데이터를 가중치 기준으로 오름차순 정렬하고, 작은 것부터 선택을 하는 방법을 적용할 수 있습니다!

// 환경부담금 기준 오름차순 정렬
@Override
public int compareTo(Edge edge) {
  if(edge.cost < cost) return 1;
  else if(edge.cost > cost) return -1;
  return 0;
}

// 환경부담금 순으로 오름차순 정렬
Collections.sort(edges);

가중치가 적은 간선부터 선택을 하는데, 주의해야 하는 부분은 cycle이 생기지 않도록 하는 것입니다. 이미 두 노드 사이가 연결되어있는데 또 연결을 해서 cycle을 만들면 더이상 최소라고 볼 수 없기 때문입니다!

cycle이 생길 수 있는지, 즉 이미 두 섬 사이가 연결되어 있는지 확인하기 위해서 각 노드의 root 노드를 찾고 비교하는 작업을 해주었습니다. 사이클이 없게 하려면 트리 형태로 구성할 수 있기 때문에 부모 노드를 찾을 수 있습니다. 이어진 섬 중 어느쪽을 부모로 하고, 어느쪽을 자식으로 하는지는 상관 없이 풀이가 가능합니다

간선을 선택할 때마다 노드 사이가 연결되어있는지 체크하고, 연결되어 있지 않다면 해당 간선을 선택해줍니다. 그리고 N-1개의 간선이 선택되어 MST가 완성되었다면 누적가중치에 E를 곱한 뒤 반올림해주면 됩니다!!

최종 코드

// 5차시 2024.07.31.수 : SW Expert Academy - 1251. [S/W 문제해결 응용] 4일차 - 하나로
package jung0115.트리;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
import java.lang.Math;


public class SWEA_1251 {
  static Long[][] island;
  static int[] parents;
  private static class Edge implements Comparable<Edge> {
    int island1, island2;
    Long cost; // 비용 = 환경 부담금 (* E는 마지막에)

    Edge(int island1, int island2, Long cost) {
      this.island1 = island1;
      this.island2 = island2;
      this.cost = cost;
    }

    // 환경부담금 기준 오름차순 정렬
    @Override
    public int compareTo(Edge edge) {
      if(edge.cost < cost) return 1;
      else if(edge.cost > cost) return -1;
      return 0;
    }
  }

	public static void main(String args[]) throws Exception
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringBuilder printSet = new StringBuilder();

		int T = Integer.parseInt(br.readLine());

		for(int test_case = 1; test_case <= T; test_case++)
		{
      int N = Integer.parseInt(br.readLine()); // 섬의 개수
      island = new Long[N][2];

      // X 좌표
      StringTokenizer st = new StringTokenizer(br.readLine());
      for(int i = 0; i < N; i++) {
        island[i][0] = Long.parseLong(st.nextToken());
      }

      // Y 좌표
      st = new StringTokenizer(br.readLine());
      for(int i = 0; i < N; i++) {
        island[i][1] = Long.parseLong(st.nextToken());
      }

      Double E = Double.parseDouble(br.readLine()); // 환경 부담 세율

      // 각 섬을 잇는 해저터널의 환경 부담금 (* E는 마지막에)
      ArrayList<Edge> edges = new ArrayList<>();
      for(int i = 0; i < N; i++) {
        for(int j = i + 1; j < N; j++) {
          Long distanceX = island[i][0] - island[j][0];
          Long distanceY = island[i][1] - island[j][1];
          Long cost = (distanceX * distanceX) + (distanceY * distanceY);

          edges.add(new Edge(i, j, cost));
        }
      }

      // 환경부담금 순으로 오름차순 정렬
      Collections.sort(edges);

      // root 노드를 자기 자신으로 초기화
      parents = new int[N];
      for(int i = 0; i < N; i++) {
        parents[i] = i;
      }

      int connect = 0; // 연결된 섬의 개수
      Long totalCost = 0L; // 총 환경부담금
      for(Edge edge : edges) {
        if(isConnect(edge.island1, edge.island2)) continue;
        
        totalCost += edge.cost;
        connect++;
        if(connect == N - 1) break;
      }

      Long answer = Math.round(E * totalCost);
      printSet.append("#").append(test_case).append(" ").append(answer).append("\n");
    }

    br.close();
    System.out.print(printSet);
	}

  // 연결되어있는지 체크
  static private boolean isConnect(int island1, int island2) {
    int root1 = findRoot(island1);
    int root2 = findRoot(island2);

    if(root1 == root2) return true; // root 노드가 같다면, 이미 연결되어 있는 것
    parents[root1] = root2;
    return false;
  }

  // root 노드 찾기
  static private int findRoot(int node) {
    if(node == parents[node]) return node;
    
    parents[node] = findRoot(parents[node]);
    return parents[node];
  }
}

새롭게 알게된 내용

처음에는 해저터널이 서로 양방향 연결이 되어있으니까 당연히 그래프로 풀어야겠다고 생각했는데, 가중치를 최소로 하려면 cycle이 생기면 안 된다는 포인트를 발견하고 트리처럼 풀이하게된 것 같습니다!

5-jung0115 by jung0115 · Pull Request #137 · AlgoLeadMe/AlgoLeadMe-4

➡️ 문제 풀이 코드 문제 링크 삼성 SW Expert Academy - 트리 | 1251. [S/W 문제해결 응용] 4일차 - 하나로 ps. 이번 문제는 해당 사이트에 가입해야 문제를 볼 수 있습니다 ✔️ 소요된 시간 3시간

github.com

[백준/Kotlin] 개미굴(14725)

코딩뽀시래기 — Thu, 1 Aug 2024 00:22:49 +0900

문제 링크

백준 - 자료 구조 | 개미굴(14725)

https://www.acmicpc.net/problem/14725

... (중략) ...

행복의 비결이 개미가 사는 개미굴에 있다고 생각한 윤수는 개미굴의 구조를 알아보기 위해 로봇 개미를 만들었다.
로봇 개미는 센서가 있어 개미굴의 각 층에 먹이가 있는 방을 따라 내려가다 더 이상 내려갈 수 없으면 그 자리에서 움직이지 않고 신호를 보낸다.
이 신호로 로봇 개미는 개미굴 각 층을 따라 내려오면서 알게 된 각 방에 저장된 먹이 정보를 윤수한테 알려줄 수 있다.

로봇 개미 개발을 완료한 윤수는 개미굴 탐사를 앞두고 로봇 개미를 테스트 해보기 위해 위 그림의 개미굴에 로봇 개미를 투입했다. 로봇 개미의 수는 각 개미굴의 저장소를 모두 확인할 수 있을 만큼 넣는다.

다음은 로봇 개미들이 윤수에게 보내준 정보다.

KIWI BANANA
KIWI APPLE
APPLE APPLE
APPLE BANANA KIWI
공백을 기준으로 왼쪽부터 순서대로 로봇 개미가 각 층마다 지나온 방에 있는 먹이 이름을 뜻한다.

윤수는 로봇 개미들이 보내준 정보를 바탕으로 다음과 같이 개미굴의 구조를 손으로 그려봤다.

APPLE
--APPLE
--BANANA
----KIWI
KIWI
--APPLE
--BANANA
개미굴의 각 층은 "--" 로 구분을 하였다. 또 같은 층에 여러 개의 방이 있을 때에는 사전 순서가 앞서는 먹이 정보가 먼저 나온다.

... (중략) ...
행복의 비결을 알기 위해 윤수를 도와 개미굴이 어떤 구조인지 확인해보자.

✔️ 소요된 시간

35분

✨ 수도 코드

문제에 제시된 그림이 너무 트리의 형태를 나타내고 있어서 바로 트리를 활용해야겠다는 생각을 했습니다
다만 이진 트리가 아니라 자식 노드로 여러개가 올 수 있다는 점, 그리고 자식 노드를 먹이 알파벳 순으로 보여줘야 한다는 점에 주의했습니다!

자식으로 여러개가 올 수 있기 때문에 자식을 list로 관리해야겠다고 생각했습니다

data class Node(
  var feed: String, // 먹이
  var nodes: MutableList<Node>
)

그래서 이렇게 노드 정보에 먹이 이름과 자식을 저장할 리스트를 설정해줬습니다

문제에 제시된 예제로 설명을 하자면, 아래 그림과 같이 저장이 된다고 볼 수 있습니다

입력 데이터를 어떻게 그림과 같은 구조로 정리할 수 있을까요?

부모 노드의 자식에 해당 먹이가 있는지 확인한다
없다면 추가한다
현재 먹이가 부모가 되고 위 과정을 반복한다

저는 개미가 지나온 경로의 입력 정보마다 위 과정을 반복해서 트리 구조로 정리를 해줬습니다. 최상위의 개미굴 입구를 root로 두고, 입력 순서대로 자식 노드를 추가해준 것입니다!

Tree로 정리된 정보를 출력 형식에 맞춰서 정리

개미굴 입구, 즉 root 노드 정보는 출력할 필요가 없기 때문에 그 아래 노드부터 탐색을 해줍니다. 단, 알파벳 순으로 출력을 해야하기 때문에 자식 노드를 정렬하고, 전위순회 방식하면서출력 데이터를 정리할 수 있었습니다

✅ 최종 코드

// 4차시 2024.07.27.토 : 백준 - 개미굴(14725)
import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.StringTokenizer

const val DEPTH_STRING = "--"

data class Node(
  var feed: String, // 먹이
  var nodes: MutableList<Node>
)

var answer: StringBuilder = StringBuilder()

fun main() {
  val br = BufferedReader(InputStreamReader(System.`in`))

  val N = br.readLine().toInt()

  val root = Node("", mutableListOf())
  
  for(i: Int in 1..N) {
    val st = StringTokenizer(br.readLine())
    val num = st.nextToken().toInt()

    // 트리로 정리
    var parent = root
    for(j: Int in 1..num) {
      val currentFeed = st.nextToken()
      var index = -1
      // 부모 노드에 이미 존재하는지 확인
      for(k: Int in 0..parent.nodes.size - 1) {
        if(parent.nodes[k].feed.equals(currentFeed)) {
          index = k
          break
        }
      }
      // 존재하지 않을 경우 자식으로 추가
      if(index == -1) {
        parent.nodes.add(Node(currentFeed, mutableListOf()))
        index = parent.nodes.size - 1
      }
      
      // 다음 자식을 체크하기 위해 depth 증가
      parent = parent.nodes[index]
    }
  }

  root.nodes.sortBy{ it.feed } // 자식 노드를 먹이 이름 기준으로 오름차순 정렬
  for(node in root.nodes) {
    tree(node, "") // depth 1
  }

  print(answer)
}

fun tree(current: Node, depth: String) {
  answer.append(depth).append(current.feed).append("\n")

  current.nodes.sortBy{ it.feed } // 자식 노드를 먹이 이름 기준으로 오름차순 정렬
  for(node in current.nodes) {
    tree(node, depth + DEPTH_STRING) // Depth 증가시켜주고 자식 노드도 탐색
  }
}

새롭게 알게된 내용

ps. 이번 차시에는 다른 일정 때문에 문제를 풀 시간이 부족해서 정답률 높은 문제를 선택했는데, 다음 문제는 좀 더 시간과 고민이 많이 필요한 문제를 풀어보려고 합니다!

4-jung0115 by jung0115 · Pull Request #134 · AlgoLeadMe/AlgoLeadMe-4

[ 풀이 코드] 문제 링크 백준 - 자료 구조 | 개미굴(14725) ... (중략) ... 행복의 비결이 개미가 사는 개미굴에 있다고 생각한 윤수는 개미굴의 구조를 알아보기 위해 로봇 개미를 만들었다. 로

github.com

[백준/JavaScript] 두 용액(2470)

코딩뽀시래기 — Sun, 28 Jul 2024 13:06:04 +0900

문제

https://www.acmicpc.net/problem/2470

KOI 부설 과학연구소에서는 많은 종류의 산성 용액과 알칼리성 용액을 보유하고 있다. 각 용액에는 그 용액의 특성을 나타내는 하나의 정수가 주어져있다. 산성 용액의 특성값은 1부터 1,000,000,000까지의 양의 정수로 나타내고, 알칼리성 용액의 특성값은 -1부터 -1,000,000,000까지의 음의 정수로 나타낸다.

같은 양의 두 용액을 혼합한 용액의 특성값은 혼합에 사용된 각 용액의 특성값의 합으로 정의한다. 이 연구소에서는 같은 양의 두 용액을 혼합하여 특성값이 0에 가장 가까운 용액을 만들려고 한다.

예를 들어, 주어진 용액들의 특성값이 [-2, 4, -99, -1, 98]인 경우에는 특성값이 -99인 용액과 특성값이 98인 용액을 혼합하면 특성값이 -1인 용액을 만들 수 있고, 이 용액이 특성값이 0에 가장 가까운 용액이다. 참고로, 두 종류의 알칼리성 용액만으로나 혹은 두 종류의 산성 용액만으로 특성값이 0에 가장 가까운 혼합 용액을 만드는 경우도 존재할 수 있다.

산성 용액과 알칼리성 용액의 특성값이 주어졌을 때, 이 중 두 개의 서로 다른 용액을 혼합하여 특성값이 0에 가장 가까운 용액을 만들어내는 두 용액을 찾는 프로그램을 작성하시오.

[ 입력 ]

첫째 줄에는 전체 용액의 수 N이 입력된다. N은 2 이상 100,000 이하이다. 둘째 줄에는 용액의 특성값을 나타내는 N개의 정수가 빈칸을 사이에 두고 주어진다. 이 수들은 모두 -1,000,000,000 이상 1,000,000,000 이하이다. N개의 용액들의 특성값은 모두 다르고, 산성 용액만으로나 알칼리성 용액만으로 입력이 주어지는 경우도 있을 수 있다.

[ 출력 ]

첫째 줄에 특성값이 0에 가장 가까운 용액을 만들어내는 두 용액의 특성값을 출력한다. 출력해야 하는 두 용액은 특성값의 오름차순으로 출력한다. 특성값이 0에 가장 가까운 용액을 만들어내는 경우가 두 개 이상일 경우에는 그 중 아무것이나 하나를 출력한다.

풀이

문제를 읽자마자 이분탐색 문제라는 게 감이 왔다 실력이 늘었나...!
더 근접한 값인지 확인할 때, 용액을 혼합했을 때 숫자 말고도 그 두 용액의 특성값도 함께 저장해야한다

// 백준 - 두 용액(2470)
const solution = ( input ) => {
  const N = parseInt(input.shift());
  let liquid = input.shift().split(" ").map(el => parseInt(el));

  liquid = liquid.sort((o1, o2) => o1 - o2); // 오름차순 정렬

  let min = 0;
  let max = N - 1;

  let answer = [min, max, Infinity];

  while(min < max) {
    let mix = liquid[min] + liquid[max];

    // 0에 더 근접한 값인지 확인
    if(Math.abs(mix) < answer[2]) {
      answer[0] = liquid[min];
      answer[1] = liquid[max];
      answer[2] = Math.abs(mix);
    }

    if(mix < 0) { // 용액의 합이 0보다 작을 때는 작은 값을 키우기
      min++;
    }
    else { // 용액의 합이 0보다 클 때는 큰 값을 줄이기
      max--;
    }
  }

  console.log(answer[0] + " " + answer[1]);
}

/*
테스트용: __dirname + '/input.txt'
제출용: '/dev/stdin'
*/
const fs = require('fs');
const input = fs.readFileSync('/dev/stdin').toString().split('\n');

solution(input);

[백준/Kotlin] 휴게소 세우기(1477)

코딩뽀시래기 — Wed, 24 Jul 2024 10:08:33 +0900

문제 링크

백준 - 이분 탐색 | 휴게소 세우기(1477)

https://www.acmicpc.net/problem/1477

다솜이는 유료 고속도로를 가지고 있다. 다솜이는 현재 고속도로에 휴게소를 N개 가지고 있는데, 휴게소의 위치는 고속도로의 시작으로부터 얼만큼 떨어져 있는지로 주어진다. 다솜이는 지금 휴게소를 M개 더 세우려고 한다.

다솜이는 이미 휴게소가 있는 곳에 휴게소를 또 세울 수 없고, 고속도로의 끝에도 휴게소를 세울 수 없다. 휴게소는 정수 위치에만 세울 수 있다.

다솜이는 이 고속도로를 이용할 때, 모든 휴게소를 방문한다. 다솜이는 휴게소를 M개 더 지어서 휴게소가 없는 구간의 길이의 최댓값을 최소로 하려고 한다. (반드시 M개를 모두 지어야 한다.)

예를 들어, 고속도로의 길이가 1000이고, 현재 휴게소가 {200, 701, 800}에 있고, 휴게소를 1개 더 세우려고 한다고 해보자.

일단, 지금 이 고속도로를 타고 달릴 때, 휴게소가 없는 구간의 최댓값은 200~701구간인 501이다. 하지만, 새로운 휴게소를 451구간에 짓게 되면, 최대가 251이 되어서 최소가 된다.

✔️ 소요된 시간

40분

✨ 수도 코드

처음에 문제를 봤을 때는 단순하게 각 휴게소 사이의 거리를 기준으로 내림차순 정렬하고, 거리가 가장 큰 값부터 그 중간에 새로운 휴게소를 설치하면 되지 않을까? 생각했습니다. 그래서 이게 왜 이분탐색 문제인지 의문이 들었는데, 이 방법대로 구현할 경우 문제가 있었습니다

위 그림에서 보면 노란색이 기존의 휴게소 위치라고 했을 때, 각각 4, 6, 8, 2의 거리만큼 떨어져있습니다. 처음 생각대로 구현한다면 길이 8인 구간의 가운데에 새로운 휴게소를 설치하고, 다음으로 6인 구간, 4인 구간 순으로 가운데에 휴게소를 배치하게 됩니다. 이 경우 최종적으로 최대 구간의 길이는 4가 됩니다.

하지만 위 그림처럼 배치한다면 최대 구간의 길이를 3으로 만들 수 있습니다. 구간의 가운데에 휴게소를 놓는 것이 가장 최적화된 방법이 아니라, 여러 개를 배치할 수 있다는 것이 첫번째 방법의 문제점이었습니다.

그래서 고민해본 결과, 최대길이를 특정 값으로 지정했을 때 배치 가능한 휴게소의 수를 세면서 최대 길이의 최소를 찾아나가는 방법을 생각했습니다.

예를 들어 위 그림에서 최대 길이를 4로 만들기 위해서는 2개를 배치해야 하고, 3으로 만들려면 3개, 2로 만들려면 5개가 필요하다는 것을 구해냅니다. 이때 K가 3이기 때문에 3개를 사용하면서 최소의 길이가 되는 3이 정답이 되게 됩니다.

최종 코드

// 3차시 2024.07.24.수 : 백준 - 휴게소 세우기(1477)
import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.StringTokenizer

fun main() {
  // ✅ Input
  val br = BufferedReader(InputStreamReader(System.`in`))
  var st = StringTokenizer(br.readLine())

  val N = st.nextToken().toInt() // 현재 휴게소의 개수
  var M = st.nextToken().toInt() // 더 지으려고 하는 휴게소의 개수
  val L = st.nextToken().toInt() // 고속도로의 길이

  val position = mutableListOf<Int>() // 휴게소의 위치
  position.add(0)  // 시작 위치
  position.add(L)  // 끝 위치
  st = StringTokenizer(br.readLine())
  for(i: Int in 1..N) {
    position.add(st.nextToken().toInt())
  }

  // ✅ Solve
  position.sort() // 오름차순 정렬

  var left = 1 // 0으로 하면 런타임 에러 (/ by zero) 발생
  var right = L
  while(left <= right) {
    var mid: Int = (left + right) / 2 // 최대 길이

    var cnt = 0
    // 최대 mid 길이만큼씩 떨어지게 휴게소 배치했을 때, 필요한 새 휴게소의 개수
    for(i: Int in 1..position.size - 1) {
      cnt += (position[i] - position[i - 1] - 1) / mid
      // 1을 빼주는 이유: i번 휴게소와 i-1번 휴게소 사이의 거리가 mid의 배수라면 새 휴게소가 하나 덜 필요함
    }

    // 필요한 휴게소의 개수가 M개 이상이라면, 최대 길이를 늘려야 함
    if(cnt > M) left = mid + 1
    // M개 이하라면, 더 짧은 길이를 최대로 해도 가능한지 체크하기 위해 최대 길이 줄이기
    else right = mid - 1
  }

  // ✅ Output
  print(left)
}

새롭게 알게된 내용

알고리즘 분류가 이분 탐색이라는 걸 알지 못했다면 풀이 방법을 생각해내는 게 더 어려웠을 것 같습니다...! 이분 탐색이라고 생각되지 않는 문제들도 한 번쯤 이분 탐색으로 풀어낼 수 있는 방법을 고민해보면 좋을 것 같다는 생각을 했습니다

3-jung0115 by jung0115 · Pull Request #129 · AlgoLeadMe/AlgoLeadMe-4

[ 풀이 코드] 문제 링크 백준 - 이분 탐색 | 휴게소 세우기(1477) 다솜이는 유료 고속도로를 가지고 있다. 다솜이는 현재 고속도로에 휴게소를 N개 가지고 있는데, 휴게소의 위치는 고속도로

github.com

[백준/Kotlin] 우주 탐사선(17182)

코딩뽀시래기 — Mon, 22 Jul 2024 00:26:07 +0900

문제 링크

https://www.acmicpc.net/problem/17182

백준 - 백트래킹 | 우주 탐사선(17182)

우주 탐사선 ana호는 어떤 행성계를 탐사하기 위해 발사된다. 모든 행성을 탐사하는데 걸리는 최소 시간을 계산하려 한다. 입력으로는 ana호가 탐색할 행성의 개수와 ana호가 발사되는 행성의 위치와 ana호가 행성 간 이동을 하는데 걸리는 시간이 2차원 행렬로 주어진다. 행성의 위치는 0부터 시작하여 0은 행렬에서 0번째 인덱스에 해당하는 행성을 의미한다. 2차원 행렬에서 i, j 번 요소는 i 번째 행성에서 j 번째 행성에 도달하는데 걸리는 시간을 나타낸다. i와 j가 같을 때는 항상 0이 주어진다. 모든 행성을 탐사하는데 걸리는 최소 시간을 계산하여라.

탐사 후 다시 시작 행성으로 돌아올 필요는 없으며 이미 방문한 행성도 중복해서 갈 수 있다.

✔️ 소요된 시간

3시간

✨ 수도 코드

정답 비율이 50%가 넘길래 호기롭게 도전했다가 결국 솔루션을 찾아봤습니다

1️⃣차 시도 방법 (메모리 초과)

현재 행성에서 자기자신을 제외한 다른 행성으로 가는 경우의 수를 다 체크하면서 반복하다가 모든 행성을 다 탐색했을 때 소요된 시간을 비교하면서 최소 시간을 찾아갔습니다!

모든 행성을 다 탐색해야 하지만, 같은 행성을 여러번 탐색해도 된다는 조건이 있어서 지금까지 탐색한 행성의 수와 각 행성의 방문 유무를 함께 체크해줬습니다

data class Path(
  val position: Int, // 현재 있는 행성 위치
  val time: Int, // 지금까지 이동에 소요된 시간
  val visitedCnt: Int, // 지금까지 방문한 행성의 수
  val visited: Array<Boolean>, // 행성들 방문 체크
)

이렇게 data class를 정의해두고, 행성 하나를 탐색할 때마다 queue에 넣어서 bfs로 탐색해줬습니다

대신 이렇게 실행하다보면 너무 많은 연산이 반복될 수 있기 때문에 이미 현재 구해둔 최소 소요시간보다 더 많은 시간을 썼다면 해당 경우의 수를 중간에 걸러주는 작업을 넣었습니다

var planetPath = LinkedList<Path>() as Queue<Path>
var visited = Array(N, {false})
visited[K] = true
planetPath.offer(Path(K, 0, 1, visited))

var answer = 1000 * 10

while(!planetPath.isEmpty()) {
  val current = planetPath.poll()

  // 모든 행성을 탐색했다면
  if(current.visitedCnt == N) {
    answer = min(answer, current.time)
    continue
  }
  
  for(i: Int in 0..N-1) {
    // 현재 위치랑 같거나 이미 현재의 최소 시간을 넘어섰다면 
    if(current.position == i || current.time >= answer) continue

    var newVisitedCnt = current.visitedCnt
    if(!current.visited[i]) newVisitedCnt++

    val newVisited = current.visited.clone()
    newVisited[i] = true

    planetPath.offer(
      Path(
        position = i,
        time = current.time + planet[current.position][i],
        newVisitedCnt,
        visited = newVisited
      )
    )
  }
}

경로를 탐색할 때마다 visited 배열이 추가로 생성되는데, 계산되는 경로가 많아지거나 행성의 수가 많아질수록 메모리를 많이 사용하게 된다는 문제가 있어서 결국 메모리 초과가 발생했습니다

2️⃣차 시도 방법 (시간 초과)

메모리를 덜 사용하면서, 방문한 행성을 체크해주기 위해 고민하다가 비트마스킹을 적용해봤습니다

data class Path(
  val position: Int, // 현재 있는 행성 위치
  val time: Int, // 지금까지 이동에 소요된 시간
  val visitedCnt: Int, // 지금까지 방문한 행성의 수
  val visitedMask: Int, // 행성들 방문 체크 - ⭐️ 비트마스킹
)

data class를 이렇게 변경해주었고, 방문 체크하는 방법이 비트마스킹으로 변경된 것 외에 다른 로직은 그대로 구현했습니다!

비트마스킹은 단어에서 유추해볼 수 있듯이 비트로 마스킹하여 무언가를 기록해두는 방식입니다

방문한 곳을 1, 방문하지 않은 곳을 0으로 체크하고 인덱스를 기준으로는 오른쪽 끝이 0번, 왼쪽 끝이 N-1번입니다

새롭게 방문한 행성을 체크 해주려면 해당 행성의 인덱스 위치에만 1을 놓고 OR 연산을 진행해주면 됩니다
예를 들어, 0번 행성만 방문한 상태인 00001에서 2번 행성을 추가로 방문했다면, 00001 OR 00100 = 00101로 체크해줄 수 있습니다

var planetPath = LinkedList<Path>() as Queue<Path>
var visitedMask = 1 shl K // ⭐️ ex) 0001이면 첫번째 행성만 방문한 것
planetPath.offer(Path(K, 0, 1, visitedMask))

var answer = 1000 * 10

while(!planetPath.isEmpty()) {
  val current = planetPath.poll()

  // 모든 행성을 탐색했다면
  if(current.visitedCnt == N) {
    answer = min(answer, current.time)
    continue
  }
  
  for(i: Int in 0..N-1) {
    // 현재 위치랑 같거나 이미 현재의 최소 시간을 넘어섰다면 
    if(current.position == i || current.time >= answer) continue

    var newVisitedCnt = current.visitedCnt
    if((current.visitedMask and (1 shl i)) == 0) newVisitedCnt++

    val newVisitedMask = current.visitedMask or (1 shl i)

    planetPath.offer(
      Path(
        position = i,
        time = current.time + planet[current.position][i],
        newVisitedCnt,
        visitedMask = newVisitedMask
      )
    )
  }
}

메모리 초과 문제는 해결되었지만, 아무래도 같은 행성을 여러번 방문할 수 있다보니 경로 탐색을 너무 많이 하게 되어서 시간 초과가 발생한 것 같습니다

경로를 탐색하는 중간에 끊어줄 수 있는 방법을 고민하다가 도저히 떠오르지 않아서 솔루션을 찾아보게 되었습니다

3️⃣차 시도 방법 (솔루션 참고)

솔루션을 찾아보니 완전히 다른 방법으로 해결해내고 있었습니다...!

같은 행성을 여러번 방문할 수 있기 때문에 바로 가는 경우와 다른 행성을 거쳐서 가는 경우 중 더 시간이 적게 걸리는 경우를 미리 계산하고, 총 경로를 이후에 계산하는 방식으로 구현했습니다

A, B, C라는 행성이 있다고 할 때, A에서 C로 바로 가는 경우는 4의 시간이 걸리지만 A에서 B는 1, B에서 C는 2의 시간이 걸린다면 A -> B -> C로 가는 것이 총 3의 시간으로 더 적은 시간이 걸리게 됩니다

for(k: Int in 0..N-1) {
  for(i: Int in 0..N-1) {
    for(j: Int in 0..N-1) {
      if(i == j) continue // 출발과 도착이 같으면 패스
      // i에서 j로 바로 가는 것과 k를 거쳐서 가는 것 중 더 빠른 길을 저장
      planet[i][j] = min(planet[i][j], planet[i][k] + planet[k][j])
    }
  }
}

이렇게 미리 최소시간을 구해두고, 처음 방법처럼 경로를 구해줍니다.

대신 이번에는 이미 방문한 행성을 또 방문하지 않도록 막아주게 되어 시간이 단축되는 효과가 있습니다. 각 경우의 수마다 방문 유무를 체크하는 배열이 따로 필요하지 않기 때문에 저장 공간도 더 적게 사용하게 됩니다!

하지만 여기서 의문이 든 점은, '만약 A->D보다 A->B->C->D가 더 적은 시간이 걸린다면, 이 경우는 어떻게 처리해줄 수 있는가?' 입니다 이 의문점은 해소하지 못했지만 정답 처리가 되었습니다... 이 부분은 좀 더 고민이 필요할 것 같습니다...!

+) k가 결국 모든 행성을 체크하기 때문에 모든 경우의 수를 확인하고 최소 거리를 고려하게 되는 것이었습니다

✅ 정답 코드

import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.StringTokenizer
import kotlin.math.min

var N: Int = 0
var K: Int = 0
lateinit var planet: Array<Array<Int>>
lateinit var visited: Array<Boolean>
var answer = Integer.MAX_VALUE

fun main() {
  // ✅ Input
  val br = BufferedReader(InputStreamReader(System.`in`))
  var st = StringTokenizer(br.readLine())

  N = st.nextToken().toInt() // 행성의 개수
  K = st.nextToken().toInt() // 발사되는 행성의 위치 = 시작점

  // 각 행성간 이동거리
  planet = Array(N, {Array(N, {0})})
  for(i: Int in 0..N-1) {
    st = StringTokenizer(br.readLine())
    for(j: Int in 0..N-1) {
      planet[i][j] = st.nextToken().toInt()
    }
  }

  // ✅ Solve
  visited = Array(N, {false})
  for(k: Int in 0..N-1) {
    for(i: Int in 0..N-1) {
      for(j: Int in 0..N-1) {
        if(i == j) continue // 출발과 도착이 같으면 패스
        // i에서 j로 바로 가는 것과 k를 거쳐서 가는 것 중 더 빠른 길을 저장
        planet[i][j] = min(planet[i][j], planet[i][k] + planet[k][j])
      }
    }
  }

  visited[K] = true
  dfs(1, K, 0)

  // ✅ Output
  print(answer)
}

// ✅ Solve
fun dfs(visitCnt: Int, position: Int, time: Int) {
  if(visitCnt == N) {
    answer = min(answer, time)
    return
  }

  for(i: Int in 0..N-1) {
    if(!visited[i]) {
      visited[i] = true
      dfs(visitCnt + 1, i, time + planet[position][i])
      visited[i] = false
    }
  }
}

새롭게 알게된 내용

결국 정답 코드에서는 사용되지 않았지만 비트마스킹을 사용해보면서, 이후에 메모리 사용을 줄이기 위한 방법으로 적용해 보아야겠다는 생각을 했습니다!

+) 비트마스킹을 사용하면 속도 측면에서도 이득을 볼 수 있습니다

2-jung0115 by jung0115 · Pull Request #125 · AlgoLeadMe/AlgoLeadMe-4

풀이 코드 1차 시도 - 메모리 초과 2차 시도 - 시간 초과 3차 시도 문제 링크 백준 - 백트래킹 | 우주 탐사선(17182) 우주 탐사선 ana호는 어떤 행성계를 탐사하기 위해 발사된다. 모든 행성을

github.com

[백준/JavaScript] RGB거리 2(17404)

코딩뽀시래기 — Fri, 19 Jul 2024 20:56:56 +0900

문제

https://www.acmicpc.net/problem/17404

RGB거리에는 집이 N개 있다. 거리는 선분으로 나타낼 수 있고, 1번 집부터 N번 집이 순서대로 있다.

집은 빨강, 초록, 파랑 중 하나의 색으로 칠해야 한다. 각각의 집을 빨강, 초록, 파랑으로 칠하는 비용이 주어졌을 때, 아래 규칙을 만족하면서 모든 집을 칠하는 비용의 최솟값을 구해보자.

1번 집의 색은 2번, N번 집의 색과 같지 않아야 한다.
N번 집의 색은 N-1번, 1번 집의 색과 같지 않아야 한다.
i(2 ≤ i ≤ N-1)번 집의 색은 i-1, i+1번 집의 색과 같지 않아야 한다.

[ 입력 ]

첫째 줄에 집의 수 N(2 ≤ N ≤ 1,000)이 주어진다. 둘째 줄부터 N개의 줄에는 각 집을 빨강, 초록, 파랑으로 칠하는 비용이 1번 집부터 한 줄에 하나씩 주어진다. 집을 칠하는 비용은 1,000보다 작거나 같은 자연수이다.

[ 출력 ]

첫째 줄에 모든 집을 칠하는 비용의 최솟값을 출력한다.

풀이

첫번째 집과 마지막 집도 색깔이 달라야 한다는 점을 주의하면 된다.
첫번째 집의 색깔을 고정해서 3가지 색의 경우를 구하고, 마지막 집의 색상과 비교해서 최소값을 구해낼 수 있다

// 백준 - RGB거리 2(17404)
const solution = ( input ) => {
  const N = parseInt(input.shift());

  let house = [];
  for(let i = 0; i < N; i++) {
    house.push(input.shift().split(" ").map(el => parseInt(el)));
  }

  let answer = Infinity;
  
  for(let first = 0; first < 3; first++) {
    let dp = [];

    let one = first == 0 ? house[0][0] : Infinity;
    let two = first == 1 ? house[0][1] : Infinity;
    let three = first == 2 ? house[0][2] : Infinity;

    // 첫번째 집
    let firstList = [one, two, three];

    dp.push(firstList);

    for(let i = 1; i < N; i++) {
      let line = [];
      // 이전 집과 같은 경우를 제외
      line.push(Math.min(dp[i-1][1], dp[i-1][2]) + house[i][0]);
      line.push(Math.min(dp[i-1][0], dp[i-1][2]) + house[i][1]);
      line.push(Math.min(dp[i-1][0], dp[i-1][1]) + house[i][2]);

      dp.push(line);
    }

    for(let i = 0; i < 3; i++) {
      if(first != i) answer = Math.min(dp[N - 1][i], answer);
    }
  }

  console.log(answer);
}
/*
테스트용: __dirname + '/input.txt'
제출용: '/dev/stdin'
*/
const fs = require('fs');
const input = fs.readFileSync('/dev/stdin').toString().split('\n');

solution(input);

[정보처리기사 실기] 2023년 3회 공부(1)

코딩뽀시래기 — Fri, 19 Jul 2024 20:41:51 +0900

OAuth

인터넷 애플리케이션에서 사용자 인증에 사용되는 표준 인증 방법
공개 API(Open API)로 구현됨
인터넷 사용자가 웹사이트나 애플리케이션에 비밀번호를 제공하지 않고 자신에게 접근 권한을 부여하여 사용 가능
2010년 ETF에서 1.0이 공식 표준안으로 발표됨

IDEA
- DES를 대체하기 위해 스위스 연방기술 기관에서 개발
SSPI
- 보안 지원 공급자 인터페이스
- 안전한 분산 애플리케이션을 위한 범용 산업 표준 인터페이스
SASL
- 인터넷 프로토콜에서 인증과 데이터보안을 위한 프레임워크
- 애플리케이션 프로토콜들로부터 인증 메커니즘을 분리시킴
EAP-TLS
- 전송 계층 보안(TLS) 프로토콜을 사용하여 클라이언트와 서버 간의 상호 인증을 수행함
- 클라이언트와 서버 간에 암호화된 채널을 생성하고, 인증서를 사용하여 클라이언트와 서버 간의 상호 인증을 수행
- 매우 안전하고, 서버 측에서 인증서를 관리할 수 있으므로 보안성이 높음
PEAP
- EAP의 변형
- EAP-TLS와 달리 사용자 이름과 암호를 암호화하여 보호함
- 클라이언트와 서버 간에 암호화된 채널을 생성하고, 사용자 이름과 암호를 암호화하여 인증
- PEAP은 EAP-TLS보다 간단하게 구성할 수 있으며, 보안성이 높음
TTLS
- EAP와 TLS을 결합한 프로토콜
- EAP-TLS와 유사하지만, 인증서 대신 사용자 이름과 앟모를 사용하여 인증함.
- 클라이언트와 서버 간에 암호화된 채널을 생성하고, 사용자 이름과 암호를 사용하여 인증
- PEAP과 마찬가지로 보안성이 높으며, 사용자 이름과 암호를 보호할 수 있음.
OIDC
- OpenID Connect
- OAuth 2.0 위에 구축된 인증 및 권한 부여 프로토콜
- 인증과 사용자 정보 제공을 위한 간단한 인증 계정을 추가함
JAAS
- 자바 프로그래밍 언어의 보안 프레임워크
- 자바 런타임 1.4 이후로 JAAS는 JRE에 통합됨

패키지

UML 정적 모델링의 하나
관련있는 객체들을 하나로 묶어 상위 개념으로 추상화한 것
유스케이스, 클래스 등의 요소들을 그룹화하여 의존 관계를 표현
대규모 시스템에서 주요 요소간의 종속성을 파악하는 데 사용됨
시스템의 구조를 간략하게 표현 가능
의존 관계를 명확하게 파악 가능
불필요한 의존 관계를 제거하거나 간략화함으로써 시스템의 복잡도를 낮추는 곳에도 사용 가능

Equivalence Partition(동등 분할)

예상되는 출력값이 나오는지 실제 값과 비교하는 명세 기반 테스트 기법
입력값을 다양한 동등한 그룹으로 나누어, 각 그룹에서 대푯값을 선택하여 테스트하는 방법
입력값의 유사한 도메인을 나누어 테스트 케이스를 선택하는 것
특정 그룹에서 발생한 문제를 파악하고, 해당 그룹의 대푯값을 통해 다양한 입력 조건을 테스트함으로써 프로그램 전체를 효과적으로 검증 가능
동치 분할 기법이라고도 함
입력 자료에 초점을 두어 테스트 케이스를 만들고 검사하는 기법

Boundary Value Analysis(경계값 분석)
- 블랙박스 테스트 중 하나
- 입력 자료에만 치중한 동치 분할 기법을 보완하기 위한 기법
- 입력 조건의 중간값보다 경계값에서 오류가 발생될 확률이 높다는 점을 이용하여 입력 조건의 경계값을 테스트 케이스로 선정하여 검사하는 기법

Cause-Effect Graph(원인-효과 그래프 검사)
- 블랙박스 테스트 중 하나
- 입력 데이터 간의 관계와 출력에 영향을 미치는 상황을 체계적으로 분석한 다음 효용성이 높은 테스트 케이스를 선정하여 검사하는 기법

Error Guess(오류 예측 검사)
- 블랙박스 테스트 중 하나
- 과거의 경험이나 확인자의 감각으로 테스트하는 기법
- 다른 블랙 박스 테스트 기법으로는 찾아낼 수 없는 오류를 찾아내는 일력의 보충적 검사 기법
- 데이터 확인 검사라고도 함
Comparsion Test(비교 검사)
- 블랙박스 테스트 중 하나
- 여러 버전의 프로그램에 동일한 테스트 자료를 제공하여 동일한 결과가 출력되는지 테스트하는 기법
Base Path Test(기초 경로 검사)
- 대표적인 화이트박스 테스트 기법
- 테스트 케이스 설계자가 절차적 설계의 논리적 복잡성을 측정할 수 있게 해주는 테스트 기법
- 테스트 측정 결과는 실행 경로의 기초를 정의하는 데 지침으로 사용됨
Loop Test(루프 검사)
- 화이트박스 테스트 기법에서 제어 구조 검사 중 하나
- 프로그램의 반복(Loop) 구조에 초점을 맞춰 실시하는 테스트 케이스 설계 기법
Data Flow Test(데이터 흐름 검사)
- 화이트박스 테스트 기법에서 제어 구조 검사 중 하나
- 프로그램에서 변수의 정의와 변수 사용의 위치에 초점을 맞춰 실시하는 테스트 케이스 설계 기법

코딩가딩가딩

블로그 이사

[백준/JavaScript] 거짓말(1043)

문제

[백준/JavaScript] 프렉탈 평면(1030)

문제

풀이

[SWEA/Java] 1251. [S/W 문제해결 응용] 4일차 - 하나로﻿

문제 링크

삼성 SW Expert Academy - 트리 | 1251. [S/W 문제해결 응용] 4일차 - 하나로

✔️ 소요된 시간

✨ 수도 코드

✅ Minimum Spanning Tree란?

최종 코드

새롭게 알게된 내용

[백준/Kotlin] 개미굴(14725)

문제 링크

백준 - 자료 구조 | 개미굴(14725)

✔️ 소요된 시간

✨ 수도 코드

입력 데이터를 어떻게 그림과 같은 구조로 정리할 수 있을까요?

Tree로 정리된 정보를 출력 형식에 맞춰서 정리

✅ 최종 코드

새롭게 알게된 내용

[백준/JavaScript] 두 용액(2470)

문제

풀이

[백준/Kotlin] 휴게소 세우기(1477)

문제 링크

✔️ 소요된 시간

✨ 수도 코드

새롭게 알게된 내용

[백준/Kotlin] 우주 탐사선(17182)

문제 링크

백준 - 백트래킹 | 우주 탐사선(17182)

✔️ 소요된 시간

✨ 수도 코드

1️⃣차 시도 방법 (메모리 초과)

2️⃣차 시도 방법 (시간 초과)

3️⃣차 시도 방법 (솔루션 참고)

✅ 정답 코드

새롭게 알게된 내용

[백준/JavaScript] RGB거리 2(17404)

문제

풀이

[정보처리기사 실기] 2023년 3회 공부(1)

[SWEA/Java] 1251. [S/W 문제해결 응용] 4일차 - 하나로