[2025/07/15]TIL

오늘의 코딩테스트

자릿수 구하기 문제

문제 설명

자연수 N이 주어지면, N의 각 자릿수의 합을 구해서 return 하는 solution 함수를 만들어 주세요.
예를들어 N = 123이면 1 + 2 + 3 = 6을 return 하면 됩니다.

제한 사항

N의 범위 : 100,000,000 이하의 자연수

솔루션

using System;

public class Solution {
    public int solution(int n) {
        int answer = 0;
        for(int i = 1; i <= n; i*=10)
        {
            int j = i*10; 
            int temp = n/j;
            temp  = n - temp * j - answer;
            temp /= i;
            answer += temp;
        }
        return answer;
    }
}

일의 자리를 초과하는 숫자를 N에서 빼면, 일의자리 숫자만 남음. 이 상태를 answer에 더해준다.
십의 자리를 초과하는 숫자를 N에서 빼고, answer(일의 자리값) 을 빼면 십의 자리 숫자만 남는다.
여기서, 십을 나누면 해당 자릿수의 계수가 나온다.
이것을 반복문으로 돌려주면 각 자리 숫자의 합이 answer에 저장된다.

---

유니티 상태머신 구현

상태머신을 통해서 캐릭터의 상태를 관리한다.

1. 인터페이스 IState를 통해 상태를 확장해서 만든다


2. StateMachine에 currentState를 가지고 있는다.


3. State가 바뀔때는 ChangeState를 통해 바뀐다.


4. ChangeState가 이루어질때는 currentState?.Exit(); 후 currentState = 바뀔 State; currentState?.Enter(); 를 통해 State가 바뀔 때의 값을 초기화 해준다.


5. 플레이어의 경우 BaseState를 두고, 이를 확장해 GroundState (땅에 있을때 State), AirState(공중에 떴을 때 State) 등을 만들고 여기서 이어지는 Idle, Walk, Run등의 State를 이어지게 만든다.

public class PlayerStateMachine : StateMachine
{
    public Player Player { get; }

    public Vector2 MovementInput { get; set; }
    public float MovementSpeed { get; private set; }
    public float RotationDamping { get; private set; }
    public float MovementSpeedModifier { get; set; } = 1f;

    public float JumpForce { get; set; }

    public Transform MainCameraTransform { get; set; }

    public PlayerStateMachine(Player player)
    {
        this.Player = player;

        MainCameraTransform = Camera.main.transform;

        MovementSpeed = player.Data.GroundedData.BaseSpeed;
        RotationDamping = player.Data.GroundedData.BaseRotationDamping;
    }
}

public class PlayerBaseState : IState
{
    protected PlayerStateMachine stateMachine;
    protected readonly PlayerGroundData groundData;

    public PlayerBaseState(PlayerStateMachine playerStateMachine)
    {
        stateMachine = playerStateMachine;
        groundData = stateMachine.Player.Data.GroundedData;
    }

    public virtual void Enter()
    {

    }

    public virtual void Exit()
    {

    }

    public virtual void HandleInput()
    {
        ReadMovementInput();
    }

    public virtual void PhysicsUpdate()
    {

    }

    public virtual void Update()
    {
		    // StartAnimation 함수 먼저 작성
        Move();
    }

    protected void StartAnimation(int animationHash)
    {
        stateMachine.Player.Animator.SetBool(animationHash, true);
    }

    protected void StopAnimation(int animationHash)
    {
        stateMachine.Player.Animator.SetBool(animationHash, false);
    }

    private void ReadMovementInput()
    {
        stateMachine.MovementInput = stateMachine.Player.Input.playerActions.Movement.ReadValue<Vector2>();
    }

    private void Move()
    {
		    // GetMoveMentDirection 함수 먼저 작성
        Vector3 movementDirection = GetMovementDirection();
        
        Move(movementDirection);
				
				// Rotate 함수 먼저 작성
				Rotate(movementDirection);
    }

    private Vector3 GetMovementDirection()
    {
        Vector3 forward = stateMachine.MainCameraTransform.forward;
        Vector3 right = stateMachine.MainCameraTransform.right;

        forward.y = 0;
        right.y = 0;

        forward.Normalize();
        right.Normalize();

        return forward * stateMachine.MovementInput.y + right * stateMachine.MovementInput.x; 
    }

    private void Move(Vector3 direction)
    {
        float movementSpeed = GetMovementSpeed();
        
        stateMachine.Player.Controller.Move(
            (direction * movementSpeed) * Time.deltaTime
        );
    }

    private float GetMovementSpeed()
    {
        float moveSpeed = stateMachine.MovementSpeed * stateMachine.MovementSpeedModifier;
        return moveSpeed;
    }

    private void Rotate(Vector3 direction)
    {
        if(direction != Vector3.zero)
        {
            Transform playerTransform = stateMachine.Player.transform;
            Quaternion targetRotation = Quaternion.LookRotation(direction);
            playerTransform.rotation = Quaternion.Slerp(playerTransform.rotation, targetRotation, stateMachine.RotationDamping * Time.deltaTime);
        }
    }
}

public class PlayerIdleState : PlayerGroundedState
{
    public PlayerIdleState(PlayerStateMachine playerStateMachine) : base(playerStateMachine)
    {
    }

    public override void Enter()
    {
        stateMachine.MovementSpeedModifier = 0f;
        base.Enter();
        StartAnimation(stateMachine.Player.AnimationData.IdleParameterHash);
    }

    public override void Exit()
    {
        base.Exit();
        StopAnimation(stateMachine.Player.AnimationData.IdleParameterHash);
    }

    public override void Update()
    {
        base.Update();
    }
}