sunlight-dby 님의 블로그

[코딩테스트 40일차] BAEKJOON 9012번 : 괄호

sunlight-dby — Fri, 11 Jul 2025 01:22:18 +0900

[BAEKJOON 9012번 : 괄호]

[문제]

[고찰]

저는 해당 문제에 대해서 정수형 count 변수를 선언한 후, ' ( '가 나오면 count++을 해주고, ' ) '가 나오면 count--를 해주는 방식으로 하여 count가 0일 때 해당 문자열이 VPS라는 아이디어로 풀었습니다.

다만, 다른 분들의 풀이를 보니 스택으로 해당 문제를 풀었고, 문제의 알고리즘 분류에도 스택이 있어 스택으로도 풀어보려고 합니다.

아래는 괄호를 카운트하는 방식으로 푼 제 코드입니다.

#include <iostream>
#include <string>    

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	int t;
	cin >> t;

	while (t--)
	{
		string str;
		int count = 0;

		cin >> str;

		for (char c : str)
		{
			if (c == '(')
				count++;
			if (c == ')')
				count--;

			if (count < 0)
				break;
		}

		cout << ((count == 0) ? "YES" : "NO") << '\n';
	}

	return 0;
}

[개념]

먼저 스택의 개념을 정리하고자 합니다.

Stack

스택은 컨테이너 어댑터(Container Adapter)입니다.

이는 특정 컨테이너의 기능을 제한하여 특정 데이터 구조의 인터페이스를 제공하는 클래스입니다.

문법

#include <stack>

stack<int> s;      // int형 스택
stack<string> st;  // string형 스택

stack은 <stack> 헤더에 정의되어 있으며,

LIFO (Last In, First Out), 후입선출의 구조로, 마지막에 넣은 데이터가 가장 먼저 나오는 자료구조입니다.

템플릿 매개변수

template <class T, class Container = std::deque<T>>
class stack;

T : 스택에 저장될 요소의 타입입니다.
Container : 스택의 내부 구현에 사용될 컨테이너의 타입입니다. 기본값은 std::deque<T>입니다.
- 해당 매개변수에 std::deque<T> 대신 std::vector<T>나 std::list<T>를 지정할 수 있습니다.

주요 함수

st.push(x) : 스택의 맨 위에 x를 추가
st.pop( ) : 맨 위 요소 제거
st.top( ) : 맨 위 요소 반환
st.empty( ) : 스택이 비어있는지 확인하여 true 또는 false 반환
st.size( ) : 현재 스택에 들어있는 요소 개수 반환

이제 스택을 활용하여 해당 문제를 푸는 방법을 정리해보겠습니다.

char형 스택을 생성한뒤, 입력 받은 문자열을 for문으로 반복하면서, ' ( '면 push, ' ) '면 pop을 하는 것이 기본 아이디어입니다.다만, ' ) '일 때, 스택이 비어있다면 카운트 방식으로 따졌을 때 count가 0 이하가 되는 것이기 때문에, 이때는 push를 해주고 for문 반복을 break를 통해 멈춰줍니다.

이후 스택이 비었는지 안비었는지에 따라 YES 또는 NO를 출력해주면 됩니다.

이를 코드로 표현하면 아래와 같습니다.

stack<char> st;
string str;

cin >> str;

for (char c : str)
{
	if (c == '(')
	{
		st.push(c);
	}
	else
	{
		if (st.empty())
		{
			st.push(c);
			break;
		}
		st.pop();
	}
}

cout << (st.empty() ? "YES" : "NO") << '\n';

[정리]

실버 4가 되니, 슬슬 자료구조에 대해 나오는 것 같습니다.

앞으로 컨테이너 클래스 템플릿에 관해서도 정리해야겠습니다.

[Solution]

#include <iostream>
#include <string>    
#include <stack>    

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	int t;
	cin >> t;

	while (t--)
	{
		stack<char> st;
		string str;

		cin >> str;

		for (char c : str)
		{
			if (c == '(')
			{
				st.push(c);
			}
			else
			{
				if (st.empty())
				{
					st.push(c);
					break;
				}
				st.pop();
			}
		}

		cout << (st.empty() ? "YES" : "NO") << '\n';
	}

	return 0;
}

[코딩테스트 39일차] BAEKJOON 2839번 : 설탕 배달

sunlight-dby — Wed, 2 Jul 2025 00:34:50 +0900

[BAEKJOON 2839번 : 설탕 배달]

[문제]

[고찰]

해당 문제에 대해 저는 아래와 같이 풀었습니다.

저는 5를 우선적으로 빼는 조건을 3의 배수가 아니거나 n이 10보다 클 때로 정했습니다.

그리고 위의 조건을 만족하지 않으면 3을 빼게 하였습니다.

조건을 이렇게 정한 이유는, n이 3의 배수가 아니면 당연히 5를 빼면 되고, n이 10보다 커야한다는 조건은 n이 18일 때 3의 배수이지만 5로 우선적으로 빼야하기 때문입니다. 그래서 10보다 큰 n에 대해서는 우선적으로 5를 빼게 설정한 것이였습니다.

하지만, 이 문제 풀이는 잘못된 풀이였습니다.

n이 12일 때를 생각해보면, n은 10보다 크기 때문에 5를 우선적으로 빼게됩니다.

하지만 5를 뺀 후의 7이 된 n은 어떻게 해도 원하는 답으로 도출되지 못합니다.

제대로된 정답은 n을 모두 3으로 빼는 것이기 때문입니다.

이런 식으로 제가 설정한 조건은 너무 애매한 조건이였습니다.

이에 제대로 된 방법을 정리하고자 합니다.

아래의 코드는 제가 작성한 틀린 답변입니다.

#include <iostream>

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	int n;
	cin >> n;

	int count = 0;

	while (1)
	{
		if (n == 0)
		{
			break;
		}
		else if (n < 0)
		{
			count = -1;
			break;
		}

		if ((n % 3) != 0 || n > 10)
		{
			n -= 5;
			count++;
		}
		else
		{
			n -= 3;
			count++;
		}
	}

	cout << count;

	return 0;
}

[개념]

처음에 5를 빼는 조건을, n이 3의 배수가 아닐 때를 기준으로 잡는 것이 아니라 단순히 n을 5로 나눴을 때 나머지가 0이라는 것으로 기준을 잡았으면 됐었습니다.

그리고 위의 조건이 아닐 때는 3을 빼면 되는 것입니다.

예를 들어 n이 18이라면, 5의 배수가 아니기 때문에 3을 뺍니다.

이후의 n은 15가 되기 때문에 5의 배수라는 조건을 충족하게 됩니다.

n이 5의 배수라는 조건을 충족하게 되면, 3을 고려하지 않아도 되기 때문에 더 이상 n에 추가적인 계산을 하지 않고, count를 n / 5만큼 더해주면 됩니다.

이를 코드로 구현하면 아래와 같습니다.

while (1)
{
	if (n % 5 == 0)
	{
		count += n / 5;
		break;
	}

	n -= 3;
	count++;

	if (n < 0)
	{
		count = -1;
		break;
	}
}

만약 위의 방식이 아니라, n % 3 == 0일 때, count += n / 3;을 하고,
아래에서는 n −= 5를 한다고 하면 최소 봉지 수를 보장하지 않는다는 문제가 발생합니다.

그렇기 때문에 n에서 3을 빼면서, n을 5의 배수로 만드는 방식이 옳은 풀이입니다.

[정리]

위의 정리한 것과 같이 계산하면 되는 문제인데, 저는 큰 수인 5로부터 우선적으로 뺄 생각을 하느라 시야가 좁아졌던 것 같습니다.

시야를 넓혀야 하는데 문제를 풀다보면 계속해서 좁아지고, 어떻게든 예제 입력 답변에 맞추기 위해 억지로 조건을 껴맞치고 있습니다.

계속 놓치고 있는 부분들을 계속 생각하면서 발전해 나가도록 하겠습니다.

[Solution]

#include <iostream>

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	int n;
	cin >> n;

	int count = 0;

	while (1)
	{
		cout << n << endl;
		if (n % 5 == 0)
		{
			count += n / 5;
			break;
		}

		n -= 3;
		count++;

		if (n < 0)
		{
			count = -1;
			break;
		}
	}

	cout << count;

	return 0;
}

[Unity 개발] King's Adventure - Player 상태 세부 구현

sunlight-dby — Tue, 1 Jul 2025 22:53:23 +0900

Unity 2D 기반으로 픽셀 컨셉의 Adventure RPG를 개발하려고 합니다.

모바일, PC 기반으로 개발할 예정입니다.

일단 가제는 'King's Adventure'로 정하였습니다.

오늘 기획 및 개발한 내용을 블로그에 정리합니다.

State 구조

상위 State는 Singleton으로 만든 Player, PlayerController에서 관리하는 변수 사용을 위해 PlayerController와 하위 상태 관리를 위한 SubStateMachine, 하위 상태들로 이루어져있습니다.

public enum PlayerSubStateType
{
    Attack,
    Skill_1,
    Skill_2,
    Roll,
    Block,
    Pray,
    Sleep
}

또한, 열거형 Player Sub State Type을 설정하여, 필요할 때 하위 상태를 한번에 변경할 수 있게 구성하였습니다.

Super State : GroundedState

public class PlayerGroundedState : IState
{
    // Singleton Instance
    protected Player player;

    protected PlayerController playerController;
    private StateMachine subStateMachine;

    // Sub State
    public PlayerIdleState idleState { get; private set; }
    public PlayerWalkState walkState { get; private set; }

    public PlayerGroundedState(Player player, PlayerController playerController)
    {
        this.player = player;
        this.playerController = playerController;
    }

    public virtual void Enter()
    {
        if (subStateMachine == null)
        {
            subStateMachine = new StateMachine();

            idleState = new PlayerIdleState(player, playerController, subStateMachine);
            walkState = new PlayerWalkState(player, playerController, subStateMachine);

            subStateMachine.Initialize(idleState);
        }
    }

    public virtual void Update()
    {
        subStateMachine.Update();
    }

    public virtual void Exit()
    {
        subStateMachine?.Exit();

        subStateMachine = null;
    }
}

실제 플레이어의 움직임은 PlayerController에서 구현되어 있기 때문에, Grounded State의 하위 상태는 주로 PlayerController에서 변경됩니다.

Sub State : IdleState

public class PlayerIdleState : PlayerGroundedState
{
    private StateMachine _stateMachine;

    public PlayerIdleState(Player player, PlayerController playerController, StateMachine parentStateMachine)
        : base(player, playerController)
    {
        _stateMachine = parentStateMachine;
    }

    public override void Enter()
    {
        playerController.PlayAnim("Idle");
        playerController.PlayAnim("isWalking", false);
    }

    public override void Update()
    {
        HandleTransitions();
    }

    private void HandleTransitions()
    {
        if (playerController.moveVec != Vector2.zero)
        {
            playerController.PlayAnim("Idle");
            playerController.PlayAnim("isWalking", false);
            _stateMachine.ChangeState(this.playerController.groundedState.walkState);
        }
    }

    public override void Exit()
    {
        
    }
}

Idle State에서는 Idle 애니메이션을 재생합니다.

또한, 플레이어가 움직일 때, Walk State로 상태를 변경합니다.

Sub State : WalkState

public class PlayerWalkState : PlayerGroundedState
{
    private StateMachine _stateMachine;

    public PlayerWalkState(Player player, PlayerController playerController, StateMachine parentStateMachine)
        : base(player, playerController)
    {
        _stateMachine = parentStateMachine;
    }

    public override void Enter()
    {
        playerController.PlayAnim("isWalking", true);
    }

    public override void Update()
    {
        HandleTransitions();
    }

    private void HandleTransitions()
    {
        if (playerController.moveVec == Vector2.zero)
        {
            _stateMachine.ChangeState(this.playerController.groundedState.idleState);
        }
    }

    public override void Exit()
    {

    }
}

Walk State에서는 Walk 애니메이션을 재생하고,

플레이어가 움직이지 않을 때 Idle State로 상태를 변경합니다.

Super State : InAirState

public class PlayerInAirState : IState
{
    // Singleton Instance
    protected Player player;

    // Constant
    public readonly float JUMP_FORCE = 6.5f;
    public readonly float WALL_SLIDE_SCALE = 0.8f;
    public readonly float GRAVITY_SCALE = 1.5f;
    public readonly float STANDARD_HOLDTIME = 0.6f;
    public readonly float MIN_FORCE_SCALE = 1.0f;
    public readonly float MAX_FORCE_SCLAE = 1.3f;

    protected PlayerController playerController;
    private StateMachine subStateMachine;

    // Sub State
    public PlayerJumpState jumpState{ get; private set; }
    public PlayerFallState fallState { get; private set; }
    public PlayerWallSlideState wallSlideState { get; private set; }

    private float jumpPressStartTime;
    private float jumpDuration;
    private bool isPressingJump = false;

    public PlayerInAirState(Player player, PlayerController playerController)
    {
        this.player = player;
        this.playerController = playerController;
    }

    public virtual void Enter()
    {
        if (subStateMachine == null)
        {
            subStateMachine = new StateMachine();

            jumpState = new PlayerJumpState(player, playerController, subStateMachine);
            fallState = new PlayerFallState(player, playerController, subStateMachine);
            wallSlideState = new PlayerWallSlideState(player, playerController, subStateMachine);
        }

        if (!playerController.isJumping)
        {
            if (playerController.isWallSliding)
            {
                subStateMachine.Initialize(wallSlideState);
            }
            else
            {
                subStateMachine.Initialize(fallState);
            }
        }
    }

    public virtual void Update()
    {
        subStateMachine.Update();
    }

    public virtual void HandleInput(InputAction.CallbackContext context)
    {
        // if (playerController.isJumping) return;

        if (context.started)
        {
            jumpPressStartTime = Time.time;
            isPressingJump = true;
        }

        if (context.canceled && isPressingJump)
        {
            jumpDuration = Time.time - jumpPressStartTime;
            isPressingJump = false;

            if (jumpDuration >= STANDARD_HOLDTIME)
                playerController.holdingTime = MAX_FORCE_SCLAE;
            else if (jumpDuration < STANDARD_HOLDTIME)
                playerController.holdingTime = MIN_FORCE_SCALE;
            else
                playerController.holdingTime = jumpDuration;

            if (playerController.jumpCount == 0)
                subStateMachine.Initialize(jumpState);
        }
    }

    public virtual void Exit()
    {
        subStateMachine?.Exit();
        
        playerController.isJumping = false;
        playerController.jumpCount = 0;
        
        playerController.isWallSliding = false;
        playerController.PlayAnim("WallSlide", false);

        subStateMachine = null;
    }
}

전의 게시글에서 설명한 것과 같이 스페이스바를 누르고 있는 시간에 따라 점프 길이가 길어지게끔 구현하였습니다.

플레이어가 공중에 떠있는 순간은, 점프 또는 떨어지는 것, 벽 슬라이드 뿐입니다.

떨어지거나 벽 슬라이드를 하기 전에는 반드시 점프가 선행되어야 하기 때문에,

subStateMachine.Initialize(jumpState)를 통해 InAirState의 하위 스테이트 머신에서 점프 스테이트로 변경되게끔 하였습니다.

InAirState에서 상태가 종료될 때, 여러 변수를 초기화해줍니다.

Sub State : JumpState

public class PlayerJumpState : PlayerInAirState
{
    private StateMachine _stateMachine;

    private bool isPlayAnim;

    public PlayerJumpState(Player player, PlayerController playerController, StateMachine parentStateMachine)
        : base(player, playerController)
    {
        _stateMachine = parentStateMachine;
    }

    public override void Enter()
    {
        playerController.jumpCount++;

        isPlayAnim = false;
        player.rigidBody.velocity = new Vector2(player.rigidBody.velocity.x, JUMP_FORCE * playerController.holdingTime);
    }

    public void PlayJumpAnim()
    {
        if (!isPlayAnim)
        {
            playerController.PlayAnim("Jump");
            isPlayAnim = true;
        }
    }

    public override void Update()
    {
        if (player.rigidBody.velocity.y > 0)
            PlayJumpAnim();

        HandleTransitions();
    }

    private void HandleTransitions()
    {
        if (player.rigidBody.velocity.y < 0)
        {
            _stateMachine.ChangeState(this.playerController.inAirState.fallState);
        }
    }

    public override void Exit()
    {

    }
}

점프에 대해서는 더블 점프와 같은 기능은 제외하기 위해, jumpCount 변수를 통해 제한을 둡니다.

또한 실제로 점프를 해당 스크립트에서 실행되고, 추락할 때 Fall State로 상태를 변경합니다.

Sub State : FallState

public class PlayerFallState : PlayerInAirState
{
    private StateMachine _stateMachine;

    public PlayerFallState(Player player, PlayerController playerController, StateMachine parentStateMachine)
        : base(player, playerController)
    {
        _stateMachine = parentStateMachine;
    }

    public override void Enter()
    {
        playerController.PlayAnim("Fall");
    }

    public override void Update()
    {
        player.rigidBody.velocity -= Vector2.down * Physics2D.gravity.y * GRAVITY_SCALE * Time.deltaTime;

        HandleTransitions();
    }

    private void HandleTransitions()
    {
        if (playerController.isWallSliding)
        {
            _stateMachine.ChangeState(this.playerController.inAirState.wallSlideState);
        }
    }

    public override void Exit()
    {

    }
}

JumpState에서 FallState로 상태가 변경될 때, 만약 isWallSliding이 true라면 WallSlideState로 상태가 변경됩니다.

실제로 떨어지는 로직과 애니메이션이 해당 스크립트에서 실행됩니다.

Sub State : WallSlideState

public class PlayerWallSlideState : PlayerInAirState
{
    private StateMachine _stateMachine;

    public PlayerWallSlideState(Player player, PlayerController playerController, StateMachine parentStateMachine)
        : base(player, playerController)
    {
        _stateMachine = parentStateMachine;
    }

    public override void Enter()
    {
        playerController.PlayAnim("WallSlide", true);
    }

    public override void Update()
    {
        if (playerController.isJumping)
        {
            player.rigidBody.velocity -= Vector2.down * Physics2D.gravity.y * GRAVITY_SCALE * WALL_SLIDE_SCALE * Time.deltaTime;
        }

        HandleTransitions();
    }

    private void HandleTransitions()
    {
        if (!playerController.isWallSliding)
        {
            player.animator.StopPlayback();
            _stateMachine.ChangeState(this.playerController.groundedState);
        }
    }
}

WallSlideState에서는 떨어질 때, WALL_SLIDE_SCALE을 추가로 곱해줌으로써, 일반적으로 떨어질 때와 벽을 슬라이드할 때와 다르게 떨어지게끔 구현하였습니다.

Super State : CombatState

public class PlayerCombatState : IState
{
    // Singleton Instance
    protected Player player;
    
    // Constant
    public readonly int MAX_ATTACK_COUNT = 3;
    public readonly float MIN_ATTACK_TIME = 0.5f;
    
    protected PlayerController playerController;
    private StateMachine subStateMachine;

    // Sub State
    public PlayerAttackState attackState { get; private set; }

    // Attack
    protected int attackCount = 0;
    protected float attackIntervalTime;

    public PlayerCombatState(Player player, PlayerController playerController)
    {
        this.player = player;
        this.playerController = playerController;
    }

    public virtual void Enter()
    {
        if (subStateMachine == null)
        {
            subStateMachine = new StateMachine();
            
            attackState = new PlayerAttackState(player, playerController, subStateMachine);
        }
    }

    public virtual void Update()
    {
        subStateMachine.Update();
    }

    public virtual void HandleInput(InputAction.CallbackContext context, PlayerSubStateType stateName)
    {
        switch (stateName)
        {
            case PlayerSubStateType.Attack :
                if (context.started)
                {
                    playerController.isAttacking = true;

                    if (playerController.CurrentAnim("Attack1") || playerController.CurrentAnim("Attack2") || playerController.CurrentAnim("Attack3"))
                    {
                        float animTime = playerController.CurrentAnimTime(true);

                        if (animTime >= 0.7f && animTime < 1f)
                        {
                            subStateMachine.Initialize(attackState);
                        }
                    }
                    else
                    {
                        subStateMachine.Initialize(attackState);
                    }
                }
                break;
            case PlayerSubStateType.Skill_1 :
                break;
            case PlayerSubStateType.Skill_2 :
                break;
            default:
                break;
        }
    }

    public virtual void Exit()
    {
        subStateMachine?.Exit();

        playerController.isAttacking = false;

        subStateMachine = null;
    }
}

Combat State로는 마우스 클릭을 통해 상태가 변경됩니다.

Handle Input 메서드에서 공격일때와 스킬일 때를 구분합니다.

Sub State : AttackState

public class PlayerAttackState : PlayerCombatState
{
    private StateMachine _stateMachine;

    public PlayerAttackState(Player player, PlayerController playerController, StateMachine parentStateMachine)
        : base(player, playerController)
    {
        _stateMachine = parentStateMachine;
    }

    public override void Enter()
    {
        attackIntervalTime = 0;

        if (attackCount == MAX_ATTACK_COUNT)
            attackCount = 0;

        if (attackIntervalTime > MIN_ATTACK_TIME)
            attackCount = 0;

        attackCount++;
        playerController.PlayAnim("Attack" + attackCount);
    }

    public override void Update()
    {
        attackIntervalTime += Time.deltaTime;
        HandleTransitions();
    }

    private void HandleTransitions()
    {
        if (attackIntervalTime > playerController.CurrentAnimTime(false))
            playerController.ChangeState(playerController.groundedState);
    }

    public override void Exit()
    {

    }
}

플레이어는 공격을 3번까지 콤보로 사용 가능합니다.

일정 시간 안에 공격을 하면 3번까지 공격을 연달아 가능하고, 일정 시간이 지나면 다시 첫번째 공격으로 하게 됩니다.

다른 스킬에 대한 것은 추후 추가될 예정입니다.

Super State : EvasionState

public class PlayerEvasionState : IState
{
    // Singleton Instance
    protected Player player;

    // Constatnt
    public readonly float ROLL_FORCE = 10f;
    public readonly float ROLL_WAIT_TIME = 0.3f;
    public readonly float BLOCK_WAIT_TIME = 2f;

    protected PlayerController playerController;
    private StateMachine subStateMachine;

    // Sub State
    public PlayerRollState rollState { get; private set; }
    public PlayerBlockState blockState { get; private set; }

    public PlayerEvasionState(Player player, PlayerController playerController)
    {
        this.player = player;
        this.playerController = playerController;
    }

    public virtual void Enter()
    {
        if (subStateMachine == null)
        {
            subStateMachine = new StateMachine();

            rollState = new PlayerRollState(player, playerController, subStateMachine);
            blockState = new PlayerBlockState(player, playerController, subStateMachine);
        }
    }

    public virtual void Update()
    {
        subStateMachine.Update();
    }

    public virtual void HandleInput(InputAction.CallbackContext context, PlayerSubStateType stateName)
    {
        switch (stateName)
        {
            case PlayerSubStateType.Roll :
                if (!playerController.isRolling && playerController.inputVec.x != 0)
                {
                    subStateMachine.ChangeState(rollState);
                }
                break;
            case PlayerSubStateType.Block :
                Debug.Log("Block");
                if (context.started && !playerController.isBlocking)
                {
                    subStateMachine.ChangeState(blockState);
                }
                if (context.canceled && playerController.isBlocking)
                {
                    playerController.isBlocking = false;
                }
                break;
            default:
                break;
        }
    }

    public virtual void Exit()
    {
        subStateMachine?.Exit();

        subStateMachine = null;
    }
}

PlayerController에서 Roll과 Block은 바인딩된 키에 따라 하위 상태가 바로 변경되게끔 구현해놓았기 때문에,

HandleInput 메서드에서 PlayerSubStateType에 따라 Roll State 또는 Block State로 상태가 시작되게끔 하였습니다.

Sub State : RollState

public class PlayerRollState : PlayerEvasionState
{
    private StateMachine _stateMachine;

    public PlayerRollState(Player player, PlayerController playerController, StateMachine parentStateMachine)
        : base(player, playerController)
    {
        _stateMachine = parentStateMachine;
    }

    public override void Enter()
    {
        playerController.isRolling = true;

        float direction = Mathf.Sign(playerController.inputVec.x);

        playerController.PlayAnim("Roll");
        player.rigidBody.AddForce(new Vector2(direction * ROLL_FORCE, 0), ForceMode2D.Impulse);

        playerController.CallStartCoroutine(RollCoroutine());
    }

    IEnumerator RollCoroutine()
    {
        yield return new WaitForSeconds(ROLL_WAIT_TIME);

        playerController.isRolling = false;
        playerController.StopPlayer();
    }

    public override void Update()
    {
        HandleTransitions();
    }

    private void HandleTransitions()
    {
        if (!playerController.isRolling)
        {
            playerController.ChangeState(this.playerController.groundedState);
        }
    }

    public override void Exit()
    {
        playerController.isRolling = false;
    }
}

RollState에서는 코루틴을 적용하여, 정해진 시간동안 무조건 구르기가 실행되게끔 하였습니다.

그리고 공중에서는 구르기를 하지 못하게 하였기 때문에, HandleTransitions에서 플레이어가 구르고있지 않다면 Grounded State로 상태가 변경되게끔 구현하였습니다.

Sub State : BlockState

public class PlayerBlockState : PlayerEvasionState
{
    private StateMachine _stateMachine;

    // Variables
    private IEnumerator blockCoroutine;

    public PlayerBlockState(Player player, PlayerController playerController, StateMachine parentStateMachine)
        : base(player, playerController)
    {
        _stateMachine = parentStateMachine;
    }

    public override void Enter()
    {
        playerController.isBlocking = true;

        playerController.PlayAnim("Block");;

        playerController.StopPlayer();

        blockCoroutine = BlockCoroutine();
        playerController.CallStartCoroutine(blockCoroutine);
    }

    IEnumerator BlockCoroutine()
    {
        yield return new WaitForSeconds(BLOCK_WAIT_TIME);

        playerController.isBlocking = false;
    }

    public override void Update()
    {
        HandleTransitions();
    }

    private void HandleTransitions()
    {
        if (!playerController.isBlocking)
        {
            playerController.CallStopCoroutine(blockCoroutine);

            playerController.ChangeState(playerController.groundedState);
        }
    }

    public override void Exit()
    {
        playerController.isBlocking = false;
    }
}

Block State는 마우스 오른쪽 클릭으로 상태가 전환됩니다.

Block은 최대 초가 존재하기에, 만약 최대 초 이상으로 계속 마우스 오른쪽 클릭을 누르고 있으면,

Block 상태가 풀리면서 Grounded State로 상태가 변경됩니다.

다른 State들에 대해서는, 추후 구현할 예정입니다.

[코딩테스트 37일차] BAEKJOON 2563번 : 색종이

sunlight-dby — Sat, 28 Jun 2025 03:40:58 +0900

[BAEKJOON 2563번 : 색종이]

[문제]

[고찰]

해당 문제에 대해 아이디어가 너무 떠오르지 않아, 잘못된 풀이일거라는 직감이 있었지만 어떻게든 풀기 위해 아래와 같이 풀게 되었습니다.

결과는 물론 틀렸기는 합니다만.. 모든 경우의 수를 고려했다고 생각했는데 아니였던 것 같습니다.

이에 올바른 풀이를 정리하고자 합니다.

#include <iostream>
#include <vector>     

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	int n;
	cin >> n;

	vector<pair<int, int>> squares(n);

	int blackArea = 0;
	int area = 100 * n;

	for (int i = 0; i < n; i ++)
	{
		cin >> squares[i].first >> squares[i].second;
	}

	for (int i = 0; i < squares.size() - 1; i++)
	{
		for (int j = i + 1; j < squares.size(); j++)
		{
			int a = squares[i].first; int b = squares[i].second;
			int x = squares[j].first; int y = squares[j].second;

			if (a < x && x < a + 10)
			{
				if (b < y + 10 && y + 10 < b + 10)
				{
					blackArea += (a + 10 - x) * (y + 10 - b);
				}
				else if (b < y && y < b + 10)
				{
					blackArea += (x - a + 10) * (b + 10 - y);
				}
				else if (y == b)
				{
					blackArea += (a + 10 - x) * 10;
				}
			}
			else if (a < x + 10 && x + 10 < a + 10)
			{
				if (b < y + 10 && y + 10 < b + 10)
				{
					blackArea += (x + 10 - a) * (y + 10 - b);
				}
				else if (b < y && y < b + 10)
				{
					blackArea += (x + 10 - a) * (b + 10 - y);
				}
				else if (y == b)
				{
					blackArea += (x + 10 - a) * 10;
				}
			}
			else if (a == x)
			{
				if (b < y + 10 && y + 10 < b + 10)
				{
					blackArea += 10 * (y + 10 - b);
				}
				else if (b < y && y < b + 10)
				{
					blackArea += 10 * (b + 10 - y);
				}
				else if (y == b)
				{
					blackArea += 10 * 10;
				}
			}
		}
	}

	cout << area - blackArea;

	return 0;
}

[개념]

해당 문제를 풀기 위한 아이디어는 도화지를 고려하여, 색칠한 부분만 계산하는 것입니다.

물론 저도 이 방법을 못떠올린 것은 아니지만, 이를 구현할 능력이 부족하였었습니다..

일단 도화지를 100 x 100으로 초기화하는데, bool 타입의 2차원 배열을 만듭니다.

n번만큼 색종이를 입력 받을 때, 그 색종이에 해당하는 부분을 색칠합니다.

이중 for문으로, i가 x부터 x + 10까지, j가 y부터 y + 10까지 반복하면서

paper[ i ][ j ]를 true로 바꾸어 색칠한 것으로 칩니다.

이후 area를 1 더해주면 됩니다.

겹쳐진 부분은 칠하면 안되기 때문에, 이중 for문에 if문을 추가하여, 이를 방지합니다.

if (!paper[ i ][ j ])로 이를 확인해주면, 색칠한 부분은 다시 색칠하지 않습니다.

이를 코드로 구현하면 아래와 같습니다.

while (n--)
{
	int x, y;
	cin >> x >> y;

	for (int i = x; i < x + 10; i++)
	{
		for (int j = y; j < y + 10; j++)
		{
			if (!paper[i][j])
			{
				paper[i][j] = true;
				area++;
			}
		}
	}
}

[정리]

이런 문제를 푸는 것은, 코딩테스트 쪽으로 머리가 잘 굴러가야하는 것 같습니다.

더욱 증진해보겠습니다.

[Solution]

#include <iostream>
using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;

    bool paper[100][100] = { false };
    int area = 0;

    while (n--)
    {
        int x, y;
        cin >> x >> y;

        for (int i = x; i < x + 10; i++)
        {
            for (int j = y; j < y + 10; j++)
            {
                if (!paper[i][j])
                {
                    paper[i][j] = true;
                    area++;
                }
            }
        }
    }

    cout << area;
    
    return 0;
}

[코딩테스트 36일차] BAEKJOON 1436번 : 영화감독 숌

sunlight-dby — Fri, 27 Jun 2025 01:46:44 +0900

[BAEKJOON 1436번 : 영화감독 숌]

[문제]

[고찰]

이 문제를 봤을 때, 도대체 무슨 소리인지 하나도 모르겠었습니다.

사실 다른 분들의 풀이를 여러번 보았는데도 이해가 안됐었습니다.

하지만 코드를 이해하고 보니, 그제서야 무슨 소리인지가 이해가 되었습니다.

처음에는 어떤 규칙이 숨어있나 계속 뜯어보고, 생각하고 했었는데 규칙이 아니였습니다.

문제에서 요구하는 것은 666을 제일 작은 종말의 수로 하여금, 666이 포함된 N번째로 작은 종말의 수를 찾으라는 것이었습니다.

즉, 666부터 시작하여 계속 증가시키면서 666이 포함된 작은 수를 출력하라는 것이었습니다.

이를 기반으로 내용을 정리해보겠습니다.

[개념]

문제를 풀기 전, 알아야 할 개념은 to_string과 find입니다.

간단하게 설명하면,

to_string은 인자를 string으로 변환시켜주는 것이고,

find는 인자가 있는지 확인하여 문자열에서 위치를 리턴합니다. 그리고 만약 존재하지 않는다면 string::npos를 리턴합니다.

이 개념을 알고, 문제를 풀 때 필요한 변수는 count와 number입니다.

count는 반복문에서 n과 같을 때, n번째로 작은 종말의 수를 찾았다는 것을 확인하기 위한 변수로, 초기값은 0으로 선언합니다.

number는 666으로 선언하여, 반복문에서 n번째로 작은 종말의 수를 찾기 전까지 계속 ++ 연산자로 1씩 더해줍니다.

while (true)
{
	if (to_string(number).find("666") != string::npos)
		count++;

	if (count == n)
	{
		cout << number;
		break;
	}

	number++;
}

[정리]

이번 문제는 사실 어떻게 했어도 이해가 되지 않았을 것 같습니다..

정말 많은 시간을 투자하면서 고민을 했는데도, 문제 자체를 파악하지 못했기 때문입니다.

많은 문제를 풀다보면 괜찮아지지 않을까 생각해봅니다..

[Solution]

#include <iostream>
#include <string>

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	int n;
	cin >> n;

	int count = 0;
	int number = 666;

	while (true)
	{
		if (to_string(number).find("666") != string::npos)
			count++;

		if (count == n)
		{
			cout << number;
			break;
		}

		number++;
	}

	return 0;
}

[코딩테스트 35일차] BAEKJOON 10814번 : 나이순 정렬

sunlight-dby — Tue, 24 Jun 2025 01:36:06 +0900

[BAEKJOON 10814번 : 나이순 정렬]

[문제]

[고찰]

저는 이 문제를 어떻게 풀지 고민할 때, pair 클래스는 sort를 적용할 때, 자동으로 second 요소까지 자동으로 정렬을 적용한다는 것을 생각하였습니다.

그래서 sort를 사용하는 것은 안되겠다 하여, 직접 정렬을 구현하였습니다.

어떻게 구현할지 많은 고민 끝에, 비효율적인 것을 알지만서도 방법이 없어 아래와 같이 구현하였습니다.

무한 루프 안에서, 제대로 정렬이 될 때까지 계속 입력받은 벡터를 반복하는 형태로 구현하였습니다.

#include <iostream>
#include <vector>     // 10814번

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	int n;
	cin >> n;

	pair<int, string> p;
	vector<pair<int, string>> subscriber;
	bool bIsSort = false;

	while (n--)
	{
		cin >> p.first >> p.second;
		subscriber.push_back(p);
	}

	while (true)
	{
		int i = 0;
		bIsSort = false;

		for (i; i < subscriber.size(); i++)
		{
			if (i + 1 >= subscriber.size())
				break;

			if (subscriber[i].first == subscriber[i + 1].first)
				continue;

			if (subscriber[i].first > subscriber[i + 1].first)
			{
				swap(subscriber[i], subscriber[i + 1]);

				bIsSort = true;
			}
		}

		if (!bIsSort)
		{
			break;
		}
	}

	for (const auto& p : subscriber)
	{
		cout << p.first << ' ' << p.second << '\n';
	}

	return 0;
}

물론 위의 작성된 코드로, 시간 초과가 뜨면서 실패하였습니다.

다른 분들의 풀이를 보니, 해당 문제를 풀 수 있는 간단한 방법이 존재하였습니다.

그 간단한 방법은 stable_sort() 함수였습니다.

또한, 구조체를 사용하는 방법도 있었습니다.

나이와 이름, 그리고 입력 순서를 저장할 수 있는 구조체를 만들고, 이 구조체를 기반으로 벡터를 만들어서 sort를 적용했어도 됩니다.

입력 순서를 저장하는 방법도 생각을 못한건 아니지만, pair 클래스에만 생각이 갇혀있어 구조체를 생각하지 못했습니다.

그래서 stable_sort( )와 구조체를 활용하는 풀이에 대해 정리하고자 합니다.

[개념]

제가 푼 코드는 시간 복잡도가 O(n²)로 매우 비효율적입니다.

이를 개선하기 위해서 stable_sort( )를 사용하는 방법과, 구조체를 사용하는 방법에 대해 정리합니다.

stable_sort

#include <algorithm>

template <class RandomIt, class Compare>
void stable_sort(RandomIt first, RandomIt last, Compare comp);

stable_sort는 정렬 시, 원래의 순서를 보장해주는 정렬 함수입니다.

sort와 사용법은 동일하지만, sort와는 달리 정렬 기준이 동일한 요소끼리는 원래의 입력 순서를 유지합니다.

stable_sort를 사용할 시 시간 복잡도는 최악의 경우 O(n log² n)이며, 평균적으로는 O(n log n)의 시간 복잡도를 갖습니다.

struct 사용

나이와 이름, 입력 순서를 저장할 수 있는 구조체를 만듭니다.

struct Person
{
    int age;
    string name;
    int order;
}

이후 boolean을 반환형으로 하는 comapre 함수를 만들어, Person a와 Person b를 비교할 수 있게 합니다.

[정리]

몰랐던 개념인 것도 있었지만, 충분히 풀 수 있었던 문제라고 생각합니다.

코딩테스트에서 생각의 틀이 갇히는 것만큼 위험한 것은 없는 것 같다고 느꼈고, 생각의 틀에 갇히지 않게 조심해야 겠습니다.

[Solution : stable_sort 활용]

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

bool compare(const pair<int, string>& a, const pair<int, string>& b)
{
	return a.first < b.first;
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(nullptr);

	int n;
	cin >> n;

	vector<pair<int, string>> members(n);

	for (int i = 0; i < n; ++i)
	{
		cin >> members[i].first >> members[i].second;
	}

	stable_sort(members.begin(), members.end(), compare);

	for (const auto& member : members)
	{
		cout << member.first << " " << member.second << '\n';
	}

	return 0;
}

[Solution : struct 활용]

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

struct Person
{
    int age;
    string name;
    int order;
};

bool compare(const Person& a, const Person& b)
{
    if (a.age == b.age)
        return a.order < b.order;
        
    return a.age < b.age;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;

    vector<Person> people(n);

    for (int i = 0; i < n; i++)
    {
        cin >> people[i].age >> people[i].name;
        people[i].order = i;
    }

    sort(people.begin(), people.end(), compare);

    for (const auto& person : people)
    {
        cout << person.age << ' ' << person.name << '\n';
    }

    return 0;
}

[코딩테스트 34일차] BAEKJOON 11650번 : 좌표 정렬하기, 1193번 : 분수찾기

sunlight-dby — Mon, 23 Jun 2025 01:07:35 +0900

[BAEKJOON 11650번 : 좌표 정렬하기]

[문제]

[고찰]

처음에 이 문제를 보고 풀 때, vector<int[2]> coordinate(n); 으로 크기 2의 int형 배열로 좌표를 입력받을 벡터를 만들었습니다.

다만 컴파일을 시작한 뒤 오류가 발생하였고, 오류에서 말하는 핵심은, 정적 배열 타입을 vector에 직접 사용하여서 발생하는 컴파일 오류였습니다.

그래서 어떻게 풀어갈까 생각하다가, 답이 나오지 않아 두 쌍을 입력받을 수 있는 형식에 대해 검색하였고, pair를 택하게 되었습니다.

pair<int, int> p;로 pair를 선언한 뒤, cin >> p.first >> p.second;로 입력을 받았습니다.

그리고 boolean을 return으로 하는 compare 함수를 만들어, pair before과 pair after를 인자로 받아, 사용자 정의 정렬을 할 수 있게 구현하였습니다.

bool compare(pair<int, int> before, pair<int, int> after)
{
	if (before.first != after.first)
		return before.first < after.first;

	return before.second < after.second;
}

하지만 여기서 제가 간과한 것은, pair 타입은 sort를 사용했을 때, first를 기본으로 정렬하고 만약 first가 같다면 자동으로 second를 기준으로 정렬을 한다는 것이었습니다.

즉, 제가 구태여 compare 함수를 만들 필요가 없던 것이었습니다.

이는 제가 pair에 대해서 잘 몰랐기 때문이었고, 그래서 이를 정리하고자 합니다.

또한 struct를 썼을 때는 어떻게 구현을 해야할지도 같이 정리해보겠습니다.

아래는 제가 작성한 코드입니다.

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

bool compare(pair<int, int> before, pair<int, int> after)
{
	if (before.first != after.first)
		return before.first < after.first;

	return before.second < after.second;
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	int n;
	cin >> n;

	vector<pair<int, int>> coordinate(n);

	for (int i = 0; i < n; i++)
	{
		pair<int, int> p;
		cin >> p.first >> p.second;
		
		coordinate[i] = p;
	}

	sort(coordinate.begin(), coordinate.end(), compare);

	for (int j = 0; j < n; j++)
	{
		cout << coordinate[j].first << " " << coordinate[j].second << '\n';
	}

	return 0;
}

[개념]

pair

#include <utility>

template <class T1, class T2> struct pair;

pair<T1, T2>는 서로 다른 타입 두 개를 묶는 STL 구조체입니다. 물론 같은 타입 두 개를 묶을 수도 있습니다.

주로 서로 연관된 2개의 데이터를 한 쌍으로 묶어서 다룰 때 사용됩니다.

헤더파일
- #include <utility>
  - pair 클래스는 #include <utility>라는 헤더파일에 존재하는 STL입니다.
  - 그러나, <algorithm>과 <vector> 헤더파일에 이미 <utility> 헤더파일이 포함되어 있기 때문에, 앞의 두 헤더파일이 사용되었다면 굳이 <utility> 헤더파일을 주가해주지 않아도 됩니다.
요소 접근
- T1과 T2는 각각 first와 second로 접근할 수 있습니다.
pair 생성
- 요소 직접 입력
  - pair<int, int> p; p.first = 0; p.second = 1;
- make_pair(value1, value2) 사용
  - value1, value2를 한 쌍으로 하는 pair를 만들어 반환합니다.
  - pair<int, int> p = make_pair(0, 1);
pair의 sort( )
- std::pair는 sort( )와 잘 호환되어 있습니다.
- 정렬 기준은 아래의 기준대로 정렬되며, 오름차순으로 자동 적용이 됩니다.
  - first 값이 작은 순서
  - first가 같으면 second 값이 작은 순서

struct 사용

만약 해당 문제를 struct를 사용해서 풀었다면, 아래와 같이 구조체를 정의합니다.

struct Point
{
    int x, y;
};

구조체는 정렬함수 sort( )에 있어서, 사용자 정의 정렬을 적용해주어야 하기 때문에 compare 함수를 정의해야 합니다.

bool compare(const Point& a, const Point& b)
{
    if (a.x == b.x) 
        return a.y < b.y;
    
    return a.x < b.x;
}

auto 사용

아래의 Solution 코드를 살펴보면, 반복문에서 const auto& p를 사용합니다.

pair 클래스를 간편하게 반복하고자 사용하였습니다.

[정리]

이런 기본도 아직 잘 모른다는 것에 반성하며, 더욱 공부에 힘써야겠습니다.

또한 auto도 알고는 있었지만, 적용할 생각은 못했었습니다. 앞으로는 이런 것도 잘 생각하면서 문제 풀이를 할 것입니다.

[Solution : pair 사용]

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	int n;
	cin >> n;

	vector<pair<int, int>> coordinate(n);

	for (int i = 0; i < n; i++)
	{
		cin >> coordinate[i].first >> coordinate[i].second;
	}

	sort(coordinate.begin(), coordinate.end());

	for (const auto& p : coordinate)
	{
		cout << p.first << " " << p.second << '\n';
	}

	return 0;
}

[Solution : struct 사용]

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct Point
{
	int x, y;
};

bool compare(const Point& a, const Point& b)
{
	if (a.x == b.x)
		return a.y < b.y;

	return a.x < b.x;
}

int main()
{
	int n;
	cin >> n;

	vector<Point> coordinate(n);

	for (int i = 0; i < n; i++)
	{
		cin >> coordinate[i].x >> coordinate[i].y;
	}

	sort(coordinate.begin(), coordinate.end(), compare);

	for (const auto& p : coordinate)
	{
		cout << p.x << " " << p.y << '\n';
	}

	return 0;
}

[BAKEJOON 1193번 : 분수찾기]

[문제]

[고찰]

처음에 저는 위의 문제를 풀 때, 지그재그 순서로 분수가 변하는 것을 생각하지 못하고 문제를 풀었습니다.

그 결과 제 답변은 틀리게 되었습니다. 아래는 제가 처음에 작성한 코드입니다.

// ...

int main()
{
	// ...

	int x;
	cin >> x;

	if (x == 1)
	{
		cout << "1/1";
		return 0;
	}

	int i;

	for (i = 1; x - i > 0; i++)
	{
		isLineLeft = !isLineLeft;
		x -= i;
	}

	pair<int, int> fraction;

	for (int j = 1; j <= x; j++, i--)
	{
		fraction = make_pair(j, i);
	}

	cout << fraction.first << "/" << fraction.second;

	return 0;
}

그래서 이번에는 지그재그를 체크하기 위해, isLineLeft라는 boolean 변수를 만들어서 이에 따라 구현을 달리 해주었습니다.

아래는 제가 수정을 해서, 정답이 된 코드입니다.

#include <iostream>
#include <utility>

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	int x;
	cin >> x;

	if (x == 1)
	{
		cout << "1/1";
		return 0;
	}

	bool isLineLeft = false;

	int i;

	for (i = 1; x - i > 0; i++)
	{
		isLineLeft = !isLineLeft;
		x -= i;
	}

	pair<int, int> fraction;

	if (isLineLeft)
	{
		for (int j = 1; j <= x; j++, i--)
		{
			fraction = make_pair(j, i);
		}
	}
	else
	{
		int denominator = 1;

		for (int j = 0; j < x; j++, i--, denominator++)
		{
			fraction = make_pair(i, denominator);
		}
	}

	cout << fraction.first << "/" << fraction.second;

	return 0;
}

다만, 다른 분들의 풀이를 보니 저처럼 pair 클래스를 사용하지 않고, line을 int로 선언한 뒤, 분자와 분모를 line을 통해 직접 계산해주는 것을 보았습니다.

그래서 제 코드가 비효율적인 코드라는 것을 깨달았습니다.

제 코드에서 좀 더 효율적으로 수정하기 위해 고민한 결과, for문을 사용하여 불필요하게 fraction을 반복 갱신할 필요가 없다는 것이었습니다.

그래서 제 코드를 효율적으로 수정한 것과, int 타입의 line을 사용하는 코드, 두 가지 버전을 함께 정리하고자 합니다.

[개념]

코드 리팩토링

for문을 불필요하게 사용하여 fraction을 계속 갱신할 필요 없이, i 와 x를 통해 한줄로 계산하는 것이 가능하였습니다.

만약, isLineLeft가 True일 때는, 분자는 x, 분모는 i - x + 1로 계산이 가능하였고,

False일 때는, 분자는 i - x + 1, 분모는 x로 계산이 가능하였습니다.

즉, isLineLeft에 따라 분자와 분모의 순서만 바꿔주면 되었습니다.

x는 위쪽의 반복문에서 i를 빼는 연산을 통해, 대각선 내에서 몇 번째 수인지를 의미합니다.

i는 해당 대각선에서 분수의 개수입니다.

만약 isLineLeft가 True일 때, 분자는 대각선 내에서 몇 번째 수인지를 통해(x를 통해) 바로 알아낼 수 있고,

대각선에서 분수의 개수인 i에서 x를 뺀 뒤, 1을 더하면 분모가 되는 것입니다.

이를 코드에 적용하여 수정하게 된다면, fraction 선언 이후 코드를 아래와 같이 수정하면 됩니다.

if (isLineLeft)
    fraction = make_pair(x, i - x + 1);
else
    fraction = make_pair(i - x + 1, x);

이렇게 적용하면 x가 1일 때 예외처리를 해주지 않아도 됩니다.

int line 활용

int line을 활용한다면, x가 line보다 이상일 때 계속 반복해주면서, x에서 line을 빼준 값을 다시 x에 넣고, line을 1 증가시켜 줍니다.

이것은 제가 for 문에서 x에서 i를 뺀 후, i++을 통해 1 증가시켜준 것과 동일하며, 제 코드에서 i가 int line을 활용했을 때의 line과 동일한 것입니다.

그리고 int numerator, donomiantor라는 분자와 분모를 위한 두 int 형 변수를 선언합니다.

이 과정은 제가 fraction을 선언한 것과 동일합니다.

이후, line % 2가 0일 때는 짝수 번째 줄이라는 의미이기 때문에, 분자를 증가시켜야 하므로,

numerator = x;
denominator = line - x + 1;

line % 2가 0이 아닐 때는 홀수 번째 줄이라는 의미이기 때문에, 분자를 감소시켜야 하므로,

numerator = line - x + 1;
denominator = x;

를 해줍니다.

이 과정도 수정한 제 코드에서 isLineLeft에 따라 fraction의 값을 지정해주는 과정과 동일합니다.

이러한 연산을 마친 후, numerator와 denominator를 출력 양식에 맞게 출력해주면 됩니다.

[정리]

좀 더 생각했다면, 효율적으로 구현할 수 있을텐데 아쉽습니다.

항상 그 전에 생각이 그치는 것 같습니다.

앞으로는 좀 더 생각을 나아가게 하여 효율적으로 구현할 수 있도록 노력할 것입니다.

[Solution : 리팩토링된 코드]

#include <iostream>
#include <utility>

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	int x;
	cin >> x;

	bool isLineLeft = false;

	int i;

	for (i = 1; x - i > 0; i++)
	{
		isLineLeft = !isLineLeft;
		x -= i;
	}

	pair<int, int> fraction;

	if (isLineLeft)
		fraction = make_pair(x, i - x + 1);
	else
		fraction = make_pair(i - x + 1, x);

	cout << fraction.first << "/" << fraction.second;

	return 0;
}

[Solution : int line을 활용한 코드]

#include <iostream>
#include <utility>

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	int x;
	cin >> x;

	int line = 1;

	while (x > line)
	{
		x -= line;
		line++;
	}

	int numerator, denominator;

	if (line % 2 == 0)
	{
		numerator = x;
		denominator = line - x + 1;
	}
	else
	{
		numerator = line - x + 1;
		denominator = x;
	}

	cout << numerator << "/" << denominator;

	return 0;
}

[코딩테스트 33일차] BAEKJOON 1181번 : 단어 정렬

sunlight-dby — Sat, 21 Jun 2025 04:05:54 +0900

[BAEKJOON 1181번 : 단어 정렬]

[문제]

[고찰]

해당 문제에 대해 아예 접근조차 하지 못해, 어쩔 수 없이 다른 분들의 풀이를 볼 수 밖에 없었습니다..

[개념]

해당 문제의 핵심 아이디어는 사용자 정의 sort를 쓸 수 있는지에 대한 것이었습니다.

bool compare()이라는 함수를 만들어,

입력받은 words를 sort(words.begin(), words.end(), compare);로 사용자 정의 정렬을 하였습니다.

compare 함수에서는,

1. 길이가 다르다면 길이에 따라 정렬하게하고,

2. 길이가 같다면 알파벳 순서에 따라 정렬하게 구현하였습니다.

bool compare(const string& a, const string& b)
{
	if (a.length() != b.length())
		return a.length() < b.length();
	return a < b;
}

정렬을 모두 마친 후에는, 전에 단어와 같은 단어가 아닐때만 출력하게 합니다.

string prev = "";
for (const string& word : words)
{
	if (word != prev)
	{
		cout << word << '\n';
		prev = word;
	}
}

[정리]

알고 있었던 개념이었지만, 정작 활용할 생각은 못했습니다.

전에 올렸던 다짐과 동일하지만, 많은 문제량이 이를 해결해줄 것 같습니다.

[Solution]

#include <iostream>
#include <vector>     
#include <algorithm>  
#include <string>

using namespace std;

// BAKEJOON 1181번 : 단어 정렬
bool compare(const string& a, const string& b)
{
	if (a.length() != b.length())
		return a.length() < b.length();
	return a < b; 
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	int n;
	cin >> n;

	vector<string> words(n);

	for (int i = 0; i < n; i++)
    {
		cin >> words[i];
	}

	sort(words.begin(), words.end(), compare);

	string prev = "";
	for (const string& word : words)
    {
		if (word != prev)
        {
			cout << word << '\n';
			prev = word;
		}
	}

	return 0;
}

[Unity 개발] King's Adventure - Player 입력 및 상태 구현

sunlight-dby — Sat, 21 Jun 2025 00:01:13 +0900

Unity 2D 기반으로 픽셀 컨셉의 Adventure RPG를 개발하려고 합니다.

모바일, PC 기반으로 개발할 예정입니다.

일단 가제는 'King's Adventure'로 정하였습니다.

오늘 기획 및 개발한 내용을 블로그에 정리합니다.

키 입력

[왼쪽] 바인딩된 Player Input Action / [오른쪽] 바인딩된 Jump Action

Player Input Action을 사용하여 기본적인 키 입력을 받았습니다.

각 동작에 있어서 필요에 맞게, Press 또는 Hold로 Interactions을 설정하였습니다.

다만, 점프에 있어서는 Hold와 Press를 모두 설정해놓았는데,

이는 스페이스바를 누르는 만큼 점프를 더 오래할 수 있게 하기 위함입니다.

점프가 시작되면서 Press로 반응한 Callback Context가

변수 jumpPressStartTime을 Time.time으로 시간을 저장하고, isPressingJump를 true로 변경합니다.

이후 스페이스바를 뗴면서 Hold되어있떤 Callback Context가 canceled되면서,

jumpDuration(Time.time - jumpPressStartTime)에 따라 플레이어가 점프하게 되는 힘이 결정됩니다.

[PlayerInAirState.cs 일부]

public virtual void HandleInput(InputAction.CallbackContext context)
{
    if (context.started)
    {
        jumpPressStartTime = Time.time;
        isPressingJump = true;
    }

    if (context.canceled && isPressingJump)
    {
        jumpDuration = Time.time - jumpPressStartTime;
        isPressingJump = false;

        if (jumpDuration >= STANDARD_HOLDTIME)
            playerController.holdingTime = MAX_FORCE_SCLAE;
        else if (jumpDuration < STANDARD_HOLDTIME)
            playerController.holdingTime = MIN_FORCE_SCALE;
        else
            playerController.holdingTime = jumpDuration;

        if (playerController.jumpCount == 0)
            subStateMachine.Initialize(jumpState);
    }
}

Player 상태 구현

플레이어의 동작에 따라 상태 패턴을 적용하였고, HFSM을 통해 아래의 상태로 구현하였습니다.

하나의 StateMachine에서 Grounded, InAir, Combat, Evasion, Recovery, Die를 관리하고,

각각의 상위 상태에서 StateMachine을 적용하여 하위 상태를 관리하는 형태입니다.

Grounded - Idle, Walk
InAir - Jump, Fall
Combat - Attack, Skill 1, Skill 2
Evasion - Roll, Block
Recovery - Pray, Sleep
Die

플레이어가 움직이는 로직은 PlayerController에서 구현되었으며, 이외의 구현부는 각 하위 상태에서 구현되었습니다.

플레이어의 움직임을 PlayerController에서 처리하는 이유는 Idle, Walk, Jump 등 모든 상태에서 이동 로직이 필요한데, PlayerController를 중앙 클래스처럼 취급하여, 중앙 클래스에서 관리하는 형태로 한 것입니다.

Player Input Action에서 바인딩된 동작에 대한 메서드는 모두 PlayerController에서 받아준 뒤, InputAction의 Callback Context가 필요한 경우에는 각 상태의 HandleInput 메서드에서 처리하게 하였습니다.

[PlayerController.cs 일부]

public void OnMove(InputAction.CallbackContext context)
{
    inputVec = context.ReadValue<Vector2>();

    if (context.performed)
        isMoving = true;
    if (context.canceled)
        isMoving = false;
}

public void OnJump(InputAction.CallbackContext context)
{
    if (!CurrentState(evasionState))
    {
        isJumping = true;

        ChangeState(inAirState);
        inAirState.HandleInput(context);
    }

    if (CurrentState(recoveryState))
    {
        ChangeState(groundedState);
    }
}

public void OnAttack(InputAction.CallbackContext context)
{
    if (!CurrentState(evasionState))
    {
        ChangeState(combatState);
        combatState.HandleInput(context, PlayerSubStateType.Attack);
    }

    if (CurrentState(recoveryState))
    {
        ChangeState(groundedState);
    }
}

public void OnRoll(InputAction.CallbackContext context)
{
    if (!CurrentState(inAirState))
    {
        ChangeState(evasionState);
        evasionState.HandleInput(context, PlayerSubStateType.Roll);
    }

    if (CurrentState(recoveryState))
    {
        ChangeState(groundedState);
    }
}

public void OnBlock(InputAction.CallbackContext context)
{
    if (!CurrentState(inAirState))
    {
        if (!((context.performed || context.canceled) && !isBlocking))
        {
            ChangeState(evasionState);
            evasionState.HandleInput(context, PlayerSubStateType.Block);
        }
    }

    if (CurrentState(recoveryState))
    {
        ChangeState(groundedState);
    }
}

public void OnPray(InputAction.CallbackContext context)
{
    if (!(CurrentState(inAirState) || CurrentState(evasionState)) && !CurrentState(recoveryState))
    {
        ChangeState(recoveryState);
        recoveryState.HandleInput(context, PlayerSubStateType.Pray);
    }
}

public void OnSleep(InputAction.CallbackContext context)
{
    if (CurrentState(groundedState) && !CurrentState(recoveryState))
    {
        ChangeState(recoveryState);
        recoveryState.HandleInput(context, PlayerSubStateType.Sleep);
    }
}

이렇게 상태패턴을 적용했을 때의 장점은, SOLID 원칙을 준수할 수 있기 때문입니다.

SRP (단일 책임 원칙)

각 상태 클래스는 자기 상태에 맞는 동작만 책임질 수 있기에, 클래스 간 책임이 면확합니다.

OCP (개방-폐쇄 원칙)

새로운 상태를 추가할 때, 기존 코드를 수정할 필요 없이 새로운 상태 클래스를 만들면 됩니다.
기존 코드를 거의 손대지 않아도 된다는 장점이 존재합니다.

LSP (리스코프 치환 원칙)

모든 상태가 IState를 구현하므로, StateMachine 입장에서는 어떤 상태가 들어와도 문제가 없습니다.

ISP (인터페이스 분리 원칙)

IState 인터페이스가 정말 최소한의 기능만 제공하고, 불필요한 메서드에 대한 강제가 없습니다.

DIP (의존 역전 원칙)

StateMachine은 InAirState 같은 구체적인 클래스에 의존하지 않고, IState라는 추상화에만 의존합니다.
덕분에 StateMachine은 재사용성이 높습니다.

IState

public interface IState
{
    void Enter();
    void Update();
    void Exit();
}

인터페이스로 생성한 IState를 통해, 각 상태가 해당 인터페이스를 상속하게끔 합니다.

모든 상태 클래스의 공통 계약을 정의하고, StateMachine은 해당 인터페이스만 알고 있으면 어떤 상태든 동일한 방식으로 다룰 수 있습니다.

IState를 통해, 다형성과 유연한 확장을 챙길 수 있게 됩니다.

StateMachine

public class StateMachine
{
    public IState currentState { get; private set; }

    public void Initialize(IState startState)
    {
        //Debug.Log($"InitState : {startState}");

        currentState = startState;
        currentState.Enter();
    }

    public bool CurrentState(IState state)
    {
        return currentState == state;
    }

    public void ChangeState(IState newState)
    {
        if (currentState == newState && currentState != null && newState != null)
            return;       
            
        //Debug.Log($"ChangeState : {currentState} -> {newState}");

        currentState?.Exit();
        currentState = newState;
        currentState.Enter();
    }

    public void Update()
    {
        currentState?.Update();
    }

    public void Exit()
    {
        currentState?.Exit();
    }
}

스테이트머신은 현재 상태 추적, 상태 전환 관리와 같은 역할을 합니다.

외부에서는 StateMachine에 상태 변경을 요청하기만 하면 되고, 실제 상태 변경은 StateMachine 내부에서 처리되게 됩니다.

이로써 상태 전환 로직이 분산되지 않고 한 곳에서 관리되기 때문에 유지보수성이 향상되고, 추후 상태 확장에 있어서도 효율적입니다.

[코딩테스트 32일차] BAEKJOON 2941번 : 크로아티아 알파벳

sunlight-dby — Fri, 20 Jun 2025 01:58:36 +0900

[BAEKJOON 2941번 : 크로아티아 알파벳]

[문제]

[고찰]

저는 이 문제를 alphabets이라는 7의 크기를 가지는 string 배열을 만들어, 글자 수가 2개인 크로아티아 알파벳을 값으로 지정하였고, aplhabet이라는 string 타입의 변수를 만들어 글자 수가 3개인 크로아티아 알파벳인 'dz='를 지정하였습니다.

그 후 i = 0부터 입력받은 단어인 word의 size만큼 반복하면서, 크로아티아 알파벳인지 아닌지를 판별하여 해당 문제를 풀었습니다.

먼저 i + 1이 word.size()보다 크거나 같다면, 마지막 글자라는 의미이기 때문에 바로 알파벳 수를 1 더해줬습니다.

만약 아니라면, string str 변수를 만들어, string(1, word[ i ])와 word[i + 1]을 더해주었고,이후 for (string ss : alphabets)의 반복문을 통해 str이 ss라면 알파벳 수를 1 더해주고 i 또한 1을 더 해주어, 크로아티아 알파벳은 넘기게 하였습니다.또한 isNext라는 boolean 변수를 true로 하여, 해당 반복문이 끝난 후 isNext가 false일 때를 고려하였습니다.

isNext가 false일 때, 혹여나 크로아티아 알파벳 'dz='일수도 있기 때문에, str에 word[i + 2]를 더해준 후,str이 aplhabet('dz=')인지와 'dz='이 마지막 글자인지를 확인하기 위해 i가 word.size() - 2보다 작은지를 체크하여주었습니다.

만약 맞다면, 알파벳 수를 1 더해주고, i는 2를 더해주어 크로아티아 알파벳은 넘기게 하였습니다.

만약 아니라면, 크로아티아 알파벳이 아닌 그냥 알파벳이기 때문에, 알파벳 수를 1 더해주었습니다.

제 방식은 좀 복잡하게 구현되었는데, 다른 분들의 풀이를 보니 find와 replace를 써서 간편하게 푼 것을 확인하였습니다.

그래서 find와 replace를 쓴 방식을 정리하고자 합니다.

아래는 제가 작성한 코드입니다.

#include <iostream>

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	string word;
	cin >> word;

	string alphabets[7] = { "c=", "c-", "d-", "lj", "nj", "s=", "z=" };
	string alphabet = "dz=";
	int count = 0;
	bool isNext = false;

	for (int i = 0; i < word.size(); i++)
	{
		string str;

		if ((i + 1) >= word.size())
		{
			count++;
			break;
		}
		else
		{
			str = string(1, word[i]) + word[i + 1];
		}

		for (string ss : alphabets)
		{
			if (str == ss)
			{
				count++;
				i++;
				isNext = true;
				break;
			}
		}

		if (!isNext)
		{
			str += word[i + 2];
			if (str == alphabet && i < word.size() - 2)
			{
				count++;
				i += 2;
			}
			else
			{
				count++;
			}
		}

		isNext = false;
	}

	cout << count;

	return 0;
}

[개념]

일단 제가 푼 방식에서도 하나 짚고 넘어갈 것이 있습니다.

처음에는 string = char + char 형식으로 str을 만들려고 하다가, 아차 싶어서 위의 코드에서 보시다시피 string = string + char 형태로 바꾸었습니다.

까먹고 있었던 내용인데, char + char은 아스키코드로 계산이 되기 때문에, 원하는 방식으로 string이 만들어지지 않습니다.

따라서 아래와 같은 방식으로 string을 만들어야 합니다.

문자(character)의 결합

string 생성자 이용

string str(1, char1);
str1 += char2;

push_back() 함수 이용

string str;
str.push_back(char1);
str.push_back(char2);

char + char은 아스키코드로 계산됨

find() 함수

문자열에서 문자 및 문자열 탐색하기 위한 함수로, 다양한 형태의 오버로딩이 존재합니다.

만약 문자열을 찾는데 성공하였다면, 해당 문자열의 시작 위치를 반환하고, 찾지 못했따면 npos를 리턴합니다.

※ npos는 string::npos로 정의되는 상수로, -1의 값을 가집니다.

size_type find(const basic_string& str, size_type pos = 0) const;

탐색은 'pos'부터 시작되며, 문자열에서 'str'의 위치를 리턴합니다.

size_type find(const CharT* s, size_type pos, size_type count) const;

탐색은 'pos'부터 시작되며, 's'가 가리키는 문자부터 'count'개 만큼을 취한 부분 문자열을 원 문자열에서 찾습니다.
참고로 's' 중간에 'NULL'이 있어도 됩니다.

size_type find(const CharT* s, size_type pos = 0) const;

탐색은 'pos'부터 시작되며, 's'가 가리키는 문자열을 원 문자열에서 검색합니다. 이 때 's'는 널 종료 문자열로 간주됩니다.

size_type find(CharT ch, size_type pos = 0) const;

탐색은 'pos'부터 시작되며, 원 문자열에서 문자 'ch'의 위치를 찾습니다.

replace() 함수

문자열의 일부를 다른 문자열로 치환하는 함수로, 다양한 형태의 오버로딩이 존재합니다.

basic_string& replace(size_type pos, size_type count, const basic_string& str);
basic_string& replace(const_iterator first, const_iterator last, const basic_string& str);

기존 문자열의 'pos'부터 'count'개의 문자들을, 혹은 'first'부터 'last' 전까지의 문자들을 'str'로 치환합니다.

basic_string& replace(size_type pos, size_type count, 
    const basic_string& str, size_type pos2, size_type count2 = npos);

기존 문자열의 'pos'부터 'count'개의 문자들을 'str'의 'pos2'부터 'count2'개의 문자들로 치환합니다.

template <class InputIt>
basic_string& replace(const_iterator first, const_iterator last, InputIt first2, InputIt last2);

기존 문자열의 'first'부터 'last'를 'first2'부터 'last2'로 치환합니다.

basic_string& replace(size_type pos, size_type count, const CharT* cstr, size_type count2);
basic_string& replace(const_iterator first, const_iterator last, const CharT* cstr, size_type count2);

기존 문자열의 'pos'부터 'count'개의 문자를, 혹은 'first'부터 'last'까지의 문자를 'cstr'이 가리키는 배열의 'count2'개만큼의 문자들로 치환합니다.
이 때 'cstr'이 가리키는 문자 배열은 널 문자를 포함하고 있어도 됩니다.

basic_string& replace(size_type pos, size_type count, const CharT* cstr);
basic_string& replace(const_iterator first, const_iterator last, const CharT* cstr);

기존 문자열의 'pos'부터 'count'개의 문자를, 혹은 'first'부터 'last'까지의 문자를 'cstr'이 가리키는 널 종료 문자열로 치환합니다.

basic_string& replace(size_type pos, size_type count, size_type count2, CharT ch);
basic_string& replace(const_iterator first, const_iterator last, size_type count2, CharT ch);

기존 문자열의 'pos'부터 'count'개의 문자를, 혹은 'first'부터 'last'까지의 문자를 'ch' 문자 'count2'개로 치환합니다.

basic_string& replace(const_iterator first, const_iterator last, std::initializer_list<CharT> ilist);

기존 문자열의 'first'부터 'last'까지의 문자들을 'ilist'에 있는 문자들로 바꿉니다.

[정리]

기존에 알고있던 함수들이더라도, 자주 활용하지 않으면 활용법을 떠올리지 못하는 것 같습니다.

문제 수를 많이 풀면 풀수록 이런 문제들은 더 나아질 것이라 생각하고, 더욱 많은 문제를 접하는 것에 목적을 둘 것입니다.

[Solution]

#include <iostream>
#include <string>

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	string word;
	cin >> word;

	string alphabets[8] = { "c=", "c-", "dz=", "d-", "lj", "nj", "s=", "z=" };
	int idx;

	for (int i = 0; i < 8; i++)
	{
		while (1)
		{
			idx = word.find(alphabets[i]);

			if (idx == string::npos)
				break;
			word.replace(idx, alphabets[i].size(), "0");
		}
	}

	cout << word.size();

	return 0;
}