백준 2741 : N 찍기

C# 2020. 11. 28. 22:00

자연수 N이 주어졌을 때, 1부터 N까지 한 줄에 하나씩 출력하는 프로그램을 작성하시오.

첫째 줄에 100,000보다 작거나 같은 자연수 N이 주어진다.
첫째 줄부터 N번째 줄 까지 차례대로 출력한다.

:: 성공

: 개선점 : 없음

using System;

namespace for01
{
    class Program
    {
        static void Main(string[] args)
        {
            // :: Input size and Parse
            int size = Int32.Parse(Console.ReadLine());

            // :: result Array
            string[] result = new string[size];

            // :: Loop with size
            for(int i = 1; i <= size; i++)
            {
                // :: Save Result
                result[i - 1] = i.ToString();
            }

            // :: Print with "Wn" for Spped
            Console.WriteLine(string.Join("\n", result));
        }
    }
}

'C#' 카테고리의 다른 글

백준 11021 : A+B - 7  (0) 2020.11.30
백준 2742 : 기찍 N  (0) 2020.11.29
백준 15552 : 빠른 A+B  (0) 2020.11.27
백준 2739 : 구구단  (0) 2020.11.24
백준 2753 : 윤년  (0) 2020.11.20
블로그 이미지

RIsN

,

백준 15552 : 빠른 A+B

C# 2020. 11. 27. 22:35

본격적으로 for문 문제를 풀기 전에 주의해야 할 점이 있다. 입출력 방식이 느리면 여러 줄을 입력받거나 출력할 때 시간초과가 날 수 있다는 점이다.

C++을 사용하고 있고 cin/cout을 사용하고자 한다면, cin.tie(NULL)과 sync_with_stdio(false)를 둘 다 적용해 주고, endl 대신 개행문자(\n)를 쓰자. 단, 이렇게 하면 더 이상 scanf/printf/puts/getchar/putchar 등 C의 입출력 방식을 사용하면 안 된다.

Java를 사용하고 있다면, Scanner와 System.out.println 대신 BufferedReader와 BufferedWriter를 사용할 수 있다. BufferedWriter.flush는 맨 마지막에 한 번만 하면 된다.

Python을 사용하고 있다면, input 대신 sys.stdin.readline을 사용할 수 있다. 단, 이때는 맨 끝의 개행문자까지 같이 입력받기 때문에 문자열을 저장하고 싶을 경우 .rstrip()을 추가로 해 주는 것이 좋다.

또한 입력과 출력 스트림은 별개이므로, 테스트케이스를 전부 입력받아서 저장한 뒤 전부 출력할 필요는 없다. 테스트케이스를 하나 받은 뒤 하나 출력해도 된다.

자세한 설명 및 다른 언어의 경우는 이 글에 설명되어 있다.

이 블로그 글에서 BOJ의 기타 여러 가지 팁을 볼 수 있다.

첫 줄에 테스트케이스의 개수 T가 주어진다. T는 최대 1,000,000이다. 다음 T줄에는 각각 두 정수 A와 B가 주어진다. A와 B는 1 이상, 1,000 이하이다.
각 테스트케이스마다 A+B를 한 줄에 하나씩 순서대로 출력한다.

:: 성공

: 개선점 : 정리 필요

>> Console.WriteLine이 상당한 시간을 잡아 먹는다, 한 번만 쓸 것

>> string의 길이에 한계가 있음, 나중에 합칠 것

using System;

namespace for01
{
    class Program
    {
        static void Main(string[] args)
        {
            // :: Input size and Parse
            int size = Int32.Parse(Console.ReadLine());

            // :: result Array
            string[] result = new string[size];

            // :: Loop with size
            for(int i = 0; i < size; i++)
            {
                // :: Input numbers and Parse
                string[] input = Console.ReadLine().Split(' ');
                long a = long.Parse(input[0]);
                long b = long.Parse(input[1]);

                // :: Save Result
                result[i] = (a + b).ToString();
            }

            // :: Print with "Wn" for Spped
            Console.WriteLine(string.Join("\n", result));
        }
    }
}

'C#' 카테고리의 다른 글

백준 2742 : 기찍 N  (0) 2020.11.29
백준 2741 : N 찍기  (0) 2020.11.28
백준 2739 : 구구단  (0) 2020.11.24
백준 2753 : 윤년  (0) 2020.11.20
백준 1330 : 두 수 비교하기  (0) 2020.11.18
블로그 이미지

RIsN

,

복제 게임 : 아이작의 번제

youtu.be/27Le3kOOFQk

[복제 목표]

  • 튜토리얼 화면 구성
  • 이동 구현
  • 공격 구현

[구현 설계]

  1. 튜토리얼 맵 배치 // 완료
  2. 캐릭터 배치 // 완료
  3. 캐릭터 이동 // 완료
    1. 난제 : ASDW에 방향키를 둘다 쓰는 사양이라 GetAxis의 사용 난제
      • 유니티 에디터 상에서 수정하면 되겠지만,
        유니티 한정으로 생각하지 않기 위해 GetAxis 대신 다른 것을 고려
      • 속도 문제 : 왜 갑자기 속도가 변하는지 확인 필요
  4. 캐릭터 애니메이션 제작 // 완료
  5. 공격 구현 // 진행중 시간초과
  6. 완성

[추정 소요시간] : 8H

[실제 소요시간] : 9H(미완)

블로그 이미지

RIsN

,

복제 게임 : 쿠키런 : 오븐 브레이크

youtu.be/4yritPZC7Vg

 

[복제 목표]

  • Unity2D가 아닌 Unity3D를 사용해서 2D 느낌을 구현
  • 1단 점프
  • 슬라이드 구현
  • 움직이는 배경 구현

[구현 설계]

  1. 캐릭터 배치 : 완료
  2. 점프, 슬라이드 버튼 배치 : 완료
  3. 캐릭터 애니메이션 제작 : 완료
  4. 버튼을 캐릭터 애니메이션과 연동 : 완료
  5. 점프 구현
    1. 점프 공식 확인 : 완료
    2. 구현 : 완료
  6. 슬라이드 구현
    1. Collider 사이즈 조정 테스트 : 완료
    2. Collider 이동 테스트 : 완료
  7. 움직이는 배경 구현
    1. 배경 리소스 확인 및 적용 : 완료
    2. 배경 움직임 구현 : 완료
  8. 버그 제거
    1. 점프 시에 슬라이드 애니메이션 돌입하지 못하도록 : 완료
    2. 점프 후에 누르고 있으면 슬라이드로 돌입하도록 : 완료
  9. 완성
  10. 타 클로닝 완료 후, 시간적 여유가 있을 경우 추가적 활동 : 진행중

[추정 소요시간] : 6H

[실제 소요시간] : 5H

 

[완성]

youtu.be/wLSpruromYo

 

블로그 이미지

RIsN

,

:: プラットフォームゲームテスト

:: 上に上がる時は衝突無視

youtu.be/hzvA86wAHAo

>>改善すべき:UpdateのたびにBoxColliderを探すのは非効率的。

using UnityEngine;

// PlayerController는 플레이어 캐릭터로서 Player 게임 오브젝트를 제어한다.
public class PlayerController : MonoBehaviour {
   public AudioClip deathClip; // 사망시 재생할 오디오 클립
   public float jumpForce = 700f; // 점프 힘

   private int jumpCount = 0; // 누적 점프 횟수
   private bool isGrounded = false; // 바닥에 닿았는지 나타냄
   private bool isDead = false; // 사망 상태

   private Rigidbody2D playerRigidbody; // 사용할 리지드바디 컴포넌트
   private Animator animator; // 사용할 애니메이터 컴포넌트
   private AudioSource playerAudio; // 사용할 오디오 소스 컴포넌트


   private void Start() {
        // 초기화
        // 게임 오브젝트로부터 사용할 컴포넌트들을 가져와 변수에 할당
        this.playerRigidbody = this.GetComponent<Rigidbody2D>();
        this.animator = this.GetComponent<Animator>();
        this.playerAudio = this.GetComponent<AudioSource>();
   }

    private Vector2 playerVelocity;
    private void Update() {
        // 사용자 입력을 감지하고 점프하는 처리
        // 사망 시 처리를 더 이상 진행하지 않고 종료
        if(isDead)
        {
            return;
        }

        this.playerVelocity = playerRigidbody.velocity;
        if(playerRigidbody.velocity.y > 0)
        {
            // :: Find all BoxCollider2D
            foreach (var itm in GameObject.FindObjectsOfType<BoxCollider2D>())
            {
                // :: Player : Ignore it
                Physics2D.IgnoreCollision(playerRigidbody.gameObject.GetComponent<CircleCollider2D>(), itm, true);
            }
        } else if(playerRigidbody.velocity.y < 0)
        {
            foreach(var itm in GameObject.FindObjectsOfType<BoxCollider2D>())
            {
                Physics2D.IgnoreCollision(playerRigidbody.gameObject.GetComponent<CircleCollider2D>(), itm, false);
            }
        }

        // :: When Mouse Right Button Clicking
        if(Input.GetMouseButton(1))
        {
            // :: Igonore all Box Collider
            foreach (var itm in GameObject.FindObjectsOfType<BoxCollider2D>())
            {
                // :: If it's not Start Block
                if(!itm.gameObject.name.Contains("Start"))
                    Physics2D.IgnoreCollision(playerRigidbody.gameObject.GetComponent<CircleCollider2D>(), itm, true);
            }
        }

        if(Input.GetMouseButtonDown(0) && jumpCount < 2)
        {
            // 점프 횟수 증가
            jumpCount++;
            // 점프 직전에 속도를 순간적으로 제로(0, 0)로 변경
            playerRigidbody.velocity = Vector2.zero;
            // 리지드 바디에 위쪽으로 힘 주기
            playerRigidbody.AddForce(new Vector2(0, jumpForce));
            // 오디오 소스 재생
            playerAudio.Play();
        } else if(Input.GetMouseButtonUp(0) && playerRigidbody.velocity.y > 0)
        {
            // 마우스 왼쪽 버튼에서 손을 떼는 순간 && 속도의 y 값이 양수라면(위로 상승 중)
            // 현재 속도를 절반으로 변경
            playerRigidbody.velocity = playerRigidbody.velocity * 0.5f;
        }

        // 애니메이터의 Grounded 파라미터를 isGrounded 값으로 갱신
        animator.SetBool("Grounded", isGrounded);
   }

   private void Die() {
        // 사망 처리
        // 애니메이터의 Die 트리거 파라미터를 셋
        animator.SetTrigger("Die");

        // 오디오 소스에 할당된 오디오 클립을 deathClip으로 변경
        playerAudio.clip = deathClip;
        // 사망 효과음 재생
        playerAudio.Play();

        // 속도를 제로(0, 0)으로 변경
        playerRigidbody.velocity = Vector2.zero;
        // 사망 상태를 true로 변경
        isDead = true;
   }

   private void OnTriggerEnter2D(Collider2D other)
    {

        Debug.LogFormat("OnTriggerEnter2D : {0}", other.gameObject.name);

        // 트리거 콜라이더를 가진 장애물과의 충돌을 감지
        if (other.tag == "Dead" && !isDead)
        {
            // 충돌한 상대방의 태그가 Dead이며 아직 사망하지 않았다면 Die() 실행
            Die();
        }
   }

   private void OnCollisionEnter2D(Collision2D collision)
    {

        Debug.LogFormat("OnCollisionEnter2D : {0} / {1}", playerRigidbody.velocity.y, collision.contacts[0].normal.y);

        // 바닥에 닿았음을 감지하는 처리
        // 어떤 콜라이더와 닿았으며, 충돌 표면이 위쪽을 보고 있으면
        if (collision.contacts[0].normal.y > 0.7f)
        {
            // isGrounded를 true로 변경하고, 누적 점프 횟수를 0으로 리셋
            isGrounded = true;
            jumpCount = 0;
        }
   }

   private void OnCollisionExit2D(Collision2D collision) {

        Debug.LogFormat("OnCollisionExit2D : {0}", collision.gameObject.name);

        // 바닥에서 벗어났음을 감지하는 처리
        // 어떤 콜라이더에서 떼어진 경우 isGrounded를 false로 변경
        isGrounded = false;
   }
}
블로그 이미지

RIsN

,

백준 2739 : 구구단

C# 2020. 11. 24. 22:45

N을 입력받은 뒤, 구구단 N단을 출력하는 프로그램을 작성하시오. 출력 형식에 맞춰서 출력하면 된다.

첫째 줄에 N이 주어진다. N은 1보다 크거나 같고, 9보다 작거나 같다.
출력형식과 같게 N*1부터 N*9까지 출력한다.

:: 성공

: 개선점 : 없음

using System;

namespace for01
{
    class Program
    {
        static void Main(string[] args)
        {
            // :: Input and Parse
            int a = Int32.Parse(Console.ReadLine());

            // :: Calculate and Print
            for(int i = 1; i <= 9; i++)
            {
                Console.WriteLine("{0} * {1} = {2}", a, i, a * i);
            }
        }
    }
}

'C#' 카테고리의 다른 글

백준 2741 : N 찍기  (0) 2020.11.28
백준 15552 : 빠른 A+B  (0) 2020.11.27
백준 2753 : 윤년  (0) 2020.11.20
백준 1330 : 두 수 비교하기  (0) 2020.11.18
백준 2588 : 곱셈  (0) 2020.11.16
블로그 이미지

RIsN

,

>Durationがよく作動しない感じがする?

>もっと確認が必要。

// :: Fade Out
public System.Action CallBack_FadeOut = null; // Callback delegate
public void FadeOut(Image image)
{
	image.gameObject.SetActive(true); // :: Render TRUE
	DOTween.ToAlpha(
		() => image.color,
		alpha => image.color = alpha,
		0f, // :: Target Value
		1f) // :: Duration
		.SetEase(Ease.InQuad) // :: Set Animation Play Type
		.onComplete = () =>  // :: On Complete
		{
			this.CallBack_FadeOut?.Invoke(); // :: Call Back when this Action isn't null
			this.CallBack_FadeOut = null; // :: Reset Action
            image.gameObject.SetActive(false); // :: Render FALSE
		};
}
// :: Fade In
public System.Action CallBack_FadeIn = null; // Callback delegate
public void FadeIn(Image image)
{
    image.gameObject.SetActive(true); // :: Render TRUE
    DOTween.ToAlpha(
        () => image.color,
        alpha => image.color = alpha,
        1f, // :: Target Value
        1f) // :: Duration
        .SetEase(Ease.InQuad) // :: Set Animation Play Type
        .onComplete = () =>  // :: On Complete
        {
            this.CallBack_FadeIn?.Invoke(); // :: Call Back when this Action isn't null
            this.CallBack_FadeIn = null; // :: Reset Action
            image.gameObject.SetActive(true); // :: Render TRUE
        };
}
블로그 이미지

RIsN

,

[프로젝트명] S? : Charles VII

[장르] 전략

[목적] 스터디 전용 & 취업 포트폴리오

 

[사용 에셋]

 

 

 

 

일지 #1

<0> 시작
<1> 캐릭터 [0][0][0]에 출력
<2> 캐릭터 [1][-1][0]으로 이동 with DOTween
<3> 캐릭터 [4][-7][3]으로 이동 by AStar Algorithm

<1> 캐릭터 [0][0][0]에 출력

[A. 출력시 캐릭터 <-> 맵 상호간 오브젝트 보유]

// :: Connect Character and Tile
private void ConnectCharacterAndTile(GameObject character, GameObject tile)
{
    character.GetComponent<Battle_Class_Character>().SetTileObject(tile);
    tile.GetComponent<Battle_Class_Tile>().SetCharacterObject(character);
}

<2> 캐릭터 [1][-1][0]으로 이동 with DOTween

// :: Move Position
public void MovePosition(Vector3 position, System.Action action)
{
    // :: Rotation
    this.gameObject.transform.DOLookAt(position, ROTATION_SPEED)
        .onComplete = () =>
        {
            // :: Move
            this.gameObject.transform.DOMove(position, MOVING_SPEED)
            	.onComplete = () => { action?.Invoke(); };
    	};
}

<3> 캐릭터 [4][-7][3]으로 이동 by AStar Algorithm

[AStar Algorithm이란?]

: A* search algorithm

: 간단 설명 : 거리를 추정해서 가까운 곳 위주로 탐색해서 나아가는 알고리즘

: 참고 : よくわかるA*(A-star)アルゴリズム

: 쓰는 이유?

>> 길찾기를 할 때 쓰는 알고리즘으로 기본적인 알고리즘이라는 소문

 

youtu.be/ESLPnJmlvew

 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Battle_GOFunc_Astar
{
    // :: Constructor
    public Battle_GOFunc_Astar() { }

    // :: Constant
    private int[,] DIRECTION = new int[6, 3] { { -1, 0, 1 }, { 0, -1, 1 }, { 1, -1, 0 }, { 1, 0, -1 }, { 0, 1, -1 }, { -1, 1, 0 } };

    // :: Variable : for Node
    private LinkedList<int[]> paths;
    private List<Astar_Node> listNode;
    private List<Astar_Node> listOpenNode;
    private List<Astar_Node> listClosedNode;

    // :: Initialise
    public void Init(List<Battle_Class_Tile> listTile)
    {
        // :: Use
        this.paths = new LinkedList<int[]>();
        this.listNode = new List<Astar_Node>();
        this.listOpenNode = new List<Astar_Node>();
        this.listClosedNode = new List<Astar_Node>();

        // :: Make Node and put it in list
        this.AddNodeList(listTile);
    }

    // :: Make Node
    private void AddNodeList(List<Battle_Class_Tile> listTile)
    {
        // :: Convert
        foreach (var itm in listTile)
        {
            // :: Make Node
            Astar_Node node = new Astar_Node();
            node.Init(itm.X, itm.Y, itm.Z);

            // :: Add it
            this.listNode.Add(node);
        }
    }

    // :: GET Path
    public LinkedList<int[]> GetPath(Battle_Class_Tile baseTile, Battle_Class_Tile targetTile)
    {
        // :: Set Base and Target Node
        Astar_Node baseNode = this.GetNode(baseTile.X, baseTile.Y, baseTile.Z);
        Astar_Node targetNode = this.GetNode(targetTile.X, targetTile.Y, targetTile.Z);

        // :: Find Min Path
        this.GetPathImplement(baseNode, targetNode);

        // :: Return
        return this.paths;
    }
    // :: Get Path Implement
    private void GetPathImplement(Astar_Node baseNode, Astar_Node targetNode)
    {
        // :: EXIT : Found Target
        if (baseNode == targetNode)
            return;

        // :: Status Open
        foreach (var itm in this.CheckDirectionNode(baseNode))
        {
            var openNode = itm.Open(targetNode);
            if(openNode != null)
                this.listOpenNode.Add(openNode);
        }

        // :: Find Min
        var minNode = this.FindMinCost();

        // :: Check Distance : And Turn Back When it's 2+
        this.TurnBackPath(baseNode, minNode);

        // :: Add Path
        this.paths.AddLast(new int[3] { minNode.x, minNode.y, minNode.z });

        // :: Close Min and Add Closed Node
        this.listClosedNode.Add(minNode.Closed());
        this.listOpenNode.Remove(minNode);

        // :: Return Self : When reach target Node
        this.GetPathImplement(minNode, targetNode);
    }
    // :: Turn Back Path : When distance is 2+
    private void TurnBackPath(Astar_Node baseNode, Astar_Node minNode)
    {
        // :: Check Distance and Same Distance
        var distance = this.CheckDistance(baseNode, minNode);
        var lastPathSameDistance = baseNode.estimateCost == minNode.estimateCost;

        if (distance == false)
        {
            // :: Close Base Node
            this.listClosedNode.Add(baseNode.Closed());
            this.listOpenNode.Remove(baseNode);

            // :: Delete Last Path
            this.paths.RemoveLast();

            // :: Return Path
            Astar_Node newBaseNode = this.GetNode(this.paths.Last.Value[0], this.paths.Last.Value[1], this.paths.Last.Value[2]);

            // :: Return Self : When distance <= 2 or Same Distance
            distance = this.CheckDistance(newBaseNode, minNode);
            lastPathSameDistance = newBaseNode.estimateCost == minNode.estimateCost;
            if (distance == false)
            {
                this.TurnBackPath(newBaseNode, minNode);
            }
            // :: or Same Distance
            else if (lastPathSameDistance)
            {
                // :: Close Base Node
                this.listClosedNode.Add(newBaseNode.Closed());
                this.listOpenNode.Remove(newBaseNode);

                // :: Delete Last Path
                this.paths.RemoveLast();

                Debug.LogFormat("마지막이 거리와 같을 때 {0},{1},{2} / {3},{4},{5}", newBaseNode.x, newBaseNode.y, newBaseNode.z, minNode.x, minNode.y, minNode.z);
            }
        }
        // :: or Same Distance
        else if (lastPathSameDistance)
        {
            // :: Close Base Node
            this.listClosedNode.Add(baseNode.Closed());
            this.listOpenNode.Remove(baseNode);

            // :: Delete Last Path
            this.paths.RemoveLast();

            Debug.LogFormat("마지막이 거리와 같을 때 {0},{1},{2} / {3},{4},{5}", baseNode.x, baseNode.y, baseNode.z, minNode.x, minNode.y, minNode.z);
        }
    }
    // :: Find Min Distance
    private Astar_Node FindMinCost()
    {
        // :: First Set
        Astar_Node minNode = this.listOpenNode[0];

        // :: Find
        foreach(var itm in this.listOpenNode)
        {
            if (minNode.estimateCost > itm.estimateCost)
                minNode = itm;
        }

        // :: Return
        return minNode;
    }
    // :: CheckDistance
    private bool CheckDistance(Astar_Node baseNode, Astar_Node targetNode)
    {
        var distance = Mathf.Abs(baseNode.x - targetNode.x) + Mathf.Abs(baseNode.y - targetNode.y) + Mathf.Abs(baseNode.z - targetNode.z);
        return distance <= 2;
    }

    // :: Check Direction and Return which isn't null
    private List<Astar_Node> CheckDirectionNode(Astar_Node baseNode)
    {
        // :: List Direction Node
        List<Astar_Node> listDirectionNode = new List<Astar_Node>();

        for(var i = 0; i < DIRECTION.GetLength(0); i++)
        {
            // :: Check Direction with Const
            Astar_Node node = this.GetNode(baseNode.x + DIRECTION[i,0], baseNode.y + DIRECTION[i, 1], baseNode.z + DIRECTION[i, 2]);
            if(node != null 
                && this.listOpenNode.Contains(node) == false
                && this.listClosedNode.Contains(node) == false)
            {
                listDirectionNode.Add(node);
            }
        }

        // :: Return
        return listDirectionNode;
    }
    // :: Get Node
    private Astar_Node GetNode(int x, int y, int z)
    {
        return this.listNode.Find(ele => ele.x == x && ele.y == y && ele.z == z);
    }

    // :: Node Status Enum
    private enum eNodeStatus
    {
        NONE,
        OPEN,
        CLOSED
    }
    // :: Node
    private class Astar_Node
    {
        // :: Constructor
        public Astar_Node() { }

        // :: XYZ
        public int x;
        public int y;
        public int z;

        // :: Status
        public eNodeStatus status;

        // :: Cost
        public int realCost;
        public int heuristicCost;
        public int estimateCost;

        // :: Initialise
        public void Init(int x, int y, int z)
        {
            // :: XYZ
            this.x = x;
            this.y = y;
            this.z = z;

            // :: Status
            this.status = eNodeStatus.NONE;

            // :: Cost
            this.realCost = 0;
            this.heuristicCost = 0;
            this.estimateCost = this.realCost + this.heuristicCost;
        }
        // :: Chagne Status
        public Astar_Node Open(Astar_Node targetNode)
        {
            // :: Don't Open this when Closed
            if (this.status == eNodeStatus.CLOSED)
                return null;

            // :: Open
            this.status = eNodeStatus.OPEN;

            // :: Calculate Cost
            this.realCost += 1;
            this.heuristicCost = Mathf.Abs(this.x - targetNode.x) + Mathf.Abs(this.y - targetNode.y) + Mathf.Abs(this.z - targetNode.z);
            this.estimateCost = this.realCost + this.heuristicCost;

            // :: Return this
            return this;
        }
        public Astar_Node Closed()
        {
            // :: Close
            this.status = eNodeStatus.CLOSED;

            // :: Return this
            return this;
        }
    }
}

[개선점]

>> 엄청 많음, 장애물일 때의 시험 등 여러가지 필요

>> 고려중

블로그 이미지

RIsN

,

[프로젝트명] S? : Charles VII

[장르] 전략

[목적] 스터디 전용 & 취업 포트폴리오

 

[사용 에셋]

 

 

 

 

 

일지 #0

<0> 시작
<1> Hex Grid 제작 : Cube 좌표 사용
<2> Hex Grid를 코드로 제어
<3> 캐릭터 [0][0][0]에 출력

<1> Hex Grid 제작 : Cube 좌표 사용

[Hex Grid란?]

: 사각형이 아닌 육각형으로 이루어진 맵

: 쓰는 이유?

사각형보다 전략적이라는 소문

 

[Cube 좌표란?]

: 3방향으로 나눠진 좌표

: 참고 : 배달아~ 배달 가는길 알려줘!(단호함) - 우아한형제들 기술 블로그 (woowabros.github.io)

>> x가 (+1) 되면 y가 (-1) 되는 게 조금 독특함

>> 한쪽 방향으로 진행하면 하나가 플러스 하나가 마이너스 되는 구조?

 

<1> Hex Grid 제작 : Cube 좌표 사용
<1> Hex Grid 제작 : Cube 좌표 사용

<2> Hex Grid를 코드로 제어

// :: Found All Tiles
var tiles = GameObject.FindObjectsOfType<Transform>().Where(ele => ele.gameObject.name.Contains("Tile"));

foreach (var itm in tiles)
{
    // :: Change name
    string[] tileString = itm.gameObject.name.Replace('[', ' ').Replace(']', ' ').Replace("  ", " ").Split(' ');

    // :: Init x, y, z
    int x = Int32.Parse(tileString[1]);
    int y = Int32.Parse(tileString[2]);
    int z = Int32.Parse(tileString[3]);

    // :: Make new Tile Class and Initialise
    Battle_Class_Tile tile = new Battle_Class_Tile();
    tile.Init(x, y, z);

    // :: Add List
    listTile.Add(tile);
}

Debug.LogFormat(":: [Battle:Init] All Tiles Found : {0}", listTile.Count);

<3> 캐릭터 [0][0][0]에 출력

youtu.be/0N8xmJOlGXo

 

블로그 이미지

RIsN

,

백준 2753 : 윤년

C# 2020. 11. 20. 17:13

연도가 주어졌을 때, 윤년이면 1, 아니면 0을 출력하는 프로그램을 작성하시오.

윤년은 연도가 4의 배수이면서, 100의 배수가 아닐 때 또는 400의 배수일 때이다.

예를 들어, 2012년은 4의 배수이면서 100의 배수가 아니라서 윤년이다. 1900년은 100의 배수이고 400의 배수는 아니기 때문에 윤년이 아니다. 하지만, 2000년은 400의 배수이기 때문에 윤년이다.

첫째 줄에 연도가 주어진다. 연도는 1보다 크거나 같고, 4000보다 작거나 같은 자연수이다.
첫째 줄에 윤년이면 1, 아니면 0을 출력한다.

:: 성공

: 개선점 : 수학적으로 좀 더 쉽게 없으려나? 최대공약수?

using System;

namespace If01
{
    class Program
    {
        static void Main(string[] args)
        {
            // :: Input
            string input = Console.ReadLine();

            // :: parsing
            int a = Int32.Parse(input);

            // :: Calculate and Result
            if(a % 4 == 0 && (a % 400 == 0 || a % 100 != 0))
            {
                Console.WriteLine(1);
            } else
            {
                Console.WriteLine(0);
            }
        }
    }
}

'C#' 카테고리의 다른 글

백준 15552 : 빠른 A+B  (0) 2020.11.27
백준 2739 : 구구단  (0) 2020.11.24
백준 1330 : 두 수 비교하기  (0) 2020.11.18
백준 2588 : 곱셈  (0) 2020.11.16
백준 10430 : 나머지  (0) 2020.11.15
블로그 이미지

RIsN

,