~ 설치 로그남깁니다.

Install step by step.


1. Install dotnet core 1.1
2. install VSCode
* Link : https://www.microsoft.com/net/core#windowscmd

3. Open VS Code and "Open folder" any

4. Open Console in VS Code (CTRL+`)

5. "dnvm upgrade" in console

6. "npm install -g yo grunt-cli generator-aspnet bower" in console

7. "yo aspnet" in colsole and select "WEB API" and type your want "project name"

8. re-open project folder with "Open folder"

9. add next 2 lines into dependenciestaginproject.json file
"Microsoft.AspNetCore.StaticFiles": "1.1.0",
"Microsoft.AspNetCore.WebSockets.Server": "0.1.0"
10. Add next 2 lines into Configure in Startup.cs file
app.UseDefaultFiles();
app.UseStaticFiles();
11. Open Explorer tab and click a "wwwroot" folder

12. make new folder as "app"

13. make new file as "index.html" on wwwroot
<!DOCTYPE html>
    <html>
        <head>
            <title>Hello Angular</title>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1">
            <style>
                body {color:#369;font-family: Arial,Helvetica,sans-serif;}
            </style>

            <!-- Polyfills for older browsers -->
            <script src="https://unpkg.com/core-js/client/shim.min.js"></script>
            <script src="https://unpkg.com/zone.js@0.7.4?main=browser"></script>
            <script src="https://unpkg.com/reflect-metadata@0.1.8"></script>
            <script src="https://unpkg.com/systemjs@0.19.39/dist/system.src.js"></script>
            <script> window.autoBootstrap = true; </script>
            <script src="https://cdn.rawgit.com/angular/angular.io/b3c65a9/public/docs/_examples/_boilerplate/systemjs.config.web.js"></script>
            <script> System.import('Script').catch(function(err){ console.error(err); });</script>
        </head>

        <body>
            <my-app>Loading AppComponent content here ...</my-app>
        </body>
</html>


14. make new file as "app.component.ts" on wwwroot/app
import { Component } from '@angular/core';

@Component({
    selector: 'my-app',
    template: `<h1>Hello {{name}}</h1>`
})
export class AppComponent { name = 'Angular'; }


2017/01/23 18:26 2017/01/23 18:26
슈팅게임으로 만들었어요.

소스 다운로드
강의자료

요즘 집필중이라서 정신이 하나도 없습니다. 
부실한 자료지만 참고하시기 바랍니다.


2017/01/04 15:30 2017/01/04 15:30

많은 인디 개발자 또는 프로개발자 조차도 모바일 UX를 지키지 않고 그냥 개발하고 있어 안타깝더군요.

PC 마우스 UX의 경우는

- Hover In / Out
- Click
- Double Click 

이렇게 이벤트를 먹이지만, 

모바일의 경우는 
- Pressed 
- Unpressed 로

- Press 됐을때 버튼을 확대하고
- 만약 사용자가 버튼 영역을 벗어나서 손을 떼면 원상복귀되면서 명령이 취소됩니다.
- 만약 사용자가 버튼 영역을 벗어나지 않고 손을 떼면 원상복귀되면서 명령이 실행됩니다.

일전에 작성했던 이벤트 통합하기로 구현하였으니 참고하시고 다음 소스를 보시면 이해가 쉬우실거 같네요.

참고 링크 : http://www.wolfpack.pe.kr/909


먼저 버튼을 2개 만들어 놓으시고 이벤트 통합용 스크립트는 다음과 같습니다.

using UnityEngine;
using System.Collections;
using UnityEngine.SceneManagement;

public class UIManager_Intro : MonoBehaviour {

    const float workTerm = 0.2f;

    public static UIManager_Intro instance;
    public void Awake()
    {
        UIManager_Intro.instance = this;
     }

     private void SetScaleUp(GameObject _obj, bool isPressed)
     {
         if (isPressed)
         {
             iTween.ScaleTo(_obj, new Vector3(1.1f, 1.1f, 1.1f), workTerm);
         }
         else
         { 
             iTween.ScaleTo(_obj, new Vector3(1f, 1f, 1f), workTerm);
         }
     }

     private bool DetectHoverSameObject(GameObject _obj)
     {
         RaycastHit hit;
         Ray ray = NGUITools.FindCameraForLayer(_obj.layer).ScreenPointToRay(Input.mousePosition);
         if (Physics.Raycast(ray, out hit, Mathf.Infinity))
         {
             return (hit.collider.gameObject == _obj);
         }
         return false;
     }

     public void Button1_OnPress(GameObject _obj, bool isPressed)
     {
         SetScaleUp(_obj, isPressed);
         if (!isPressed && DetectHoverSameObject(_obj)) StartCoroutine(LoadingScene("usingAnchor"));
    }
 
    public void Button2_OnPress(GameObject _obj, bool isPressed)
     {
         SetScaleUp(_obj, isPressed);
         if (!isPressed && DetectHoverSameObject(_obj)) StartCoroutine(LoadingScene("inputField"));
     }

     IEnumerator LoadingScene(string _sceneName)
     {
         yield return new WaitForSeconds(workTerm);
         SceneManager.LoadScene(_sceneName);
     }
}


버튼1에만 우선 적용합니다. 스크립트는 다음과 같습니다. 
using UnityEngine;
using System.Collections;

public class Behavior_Button1 : MonoBehaviour {

    void Start () {
        UIEventListener.Get(gameObject).onPress += UIManager_Intro.instance.Button1_OnPress;
    }
}



결과 1. 마우스를 클릭하여 Press 시뮬레이팅
사용자 삽입 이미지
결과2. 취소 (드레그하여 다른곳에서 손 뗌)
사용자 삽입 이미지
결과 3. 명령실행 (원상복귀후 다른씬으로 이동)
사용자 삽입 이미지


2016/09/22 09:23 2016/09/22 09:23

Z사 인터뷰 후기

Developer 2016/04/23 15:08
아마 1달 좀 넘은 시간에, 취업은 개뿔... 걍 영어공부나 더 하자 하던때에...
Linkedin에서 Z사 리쿠르트가 이메일이 왔습니다.

- 유니티3D 네트워크 포지션 있는데 지원할 생각이 있나?

그날 개인 프로젝트가 막혀서 머리가 다 터져 나가던 상황이라...
개인 프로젝트 하고 있는데 문제만났어. 이거 끝나면 Resume 보내줄께 하고 답장하고는...



다음날인가에 업댓한 Resume 보냈고, 해당 팀의 정보를 포함에서 전화 인터뷰까지 몇 번의 이메일을 주고 받았습니다.
* Resume와 함께 예전에 교재로 만들어 놓은 해당팀에서 하는 일을 Working Mockup 만들어 놓은 것도 같이 보냈습니다.





첫 전화인터뷰에서는 간략한 Job Description을 들었고, 몇가지 질문이 있었는데,

- 어디사냐?
- 헤드쿼터는 SF에 있는데 이동 가능하냐? 
- 현재 채용중인 포지션은 유니티 네트워크 엔지니어인데 플랫폼 개발 경험있냐?
- 유니티 플러그인은 얼마나 만들어 봤냐?

등등등을 물어본 걸로 기억납니다. 그리고 "다음주까지 연락 주겠다."하고 전화를 끊었습니다.
이후에 XX팀과 OO팀에 줬는데 OO팀에서 너 한테 관심있다. 2차 전화면접 준비하자라는 답을 받았고,

2차 전화 면접을 기대하며 온라인 협업 코드창을 열고 헤드셋 구해서 전화를 기다렸지만, 비러먹을 Verizon 이 안터져 다시 1주일 뒤로 연기되었습니다.

2차 전화 면접에서는 
- 백그라운드 설명해봐라
- 우리팀 일이 하드한데 괜찮냐?
- 버전관리 해봤어?
- 유니티에서 Restful할때 어떻게 하지?
- 리얼타임 서버는 어때?
등등등을 물어 봤고 예정된 시간을 넘겨서 전화로 정신없이 대답하고 드디어 대망의 Onsite 면접을 받았습니다.
(눈물 날거 같더군요... T_T 한국에서 와 달라는 회사는 많았어도 이렇게 대차게 몇 백장의 Resume를 공중에 날려버린게 처음인지라... T_T)

뭐 암튼, 공짜 티켓 캄사히 받아 들고 LAX에서 샌프란으로 슈웅 날라 갔습니다. 아침 7시 뱅기라 4시에 일어난건 덤...

* 고픈 배를 채우는 땅콩과 건과류.. 맛이 꽤 있는 편입니다.
사용자 삽입 이미지

* 버스 정류장 내리는걸 놓쳐서.. 걷고 걸은 끝에 저 멀리서 보이는 Z사! 
사용자 삽입 이미지

* 10시정도에 도착해서는 세상을 게임으로 연결하고자 했던 비전을 바라보며... 맘속으로 "그럼 잘좀 해봐요!!!"
사용자 삽입 이미지

* 그렇게 시간 보내고 나서 Presentation 자료 데모를 위해 30분 일찍 아름다운 HR 담당자와 함께 인터뷰장으로 이동... 세상에나!!!!!
사용자 삽입 이미지
감격해서 쓰러질뻔 했습니다. 문을 열자 마자 격렬히 환영하는 글씨를 보고는 눈물이 글썽글썽... (저건 제가 나올때까지도 화이트 보드 테스트 보면서도 남겨뒀어요.)
드디어 4명의 인터뷰와 1:1로 제 Presentation 10분 정도 하고 알고리즘, 방법론, 관리, 설계 등등등의 화이트보드 테스트를 받았습니다.

* 구체적인건 회사 보안으로 소송 걸릴 수 있다고 지인분께서 말씀해주셔서 밝힐 수는 없고 잘 알려진 문제중

- Test코드 작성
- 자료구조 설계
- Sort 구현
- LinkedList 구현
- Auto Build System 설계
- Unity3D Plugin 개발
- 네트워크 Fault Debugging 등을 테스트 받았습니다.

가장 인상적이었던건 간단한 게임을 설계하고 자료구조 만든뒤에 판정하고 AI구현하는걸 아주 빠르게 토의하면서 만들었습니다.
(4시간이 좀 넘는 시간동안 다 태웠다고 표현할 수 밖에 없을 정도로 제가 알고 있는 지식과 경험을 다 토해 냈습니다.)

온사이트 면접 기회가 별로 없었던 제가 잘은 모르겠지만, 이 친구들 평가하는 걸 유심히 보니...

- 문제를 주고 풀어 보라 해요. OO한번 만들어보자.
- 옆에서 서서 피면접자가 문제를 푸는 과정을 관찰합니다.
- 피면접자가 이리 저리 물어보면 대답해줍니다. 
- 문제 풀이가 막히면 직접적인 힌트도 줍니다.
- 한마디로 코딩을 할 줄 알면 문제푸는건 일도 아니게 됩니다.

물론 제가 최종 오퍼받은게 아니기 때문에 너무 단정지어 이야기할 수 있지만, 정말 옆에서 문제 푸는 걸 도와줍니다. 
하지만, 그걸 주도하는 사람은 어디까지나 피면접자이고 인터뷰어는 절대 주도하지 않으면서 옆에서 앉아 있거나 옆에 서서 미소 짓고 있을 뿐입니다.
(어떤 회사는 코드 한줄 쓸때마다 마구마구 깹니다. 왜 소문자로 시작하냐? 부터 시작해서.. ㄷㄷㄷ 뽁는 회사도 있고, 어떤회사는 정답이 있고 그 정답을 체크하는 회사도 있습니다. 가령 XXX프레임워크를 사용할때 Life Cycle이 뭐냐? 등의 기초 지식을 물어보는 회사도 있습니다.)


문제푸는 방법은 개발을 조금 해보신분들이라면 다들 공감하시겠지만, 어떠한 알고리즘 문제라도 기초 지식이 있으면 숫자나 그림으로 시뮬레이션 하면 금방 답이 나옵니다.
예를 들어, 2의 승수인지 확인하는 알고리즘을 만들라가 문제라면

Test Data를 먼저 화이트 보드에 씁니다.

2^0 = 1
2^1 = 2
2^2 = 4
2^3 = 8
2^4 = 16

이렇게 그냥 써놓고는 나서 한발짝 떨어져서 보면 패턴이 보입니다. 이경우는 정확하게 Log를 사용하면 해결가능한 문제입니다.
물론 그걸 맞다 틀리다 하는 사람은 인터뷰어겠지만요.

하지만, 더 중요한건 이 문제를 풀어가는 방법과 생각하는걸 옆에서 관찰하더군요.
(정답을 맞추는건 중요하지 않았어요.)

다 했다고 하면, 그제서야 앞으로 나와서 검산하고 맞다, 틀리다하고 물어봅니다.
물론 저는 반골기질이 있어서,

- Array Sort하라고 해서 왜? C#은 Array.Sort() 있어 그거 쓰면 되잖아?
- LinkedList 만들라 해서, MS가 LinkedList 느리다고 비춘데 그걸 왜써야해?
와 같은... 쿨럭... (물론 그리고 나서 그런데 니가 원하는건 손으로 직접 하길 원하는 거지?라고 물어보고 얌전히 썼습니다. T_T)

알고리즘 테스트같이 실무적인 내용이 끝나면 반드시 2가지를 물어봅니다.
- Big-O 는 어떻게되지?
- 질문있어? <<< 이게 흘리면 나 안들어가겠다는 의미로 보시면 됩니다.

질문있어라는 말속에 숨어 있는 의미는 얼마나 네가 이회사와 인터뷰어에 대해 공부하고 왔는지 확인하는 겁니다.
(온사이트 면접이전에 HR에서 인터뷰어의 이름 미리 줍니다)

마치고 나오면서 정말 죽어도 여한이 없을 정도로 다 쏟아 놓고 나왔습니다.
너무 깔끔했고 떨어져도 "와~ 정말 좋은 경험했다. 저런 회사는 클래스가 달라도 너무 다르구나!" 이런 생각이 들 정도였습니다. 


사무실에서 나와서 건너편 Starbucks 에서 커피 한잔 시켜놓고 Thankyou Letter 써서 보내며 일정을 마무리하고 나니 시간이 얼마 안남은 관계로 지하철 플랫폼으로 이동...

* LA로 가는 길에 찍은 풍경들... 사무실 나와서 제일 처음 본 풍경
사용자 삽입 이미지
* 전기 버스도 있어요!
사용자 삽입 이미지

* 시티홀이 우어~~~ 참고로 여기에서는 갈매기가 닭둘기를 대신합니다. 오리보다 조금 큰 넘들이 뒤뚱뒤뚱 거리면서 날아 가지도 않아요...
사용자 삽입 이미지

* 지하철 플랫폼에서 요금 계산할 줄몰라 한참 혜매다가 결국 현지 샌프란 아저씨의 도움을 받아 겨우 계산하고 티켓팅 한뒤에 열차까지 안내 받는 호사를 누렸습니다 T_T
(샌프란 사람들 알라뷰!!!)
사용자 삽입 이미지
* 샌프란 지하철을 BART라고 하더군요. 자리는 앞으로 또는 뒤로 앉도록 되어 있습니다. 뒤로 앉았더니 평소 몸이 기억하던 중력과 달라서 살짝 기분이 이상하더군요.
(지금 저는 진행방향과 반대방향을 찍은 겁니다.)
사용자 삽입 이미지

좋은 소식 있었으면 좋겠습니다만, 기분 좋은 인터뷰와 다르게 결과는 신만이 아시겠죠?
(God willing...)


* 기본 알고리즘은 여기 참고하세요.
http://bigocheatsheet.com/
2016/04/23 15:08 2016/04/23 15:08

Q1. OOP?
This is a programming paradigm based on the concept of the Object.
It has "Attribute" and "Method"
OOP languages usually support "inheritance", "encapsulation", "abstract" and "polymorphism".

Example.

using System;
using System.Collections;

namespace TestCode
{
    abstract class Car //abstract
    {
        protected string Color; //encapsulation
        protected int Speed; //encapsulation
        abstract public void SpeedUp();
    }

    class RealCar : Car //inheritance
    {
        public RealCar(string color)
        {
            this.Color = color;
            this.Speed = 0;
        }
        public override void SpeedUp()
        {
            Speed += 10;
        }

        public void DescriptionCar()
        {
            Console.WriteLine("This is {0} Car, Speed is {1}", this.Color, this.Speed.ToString());
        }
    }

    class Program
    {

        static void Main(string[] args)
        {
            RealCar car = new RealCar("Red"); //polymorphism
            car.DescriptionCar();
            car.SpeedUp();
            car.DescriptionCar();
            RealCar carB = new RealCar("Blue"); //polymorphism
            carB.DescriptionCar();
            Console.ReadLine();
         }
    }
}


Q2. Restful API?
It is a computer architecture style on the Web service. 
You can Create, Read, Update, Delete by the Restful with Json or XML.

Example URI
non-Restful : /user?id=1234
Restful : /user/{1234}

The Unity3D supported HTTP Method. so, we can easy implement it.
but, you keep the rule.
- you should write Api with small letter.
- if you want "space", you should write URL with "-" (hyphen)
- don't use extension.


Q3. Linked List

class Program
{
    static void Main(string[] args)
    {
        LinkedList<int> _LinkedList = new LinkedList<int>();
         //Add
        _LinkedList.AddLast(9);
         //Add
        _LinkedList.AddLast(3);
         //Insert
        InsertNode(_LinkedList, 9, 2);
         //Remove
        RemoveNode(_LinkedList, 3);
         //Merge
        MergeNode(ref _LinkedList);
         //Sort
         LinkedList<int> _SortList = new LinkedList<int>(_LinkedList.OrderBy(x=>x));
         //Print
         PrintList(_SortList);
        Console.ReadLine();
    }

    static void InsertNode(LinkedList<int> linkedlist, int findArg, int value )
    {
        LinkedListNode<int> _node = linkedlist.Find(findArg);
        linkedlist.AddAfter(_node, value);
    }

    static void RemoveNode(LinkedList<int> linkedlist, int findArg)
    {
        linkedlist.Remove(findArg);
    }

    static void MergeNode(ref LinkedList<int> linkedlistParents)
    {
        //TestValue
        LinkedList<int> _Child = new LinkedList<int>();
        _Child.AddLast(3);
        _Child.AddLast(7);

        linkedlistParents = new LinkedList<int>(linkedlistParents.Union(_Child));
    }

    static void PrintList(LinkedList<int> _x)
    {
        foreach (var ll in _x)
        {
            Console.WriteLine(ll);
        }
    }
}



Q4. Array 
class Program
{
    static void Main(string[] args)
    {
        int[] _intArrayA = new int[] { 1, 2, 2, 3, 4, 5, 5 };
        int[] _intArrayB = new int[] { 6,7,9,8 };

        //Merge
        int[] _MergeArray = _intArrayA.Concat(_intArrayB).ToArray();
        PrintArray(_MergeArray);

        //Count Number
        int[] _CountNum = _MergeArray.GroupBy(x => x).Select(x => new { key = x.Key, count = x.Count() }).Where(x => x.count >= 2).Select(x => x.key).ToArray();
        PrintArray(_CountNum);

        //Distract
        int[] _Dist = _MergeArray.Distinct().ToArray();
        PrintArray(_Dist);
 
        //Sort 
        int[] _Sort = _Dist.OrderBy(x=> x).ToArray();
        PrintArray(_Sort);

        Console.ReadLine();
    }

    static void PrintArray(int[] _array)
    {
        Console.WriteLine("============");
        foreach (int x in _array)
        {
            Console.WriteLine(x);
        }
    }
}




2016/04/12 12:46 2016/04/12 12:46
간만에 유니티3D 관련 글을 쓰네요.

몇 번의 프로젝트에서 사용했던 티끌 같은 팁인데 많은 분들이 모르시는 것같아 소스 하나 남겨둡니다.

using UnityEngine;
using System.Collections;

public class Test : MonoBehaviour {

    // Use this for initialization
    IEnumerator Start () {

        //for Lambda
        StartCoroutine(ReturnValue( (x) => 
        {
            Debug.Log(x);
        } 
        ));

         //for local value
        int a = 0;
        yield return StartCoroutine(ReturnValue( (x) => 
        {
            a = x;
        }
        ));
        Debug.Log(a);
    }
 
    IEnumerator ReturnValue(System.Action<int> callback)
    {
        yield return null;
        callback(10);
    }
}


핵심은 Lambda 식으로 callback 함수를 구현하는 겁니다. =)
로컬 변수에 값을 할당할때는 반듯이 yield return 명령으로 Coroutine 함수가 종료되고나서 값이 할당됐는지 확인되어야 합니다. (그럼 코루틴 쓰는 의미가.. -_-;;)


2016/04/04 17:00 2016/04/04 17:00
* 유진호님 감사합니다. =)
출처 : http://www.csharpstar.com/top-20-googl ··· tions%2F

알고리즘 문제 Top20개인데, 풀이 결과는 별거 없는데... 용어가.. 좌절스럽습니다.
일단 문제 옮겨 놓고 용어부터 풀어야 겠네요.

1. Given an unsorted array which has a number in the majority (a number appears more than 50% in the array), find that number?
2. How to detect a cycle in singly linked list?
3. How to merge two sorted linked list, write a program in your favorite programming language i.e. Java,C#
4. Write a Program which checks if two Strings are Anagram or not?
5. How to swap two numbers without using a temp variable, write code which is free from Integer overflow?
6. How to find all pairs of elements in an integer array, whose sum is equal to a given number?
7. Write a function to print nth number in Fibonacci series?
8. Write a function to count a total number of set bits in a 32 bit Integer?
9. Write a function to remove duplicate characters from String?
10. How to find the 3rd element from end, in a singly linked, in a single pass?
11. How to calculate factorial using recursion in C#?
12. C# program to check if a number is Armstrong number or not?
13. Algorithm to check if a number is Prime or not?
14. Algorithm to check if a number is Palindrome?
15. Algorithm to find if Array contains duplicates?
16. Write code to reverse a linked list, if you able to do it using loops, try to solve with recursion?
17. How to rotate an array by a given pivot ?
18. How to remove duplicates from a sorted linked list?
19. How to find sum of digits of a number using Recursion?
20. Sorting an Array using Selection Sort

흐미... -_-;; 용어 몰라서 문제 못풀뻔 했네요.
(물론 불러줘야 인터뷰를 볼 수 있겠지만....)

용어정의부터 
* a number in the Majority : 50%이상을 차지하는 수입니다. 
예를 들면, {1,2,3,4,5,2,2,2,2} 에서 2가 Majority 수가 되겠군요. 간단히 Linq로 해결할 수 있을거 같네요.

* cycle in singly linked list 는 순환 연결리스트 같네요.

* Anagram은 이전에서 다뤘던 앞으로 읽어도 뒤로 읽어도 같은 문자입니다.

* Fabonacci 수열이 있네요. 
파보나치 수열은 간단히 예로 들면 0, 1, 1, 2, 3, 5, 8, 13... 과 같이 바로 앞의 숫자와 현재 숫자를 더한 결과입니다.

* Factorial 을 계산하라네요. 팩토리얼은 예를 들어 3i = 3*2*1 = 6 (고딩때 수학이... 으으으)

* 암스트롱 넘버는 의외인데, 찾아보니 153 = 1^3 + 5^3 + 3^3 = 153 처럼 abc = a^n + b^n + c^n = x 로 n은 자릿수입니다.

* Prime number 는 영원한 수학계의 숙제인 자신외에는 나눌 수 있는 수가 없는 소수입니다. 

* Palindrome number는 anagram하고 똑같이 숫자 131, 121,  22, 11 같은 수로 꺼꾸로 읽어도 같은 수가 됩니다. 
만드는 공식은 "처음수+꺼꾸로한수"로 72 + 27 = 99 가 되는 수입니다.

* Selection Sort는 지난 포스팅에서 했던 배열 정렬 방법중 하나인데, 선택정렬이군요. 

1. {1,2,3,4,5,2,2,2,2} 이 주어졌을때 2가 나오면 되는거네요.
static void Main(string[] args)
{
     int[] _x = new int[]{ 1, 2, 4, 6, 5, 2, 2, 2, 2 };
     var query = _x.GroupBy(x => x).Select(x => new { Key = x.Key, count = x.Count() }).ToList(); //Linq로 먼저 Groupby해서 카운트를 구합니다.
     var isMajority = query.Find(x => x.count >= _x.Length / 2); //배열의 길이의 50%가 넘게 차지하는 수를 찾습니다.
     string result = (isMajority == null) ? "Not Found" : isMajority.Key.ToString();
     Console.WriteLine(result);
     Console.ReadLine();
}



2. 싱글 링크드 리스트에서 순환되는 링크드 리스트를 찾으란 말인즉슨 Child node 가 null이 있으면 순환이 아니고, null이 없으면 Loop돈다는 뜻입니다.
따라서, Linked class를 만들어서 확인해보면 되겠네요.

using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;

namespace TestCode
{
    class Program
    {
        static private Node head;
        static void Main(string[] args)
        {
            List<Node> _LinkedList = new List<Node>();
            MakeLinkedList(ref _LinkedList, 0);
            MakeLinkedList(ref _LinkedList, 1);
            MakeLinkedList(ref _LinkedList, 2);
            MakeLinkedList(ref _LinkedList, 3);

            SetCheck(_LinkedList); //정작 사용하는건 요거 하나 입니다. -_-;;

            MakeLoopList(_LinkedList);

            SetCheck(_LinkedList);
            Console.ReadLine();
        }

        static void SetCheck(List<Node> _LL)
        {
             var result = _LL.Find(a => a.Child == null);
             if (result == null) Console.WriteLine("Loop Linked List : True"); else Console.WriteLine("Loop Linked List : false");
        }

        #region for Make Linked List 
        static void MakeLinkedList(ref List<Node> _LL, int value)
        {
             if (head == null) AddFirst(ref _LL, value);
             else
             {
                Node _node = new Node { value = value, Child = null };
                _LL.Add(_node);
                Node _current = head;
                while (_current.Child != null)
                {
                     _current = _current.Child;
                }
                _current.Child = _node;
             }
        }

        static void AddFirst(ref List<Node> _LL, int value)
        {
            Node _Head = new Node { value = value, Child = null };
            _LL.Add(_Head);
            head = _Head;
        }
        #endregion 

        static void MakeLoopList(List<Node> _LL)
        {
            _LL.Find(a => a.value == 3).Child = head;
        }

        public class Node
        {
            public int value;
            public Node Child;
        }
    }
}



3번은 좀 멘붕이네요. 2개의 Sort된 Linked List를 Merge하라니... OTL... 뭐 암튼 이건 2번 문제 응용으로 Value를 비교하여 Node를 연결하면 해결되지 않을까? 합니다.
using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;

namespace TestCode
{
    class Program
    {
        static private Node head;
        static void Main(string[] args)
        {
            //Linked list를 먼저 만듭니다.
            List<Node> _LinkedListA = new List<Node>();
            MakeLinkedList(ref _LinkedListA, 0);
            MakeLinkedList(ref _LinkedListA, 1);
            MakeLinkedList(ref _LinkedListA, 2);
            MakeLinkedList(ref _LinkedListA, 3);

            List<Node> _LinkedListB = new List<Node>();
            MakeLinkedList(ref _LinkedListB, 1);
            MakeLinkedList(ref _LinkedListB, 3);
            MakeLinkedList(ref _LinkedListB, 5);
            MakeLinkedList(ref _LinkedListB, 6);
            
            //Merge할 List를 만들고,
            List<Node> _MergeList = new List<Node>();
            //Merge합니다.
            MergeLinkedList(_LinkedListA, _LinkedListB, ref _MergeList);
            Console.ReadLine();
         }

         //하나로 모아서 Sort한 뒤에 LinkedList를 생성합니다.
         static void MergeLinkedList(List<Node> _A, List<Node> _B, ref List<Node> _C)
         {
              ArrayList A = new ArrayList();
              foreach(Node x in _A) A.Add(x.value);
              foreach (Node x in _B) A.Add(x.value);
              A.Sort();
              foreach (int x in A) MakeLinkedList(ref _C, x);
          }

          #region for Make Linked List 
          static void MakeLinkedList(ref List<Node> _LL, int value)
          {
               if (head == null) AddFirst(ref _LL, value);
               else
               {
                   Node _node = new Node { value = value, Child = null };
                   _LL.Add(_node);
                   Node _current = head;
                   while (_current.Child != null)
                   {
                        _current = _current.Child;
                   }
                   _current.Child = _node;
                }
           }

           static void AddFirst(ref List<Node> _LL, int value)
           {
                Node _Head = new Node { value = value, Child = null };
                _LL.Add(_Head);
                head = _Head;
           }
           #endregion 

           static void MakeLoopList(List<Node> _LL)
           {
                _LL.Find(a => a.value == 3).Child = head;
           }

           public class Node
           {
                public int value;
                public Node Child;
           }

    }
}



4. Anagram 문자열 비교는 이전 포스팅 http://www.wolfpack.pe.kr/920 문제 5번과 동일합니다.

5. 2개의 숫자를 바꾸는 것인데, 임시 변수 사용하지말고 하라니 쬐끔 황당하긴하네요.
만약 A=200 이고 B=100이라면 2개 수의 합은 300이 됩니다. 300을 A에 저장해놓고, A에서 B를 빼면 200, 이걸 B에 할당한뒤에 다시 300에서 B를 빼면 100 올ㅋ~
따라서, 공식은 

A = A + B;
B = A - B;
A = A - B;

static void Main(string[] args)
{
    int A = 100;
    int B = 200;
    A = A + B;
    B = A - B;
    A = A - B;
    Console.WriteLine(A.ToString());
    Console.WriteLine(B.ToString());
    Console.ReadLine();
}


6. 쉬운 단어들 조합인데 해석이 제대로 안되서 까다로운 문제네요. 주어진 값이 나올수있는 배열안 2개의 원소 합을 구하라는 건데.. 간단히 TEST CASE를 작성하면,
{1,2,3,4} 라는 배열이 있다면 5가 나오는 합은 1, 4 / 2, 3 입니다. 6이 나오는 합은 2, 4가 되겠지요?
그냥 For 문 노가다입니다.

static void Main(string[] args)
{
    int[] arrayInt = new int[] { 1, 2, 3, 4, 5 };
    Console.WriteLine(SearchElement(arrayInt, 3));
    Console.ReadLine();
}

static bool SearchElement(int[] _arr, int x)
{
    for (int i = 0; i < _arr.Length; i++)
    {
        for (int y = 0; y < _arr.Length; y++)
        {
            if (i == y) continue;
            if (i + y == x) return true;
        }
    }
    return false;
}


7. 파보나치 수열은 위에 용어정의에서 이미 터치하고 왔습니다. 뭐.. 이것도 별건 없습니다. x = n-1 + n-2 단, 0과 1은 그대로 찍어주면 될 일 같습니다.
Arraylist로 간단히 해결가능할 거 같네요.

static void Main(string[] args)
{
    ArrayList _ar = new ArrayList();
    SetFibonacci(_ar, 12);
    foreach (int x in _ar)
    Console.Write(x + " ");
    Console.ReadLine();
}

static void SetFibonacci(ArrayList ar, int x)
{
    for (int i = 0; i < x; i++) {
        if (ar.Count < 1) { ar.Add(i); continue; }
        if (ar.Count < 2) { ar.Add(i); continue; }
        ar.Add((int)ar[i-2] + (int)ar[i-1]);
    }
}


8.번 문제는 32비트 int형의 bit 카운트 하라는 것같습니다. =)
이건 간단하게 10진수를 2진수로 변환하고나서 1의 갯수를 세면 bit 카운트가 됩니다. -_-;; 
static void Main(string[] args)
{
    int x = 512;
    string bit = Convert.ToString(x, 2); //int.MaxValue 로 대체하면 31이 나와야 합니다. 32비트 int형이니까요...
    int cnt = 0;
    for (int i =0; i < bit.Length; i++)
    {
        if (bit[i].ToString() == "1") cnt++;
    }
    Console.WriteLine(cnt);
    Console.ReadLine();
}


9.번은 스트링에서 중복되는 문자열을 제거하는 겁니다. Linq로 간단히 합의 볼 수 있는 수준입죠.
static void Main(string[] args)
{
    string x = "aabcded"; //기대결과값은 abcde
    var result = x.Distinct().ToArray();
    Console.WriteLine(new string(result));
    Console.ReadLine();
}


10번은 끝에서 3번째 Element를 찾는 문제네요. 이제 슬슬 LinkedList는 지겨워 지려합니다. 2번 코드 재활용해서 만들어 볼께요.
그런데 끝은 어떻게 찾느냐? 간단히 child가 null인 녀석을 찾고 그 걸 child로 가지고 있는걸 찾고, 다시 그걸 child로 가진걸 찾고... 3번 반복하면 되겠네요.

using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;

namespace TestCode
{
    class Program
    {
        static private Node head;
        static void Main(string[] args)
        {
            List<Node> _LinkedList = new List<Node>();
            MakeLinkedList(ref _LinkedList, 0);
            MakeLinkedList(ref _LinkedList, 1);
            MakeLinkedList(ref _LinkedList, 2);
            MakeLinkedList(ref _LinkedList, 3);

             //마지막 노드 찾는건 Lambda 함수로 Child가 null인 걸 찾으면 끝!
            Node LastNode = _LinkedList.Find(x => x.Child == null);
            Node findedNode;
            FindNode(_LinkedList, LastNode, 2, out findedNode);
            Console.Write(findedNode.value);
            Console.ReadLine();
        }

         //여기서 재귀함수 Recursive 로 돌려주면서 1씩 까나갑니다.
        static void FindNode(List<Node> LL, Node current, int n, out Node finded)
        {
            if (n == 0) { finded = current; return; }
            Node parent = LL.Find(x => x.Child == current);
            FindNode(LL, parent, n - 1, out finded);
        }

#region for Make Linked List 
static void MakeLinkedList(ref List<Node> _LL, int value)
{
if (head == null) AddFirst(ref _LL, value);
else
{
Node _node = new Node { value = value, Child = null };
_LL.Add(_node);
Node _current = head;
while (_current.Child != null)
{
_current = _current.Child;
}
_current.Child = _node;
}
}

static void AddFirst(ref List<Node> _LL, int value)
{
Node _Head = new Node { value = value, Child = null };
_LL.Add(_Head);
head = _Head;
}
#endregion

        static void MakeLoopList(List<Node> _LL)
        {
            _LL.Find(a => a.value == 3).Child = head;
        }

        public class Node
        {
            public int value;
            public Node Child;
        }
    }
}



11번 문제는 재귀함수로 팩토리얼 구하는 문제입니다. 3i이라면 3*2*1 = 6 이 나오면 되는 문제입니다.

static void Main(string[] args)
{
    Console.WriteLine(Factorial(4));
    Console.ReadLine();
}

static int Factorial(int x)
{
    if (x == 1) return x;
    return Factorial(x - 1) * x;
}



12번 문제는 암스트롱 수가 맞는지 확인하는거 같네요. 공식을 대입하면 abc = a^n + b^n + c^n = abc 가 나와야 합니다.
따라서, 입력한 값을 위 공식을 적용해서 테스트해보고 비교하면 올ㅋ~

static void Main(string[] args)
{
    Console.WriteLine(GetCalator(154));
    Console.ReadLine();
}

static bool GetCalator(int x)
{
    //자르기 편하게 string으로 변환부터
    string _x = x.ToString();
    //자릿수 n을 구합니다.
    int n = _x.Length;
    double y = 0;
    for (int i = 0; i < n; i++)
    {
        //C#은 C처럼 ^연산자는 2진수 계산을 하는군요. VB는 그냥 제곱인데.. 쩝..
        y += Math.Pow(int.Parse( _x[i].ToString()), n);
    }
    if (x == y) return true;
    return false;
}



13번 문제는 수학계의 영원한 숙제인 소수찾기입니다. 소수는 자기외에 나눌수 없는 성질을 가지고 있기 때문에 테스트 케이스를 작성하면,
1 소수
2 소수
3 소수
4 소수아님 (4%2==0)
5 소수 

1을 제외하면 for문으로 주어진 2~n-1까지 수로 나눠서, 그과정에서 나머지가 없으면 소수가 아닌걸로 판정하면 올ㅋ

static void Main(string[] args)
{
    Console.WriteLine(isPrime(7));
    Console.ReadLine();
}

static bool isPrime(int x)
{
    for (int i = 2; i < x; i++)
    {
        if (x % i == 0) return false;
    }
    return true;
}


14번 문제는 이전 포스팅에서 아나그람으로 다뤘지만, 조금 다른방식으로 처리해보면, Array.Reserve로 뒤집어 놓고 비교하면 더 간단하겠네요. =)

static void Main(string[] args)
{
    Console.WriteLine(isPalindrome(78));
    Console.ReadLine();
}

static bool isPalindrome(int x)
{
    char[] _x = x.ToString().ToCharArray();
    Array.Reverse(_x);
    if (x.ToString() == new string(_x)) return true;
    return false;
}



15번은 배열안에 중복되는 인자가 있는지 확인하는건데 이것도 걍 Linq한방이면 되겠네요! (1번 문제 응용이네요)
static void Main(string[] args)
{
    int[] _array = new int[] { 1, 2, 3, 3, 5 };
    var result = _array.GroupBy(x => x).Select(x => new { key = x.Key, count = x.Count() }).ToList();
    if (result.Find(x=>x.count >= 2) == null) Console.WriteLine("cant find Duplicated element");
    else Console.WriteLine("Find Duplicated element");
    Console.ReadLine();
}



16번은... 양키 형님들은 진짜 Linked List를 사랑하는거 같아요. -_-;; 
Linked List를 가능하다면 재귀함수 써서 뒤집으라 하십니다. 2번 소스 응용해서 만들어 보겠습니다.

using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;

namespace TestCode
{
    class Program
    {
        static private Node head;
        static void Main(string[] args)
        {
            List<Node> _LinkedList = new List<Node>();
            MakeLinkedList(_LinkedList, 0);
            MakeLinkedList(_LinkedList, 1);
            MakeLinkedList(_LinkedList, 2);
            MakeLinkedList(_LinkedList, 3);

            List<Node> _ReservedList = new List<Node>();

            SetReserve(_LinkedList, _ReservedList, _LinkedList.Count()-1);
            foreach (Node v in _ReservedList)
            {
                 Console.WriteLine(v.value);
            }

            Console.ReadLine();
         }

         static void SetReserve(List<Node> linked, List<Node> Reserved, int idx)
         {
              if (idx < 0) return;
              MakeLinkedList(Reserved, linked[idx].value);
              SetReserve(linked, Reserved, idx-1);
         }


#region for Make Linked List 
static void MakeLinkedList(List<Node> _LL, int value)
{
if (head == null) AddFirst(ref _LL, value);
else
{
Node _node = new Node { value = value, Child = null };
_LL.Add(_node);
Node _current = head;
while (_current.Child != null)
{
_current = _current.Child;
}
_current.Child = _node;
}
}

static void AddFirst(ref List<Node> _LL, int value)
{
Node _Head = new Node { value = value, Child = null };
_LL.Add(_Head);
head = _Head;
}
#endregion 

      public class Node
      {
           public int value;
           public Node Child;
      }
   }
}


17번 문제는 의미를 몰라서 뒤져봤습니다.
찾아 봤더니 다른 의미가 아니라, 테스트 케이스로 보면, {1,2,3,4,5}라는 배열이 있다면, 3을 주면,
-1번-> {2,3,4,5,1} -2번-> {3,4,5,1,2} -3번-> {4,5,1,2,3}
결국 {4,5,1,2,3}이 나와야 하는거네요. 이건 string으로 변환해서 맨 앞에 녀석을 뒤로 가져다 붙이기를 몇번 하느냐 하는 문제 같군요!

* 그런데, 이거 예전에 한 20여년 전에 테트리스 블록 회전하기 했었을때 알고리즘 같은데.. 풀이는 좀 다르게 되어 있네요. 뭐 암튼 재귀함수와 ref 로 간단히 해결됩니다.
(C는 포인터로...)

static void Main(string[] args)
{
    int[] _array = new int[] { 1, 2, 3, 4, 5 };
    SetPivot(ref _array, 3);
    Console.ReadLine();
}

static void SetPivot(ref int[] _arr, int cnt)
{
    if (cnt < 1) return;
    int[] _cpyarray = new int[_arr.Length];
    int tmp = _arr[0];
    for (int i = 1; i < _arr.Length; i++)
    {
         _cpyarray[i - 1] = _arr[i];
    }
    _cpyarray[_arr.Length-1] = tmp;
    _arr = _cpyarray;
    SetPivot(ref _arr, cnt - 1);
}



18. 중복되는 Linked list 값을 제거하랍니다. 
Linked list merge소스를 조금 응용하면 되겠네요.

 class Program
 {
    static private Node head;
     static void Main(string[] args)
     {
        List<Node> _LinkedListA = new List<Node>();
         MakeLinkedList(ref _LinkedListA, 0);
         MakeLinkedList(ref _LinkedListA, 1);
         MakeLinkedList(ref _LinkedListA, 2);
         MakeLinkedList(ref _LinkedListA, 3);
         MakeLinkedList(ref _LinkedListA, 2);

         //Merge할 List를 만들고,
         List<Node> _UniqueList = new List<Node>();
         //Merge합니다.
         RemoveDuplicatedLinkedList(_LinkedListA, ref _UniqueList);
         Console.ReadLine();
    }

         //하나로 모아서 Sort한 뒤에 LinkedList를 생성합니다.
    static void RemoveDuplicatedLinkedList(List<Node> _A, ref List<Node> _C)
    {
         ArrayList A = new ArrayList();
         foreach (Node x in _A) A.Add(x.value);
         var _x = A.ToArray().Distinct().ToArray();
         foreach (int x in _x) MakeLinkedList(ref _C, x);
    }

 #region for Make Linked List 
 static void MakeLinkedList(ref List<Node> _LL, int value)
 {
 if (head == null) AddFirst(ref _LL, value);
 else
 {
 Node _node = new Node { value = value, Child = null };
 _LL.Add(_node);
 Node _current = head;
 while (_current.Child != null)
 {
 _current = _current.Child;
 }
 _current.Child = _node;
 }
 }

 static void AddFirst(ref List<Node> _LL, int value)
 {
 Node _Head = new Node { value = value, Child = null };
 _LL.Add(_Head);
 head = _Head;
 }
 #endregion

    static void MakeLoopList(List<Node> _LL)
    {
        _LL.Find(a => a.value == 3).Child = head;
    }

    public class Node
   {
        public int value;
        public Node Child;
    }
}



19. digits of the number 의 합을 재귀함수로 구하라고 하는건데, 말이 어렵네요... 간단하게 테스트 케이스를 만들어 보면 123 => 6 다시 말해 자릿수에 있는 0~9까지의 수를 다 더하란 이야기 입니다.
static void Main(string[] args)
{
    int x = 158; //14가 나와야 함.
    int result = 0;
    GetSum(x, ref result, x.ToString().Length - 1);
    Console.WriteLine(result);
    Console.ReadLine();
}

static void GetSum(int _x, ref int _result, int _digit)
{
    if (_digit >= 0)
    {
        _result = _result + int.Parse(_x.ToString().ToCharArray()[_digit].ToString());
        GetSum(_x, ref _result, _digit - 1);
    }
}


20. 마지막문제는 선택정렬하라 입니다.
지난번 포스팅에서 버블소트 다뤘는데, 선택정렬의 테스트 케이스는 다음과 같습니다.
{9,2,5,1,4,6} 가 있다면 n+1~m까지 중에 가장 작은 수를 찾아 비교한후 뒤에 숫자가 더 작다면 Swap합니다.
2번째 루프에서는 2번째 자리의 수를 기준으로 n+2~m까지 수중 가장 작은 수와 비교합니다.
버블소트가 마구마구 치환하는데 비해 이건 선택한 자리수의 수를 가지고 비교하기입니다.

static void Main(string[] args)
{
    int[] x = new int[]{ 9, 2, 5, 1, 4, 6 };
    foreach(int i in SetSort(x))
        Console.WriteLine(i);
    Console.ReadLine();
}

static int[] SetSort(int[] _x)
{
    for (int i = 0; i < _x.Length; i++)
    {
        for (int j = i+1; j < _x.Length; j++)
        {
            if (_x[i] > _x[j])
            {
                _x[i] = _x[i] + _x[j];
                _x[j] = _x[i] - _x[j];
                _x[i] = _x[i] - _x[j];
            }
        }
     }
     return _x;
}



2016/03/06 20:58 2016/03/06 20:58
C# 알고리즘 연습용입니다.

문제1. 임의의 문자열을 입력받아 유일한지 검사하라.
using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;

namespace TestCode
{
    class Program
    {
        static Hashtable _UniqueTable;

        static void Main(string[] args)
        {

            string _InputString = Console.ReadLine();
            _UniqueTable = new Hashtable();

            for (int i=0; i < _InputString.Length; i++)
            {
                AddTable(_InputString[i]);
            }
            CheckTable();
            Console.ReadLine();
        }

        static void AddTable(char _x)
        {
            if (_UniqueTable != null && _UniqueTable.Contains(_x))
                _UniqueTable[_x] = (int)_UniqueTable[_x] + 1;
            else
                _UniqueTable.Add(_x, 1);
        }

        static void CheckTable()
        {
            foreach (DictionaryEntry _dt in _UniqueTable)
            {
                if ((int)_dt.Value > 1) Console.WriteLine("Error! No unique key found! {0}, Count {1}", _dt.Key, _dt.Value);
            }

        }
    }
}


결과는 Count가 2개 이상인 경우 문자메시지를 출력합니다.

Crack
1. 입력받은 문자열을 Char로 변환하여 HashTable에 넣는게 관건.
2. 이때 중복되는 키가 있으면 Value증가시킴
3. 중복되는 키가 없으면 Add시킴
4. 모든 입력과정 종료후 DictionaryEntry형으로 변환하여 Foreach날림

만약 C#의 Linq를 사용한다면 더 짧게 코딩이 가능합니다.
        static void Main(string[] args)
        {
            string InputString = "cvdss";
            Console.WriteLine(GetSameUniqueText(InputString).ToString());
            Console.ReadLine();
        }

        static bool GetSameUniqueText(string _x)
        {
            char[] ArrayChar = _x.ToCharArray();
            Array.Sort(ArrayChar);
            var Result = (from x in ArrayChar select x).Distinct().OrderBy(x => x).ToArray();
            if (new string(ArrayChar) == new string(Result)) return true;
            return false;
        }



문제2. 임의의 문자열을 받아서 역순으로 배열하여 출력하라.

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;

namespace TestCode
{
    class Program
    {
        static void Main(string[] args)
        {
            string _TempString = "";
            string _InputString = Console.ReadLine();

            for (int i= _InputString.Length; i > 0; i--)
            {
                _TempString += _InputString[i-1];
            }
            Console.WriteLine(_TempString);
            Console.ReadLine();
        }

    }
}


Crack. 이건 간단해서 패스...
만약 C#이라면 역시 Linq로...
        static void Main(string[] args)
        {
            string InputString = "cvdss";
            Console.WriteLine(SetReverse(InputString));
            Console.ReadLine();
        }

        static string SetReverse(string _x)
        {
            char[] ArrayChar = _x.ToCharArray();
            var Result = (from x in ArrayChar select x).Reverse().ToArray();
            return new string(Result);
        }



문제3. 임의의 문자열을 입력받아 공백을 %20으로 교체하라.
using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;

namespace TestCode
{
    class Program
    {
        static void Main(string[] args)
        {
            string _InputString = Console.ReadLine();
            Console.WriteLine(_InputString.Replace(" ", "%20"));
            Console.ReadLine();
        }
    }
}


Crack : 이것도 간단해서 생략

문제4. 반복되는 임의의 문자열 예를 들어 "aaaabbbccaa"를 입력받으면 "a4b3c2a2"로 압축하라.

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;

namespace TestCode
{
    class Program
    {
        static void Main(string[] args)
        {
            char _OldChar = '\x0000';
            string _OutputStr = "";
            string _InputString = Console.ReadLine();

            int _count = 0;
            for (int i = 0; i < _InputString.Length; i++)
            {
                char _NewChar = _InputString[i];
                if (_NewChar == _OldChar) {
                    if (_count < 2) _OutputStr += _NewChar.ToString();
                    _count++;
                } 
                else
                {
                    if (_count > 0) _OutputStr += _count.ToString();
                    _OldChar = _NewChar;
                    _count = 1;
                }
            }

            Console.WriteLine(_OutputStr + _count.ToString());
            Console.ReadLine();
        }
    }
}


Crack : 이것도 간단해서 패스

문제5. 앞으로 읽어도 뒤로 읽어도 똑같은 문자열인지 Bool값으로 리턴하라. 단, Letter만 확인하라.
using System;
using System.Text.RegularExpressions;

public class Palindrome
{
     public static bool IsPalindrome(string str) {
          //먼저 소문자로 치환하고 특수문자는 제거합니다.
          string _x = JustLetter(str);
          //만약 3글자라면 1번만, 4글자라면 2번만 루프돌면서 가운데를 기준으로 대칭에 있는 문자열을 비교합니다.
          //만약 틀리면 false 를 리턴하고 빠집니다.
           int lastidx = _x.Length - 1;
           for (int i = 0; i < _x.Length / 2; i++){
                     if (_x[i] != _x[lastidx]) return false;
                     lastidx--;
           }
          //아무런 문제가 없으면 true;
           return true;
     }

     public static string JustLetter(string _str)
     {
           string _x = "";
           string returnVal = _str.ToLower();
           string pattern = @"[a-z]";

          //요부분이 좀 애먹은 부분인데 C#의 정규표현식으로 MatchCollection을 만든다음에 한글자씩 따는 부분입니다.
           MatchCollection matches = Regex.Matches(returnVal, pattern);
           foreach (Match match in matches)
                     _x += match.Value;
           return _x;
      }

     public static void Main(string[] args)
     {
           Console.WriteLine(IsPalindrome("Level."));
     }
}


Crack.
1. 글자를 비교할 수 있도록 표준화하는게 관건
   - 소문자로 만들기
   - 특수문자제거
2. 처음과 끝에서 부터 한단계씩 비교

문제 6. momdad와 dadmon은 단어의 순서가 바뀐 문자열이다. 이처럼 순서가 바뀐 단어가 있으면 true, 아니라면 false를 반환하라.

using System;

public class AreAnagrams
{
    public static bool AreStringsAnagrams(string a, string b)
    {
        if (CharSort(a) == CharSort(b)) return true;
        return false;
    }
    
    public static string CharSort(string _x)
    {
        char[] x = _x.ToCharArray();
        Array.Sort(x);
        return new string(x);
    }

    public static void Main(string[] args)
    {
        Console.WriteLine(AreStringsAnagrams("momdad", "dadmom"));
    }
}


Crack.
1. 두개의 단어가 정확하게 쓰여졌다는 가정하에 2개의 문자열을 Char로 치환후 Sort하면 동일한 결과를 얻을 수 있어야 합니다.
2. 따라서, string을 char로 변환후 sort해서 비교하는 루틴으로 간단하게 처리됩니다.


*문제7. Linked list Class를 만들고 특정 문자열을 지우면 나머지 단계도 삭제되는 루틴을 만드시오.

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;
 
namespace TestCode
{
    class Program
    {
        static void Main(string[] args)
        {
            List<NodeClass> _LinkedNode = new List<NodeClass>();
            SetNode(_LinkedNode);
            #region For Debug (Input data check)
            //foreach (NodeClass _n in _LinkedNode)
            //    Console.WriteLine("Parent:{0}, Value:{1}",_n._Parent, _n._value);
            #endregion
 
            RemoveValue(_LinkedNode, "A");
 
            #region For Debug (Input data check)
            foreach (NodeClass _n in _LinkedNode)
                Console.WriteLine("Parent:{0}, Value:{1}", _n._Parent, _n._value);
            #endregion
            Console.ReadLine();
        }
 
        static void SetNode(List<NodeClass> _LinkedNode)
        {
            string[] _Values = new string[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J" };
            foreach (string _value in _Values)
                _LinkedNode.Add(new NodeClass
                {
                    _Parent =
                    ((_value == "B") ? "A" :
                    (_value == "C") ? "A" :
                    (_value == "D") ? "A" :
                    (_value == "E") ? "B" :
                    (_value == "F") ? "C" :
                    (_value == "G") ? "C" :
                    (_value == "H") ? "D" :
                    (_value == "I") ? "F" :
                    (_value == "J") ? "F" :
                    ""),
                    _value = _value
                });
 
        }
        static void RemoveValue(List<NodeClass> _LinkedNode, string _X)
        {
            foreach (NodeClass _n in _LinkedNode)
            {
                if (_n._value == _X) _n._value = "";
                if (_n._Parent == _X) RemoveValue(_LinkedNode, _n._value);  
            }
        }
    }
 
    public class NodeClass
    {
        public string _Parent { get; set; }
        public string _value { get; set; }
    }
 
}


Crack.
1. 클래스 생성은 Parent와 value구조만 있으면 문제가 없습니다. 만약 node 탐색이 들어간다면 또 다른 이야기가 되겠지만, 현재 Tree구조로는 해당 문제를 푸는데 문제없습니다.
2. 먼저 노드를 생성합니다. SetNode
3. 임의의 문자를 입력하여 하위 노드를 삭제합니다. 이때 재귀함수 (Recursion Function)을 사용해서 하위레벨도 삭제되도록 합니다.

추가로 노드를 삭제하려면 아래의 메소드를 호출해주면 되겠습니다.
static void TruncItem(ref List<NodeClass> _LinkedNode) {
     _LinkedNode = _LinkedNode.FindAll(x => x._value != "");
}
ref 키워드이니까, 당연히 TruncItem(ref _LinkNode); 로 호출해야 겠죠?


문제8. 임의의 배열이 주어졌을때 이를 Sort하라.

using System;
using System.Linq;

namespace TestCode
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arrays = new int[] { 1, 5, 6, 2, 4, 7, 9 };
            for (int i = 0; i < arrays.Count(); i++)
            {
                for (int y = 0; y < arrays.Count() - 1; y++)
                {
                    if (arrays[y] <= arrays[y + 1]) continue;
                    int x = arrays[y];
                    arrays[y] = arrays[y + 1];
                    arrays[y + 1] = x;
                }
            }

            foreach (int z in arrays)
                Console.WriteLine(z);
            Console.ReadLine();
        }
    }
}


Crack.
1. 간단한 Bubble sort입니다.
2. x개의 원소가 주어졌을 때, 총 x * (x-1)번의 Loop를 돌면서 맨 앞에서부터 차례로 데이터를 Swap 합니다.

보다 C#에 가깝게 고치면 ref 키워드를 사용해서 값 참조합니다.
using System;
using System.Linq;

namespace TestCode
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arrays = new int[] { 1, 5, 6, 2, 4, 7, 9 };
            for (int i = 0; i < arrays.Count(); i++)
            {
                for (int y = 0; y < arrays.Count() - 1; y++)
                {
                    if (arrays[y] <= arrays[y + 1]) continue;
                    SwapInt(ref arrays[y], ref arrays[y + 1]);
                }
            }
            foreach (int z in arrays)
                Console.WriteLine(z);
            Console.ReadLine();
        }

        public static void SwapInt(ref int _x, ref int _y)
        {
            int x = _x;
            _x = _y;
            _y = x;
        }
    }
}


ref 키워드와 비슷한 녀석이 out 키워드인데, ref는 반드시 선언되고 정의되어야 하지만, out은 선언만 되면 사용이 가능합니다.
만약, 여러개의 인자를 한번에 정의하려면 out 키워드가 더 적합합니다.
using System;

namespace TestCode
{
    class Program
    {
        static void Main(string[] args)
        {
            string a, b;
            SetString(out a, out b);

            Console.WriteLine(a);
            Console.ReadLine();
        }

        static void SetString(out string x, out string y)
        {
            x = "A";
            y = "B";
        }
    }
}


하지만, 역시 Just C#이라면....
        static void Main(string[] args)
        {
            int[] arrays = new int[] { 1, 5, 6, 2, 4, 7, 9 };
            Array.Sort(arrays);
            foreach (int _x in arrays) {
                Console.WriteLine(_x.ToString());
            }
            Console.ReadLine();
        }

역순으로 Sort하는건, Sort 한뒤에 Method 하나더 불러줍니다.
 Array.Sort(arrays);
 Array.Reverse(arrays); //추가


문제 9.abcdefg 라는 문자열이 주어졌을때 n = 4 라고 할때
a c e g 
b d f
로 출력하시오.
Crack First. 이건 순열 문제로 문제의 의도를 파악하기 힘들군요. 만약 피시험자였다면 출제자에게 더 자세히 물어봤겠지만, 인터넷에 있는 후기를 퍼온 덕에 추가 정보를 얻을 수 없습니다만. 일단 기대값을 볼때 2자리마다 끝어서 출력하면 되지 않을까 싶네요.

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;

namespace TestCode
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = 4;
            string InputStr = "abcdefg";
            string[] Row = new string[2];

            char[] ArrayChar = InputStr.ToCharArray();

            int indexNum = 0;
            foreach (char c in ArrayChar)
            {
                if (indexNum % (n / 2) == 0) Row[0] += ArrayChar[indexNum];
                else Row[1] += ArrayChar[indexNum];
                indexNum++;
            }

            foreach (string s in Row)
            {
                Console.WriteLine(s);
            }

            Console.ReadLine();
        }
    }
}





문제 10. 예를들어 ccbbdddbcccaabbaaeeefff 가 주어졌을때 -> cbdaef 처음으로 등장한 알파벳만 모아서 보여주시오. 
using System;
using System.Linq;

namespace TestCode
{
     class Program
     {
          static void Main(string[] args)
          {
               string _x = "ccbbdddbcccaabbaaeeefff";
               char[] _arrChar = _x.ToCharArray();
               var query = (from x in _arrChar select x).Distinct().ToArray();
               Console.WriteLine(new string(query));
               Console.ReadLine();
          }
     }
}


Crack. 

간단한 Linq 문제입니다. =)



문제 11. 2개의 임의의 배열이 주어졌을때, Merge하고 Sort하라 

using System;
using System.Linq;

namespace TestCode
{
     class Program
     {
          static void Main(string[] args)
          {
               int[] One = new int[] { 1, 4, 6, 3, 9 };
               int[] Two = new int[] { 8, 2, 5 };
               int[] Merge = new int[One.Count() + Two.Count()];

               SetMerge(ref One, ref Two, ref Merge);
               Array.Sort(Merge);

               foreach(int x in Merge)
               {
                    Console.WriteLine(x);
               }
               Console.ReadLine();
          }

          static void SetMerge (ref int[] _x, ref int[] _y, ref int[] Result)
          {
               int MergeIdx = 0;
               for (int i = 0; i < _x.Count(); i++)
               {
                    Result[MergeIdx] = _x[i];
                    MergeIdx++;
                }
                for (int i = 0; i < _y.Count(); i++)
                {
                    Result[MergeIdx] = _y[i];
                    MergeIdx++;
                }
           }
     }
}

Crack. 
전통적인 방법으로는 위와 같이 배열 2개를 합한 크기의 배열을 만들고 For문 2번 돌려서 합치겠지만, C# 이라는 Linq가 있습니다.

using System;
using System.Linq;

namespace TestCode
{
     class Program
     {
          static void Main(string[] args)
          {
               int[] One = new int[] { 1, 4, 6, 3, 9 };
               int[] Two = new int[] { 8, 2, 5 };
               int[] Merge = new int[One.Count() + Two.Count()];

               SetMerge(ref One, ref Two, ref Merge);

               foreach (int x in Merge)
               {
                    Console.WriteLine(x);
               }
               Console.ReadLine();
           }

          static void SetMerge (ref int[] _x, ref int[] _y, ref int[] Result)
          {
               Result = _x.Concat(_y).OrderBy(x => x).ToArray(); //바로 이렇게 한방에 처리항 수 있습니다.
          }
     }
}



문제 12. 사용자 input 을 문자열로 받아서 숫자로 인식하는 프로그램을 만들어라.input에는 어떤 문자든지 올 수 있고, 어떤 규칙까지 허용하고 어떤 숫자까지 지원할지는 자유이다. 
Crack.
실제 MS사에서 면접 보신분의 후기에서 가져온 문제입니다. 이 경우 저라면 Hash 테이블에 단어장을 먼저 만들겠습니다.
먼저 필요한 테이블은 숫자만 카운팅 하는 테이블
1-one, 2-two, 3-three, 4-four, 5-five, 6-six, 7-seven, 8-eight, 9-nine, 10- ten, 11- eleven, 12-twelve, 13-thirteen, 14-fouteen, 15-fivteen .... 999-ninehundredniteennine
그리고 자릿수 3자리씩 잘라서 인식할 테이블을 만듭니다.
1000-thousand, 1000000-million, 1000000000-billion, 1000000000000-trillion
linq lambda 식으로 조회합니다.

//코드는 나중에 정리 예정.



문제 13.  두번째 문제는 Binary Tree가 있다고 가정하고 그 트리에 있는 숫자를 root에서 leaf까지 해서 도달하는 숫자의 합을 구하시오.
1
/ \
2  3
/\ /
4 5 6
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace TestCode
{
     class Program
     {
          static void Main(string[] args)
          {
               BinaryTree<int> broot = new BinaryTree<int>();
               broot.Root = new Node<int>(1);
               broot.Root.LNode = new Node<int>(2);
               broot.Root.RNode = new Node<int>(3);
               broot.Root.LNode.LNode = new Node<int>(4);
               broot.Root.LNode.RNode = new Node<int>(5);
               broot.Root.RNode.LNode = new Node<int>(6);

               ArrayList result = new ArrayList();
               broot.PrintNodeValue(broot.Root, 0, ref result);

               foreach (int i in result)
               {
                     Console.WriteLine(i);
               }

                Console.ReadLine();
           }
     }

      public class Node<T>
     {
          public Node<T> LNode;
          public Node<T> RNode;
          public int Value;
          public Node(int data)
          {
                this.Value = data;
          }
     }

     public class BinaryTree<T>
     {
          public Node<T> Root;
          public void PrintNodeValue(Node<T> node, int ParentValue, ref ArrayList result)
          {
                if (node.LNode != null) PrintNodeValue(node.LNode, node.Value + ParentValue, ref result);
                if (node.RNode != null) PrintNodeValue(node.RNode, node.Value + ParentValue, ref result);
                if (node.LNode == null && node.RNode == null)
                {
                     result.Add(node.Value + ParentValue);
                }
          }
     }
}


Crack.
2진트리는 1개의 노드가 최대 2개의 자식 노드를 가진 트리형입니다.
반듯이 왼쪽부터 채워져야 하는 규칙을 가지고 있지요.
아마도 이 문제 응용문제로 2진 트리에서 공통 조상을 찾아라 든가... 혹은 2진트리를 반전 시켜라와 2진트리 Leaf를 찾아라와 같은 응용 문제가 있을 수 있습니다.
중요한건 재귀함수를 쓸 줄 아느냐 일것 같은데, C#에서는 2진트리 쓸일이 사실 별로 없어서... 쿨럭...
2016/03/02 17:11 2016/03/02 17:11
일전에 Mesh생성하는 방법에 대해 써 놓은 적이 있는데,

Link : http://www.wolfpack.pe.kr/853

문득 Hexa로 만드는것도 가능하지 않을까? 고민했습니다.
그래서, 만들어 봤습니다.

먼저 Mesh 만든 절차를 그대로 따라 했습니다.
1. 좌표를 Vector3 array로 만든다.
* Mesh의 경우는 단 4개의 Vertex로 구성되면 되기 때문에, 좌표는 총 4개를 만들면 되죠.
예를 들어, pivot point가 Center에 있는 4각의 Mesh라면,
(-1, -1, 0), (-1, 1, 0), (1, 1, 0), (1, -1, 0) >> 각각 0, 1, 2, 3 번 이라고 합시다.

2. Polygon Array를 만듭니다. 하나 중요한건 Unity3D는 왼손 좌표계이므로 Surface가 -Z축에서 보여지려면 시계방향으로 Array를 생성해야 합니다.
* 0, 1, 2, 0, 2, 3 / 3개씩 잘라서 보면 0,1,2 폴리곤과 0, 2, 3 폴리곤 2개가 있어, 4각으로 보이죠.

자세한건 위의 Link 참조바랍니다.

Hexa의 경우는 간단히 다음과 같이 하면 되겠지하고 덤볐다가.. -_-;; 개피봤습니다.
사용자 삽입 이미지
1개 일때는 문제없이 0, 1, 3, 1, 2, 3, 0, 3, 4, 0, 4, 5 로 폴리곤 셋을 잘라주면 되는데.. 2개 이상만 되도 일정한 규칙을 발견하기 어려웠습니다.
사용자 삽입 이미지
슬슬 멘붕오기 시작하지요. 여기에 Y축까지 추가되면...
사용자 삽입 이미지
규칙은 사라지고 Chaos 만 남습니다. -_-;;
만약, Pivot이 Center에 있다면? 이라는 질문을 하게 되었고 Vetex를 정리해보니 다음과 같이 그런대로 규칙이 생깁니다.
사용자 삽입 이미지
정리하자면 2*2짜리 Hexa는 가로로 n개의 Vertex를 가집니다.
이걸 수식으로 정리하면 Hexa갯수가 x라면 Vertex수는
1 - 3
2 - 5
3 - 7
4 - 9
n - 2 * 헥사갯수 + 1

입니다만, Hexa는 항상 위에서 보는바와 같이 왔다 갔다 하므로 Y축 확장을 위해 우로 Vertex열이 1줄 더 있어야 하고 좌로도 1줄 더 있어야 하는 상황이 됩니다.

그리고, 또 하나 만난 문제는 저렇게 Vertex를 배열하는게 문제였습니다.
6각형은 60도로 나누어져 있는데 소숫점 오차로 인해 제대로 배열이 안되는것도 문제여서...
그냥 다음과 같이 간단히 일렬로 배열한뒤에...
사용자 삽입 이미지
홀수 열만 0.5정도 올려주면...
사용자 삽입 이미지
근사하게 육각으로 바뀌는 군욤. ㅋ

* 여기까지 코드는 다음과 같습니다.

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

public class Hexa : MonoBehaviour {

    private Vector3[] vertexs; 

    void Awake()
    {
        gameObject.AddComponent<MeshFilter>();
        gameObject.AddComponent<MeshRenderer>();
    }

    void Start () {
        SetVertex(5, 6);
    }
    
    void SetVertex(int xSize, int ySize)
    {
        //사전처리 부분입니다. 예외처리를 위해 가로 헥사수는 2이상, 세로 헥사수는 짝수로 고정합니다.
        if (xSize < 2) xSize++; //가로 헥사수, 예외 처리를 위해 2이상으로 강제 처리
        if (ySize % 2 == 1) ySize++; //세로 헥사수  //예외 처리를 위해 짝수로 강제 처리

        // 가로와 세로의 버텍스 수를 구합니다.
        int xDotSize = 2 * xSize + 2; //가로 버텍스 수
        int yDotSize = (ySize % 2 == 0) ? (3 * ySize / 2) + 1 : 3 * (ySize / 2 + 1); //세로 버텍스 수

        //For 문으로 자동으로 찍되 홀수 줄은 0.5f만큼 올립니다.
        MeshFilter MF = GetComponent<MeshFilter>();
        vertexs = new Vector3[xDotSize * yDotSize];
        for (int i = 0, y = 0; y > yDotSize * -1 ; y--)
        {
            for (int x = 0; x < xDotSize; x++, i++)
            {
                vertexs[i] = (x % 2 == 0) ? new Vector3(x, 0f, y) : new Vector3(x, 0f, y + 0.5f);
            }
        }
        MF.mesh.vertices = vertexs;
    }

    private void OnDrawGizmos()
    {
        if (vertexs == null) return;
        Gizmos.color = Color.red;
        for (int i = 0; i < vertexs.Length; i++)
            Gizmos.DrawSphere(vertexs[i], 0.1f);
    }
}


이제 문제는 Center를 찾는 겁니다. 의외로 어렵게 해결된 부분인데,
먼저 좌변의 Center Point들을 먼저 찾고 거기에 가로로 +2를 반복하였습니다.
그 이유는 다음의 그림에서 처럼 첫 Center는 2번째, 2번째 Center는 5번째... 이런식으로 나타 났고 이를 위해 수열 공식 찾느라 오래 걸렸습니다.
사용자 삽입 이미지
암튼 위의 결과를 보인 소스는 다음과 같습니다.

        //SetVertex() 함수 밑부분에 넣었습니다.
        //Find Center
        CenterP = new Vector3[xSize * ySize];
        for (int idx =0, y = 0; y < ySize; y++) {
            int verticesIdx = 0;
            verticesIdx = xDotSize * ((y / 2) + 1 + y) + 1 + (y % 2); //버텍스인덱스는 가로크기* ((y / 2) + 1 + y) + 1 + (y % 2), y는 세로변수 y
            CenterP[idx] = vertexs[verticesIdx];
            CenterIdx.Add(verticesIdx);
            idx++;
            for (int x = 1; x < xSize; x++)
            {
                CenterP[idx] = vertexs[verticesIdx + 2 * x]; //세로에서 구한 센터값에 +2 반복
                CenterIdx.Add(verticesIdx + 2 * x);
                idx++;
            }
        }

좀 복잡하지만, CenterP는 OnGizmo에서 디버깅 용으로 만든 변수이고, 실재 사용하는 변수명은 CenterIdx입니다.
클래스 변수는 다음과 같이 위의 2개 변수를 추가했구요.

    private Vector3[] vertexs;
    private Vector3[] CenterP;
    private List<int> CenterIdx = new List<int>();


마지막으로 OnGizmo를 다음과 같은 최종형태로 만들었습니다.
    private void OnDrawGizmos()
    {
        if (vertexs == null) return;
        Gizmos.color = Color.red;
        for (int i = 0; i < vertexs.Length; i++)
            Gizmos.DrawSphere(vertexs[i], 0.1f);

        if (CenterP == null) return;
        Gizmos.color = Color.yellow;
        for (int i = 0; i < CenterP.Length; i ++ )
            Gizmos.DrawSphere(CenterP[i], 0.1f);

    }


마지막으로 Vertex 연결 순서는 짝수 열과 홀수 열이 조금 다르지만, 정리하면,

                //총 6개의 폴리곤이 있어야 6각형이 나오므로...
                triangles[idx] = CenterIdx[x];
                triangles[idx + 1] = CenterIdx[x] - 1;
                triangles[idx + 2] = CenterIdx[x] - xDotSize;
                
                triangles[idx + 3] = CenterIdx[x];
                triangles[idx + 4] = CenterIdx[x] - xDotSize;
                triangles[idx + 5] = CenterIdx[x] + 1;
                
                triangles[idx + 6] = CenterIdx[x];
                triangles[idx + 7] = CenterIdx[x] + 1;
                triangles[idx + 8] = CenterIdx[x] + xDotSize + 1;

                triangles[idx + 9] = CenterIdx[x];
                triangles[idx + 10] = CenterIdx[x] + xDotSize + 1;
                triangles[idx + 11] = CenterIdx[x] + xDotSize;
                
                triangles[idx + 12] = CenterIdx[x];
                triangles[idx + 13] = CenterIdx[x] + xDotSize;
                triangles[idx + 14] = CenterIdx[x] + xDotSize - 1;
                
                triangles[idx + 15] = CenterIdx[x];
                triangles[idx + 16] = CenterIdx[x] + xDotSize - 1;
                triangles[idx + 17] = CenterIdx[x] - 1;

위의 코드를 좀 짧게 축약하면 다음과 같습니다.

                triangles[idx] = triangles[idx + 3] = triangles[idx + 6] = triangles[idx + 9] = triangles[idx + 12] = triangles[idx + 15] = CenterIdx[x];
                triangles[idx + 1] = triangles[idx + 17] = CenterIdx[x] - 1;
                triangles[idx + 2] = triangles[idx + 4] = CenterIdx[x] - xDotSize;
                triangles[idx + 5] = triangles[idx + 7] = CenterIdx[x] + 1;
                triangles[idx + 8] = triangles[idx + 10] = CenterIdx[x] + xDotSize + 1;
                triangles[idx + 11] = triangles[idx + 13] =  CenterIdx[x] + xDotSize;
                triangles[idx + 14] = triangles[idx + 16] = CenterIdx[x] + xDotSize - 1;


이제 이걸 돌려 보면... 두둥..
사용자 삽입 이미지
전체 코드는 다음과 같습니다.

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

public class Hexa : MonoBehaviour {

    private Vector3[] vertexs;
    private Vector3[] CenterP;
    private List<int> CenterIdx = new List<int>();

    void Awake()
    {
        gameObject.AddComponent<MeshFilter>();
        gameObject.AddComponent<MeshRenderer>();
    }

    // Use this for initialization
    void Start () {
        SetVertex(5, 6);
    }
    
    void SetVertex(int xSize, int ySize)
    {
        if (xSize < 2) xSize++; //x 헥사수
        if (ySize % 2 == 1) ySize++; //y 헥사수
        int xDotSize = 2 * xSize + 2; //가로 버텍스 수
        int yDotSize = (ySize % 2 == 0) ? (3 * ySize / 2) + 1 : 3 * (ySize / 2 + 1); //세로 버텍스 수
        MeshFilter MF = GetComponent<MeshFilter>();
        vertexs = new Vector3[xDotSize * yDotSize];
        for (int i = 0, y = 0; y > yDotSize * -1 ; y--)
        {
            for (int x = 0; x < xDotSize; x++, i++)
            {
                vertexs[i] = (x % 2 == 0) ? new Vector3(x, 0f, y) : new Vector3(x, 0f, y + 0.5f);
            }
        }
        MF.mesh.vertices = vertexs;

        //Find Center
        CenterP = new Vector3[xSize * ySize];
        for (int idx =0, y = 0; y < ySize; y++) {
            int verticesIdx = 0;
            verticesIdx = xDotSize * ((y / 2) + 1 + y) + 1 + (y % 2);
            CenterP[idx] = vertexs[verticesIdx];
            CenterIdx.Add(verticesIdx);
            idx++;
            for (int x = 1; x < xSize; x++)
            {
                CenterP[idx] = vertexs[verticesIdx + 2 * x];
                CenterIdx.Add(verticesIdx + 2 * x);
                idx++;
            }
        }

        int[] triangles = new int[18 * (xSize * ySize)];

        for (int idx = 0, x = 0; x < CenterIdx.Count; x++)
        {
            if ((x / xSize) % 2 == 0)
            {
                triangles[idx] = CenterIdx[x];
                triangles[idx + 1] = CenterIdx[x] - xDotSize - 1;
                triangles[idx + 2] = CenterIdx[x] - xDotSize;

                triangles[idx + 3] = CenterIdx[x];
                triangles[idx + 4] = CenterIdx[x] - xDotSize;
                triangles[idx + 5] = CenterIdx[x] - xDotSize + 1;

                triangles[idx + 6] = CenterIdx[x];
                triangles[idx + 7] = CenterIdx[x] - xDotSize + 1;
                triangles[idx + 8] = CenterIdx[x] + 1;

                triangles[idx + 9] = CenterIdx[x];
                triangles[idx + 10] = CenterIdx[x] + 1;
                triangles[idx + 11] = CenterIdx[x] + xDotSize;

                triangles[idx + 12] = CenterIdx[x];
                triangles[idx + 13] = CenterIdx[x] + xDotSize;
                triangles[idx + 14] = CenterIdx[x] - 1;

                triangles[idx + 15] = CenterIdx[x];
                triangles[idx + 16] = CenterIdx[x] - 1;
                triangles[idx + 17] = CenterIdx[x] - xDotSize - 1;

            }
            else
            {
                triangles[idx] = CenterIdx[x];
                triangles[idx + 1] = CenterIdx[x] - 1;
                triangles[idx + 2] = CenterIdx[x] - xDotSize;
                
                triangles[idx + 3] = CenterIdx[x];
                triangles[idx + 4] = CenterIdx[x] - xDotSize;
                triangles[idx + 5] = CenterIdx[x] + 1;
                
                triangles[idx + 6] = CenterIdx[x];
                triangles[idx + 7] = CenterIdx[x] + 1;
                triangles[idx + 8] = CenterIdx[x] + xDotSize + 1;

                triangles[idx + 9] = CenterIdx[x];
                triangles[idx + 10] = CenterIdx[x] + xDotSize + 1;
                triangles[idx + 11] = CenterIdx[x] + xDotSize;
                
                triangles[idx + 12] = CenterIdx[x];
                triangles[idx + 13] = CenterIdx[x] + xDotSize;
                triangles[idx + 14] = CenterIdx[x] + xDotSize - 1;
                
                triangles[idx + 15] = CenterIdx[x];
                triangles[idx + 16] = CenterIdx[x] + xDotSize - 1;
                triangles[idx + 17] = CenterIdx[x] - 1;
            }
            idx += 18;
        }

        MF.mesh.triangles = triangles;
        MF.mesh.RecalculateNormals();

    }

    private void OnDrawGizmos()
    {
        if (vertexs == null) return;
        Gizmos.color = Color.red;
        for (int i = 0; i < vertexs.Length; i++)
            Gizmos.DrawSphere(vertexs[i], 0.1f);

        if (CenterP == null) return;
        Gizmos.color = Color.yellow;
        for (int i = 0; i < CenterP.Length; i ++ )
            Gizmos.DrawSphere(CenterP[i], 0.1f);

    }
}


그럼~ 새해 복 많이 받으세요!
2016/02/09 17:17 2016/02/09 17:17

Go 언어 강좌 2

Developer/GO 2016/02/02 17:49
이번 편에는 Golang의 Essencial이 될만한 내용만 추려서 예제를 만들어 보았습니다.
먼저 struct 입니다.
C#이나 Java, C/C++ 등에서 자료구조로 많이 쓰이는 자료구조이죠?

이걸 설명하려면, 왜? Struct구조가 필요한지 알고 넘어가야 합니다.

일단 변하지 않는 "상수" const 부터 살펴보죠.
이넘은 연산하거나 변수로 사용할 수 없습니다.
예전에 계산기 두들길때 1+2 = 3 이 나온다 치면 1과 2가 상수입니다. 항상 정해진 값을 가지고 있지요.

package main

import (
    "fmt"
)

func main() {
    const x int = 1
    x += 1
    fmt.Println(x)
}


당연히 위의 소스를 실행하면 다음과 같이 출력됩니다.
D:\DevelopSource\Go Lang>go run testVal.go
# command-line-arguments
.\testVal.go:10: cannot assign to x
처음 한번 할당하면 바꿀수 없습니다. 그러다보니 개발자 입장에서 한번 선언해두고 다시 불러와서 재활용할 수 있는 개념이 필요했는데, 이것이 바로 변수입니다.

package main

import (
    "fmt"
)

func main() {
    var x int = 1
    x += 1
    fmt.Println(x)
}


위의 코드를 실행하면 다음과 같이 변수가 변경된 채로 출력됩니다.
D:\DevelopSource\Go Lang>go run testVal.go
2

하지만, 이것도 한계가 있었습니다. 변수 하나 하나는 재활용 할 수 있지만, 여러개의 숫자를 동시에 넣고 연산하는걸 한방에 하고 싶었습니다.
그래서 만든 개념이 배열입니다.

예를 들어, 한 팀에 5명이 있다고 치고, 5명의 점수를 숫자로 입력하면 한번에 처리하고 싶다면 변수 5개를 쓰는게 아니라, 배열 1번 선언으로 모든걸 해치울 수가 있죠.

package main

import (
    "fmt"
)

func main() {
    var x []int = []int{1, 2, 3, 4, 5}
    x[0] += 1
    fmt.Println(x[0])
}

위의 코드를 실행하면 첫번째 1이 2로 바뀌어 출력됩니다.
D:\DevelopSource\Go Lang>go run testVal.go
2

문제는 여기서 부터입니다.
점수와 이름을 같이 쓰고 싶습니다. 그럼, struct 개념이 없다면 이렇게 사용했겠죠?

package main

import (
    "fmt"
)

func main() {
    var x []string = []string{"a", "b", "c", "e", "f"}
    var y []int = []int{1, 2, 3, 4, 5}
    y[0] += 1
    fmt.Println(x[0], y[0])
}

위의 코드를 실행하면 각 배열의 첫번째 값만 출력이 됩니다.
D:\DevelopSource\Go Lang>go run testVal.go
a 2
하지만, 역시 개발자는 줄이고 싶어합니다.
그래서, 만든 개념이 struct 입니다.
다양한 변수 Type를 한번에 저장할 수 있지요.
package main

import (
    "fmt"
)

func main() {
    s := Scoreboard{"a", 1}
    s.y += 1
    fmt.Println(s.x, s.y)
}

type Scoreboard struct { //대문자로 쓰면 public입니다. 소문자면 private
    x string
    y int
}


위코드를 실행하면 다음과 같이 출력됩니다.
D:\DevelopSource\Go Lang>go run testVal.go
a 2
짜잔..

여기에, 자주쓰는건 아에 struct method로 넣어버릴 수 있습니다. 
* 다음 예제는 난이도가 위의 예제에 비해 많이 상승해서 Add method 하나만 잘 익혀두면 좋겠네요.

package main

import (
    "fmt"
)

func main() {

    s := Scoreboard{
        []string{"a", "b", "c"},
        []int{2, 3, 4},
    }
    fmt.Println(s.Avg())
    fmt.Println(s.Add(0, 100))
    fmt.Println(s.y[0])
}

type Scoreboard struct {
    x []string
    y []int
}

func (s Scoreboard) Add(num int, sco int) int {
    s.y[num] += sco
    return s.y[num]
}

func (s Scoreboard) Avg() float32 {
    var _sum int = 0
    for i := 0; i < len(s.y); i++ {
        _sum += s.y[i]
    }
    var _av float32 = float32(_sum / len(s.y))
    return _av
}


위의 코드를 실행하면, 먼저 입력된 점수의 평균인 3을 출력하고 첫번째 학생에게 100점을 주고, 제대로 들어갔는지 확인합니다.
D:\DevelopSource\Go Lang>go run testVal.go
3
102
102
하지만, 이역시 문제가 많습니다.
왜냐하면, 

Scoreboard{
        []string{"a", "b", "c"},
        []int{2, 3, 4},
    }

이렇게 선언해놓고는 데이터가 추가되면 어떻게 될까요? 혹은 이름은 10자리인데, 점수는 11자리.. 
일렇게 되면 망했죠... 망했어요...

그래서 C#이나 Java 같은 현대적인 언어들은 List로 이를 해결합니다.
Golang도 List Package가 있지만, Go 언어의 기본 패키지로 이를 해결하려면 결국 포인트를 쓰던가... 아니면 처음부터 Slice로 만듭니다.

package main

import (
    "fmt"
)

func main() {

    //아래는 좀 원시적인 방법으로 포인터 선언하고 새로 다 때려넣는 방법
    //s := []*Score{}
    //row := new(Score)
    //row.x = "a"
    //row.y = 1
    //s = append(s, row)

    //조금 아는척하면서 Slice로 init하고 Slice append로 데이터 넣는 방법
    Scoreboard := Scoreboard{
        {x: "a", y: 1},
        {x: "b", y: 2},
        {x: "c", y: 3},
    }
    Scoreboard = append(Scoreboard, Score{x: "d", y: 4})
    fmt.Println(Scoreboard[3].x, Scoreboard[3].y)
}

type Score struct {
    x string
    y int
}

type Scoreboard []Score


위 코드를 실행하면 
D:\DevelopSource\Go Lang>go run testVal.go
d 4
가 출력됩니다. =)

이제 마지막으로 한 맺힌 Tree 만들어 봅시다.

A는 B, C를 가집니다. B는 D, E를 가지고 C는 F를 가지고 있습니다. B를 삭제하면 이하에 있는 값이 삭제되도록 하는 겁니다.
* 단 빈공간으로 입력했던 흔적이 남아야 합니다.
package main

import (
    "fmt"
)

func main() {
    ScoreTree := ScoreTree{
         {Parent: "", Value: "A"},
          {Parent: "A", Value: "B"},
          {Parent: "A", Value: "C"},
          {Parent: "B", Value: "D"},
          {Parent: "B", Value: "E"},
          {Parent: "C", Value: "F"},
    }

     Remove(ScoreTree, "B")

     for key, val := range ScoreTree {
         fmt.Println("K:", key, "P:", val.Parent, "V:", val.Value)
     }
}

func Remove(obj ScoreTree, _x string) {
     fmt.Println("Remove Letter:", _x)

     for key, val := range obj {
         if val.Value == _x {
             obj[key].Value = ""
         }
         if val.Parent == _x {
             obj[key].Parent = ""
             Remove(obj, obj[key].Value)
         }
     }
}

type Score struct {
     Parent string
     Value string
}

type ScoreTree []Score


위의 코드를 실행하면...
D:\DevelopSource\Go Lang>go run testVal.go
Remove Letter: B
Remove Letter: D
Remove Letter: E
K: 0 P: V: A
K: 1 P: A V:
K: 2 P: A V: C
K: 3 P: V:
K: 4 P: V:
K: 5 P: C V: F

깔끔하게 실행되는 군요! 

한이 서린 재귀함수 호출은 이제 마지막 단계로 빈 값이 있는 Item들을 날려버리는 겁니다.

package main

import (
    "fmt"
)

func main() {
     ScoreTree := ScoreTree{
         {Parent: "", Value: "A"},
         {Parent: "A", Value: "B"},
         {Parent: "A", Value: "C"},
         {Parent: "B", Value: "D"},
         {Parent: "B", Value: "E"},
         {Parent: "C", Value: "F"},
     }

     ScoreTree.Remove(ScoreTree, "B")
     ScoreTree.Trunc()
     for key, val := range ScoreTree {
         fmt.Println("K:", key, "P:", val.Parent, "V:", val.Value)
     }
}

func (s ScoreTree) Remove(obj ScoreTree, _x string) {
     for key, val := range obj {
         if val.Value == _x {
             obj[key].Value = ""
         }
         if val.Parent == _x {
             obj[key].Parent = ""
             s.Remove(obj, obj[key].Value)
         }
     }
}

func (s *ScoreTree) Trunc() {
     var r ScoreTree
     for _, val := range *s {
         if val.Value != "" {
             r = append(r, val)
         }
    }
     *s = r
}

type Score struct {
     Parent string
     Value string
}

type ScoreTree []Score

실행하면... 깔끔하게 새로 작성해 줍니다. (포인터 드뎌 한번 썼네요...)
D:\DevelopSource\Go Lang>go run testVal.go
K: 0 P: V: A
K: 1 P: A V: C
K: 2 P: C V: F

이번편 마지막으로 드디어 Interface입니다.
OOP에서는 대표적으로 abstract Class와 interface Class가 있습니다.
하지만, 추상클래스의 경우는 처음 설계에서 대충 껍데기만 만들고 들어가서는 상속받아 사용하고 이걸 또 상속받아 사용하고 또 상속받아 사용하고... 이러다 망하죠.
그래서 최근 추세는 interface class를 만들어 놓고 1단계만 확장하는 개념으로 사용합니다.
여기에 C#은 Vrtual method라는 개념까지 겹쳐있어서 머리아프게 하지만, 별거 없음.

public class 짐승
{
 public virtual void 짖기()
 {
 Console.WriteLine("없어");
 }
}
 
public class 강아지 : 짐승
{
 public override void 짖기()
 {
 Console.WriteLine("으르릉!");
 }
}
 
//이하 사용법
//강아지 강쥐 = new 강아지();
//강쥐.짖기();


이하 추상화 클래스 C#
public abstract class 짐승
{
 public abstract void 짖기();
}
 
public class 강아지 : 짐승
{
 public override void 짖기()
 {
 Console.WriteLine("멍멍멍멍");
 }
}
 
//사용
//강아지 강쥐 = new 강아지();
//강쥐.짖기();


이하는 interface입니다.
 public interface 짐승
 {
 void 짖기();
 }

 class 강아지 : 짐승
 {
 private string _이름;
 public void 짖기()
 {
 Console.WriteLine(이름 + ":멍멍!");
 }
 public string 이름
 {
 get
 {
 return _이름;
 }
 set
 {
_이름 = value;
 }
 }
 }

//사용
//강아지 강쥐 = new 강아지();
//강쥐.이름 = "멍멍이";
//강쥐.짖기(); 


뭐.. 둘이 사실상 비슷합니다만, 메소드를 오버라이딩 하지 않아도 되기 때문에 인터페이스가 약간 유리? 그리고, 무한 상속 루프에 안걸리죠.
그래서인지 Golang은 인터페이스만 지원합니다.

뭐 암튼... 인터페이스 예제는 다음과 같습니다.

package main

import (
    "fmt"
)

func main() {
     fmt.Println("=============")
     maru := Dog{Animal{"Maru", 5, 3, 1}, "LA"}
     var m Dogs = maru
     m.Hi()
     m.Stay()
     fmt.Println("=============")
     ruru := Cat{Animal{"Ruru", 2, 5, 10}, "Seoul"}
     var c Cats = ruru
     c.Hi()
}

type Animal struct {
     name string
     age int
     speed int
     attack int
}

func (a Animal) Hi() {
     fmt.Println("Im Animal as ", a.name)
}

type Dog struct {
     Animal
     home string
}

func (d Dog) Stay() {
     fmt.Println("I stay at ", d.home)
}

type Cat struct {
     Animal
     home string
}

func (c Cat) Hi() {
     fmt.Println("Ningan! Give me food!")
}

type Dogs interface {
     Hi()
     Stay()
}

type Cats interface {
     Hi()
}


위코드는
- Dogs : Animal struct method중 Hi()를 그냥사용하고 Stay() 추가했습니다.
- Cats : Animal struct method중 Hi()를 교체했습니다.

실행결과는 
D:\DevelopSource\Go Lang>go run testVal.go
=============
Im Animal as Maru
I stay at LA
=============
Ningan! Give me food!

아마도, Go Language의 수 많은 부분중에 기본 사용법 80% 이상은 예제로 남긴것 같네요.
그럼 다음 시간에는 웹서버 그냥 한번 띄워보겠습니다.

* 유니티 플러그인을 이걸로 대체할 수 있으면 좋겠는데 말입니다. LOL
(찾아본 결과 Go로 생성되는 .lib는 C로 Wrapper만들어서 사용할 수 있다는 이야기가 있네요...)

* 위에서 포인터에 대한 설명없이 포인터를 사용했는데, 다음의 예제로 감잡아서 그냥 사용했어요.

=================
package main

import (
    "fmt"
)

func main() {
    a := 43 //var a int = 43;
    fmt.Println("Value of a : ", a)
    fmt.Println("Reference of a : ", &a)

    b := &a //var b *int = &a;
    fmt.Println("Address of a : ", b)
    fmt.Println("Value of a : ", *b)
    fmt.Println("Reference of a : ", &b)

    *b = 32
    fmt.Println("Value of a by *b handle : ", a)
}


결과는 
D:\DevelopSource\Go Lang>go run Pointer.go
Value of a : 43
Reference of a : 0xc0820022b0
Address of a : 0xc0820022b0
Value of a : 43
Reference of a : 0xc082024028
Value of a by *b handle : 32

포인터는 그냥 주소만 가지고 있고 실재 값은 다른곳에 저장되는 이른바 "바로 가기" 폴더입니다.
해당 값을 꺼내올때는 & (레퍼런스)로 꺼내 올 수 있구요.

2016/02/02 17:49 2016/02/02 17:49