E-room Achievement Logs

MySQL Null 과 함께 Unique

E-room — Sat, 4 May 2024 23:49:40 +0900

특정 데이터가 삭제되지 않았을 때는 중복을 허용하지 않고, 삭제(논리)된 경우에는 중복이 가능하게 요청을 받았다.

예를 들어 email이라는 컬럼이 위와 같이 되어야 한다고 하자.

'test@test.com'이 이미 사용되고 있다. 그렇다면 더 이상 다른 사용자는 해당 이메일을 사용할 수 없다.

그러나 해당 로우가 삭제되었다면, 즉, deleted_at이 기록된 경우에는 더 이상 email은 존재하지 않는 것으로 간주되어 중복이 가능하도록 설정해야 한다.

그냥 deleted_at과 원하는 컬럼을 묶어서 UNIQUE로 지정하면 되지 않을까?

-- email과 deleted_at을 묶어서 유니크로 지정
ALTER TABLE users
ADD CONSTRAINT UK_email_deleted_at UNIQUE(email, deleted_at);

안타깝게도 MySQL에서는 NULL은 무시해 버리게 된다.

그럼 어떻게 해야 할까?

가상컬럼을 이용해 보자

-- deleted_at을 대신할 컬럼 생성
ALTER TABLE users
ADD not_archived BOOLEAN
GENERATED ALWAYS AS (IF(deleted_at IS NULL, TRUE, NULL)) VIRTUAL;

-- email과 함께 UNIQUE로 묶기
ALTER TABLE users
ADD CONSTRAINT UK_email_not_archived UNIQUE(email, not_archived);

쿼리 실행 중에 자동으로 deleted_at의 값을 기반으로 not_archived라는 컬럼을 임시로 생성하고 해당 컬럼을 가상컬럼으로 지정해 주었다.

그리고 해당 컬럼을 email과 함께 UNIQUE로 묶어 주었다.

그냥 쉽게 말해 deleted_at이라는 컬럼이 NULL일 때를 대신해서 계산될 컬럼을 하나 추가했다고 보면 된다.

그리고 다시 중복된 email 삽입을 시도해 보면 에러가 발생한다.

중복된 email을 논리삭제 후 다시 시도해보면 정상적으로 들어가는 것을 볼 수 있다.

가성컬럼을 deleted_at이 NULL이 아닐 때 NULL이 되게 한 이유?

두 개의 컬럼을 유니크로 묶을 경우 NULL을 무시하기 때문에 아래와 같이 삭제되었을 때 중복이 된다.

ps) 기존 deleted_at과 함께 지정한 유니크키 삭제를 잊지 말자

참고

Soft Delete and Unique Constraint

When using the soft delete mechanism on the database, you might run into a situation where a record with a unique constraint was deleted…

gusiol.medium.com

Prisma vs TypeORM 벤치마크

E-room — Tue, 9 Apr 2024 16:34:05 +0900

새로운 프로젝트를 시작하기에 앞서 Nest.js, MySQL과 함께 사용할 ORM을 선택해야 하는 상황이 왔다.

다양한 ORM이 존재하지만 Prisma, TypeORM 둘 중 하나를 선택하기로 했다.

많은 글에서 두 ORM의 장단점을 비교하고 있지만, 성능 비교는 많지 않았고, 그마저도 최신자료는 없었다.

Benchmark: Prisma VS TypeORM

Prisma and TypeORM are possibly the main ORM choices for the JavaScript ecosystem in 2022, so I have...

dev.to

뭐 어쨋든 참고해 보자면 위 글은 2년 전 자료이고, PostgreSQL을 사용했다고 한다.

대략 요약하자면, 전반적으로 거의 비슷하나 Prisma가 근소하게 앞서고 스트레스 시나리오에서는 TypeORM이 압도적이라고 한다.

위 테스트를 참고하여 간단하게 테스트를 진행해 보았다.

어느 진영이 더 좋다고 평소에 생각한바는 전혀 없으며, 최대한 공정하게 진행하려 노력했습니다.

테스트 환경

PC - Macbook Air M2 RAM8GB SSD512GB

Prisma - 5.12.1

TypeORM - 0.3.20

MySQL - 8.3

진행 방법

Prisma와 TypeORM 각각의 데이터베이스를 생성하고,

한쪽 먼저

CREATE * 5000
FIND(단건) * 5000
FIND(다건) * 5000
UPDATE * 5000
DELETE * 5000

모두 진행한 뒤,

다른 한쪽을 진행했다.

참고
- 모든 테스트들은 값이 작을수록 좋음
- 아래 테스트들에 등장하는 getFake~ 로 시작하는 함수들은 @faker-js/faker 패키지를 사용하여 만든 함수입니다.
- 각각 환경 구성은 Prisma와 TypeORM의 공식문서를 참조하여 구성하였습니다.
- 쿼리빌더와 같은 메서드는 사용하지 않았으며, 각각의 진영에서 제공하는 기본 함수들을 이용했습니다.

성능 테스트

데이터 생성

// Prisma
console.time('Create User - Prisma');
for (let i = 0; i < 5000; i++) {
    await this.user.create({
        data: getFakeUser()
    });
}
console.timeEnd('Create User - Prisma');

// TypeORM
console.time('Create User - TypeORM');
for (let i = 0; i < 5000; i++) {
    await this.userRepository.save(getFakeUser());
}
console.timeEnd('Create User - TypeORM');

데이터 단건 조회 by id

// Prisma
console.time('Find User - Prisma');
for (let i = 0; i < 5000; i++) {
    await this.user.findUnique({
        where: { id: getRandomId(1, 5000) }
    });
}
console.timeEnd('Find User - Prisma');

// TypeORM
console.time('Find User - TypeORM');
for (let i = 0; i < 5000; i++) {
    await this.userRepository.findOneBy({ id: getRandomId(1, 5000) });
}
console.timeEnd('Find User - TypeORM');

단건 조회의 경우에는 TypeORM이 압도적이다.

데이터 다건 조회 by 조건

// Prisma
console.time('Find Users - Prisma');
for (let i = 0; i < 5000; i++) {
    const query: Prisma.UserFindManyArgs = {
        where: {
            job: {
                contains: getRandomAlpha()
            }
        },
        take: 10,
        skip: 0
    }
    await this.$transaction([
        this.user.findMany(query),
        this.user.count({ where: query.where })
    ]);
}
console.timeEnd('Find Users - Prisma');

// TypeORM
console.time('Find Users - TypeORM');
for (let i = 0; i < 5000; i++) {
    await this.userRepository.findAndCount({
        where: {
            job: ILike(`%${getRandomAlpha()}%`)
        },
        take: 10,
        skip: 0
    });
}
console.timeEnd('Find Users - TypeORM');

해당 테스트의 경우에는 Prisma에는 TypeORM의 findAndCount와 같은 Count쿼리를 함께 보내는 기능이 기본 메서드에 없어서 트랜잭션을 통해 진행했다.

그래서 결과가 차이가 심한 건가 싶어서 find만 진행하도록 변경해서 다시 요청해 보았다.

흠 ...

차이가 더 벌어졌다.

데이터 업데이트

// Prisma
console.time('Update User - Prisma');
for (let i = 0; i < 5000; i++) {
    await this.user.update({
        select: { id: true },
        where: { id: getRandomId(1, 5000) },
        data: { name: getRandomName() }
    });
}
console.timeEnd('Update User - Prisma');

// TypeORM
console.time('Update User - TypeORM');
for (let i = 0; i < 5000; i++) {
    await this.userRepository.update(
        { id: getRandomId(1, 5000) },
        { name: getRandomName() }
    );
}
console.timeEnd('Update User - TypeORM');

해당 테스트의 경우에는

TypeORM의 경우 UPDATE 쿼리만 보낸 후 영향을 받은 row들의 숫자만 리턴하는 식이고,

Prisma는 Update 쿼리를 보낼 때, 전후로 Select 쿼리를 보낸다.

그래서 차이가 심한 것 같다.

TypeORM은 데이터가 존재하지 않아도 에러를 발생시키지 않고,

Prisma는 데이터가 없으면 에러를 발생시킨다.

Prisma의 로그

데이터 삭제

// Prisma
console.time('Delete User - Prisma');
for (let i = 1; i <= 5000; i++) {
    await this.user.delete({
        where: { id: i }
    });
}
console.timeEnd('Delete User - Prisma');

// TypeORM
console.time('Delete User - TypeORM');
for (let i = 1; i <= 5000; i++) {
    await this.userRepository.delete({ id: i });
}
console.timeEnd('Delete User - TypeORM');

Delete의 경우에도 Update와 비슷한 경우라고 볼 수 있다.

그 외

성능 외의 비교는 많은 글이 존재하기에 딱히 의미는 없으나 간략하게 적어보자면,

다운로드 추세를 보면 기존에는 TypeORM이 더 많다고 알고 있었는데, Prisma가 넘어섰다.

npm 다운로드 수 (좌 Prisma 우 TypeORM)

Prisma의 경우에는 type-safety를 지원해서 잠재적인 휴먼에러를 막아준다고 한다.

그리고 이번에 테스트를 진행하면서 Prisma를 처음 사용해 보았는데, 굉장히 쉽고 편리하다고 느꼈다.

특히 model 정의할 때, 굉장히 깔끔했다.

개인적으로 사용성 측면에서는 Prisma가 우세하다고 생각된다.

복잡한 쿼리는 TypeORM이 좀 더 유연하게 작성할 수 있다고 한다.

하지만 최근 TypeORM이 0.3으로 넘어오면서 다양한 이슈가 존재하기에 잘 고려해보아야한다.

결론

각자의 프로젝트에서 중요한 포인트들과 비교하여 선택하면 되겠다.

복잡한 쿼리를 많이 사용하며 성능이 중요하다 - TypeORM
편리한 사용성과 낮은 진입장벽, 휴먼에러를 막아주는 게 중요하다 - Prisma

TypeORM + MySQL8 AsText does not exist

E-room — Tue, 12 Mar 2024 17:00:09 +0900

개발환경

node: v20.10.0
- nestjs: v10.0.0
- typeorm: v0.3.20
- mysql2: v3.9.2
mysql: v8.0.0

문제. AsText does not exist

Mysql의 Point 타입을 사용해서 좌표 관련 기능을 구현하던 중, 문제가 발생했다.

typeorm의 조회관련 메서드를 사용해 DB에 SELECT 쿼리를 보냈더니 다음과 같은 에러가 발생했다.

QueryFailedError: FUNCTION db-name.AsText does not exist

원인.

대략 찾아보니 타 DB에는 공간(Spatial) 관련 타입을 처리할 때, AsText와 같은 함수가 존재해 이를 이용해서 조회를 할 수 있다고 한다.

그래서 Typeorm이 DB에서 해당 타입을 조회할 때, AsText를 사용하여 데이터를 가져온다.

하지만, Mysql 8버전에는 해당 함수가 없어서 위와 같은 오류가 발생한다.

해결.

검색을 해보니 스택오버플로우에서 나와 같은 문제를 겪은 사람이 있었다.

Type geometry in mysql -> AsText doesn't exist

I altered my db with a new column with type geometry. And then I am getting this error when I am trying to select something from my db. With select all and also with select of only one specific col...

stackoverflow.com

TypeOrm 모듈을 설정할 때, AsText 함수를 사용하여 조회하도록 하는 옵션을 끄면 간단히 해결된다.

TypeOrmModule.forRoot({
  legacySpatialSupport: false,

그리고 알고보니 설명서에도 친절하게 나와있다.

MysqlConnectionOptions

Nestjs - Shared modules : 의존성 주입을 통하여 모듈 공유하기

E-room — Thu, 29 Feb 2024 20:22:47 +0900

NestJS는 모듈과 서비스를 효과적으로 구성하고 관리할 수 있는 강력한 기능을 제공합니다.

오늘은 NestJS에서 서비스를 공유하는 두 가지 방법인 의존성 주입(Dependency Injection)과 모듈 임포트에 대해 알아보겠습니다.

NestJS는 모듈과 서비스를 사용하여 애플리케이션을 구성합니다.

모듈은 애플리케이션의 부분을 나타내며, 서비스는 비즈니스 로직을 처리하고 데이터를 관리합니다.

상황 가정

1. Flowers와 Places라는 기능이 있다고 가정 (nest g resources flowers, nest g resources places)

2. FlowersController에서 PlacesService를 사용하고 싶음

3. 단, PlacesService를 새로 생성하는 것이 아닌 하나의 PlacesService로 공유해서 사용해야 함

의존성 주입(Dependency Injection)

의존성 주입을 사용하면 서비스를 다른 컴포넌트로 주입할 수 있습니다.

이를 통해 서비스를 공유할 수 있습니다.

@Controller('flowers')
export class FlowersController {
  constructor(
    private readonly flowersService: FlowersService,
    private readonly placesService: PlacesService // 의존성 주입
  ) { }
  
  ...
  
}

모듈 exports

PlacesModule에서 사용 중인 PlacesService를 다른 모듈에서도 사용할 수 있도록 exports 해줍니다.

@Module({
  controllers: [PlacesController],
  providers: [PlacesService],
  exports: [PlacesService] // exports
})
export class PlacesModule {}

모듈 imports

PlacesService를 사용하고 싶은 다른 모듈에서 PlacesService를 exports 한 Module인 PlacesModule을 import 해줍니다.

‼️ PlacesService를 사용하고 싶다고 PlacesService를 imports 하거나 providers로 등록하는 것이 아닙니다!

@Module({
  imports: [PlacesModule], // 주의 !!
  controllers: [FlowersController],
  providers: [FlowersService],
})
export class FlowersModule {}

사용해보기

FlowersController의 findAll을 호출 시, FlowersService.findAll과 PlacesService.findAll이 둘 다 호출되도록 하고,

PlacesController의 findAll을 호출 시, PlacesService.findAll만 호출되도록 구성하겠습니다.

Service

@Injectable()
export class FlowersService {
  private count = 0; // 카운트

  findAll() {
    return `This action returns all flowers : ${++this.count}`;
  }
  
  ...
  
}

@Injectable()
export class PlacesService {
  private count = 0; // 카운트
  
  findAll() {
    return `This action returns all places : ${++this.count}`;
  }
  
  ...
  
}

Controller

@Controller('flowers')
export class FlowersController {
  constructor(
    private readonly flowersService: FlowersService,
    private readonly placesService: PlacesService
  ) { }

  @Get()
  findAll() {
    const flowers = this.flowersService.findAll(); // flowers의 findAll 호출
    const places = this.placesService.findAll() // places의 findAll 호출
    return `${flowers}</br>${places}`;
  }
  ...
}

@Controller('places')
export class PlacesController {
  constructor(private readonly placesService: PlacesService) {}

  @Get()
  findAll() {
    return this.placesService.findAll(); // places의 findAll만 호출
  }
...
}

테스트

GET localhost:3000/places 두 번 호출 후,

GET localhost:3000/flowers 호출했을 때의 결과는?

This action returns all flowers : 1
This action returns all places : 3

결론

하나의 인스턴스를 의존성 주입을 통해 서로 공유하여 사용할 수 있으며, 이를 통해 자원 절약과 일관된 상태를 유지할 수 있음.

번외

'모듈 imports' 단계에서 imports가 아닌 providers에 등록한다면?

@Module({
  // imports: [PlacesModule], // 해당 코드 주석 처리
  controllers: [FlowersController],
  providers: [FlowersService, PlacesService], // PlacesService 등록
})
export class FlowersModule {}

위와 마찬가지로

GET localhost:3000/places 두 번 호출 후,

GET localhost:3000/flowers 호출했을 때의 결과는?

This action returns all flowers : 1
This action returns all places : 1

하나의 PlacesService를 공유하는 것이 아닌, 각각의 모듈에서 PlacesService를 생성하여 사용하게 된다.

참고

Documentation | NestJS - A progressive Node.js framework

Nest is a framework for building efficient, scalable Node.js server-side applications. It uses progressive JavaScript, is built with TypeScript and combines elements of OOP (Object Oriented Programming), FP (Functional Programming), and FRP (Functional Rea

docs.nestjs.com

TypeORM - @Column({ unique : true }) vs @Unique()

E-room — Fri, 23 Feb 2024 18:18:00 +0900

nestjs + typeORM을 공부하던 중 특정 컬럼에 대해 유니크 속성을 주어야 하는데, 두 가지 방법이 보였다.

첫 번째는 변수에 @Column 데코레이터를 사용하는 것이고,

두 번째는 클래스에 @Unique 데코레이터를 사용하는 것이다.

두 방법 모두 유니크 속성을 부여한다는 것은 동일하지만 약간의 차이가 있다.

유니크 속성을 각각 부여하느냐, 합쳐서 부여하느냐의 차이다.

@Column({ unique : true })

일반적으로 원하는 특정 컬럼에 유니크 속성을 주기 위해 사용할 수 있다.

    @Column({ unique: true })
    first: string;

    @Column({ unique: true })
    second: string;

@Column({ unique : true })

이러한 방식으로 생성된 제약조건을 살펴보면 각각 컬럼별로 두 개의 제약조건이 생성된 것을 볼 수 있다.

@Unique(['first', 'second'])

두가지 컬럼에 하나의 유니크 제약조건을 부여한다.

즉, 'first' 및 'second' 열의 값이 모두 동일한 행이 두 번 이상 삽입되는 것을 방지한다.(복합키)

@Unique(['first', 'second'])
export class User extends BaseEntity {
 ...
}

@Unique

두 컬럼이 하나의 제약조건으로 묶여있는 모습이다.

위 사진처럼 first의 중복과 second의 각각 중복은 가능하다.

하지만, 이 상태에서

INSERT INTO users (first, second) VALUES ('a', 'b');

쿼리를 실행하게 되면 어떻게 될까?

위와 같이 에러가 발생한다.

결론

@Column 데코레이터에 unique: true 옵션을 주는 것은 일반적으로 유니크 속성을 부여하는 것이다.

@Unique 데코레이터는 복합키를 생성할 때 사용한다.

SQL Injection 방지 - 권장방식에는 다 이유가 있지..

E-room — Wed, 31 Jan 2024 13:14:56 +0900

nodejs express 공부를 하고 있는데, 쿼리를 작성하던 중 문득 생각이 들었다.

`
SELECT * FROM users
WHERE user_id = ?
`

mariadb 모듈에는 query 함수가 있는데,

첫 번째 인자로 쿼리 문자열 받고,

두 번째 인자로 쿼리의 플레이스홀더(? 부분)에 해당하는 부분을 배열 형태로 받는다.

세 번째 인자로 콜백함수를 받는다.

여기서 ${} 형태로 작성하면 가독성과 유지보수 측면에서 더 좋지 않나? 라는 생각이 들었다.

`
SELECT * FROM users
WHERE user_id = ${userId}
`

이런 식으로 작성하고 두 번째 인자를 생략하면 정상적으로 작동된다.

하지만 또 한편으로 드는 생각이 굳이 첫 번째 방식으로 작성하고 두 번째 인자로 배열을 받는 이유가 있지 않을까? 라는 생각이 들었다.

그래서 검색을 좀 해보니 두번째 방식으로 작성을 하게 되면 SQL Injection 공격에 취약해진다고 한다.

역시 개발자들은 항상 코드에 이유가 있다.

그래서 테스트를 해보았다.

1. ${변수}

// 소스코드
login1 = (email, password) => {
  return new Promise((resolve, reject) => {
    const query = `
      SELECT * FROM users u
      WHERE email = '${email}' AND password = '${password}';
      `;
    db.query(query, (error, data) => {
      if (error) reject(error);
      else resolve(data[0]);
    });
  });
}

// email과 password에 아래와 같이 입력
login1("test1", "' OR '1' = '1")
    .then(result => console.log(result));
    
/* 결과
{
    "user_id": 1,
    "email": "test1",
    "name": "네임",
    "password": "$2b$10$qJ3/h/W4yiLLygW6.1xn8uI6xpbLY1/h6EpX./PkydaZ6tBd3AakC",
    "created_at": "2024-01-21T13:04:43.000Z",
    "modified_at": "2024-01-31T02:56:35.000Z"
}
*/

위 코드를 실행하면 데이터베이스에서는 아래와 같은 쿼리가 실행된다.

-- 실제 데이터베이스에서 실행되는 쿼리
SELECT * FROM users u
WHERE email = 'test1' AND password = '' OR '1'  = '1';

-- 위 쿼리는 결국 아래 쿼리와 같다
SELECT * FROM users u

DB에서 해당 쿼리를 실행하였을 경우 users테이블의 모든 데이터가 조회된다.

코드에서 data[0]를 통해 첫번째 데이터만 응답하도록 했기 때문에 한건만 조회가 되었지만,

모든 데이터에서 첫번째 데이터가 반환되게 된다.

2. 플레이스 홀더(공식 권장 방식)

// 소스코드
const login2 = (email, password) => {
    return new Promise((resolve, reject) => {
        const query = `
        SELECT * FROM users u
        WHERE email = ? AND password = ?;
        `;
        db.query(query, [email, password], (error, data) => {
            if (error) reject(error);
            else resolve(data[0]);
        });
    });
}

// email과 password에 아래와 같이 입력
login2("test1", "' OR '1' = '1")
    .then(result => console.log(result));
    
/* 결과
undefined
*/

위 코드를 실행하면 데이터베이스에서는 아래와 같은 쿼리가 실행된다.

-- 실제 데이터베이스에서 실행되는 쿼리
SELECT * FROM users u
WHERE email = 'test1' AND password = "'' OR '1'  = '1'";

SQL 인젝션을 위해 입력한 password부분이 하나의 문자열로 데이터베이스에서 실행이 된다.

그러므로 조건에 맞는 데이터가 없기 때문에 빈 배열을 가져오게 되고, 빈 배열의 첫 번째 데이터를 리턴하기 때문에 undefined가 반환된다.

mariadb의 공식문서를 살펴보면

https://github.com/mariadb-corporation/mariadb-connector-nodejs/blob/master/documentation/callback-api.md

첫번째 줄을 살펴보면 To avoid SQL Injection attacks, 라고 되어 있는 것을 볼 수 있다.

SQL Injection attacks를 피하기 위해 라고 친절하게 적어놓았다.

결론

물론, 비밀번호의 경우 데이터베이스에 암호화해서 저장을 하고, 암호화 모듈에서 제공하는 함수를 이용해서 비교를 하기 때문에 위 쿼리처럼 WHERE절에 email AND password를 사용해서 로그인을 진행하는 경우는 드물다.

그렇다면 첫번째 방법을 사용해도 되는 거냐?

당연히 절대 안 된다.

위에서는 password에 조건문만 집어넣었지만 DELETE, DROP TABLE, UPDATE 등 다양한 쿼리를 사용해서 공격을 시도할 수 있다.

(이 경우에도 생각해야 할 것들이 있지만 주제와 맞지 않으므로 pass)

어쨌든 해커가 공격할 여지를 남겨주는 것은 좋은 방법이 아니다.

권장하는 방법을 쓰자.

전체 코드

const mariadb = require('mariadb/callback');

const DB_HOST = '호스트';
const DB_PORT = '포트';
const DB_USER = '유저';
const DB_PASSWORD = '비밀번호';
const DB_DATABASE = '데이터베이스명';

const db = mariadb.createConnection({
    host: DB_HOST,
    port: DB_PORT,
    user: DB_USER,
    password: DB_PASSWORD,
    database: DB_DATABASE,
});

// ${} 방식
const login1 = (email, password) => {
    return new Promise((resolve, reject) => {
        const query = `
        SELECT * FROM users u
        WHERE email = '${email}' AND password = '${password}';
        `;
        db.query(query, (error, data) => {
            if (error) reject(error);
            else resolve(data[0]);
        });
    });
}
login1("test1", "' OR '1' = '1")
    .then(result => console.log(result));

// ? 방식
const login2 = (email, password) => {
    return new Promise((resolve, reject) => {
        const query = `
            SELECT * FROM users u
            WHERE email = ? AND password = ?;
            `;
        db.query(query, [email, password], (error, data) => {
            if (error) reject(error);
            else resolve(data[0]);
        });
    });
}
login2("test1", "' OR '1' = '1")
    .then(result => console.log(result));

프로그래머스 - 뉴스 클러스터링 [자바]

E-room — Tue, 28 Nov 2023 15:59:14 +0900

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

1. 문제 요약

두 문자열의 자카드 유사도를 구하시오.

2. 접근 방법

문자열이 주어질 때, 알파벳의 경우에만 원소로 사용한다는 점을 이용합니다.
- 2글자까지만 사용하기 때문에 경우의 수는 26 * 26이 됩니다.
- 각각의 문자열을 검사하여 26 * 26의 int[][] 배열에 담아줍니다.
문제를 읽어보면 교집합 A ∩ B는 원소 "1"을 min(3, 5)인 3개, 합집합 A ∪ B는 원소 "1"을 max(3, 5)인 5개 가지게 된다. 라고 힌트를 주고 있습니다.
- 이전 단계에서 생성한 배열에 힌트를 그대로 사용합니다.
시간 복잡도는 문자열을 배열로 변환하는 과정에서 문자열이 한글자 늘어날때마다 1번의 연산이 추가됩니다.
- 즉, 문자열의 길이에 비례하므로 O(N)입니다.

3. 자바

class Solution {
    public int solution(String str1, String str2) {
        float intersection = 0;
        float union = 0;

		// 사용할 수 있는 모든 원소를 26 * 26 이중배열에 모두 담아준다.
        int[][] multiset1 = toMultiset(str1);
        int[][] multiset2 = toMultiset(str2);
        
        // 두 이중배열을 순회하면서 힌트를 그대로 사용해준다.
        for (int i = 0; i < 26; i++) {
            for (int j = 0; j < 26; j++) {
                intersection += Math.min(multiset1[i][j], multiset2[i][j]);
                union += Math.max(multiset1[i][j], multiset2[i][j]);
            }
        }

		// 문제에서 제시한 조건대로 정답 가공
        return union == 0
                ? 65536
                : (int) (intersection / union * 65536);
    }

    private int[][] toMultiset(String str) {
        int[][] multiset = new int[26][26];

		// 소대문자 구분하지 않으므로 하나로 통일.
        char[] arr = str.toUpperCase().toCharArray();
        for (int i = 0; i < arr.length - 1; i++) {
            char c1 = arr[i];
            char c2 = arr[i + 1];
            // 원소로 활용할 수 있는지 검사하여 이중배열에 담아준다.
            if (Character.isAlphabetic(c1) && Character.isAlphabetic(c2)) {
                multiset[c1 - 65][c2 - 65]++;
            }
        }

        return multiset;
    }
}

5. 전체 코드

https://github.com/Ksiyeong/Algorithm/blob/main/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4/2/17677.%E2%80%85%EF%BC%BB1%EC%B0%A8%EF%BC%BD%E2%80%85%EB%89%B4%EC%8A%A4%E2%80%85%ED%81%B4%EB%9F%AC%EC%8A%A4%ED%84%B0%EB%A7%81/%EF%BC%BB1%EC%B0%A8%EF%BC%BD%E2%80%85%EB%89%B4%EC%8A%A4%E2%80%85%ED%81%B4%EB%9F%AC%EC%8A%A4%ED%84%B0%EB%A7%81.java

백준 - 11725 트리의 부모 찾기 [DFS][BFS]

E-room — Sun, 5 Nov 2023 12:20:03 +0900

11725번: 트리의 부모 찾기

루트 없는 트리가 주어진다. 이때, 트리의 루트를 1이라고 정했을 때, 각 노드의 부모를 구하는 프로그램을 작성하시오.

www.acmicpc.net

1. 문제 요약

루트 없는 트리가 주어진다. 이때, 트리의 루트를 1이라고 정했을 때, 각 노드의 부모를 구하는 프로그램을 작성하시오.

2. 파이썬

2 - 1. BFS

백준 - 2606 바이러스 [BFS]

2606번: 바이러스 첫째 줄에는 컴퓨터의 수가 주어진다. 컴퓨터의 수는 100 이하인 양의 정수이고 각 컴퓨터에는 1번 부터 차례대로 번호가 매겨진다. 둘째 줄에는 네트워크 상에서 직접 연결되어

e-room.tistory.com

2 - 2. 코드

N = int(input())
tree = [[] for _ in range(N+1)]
for _ in range(N-1):
    a, b = map(int, input().split())
    tree[a].append(b)
    tree[b].append(a)

parents = [0] * (N+1)
parents[1] = 1

q = [1]
while q:
    node = q.pop()
    for next in tree[node]:
        if not parents[next]:
            parents[next] = node
            q.append(next)

print(*parents[2:], sep='\n')

3. 자바

3 - 1. DFS

백준 - 2606 바이러스 [DFS] 자바 백준 1위

e-room.tistory.com

3 - 2. 코드

static List<Integer>[] tree;
static int[] parents;

private static void solution(int node) {
    for (int next : tree[node]) {
        if (parents[next] == 0) {
            parents[next] = node;
            solution(next);
        }
    }
}

4. 전체 코드

https://github.com/Ksiyeong/Algorithm/tree/main/%EB%B0%B1%EC%A4%80/Silver/11725.%E2%80%85%ED%8A%B8%EB%A6%AC%EC%9D%98%E2%80%85%EB%B6%80%EB%AA%A8%E2%80%85%EC%B0%BE%EA%B8%B0

백준 - 1991 트리 순회 [Tree]

E-room — Wed, 1 Nov 2023 16:47:23 +0900

1991번: 트리 순회

첫째 줄에는 이진 트리의 노드의 개수 N(1 ≤ N ≤ 26)이 주어진다. 둘째 줄부터 N개의 줄에 걸쳐 각 노드와 그의 왼쪽 자식 노드, 오른쪽 자식 노드가 주어진다. 노드의 이름은 A부터 차례대로 알파

www.acmicpc.net

1. 문제 요약

이진 트리를 입력받아 전위 순회(preorder traversal), 중위 순회(inorder traversal), 후위 순회(postorder traversal)한 결과를 출력하라.

2. 접근 방법

트리 예시

새로운 노드로 이동할 때마다 순회별 방문 순서를 반복한다고 생각하면 됩니다.

순서가 헷갈릴 수 있는데, 세 단계를 반복하면 쉽습니다.

예시) 전위 순회의 경우

현재 노드 출력
왼쪽 이동
오른쪽 이동

2 - 1. 전위 순회

전위 순회

ABDCEFG // (루트) (왼쪽 자식) (오른쪽 자식)

전위 순회의 경우 루트가 가장 먼저 나오기 때문에, 노드를 방문하자마자 A(1)를 출력합니다.
왼쪽 노드(B)로 이동합니다.
1. 루트가 나왔으므로 B(2)를 출력합니다.(다시 루트-왼쪽-오른쪽 순서를 반복)
2. 왼쪽 노드(D)로 이동합니다.
  1. 루트가 나왔으므로 D(3)를 출력합니다.(다시 루트-왼쪽-오른쪽 순서를 반복)
  2. 왼쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
  3. 오른쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
3. 오른쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
오른쪽 노드(C)로 이동합니다.
1. 루트가 나왔으므로 C(4)를 출력합니다.(다시 루트-왼쪽-오른쪽 순서를 반복)
2. 왼쪽 노드(E)로 이동합니다.
  1. 루트가 나왔으므로 E(5)를 출력합니다.(다시 루트-왼쪽-오른쪽 순서를 반복)
  2. 왼쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
  3. 오른쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
3. 오른쪽 노드(F)로 이동합니다.
  1. 루트가 나왔으므로 F(6)를 출력합니다.(다시 루트-왼쪽-오른쪽 순서를 반복)
  2. 왼쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
  3. 오른쪽 노드(G)로 이동합니다.
    1. 루트가 나왔으므로 G(7)를 출력합니다.(다시 루트-왼쪽-오른쪽 순서를 반복)
    2. 왼쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
    3. 오른쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.

2 - 2. 중위 순회

중위 순회

DBAECFG // (왼쪽 자식) (루트) (오른쪽 자식)

중위 순회의 경우 각각의 노드의 자식이 두 개 이하일 때만 사용할 수 있습니다.

중위 순회의 경우 왼쪽 노드가 가장 먼저 나오기 때문에 왼쪽 노드(B)로 이동합니다.
1. 왼쪽 노드(D)로 이동합니다.(다시 왼쪽-루트-오른쪽 순서를 반복)
  1. 왼쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.(다시 왼쪽-루트-오른쪽 순서를 반복)
  2. 루트가 나왔으므로 D(1)를 출력합니다.
  3. 오른쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
2. 루트가 나왔으므로 B(2)를 출력합니다.
3. 오른쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
루트가 나왔으므로 A(3)를 출력합니다.
오른쪽 노드(C)로 이동합니다.
1. 왼쪽 노드(E)로 이동합니다.(다시 왼쪽-루트-오른쪽 순서를 반복)
  1. 왼쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.(다시 왼쪽-루트-오른쪽 순서를 반복)
  2. 루트가 나왔으므로 E(4)를 출력합니다.
  3. 오른쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
2. 루트가 나왔으므로 C(5)를 출력합니다.
3. 오른쪽 노드(F)로 이동합니다.
  1. 왼쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.(다시 왼쪽-루트-오른쪽 순서를 반복)
  2. 루트가 나왔으므로 F(6)를 출력합니다.
  3. 오른쪽 노드(G)로 이동합니다.
    1. 왼쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.(다시 왼쪽-루트-오른쪽 순서를 반복)
    2. 루트가 나왔으므로 G(7)를 출력합니다.
    3. 오른쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.

2 - 3. 후위 순회

DBEGFCA // (왼쪽 자식) (오른쪽 자식) (루트)

후위 순회

중위 순회의 경우 왼쪽 노드가 가장 먼저 나오기 때문에 왼쪽 노드(B)로 이동합니다.
1. 왼쪽 노드(D)로 이동합니다.(다시 왼쪽-오른쪽-루트 순서를 반복)
  1. 왼쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.(다시 왼쪽-오른쪽-루트 순서를 반복)
  2. 오른쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
  3. 루트가 나왔으므로 D(1)를 출력합니다.
2. 오른쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
3. 루트가 나왔으므로 B(2)를 출력합니다.
오른쪽 노드(C)로 이동합니다.
1. 왼쪽 노드(E)로 이동합니다.(다시 왼쪽-오른쪽-루트 순서를 반복)
  1. 왼쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.(다시 왼쪽-오른쪽-루트 순서를 반복)
  2. 오른쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
  3. 루트가 나왔으므로 E(3)를 출력합니다.
2. 오른쪽 노드(F)로 이동합니다.
  1. 왼쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.(다시 왼쪽-오른쪽-루트 순서를 반복)
  2. 오른쪽 노드(G)로 이동합니다.
    1. 왼쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.(다시 왼쪽-오른쪽-루트 순서를 반복)
    2. 오른쪽 노드를 방문할 차례인데, 방문할 곳이 없습니다.
    3. 루트가 나왔으므로 G(4)를 출력합니다.
  3. 루트가 나왔으므로 F(5)를 출력합니다.
3. 루트가 나왔으므로 C(6)를 출력합니다.
루트가 나왔으므로 A(7)를 출력합니다.

3. 파이썬

# 전위 순회
def preorder(node):
    if node != '.':
        print(node, end='') # 현재 노드 출력
        preorder(tree[node][0]) # 왼쪽 노드
        preorder(tree[node][1]) # 오른쪽 노드
        
# 중위 순회
def inorder(node):
    if node != '.':
        inorder(tree[node][0]) # 왼쪽 노드
        print(node, end='') # 현재 노드 출력
        inorder(tree[node][1]) # 오른쪽 노드
        
# 후위 순회
def postorder(node):
    if node != '.':
        postorder(tree[node][0]) # 왼쪽 노드
        postorder(tree[node][1]) # 오른쪽 노드
        print(node, end='') # 현재 노드 출력

4. 자바

// 전위 순회
private static void preorder(char node) {
    if (node != '.') {
        System.out.print(node); // 현재 노드 출력
        preorder(tree.get(node).left); // 왼쪽 노드
        preorder(tree.get(node).right); // 오른쪽 노드
    }
}

// 중위 순회
private static void inorder(char node) {
    if (node != '.') {
        inorder(tree.get(node).left); // 왼쪽 노드
        System.out.print(node); // 현재 노드 출력
        inorder(tree.get(node).right); // 오른쪽 노드
    }
}

// 후위 순회
private static void postorder(char node) {
    if (node != '.') {
        postorder(tree.get(node).left); // 왼쪽 노드
        postorder(tree.get(node).right); // 오른쪽 노드
        System.out.print(node); // 현재 노드 출력
    }
}

5. 전체 코드

https://github.com/Ksiyeong/Algorithm/tree/main/%EB%B0%B1%EC%A4%80/Silver/1991.%E2%80%85%ED%8A%B8%EB%A6%AC%E2%80%85%EC%88%9C%ED%9A%8C

프로그래머스 - 짝지어 제거하기 [Stack]

E-room — Mon, 30 Oct 2023 23:08:55 +0900

프로그래머스

programmers.co.kr

1. 문제 요약

문자열 s가 주어집니다.

문자열 s안에 연속으로 같은 알파벳 2개가 있으면 제거하고 앞뒤로 이어 붙입니다.

해당 과정을 계속 반복하여 모든 알파벳을 제거할 수 있으면 1을 리턴하고, 없으면 0을 리턴합니다.

2. 접근 방법

제거할 수 없는 알파벳을 담을 Stack을 초기화합니다.
문자열을 순차적으로 방문합니다.
- Stack이 비어있으면 현재 알파벳을 넣습니다.
- Stack에 최근에 넣은 알파벳과 현재 알파벳이 다를 경우 제거할 수 없으므로 현재 알파벳을 넣습니다.
- Stack에 최근에 넣은 알파벳과 현재 알파벳이 같을 경우 제거할 수 있으므로 Stack의 해당 알파벳을 제거합니다.
과정을 마친 후 Stack이 비어있다면 1, 아니면 0을 리턴합니다.

3. 파이썬

def solution(s: str):
    if len(s) % 2 == 1:
        return 0
    
    stack = []
    for char in s:
        if not(stack) or stack[-1] != char:
            stack.append(char)
        else: # stack[-1] == char:
            stack.pop()
    
    return 1 if not(stack) else 0

4. 자바

public int solution(String s) {
    if (s.length() % 2 == 1) {
        return 0;
    }

    Stack<Character> stack = new Stack<>();
    for (char c : s.toCharArray()) {
        if (stack.isEmpty() || stack.peek() != c) {
            stack.push(c);
        } else {
            stack.pop();
        }
    }

    return stack.isEmpty() ? 1 : 0;
}