반응형

안녕하세요.

유니티에서 개발을 하다보면, 투명도를 설정하려면 어떻게 해야할까요?

Inspector에 color에서 설정할 수 있습니다.

color설정창을 열어서 알파값을 변경하면 됩니다.

수치를 낮추면, 더 투명하게 할 수 있습니다.

 

코드로 추가할 수도 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;   // Image class를 사용하기 위해 추가합니다.
 
 
public class CGameManager : MonoBehaviour
{
    void Start()
    {
        GameObject goImage = GameObject.Find("Canvas/Image");
        Color color = goImage.GetComponent<Image>().color;
        color.a = 0.5f;
        goImage.GetComponent<Image>().color = color;
    }
}
cs

0.5f는 255를 기준으로 255 * 0.5 = 127.5 소수점 반올림해서 128을 의미합니다.

반응형
반응형

안녕하세요.

오늘은 문자가 숫자인지를 확인하는 함수에 대해 알아보도록 하겠습니다.

문자가 숫자('0'~'9')인지를 확인하는 함수입니다.

함수 원형
int isdigit(int _C);
_C가 숫자인지를 판별합니다.

헤더파일
ctype.h

리턴값
숫자이면 0이 아닌값을 리턴합니다.( 4를 리턴 합니다)
숫자가 아니면 0을 리턴합니다.

예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <ctype.h>
 
void main()
{
    char chString[] = "a1-2+&ZY8b";
    
    for (int i = 0; chString[i] != '\0'; i++)
    {
        if (isdigit(chString[i]))
            printf("digit : %c\n", chString[i]);
        else
            printf("not digit : %c\n", chString[i]);
    }
}
cs

결과

isdigit함수를 사용하지 않고 구현하려면 다음과 같이 구현합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <ctype.h>
 
void main()
{
    char chString[] = "a1-2+&ZY8b";
        
    for (int i = 0; chString[i] != '\0'; i++)
    {
        if ((chString[i] >= '0' && chString[i] <= '9'))
            printf("digit : %c\n", chString[i]);
        else
            printf("not digit : %c\n", chString[i]);
    }
}
cs
반응형
반응형

안녕하세요.

오늘은 C언어에서 문자가 알파벳이거나 숫자인지 확인하는 함수에 대해 알아보로독 하겠습니다.

문자가 특수문자가 아닌 알파벳('a'~'z', 'A'~'Z')과 숫자('0'~'9')인지를 확인할 때 사용할 수 있습니다.

함수 원형
int isalnum( int _C );
_C가 알파벳이거나 숫자인지를 판별하게 됩니다.


헤더파일
ctype.h


리턴값
알파벳이거나 숫자이면 0이 아닌 값을 리턴합니다.(알파벳 대문자 : 1, 알파벳 소문자 : 2, 숫자 : 4를 리턴합니다.)
알파벳이거나 숫자가 아니면 0을 리턴합니다.

예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <ctype.h>
 
void main()
{
    char chString[] = "a1-2+&ZY8b";
    
    for (int i = 0; chString[i] != '\0'; i++)
    {
        if (isalnum(chString[i]))
            printf("alphanumeric : %c\n", chString[i]);
        else
            printf("not alphanumeric : %c\n", chString[i]);
    }
}
cs

 

isalnum함수를 사용하지 않고 직접 구현하려면 다음과 같이 구현하면 됩니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <ctype.h>
 
void main()
{
    char chString[] = "a1-2+&ZY8b";
        
    for (int i = 0; chString[i] != '\0'; i++)
    {
        if ( (chString[i] >= 'a' && chString[i] <= 'z'
            || (chString[i] >= 'A' && chString[i] <= 'Z'
            || (chString[i] >= '0' && chString[i] <= '9'))
            printf("alphanumeric : %c\n", chString[i]);
        else
            printf("not alphanumeric : %c\n", chString[i]);
    }
}
cs
반응형
반응형

안녕하세요.

C언어에서 문자가 알파벳인지 아닌지 확인해주는 함수에 대해 알아보도록 하겠습니다.

캐릭터명이 알파벳으로만 만들어졌는지 확인할 때 유용합니다.

함수 원형
int isalpha( int _C );
_C가 문자 알파벳인지 판별하게 됩니다.

헤더 파일
ctype.h

리턴값
알파벳이면 0이 아닌 값(true), 대문자는 2, 소문자는 1
알파벳이 아니면 0(false)

예제

간단하게 문자를 하나씩 isalpha함수 파라메터에 넣어서 알파벳인지 판별합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <ctype.h>
 
void main()
{
    char chString[] = "a-+&b";
    
    for (int i = 0; chString[i] != '\0'; i++)
    {
        if (isalpha(chString[i]))
            printf("alpha : %c\n", chString[i]);
        else
            printf("not alpha : %c\n", chString[i]);
    }
}
cs

 

isalpha함수를 이용하지 않고 직접 구현해볼 수 도 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <ctype.h>
 
void main()
{
    char chString[] = "a-+&b";
 
    for (int i = 0; chString[i] != '\0'; i++)
    {
        if ((chString[i] >= 'a' && chString[i] <= 'z'|| (chString[i] >= 'A' && chString[i] <= 'Z'))
            printf("alpha : %c\n", chString[i]);
        else
            printf("not alpha : %c\n", chString[i]);
    }
}
cs
반응형
반응형

안녕하세요

만약 게임에서 몬스터가 랜덤한 위치에 나오게 하거나,
상자를 열었을 경우 랜덤하게 아이템이 나오게 하려면 어떻게 구현을 해야할까요??
오늘은 이러한 경우에 난수(Random)값을 추출하는 함수에 대해 이야기하려고 합니다.

 

rand

함수 원형
int rand();

헤더 파일
stdlib.h

리턴값
0에서 32,767까지 값이 리턴됩니다.
0~RAND_MAX(0~32767) 
RAND_MAX값이 32767(16진수로 0x7fff)로 정의되어있습니다.

예제

1
2
3
4
5
6
7
8
#include <stdio.h>
#include <stdlib.h>
 
void main()
{
    for ( int i = 0; i < 10; i++ )
        printf("%d\n", rand());
}
cs

문제점
예제를 여러번 실행해보면 항상 값이 같다는 것을 확인할 수 있습니다.
프로그램이 실행될 때마다 rand함수 호출 시 다른 값을 호출하기 위해서는 srand함수를 이용해야합니다.

srand

함수 원형
void srand(unsigned int _Seed);

헤더 파일
stdlib.h

리턴값
없습니다.

설명
Seed를 다른 값을 넣어주면 rand호출 시 마다 다른 값을 리턴해줄 수 있습니다.
시드에 상수를 넣어버리면 의미가 없기 떄문에 time함수를 넣어서 시간마다 다른 시드가 들어가도록 합니다.
time함수를 사용하기 위해서는 time.h 헤더파일을 추가해줘야합니다.

예제

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void main()
{
    srand((unsigned)time(NULL));
    for ( int i = 0; i < 10; i++ )
        printf("%d\n", rand());
}
 
cs

 

응용하기

1~3 랜덤값 추출하기
rand값에 3으로 나눈 나머지를 구하면 0~2까지 값이 나오고 여기서 1을 더해줍니다.

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void main()
{
    srand((unsigned)time(NULL));
    for ( int i = 0; i < 10; i++ )
        printf("%d\n", rand()%3+1);
}
cs

 

중복값이 없도록 난수 생성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void main()
{
    srand((unsigned)time(NULL));
    int nResult[10= { 0, };
    int nCount = 0;
    int nNum = 0;
    bool bExist = false;
    while(nCount < 10 )
    {
        bExist = false;
        nNum = rand() % 10 + 1;
        for (int i = 0; i < 10; i++)
        {
            if (nNum == nResult[i])
                bExist = true;
        }
 
        if (!bExist)
        {
            nResult[nCount++= nNum;
        }
            
    }
    for ( int i = 0; i < 10; i++ )
        printf("%d\n", nResult[i]);
}
cs

 

반응형
반응형

안녕하세요.

vecter에서 특정 데이터를 삭제할 때는 erase를 사용합니다.

간단하게 다음과 같이 삭제하면 될거같은데, 에러가 발생합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
#include <vector>
using namespace std;
 
void main()
{
    vector<int> v;
 
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
 
    for (vector<int>::iterator iter = v.begin(); iter != v.end(); ++iter)
    {
        if ( *iter == 3 )
        {
            v.erase(iter);
        }
    }
 
    for (vector<int>::iterator iter = v.begin(); iter != v.end(); ++iter)
    {
        printf("%d\n"*iter);
    }
    printf("size : %d\n", v.size());
}
cs

 

vector 이터레이터(iterator)가 더이상증가할 수 없다고 나옵니다.

 

해결 코드

earse후에 반환되는 이터레이터(iterator)가 있습니다.
erase후 반환 이터레이터(iterator)를 넣어줍니다.

v.erase(iter);

이렇게 변경합니다. iter = v.erase(iter); 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
#include <vector>
using namespace std;
 
void main()
{
    vector<int> v;
 
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
 
    for (vector<int>::iterator iter = v.begin(); iter != v.end(); ++iter)
    {
        if ( *iter == 3 )
        {
            iter = v.erase(iter);
        }
    }
 
    for (vector<int>::iterator iter = v.begin(); iter != v.end(); ++iter)
    {
        printf("%d\n"*iter);
    }
    printf("size : %d\n", v.size());
}
cs

 

이터레이터(iterator)를 사용하지 않는 경우는 다음과 같이 구현합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
#include <vector>
using namespace std;
 
void main()
{
    vector<int> v;
 
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
 
    for (int i = 0; i < v.size(); i++)
    {
        if ( v[i] == 3 )
        {
            v.erase(v.begin()+i);
        }
    }
 
    for (vector<int>::iterator iter = v.begin(); iter != v.end(); ++iter)
    {
        printf("%d\n"*iter);
    }
    printf("size : %d\n", v.size());
}
cs

 

감사합니다.

반응형
반응형

안녕하세요.

오늘은 삽입 정렬 알고리즘에 대해 알아보도록 하겠습니다.

 

삽입 정렬 알고리즘

데이터를 정렬 위치에 맞게 삽입하면서 정렬하는 알고리즘

 

구현 방법

오름차순 기준으로 설명하겠습니다.
두 번째 데이터부터 첫 번째 데이터랑 비교 후 두 번째 데이터가 작다면, 두 값을 스왑 하고,
세 번째 데이터를 첫 번째, 두 번째와 비교 후 세 번째 데이터보다 큰 값이 있다면 값이 하나씩 뒤로 밀리게 됩니다.
이것을 반복합니다.

 

예제

배열 arrData에 100, 20, 10, 12, 5 값이 있다면, 다음과 같이 정렬이 되게 됩니다.


첫 번째 회전
두번째 데이터 arrData[1](20)를 임시 변수에 저장합니다.
임시 변수와 첫 번째 데이터와 비교하면, 임시 변수 데이터인 20이 첫 번째 데이터인 arrData[0](100)보다 작기 때문에 arrData[0]을 arrData[1]로 이동합니다.
그리고 임시 변수에 저장한 값을 arrData[0]에 저장합니다. (20, 100, 10, 12, 5)


두 번째 회전
세 번째 데이터 arrData[2](10)를 임시 변수에 저장합니다.
임시 변수와 두 번째 데이터와 비교하면, 임시변수 데이터인 10이 두 번째 데이터인 arrData[1](100)보다 작기 때문에 arrData[1]을 arrData[2]로 이동합니다.
임시 변수와 첫 번째 데이터와 비교하면, 임시 변수 데이터인 10이 두 번째 데이터인 arrData[0](20)보다 작기 때문에 arrData[0]을 arrData[1]로 이동합니다.
그리고 임시 변수에 저장한 값을 arrData[0]에 저장합니다. (10, 20, 100, 12, 5)


세 번째 회전
네 번째 데이터 arrData[3](12)를 임시 변수에 저장합니다.
임시 변수와 세 번째 데이터와 비교하면, 임시 변수 데이터인 12가 세 번째 데이터인 arrData[2](100)보다 작기 때문에 arrData[2]을 arrData[3]로 이동합니다.
임시 변수와 두 번째 데이터와 비교하면, 임시 변수 데이터인 12가 두 번째 데이터인 arrData[1](20)보다 작기 때문에 arrData[1]을 arrData[2]로 이동합니다.
임시 변수와 첫 번째 데이터와 비교하면, 임시 변수 데이터인 12가 첫 번째 데이터인 arrData[0](10)보다 크기 때문에 이동을 멈춥니다.
임시 변수에 저장한 값을 arrData[1]에 저장합니다. (10, 12, 20, 100, 5)


네 번째 회전
다섯 번째 데이터 arrData[4](5)를 임시 변수에 저장합니다.
임시 변수와 네 번째 데이터와 비교하면, 임시 변수 데이터인 5가 네 번째 데이터인 arrData[3](100)보다 작기 때문에 arrData[3]을 arrData[4]로 이동합니다.
임시 변수와 세 번째 데이터와 비교하면, 임시 변수 데이터인 5가 세 번째 데이터인 arrData[2](20)보다 작기 때문에 arrData[2]을 arrData[3]로 이동합니다.
임시 변수와 두 번째 데이터와 비교하면, 임시 변수 데이터인 5가 두 번째 데이터인 arrData[1](12)보다 작기 때문에 arrData[1]을 arrData[2]로 이동합니다.
임시 변수와 첫 번째 데이터와 비교하면, 임시 변수 데이터인 5가 첫 번째 데이터인 arrData[0](10)보다 작기 때문에 arrData[0]을 arrData[1]로 이동합니다.
임시 변수에 저장한 값을 arrData[0]에 저장합니다. (5, 10, 12, 20, 100)

 

C++ 코드로 구현

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <iostream>
using namespace std;
 
void main()
{
    int arrData[5= { 1002010125 };
    int nTemp;
    int nIndex;
    int nSize = sizeof(arrData) / sizeof(int);
    int j;
    cout << "before : ";
    forint i = 0; i < 5; i++ )
        cout << arrData[i] << " ";
    cout << endl;
 
    forint i = 1; i < nSize ; i++ )
    {
        nTemp = arrData[i];
        for( j = i; j > 0; j-- )
        {
            if( nTemp < arrData[j-1] )
            {
                arrData[j] = arrData[j-1];
                if( j == 1 )
                {
                    arrData[j-1= nTemp;
                    break;
                }
            }
            else
            {
                arrData[j] = nTemp;
                break;
            }
            
        }
        
    }
    cout << "after : ";
    forint i = 0; i < 5; i++ )
        cout << arrData[i] << " ";
    cout << endl;
}
cs
반응형
반응형

안녕하세요.

오늘은 선택 정렬 알고리즘에 대해 알아보도록 하겠습니다.

 

선택 정렬 알고리즘

배열등 리스트에서 배열 위치에 맞게 오름/내림 정렬하는 알고리즘

 

구현 방법


오름차순 기준(제일 작은 값이 앞으로, 제일 큰 값이 뒤로 정렬)으로 설명하면,
첫 번째 데이터를 전체 데이터와 비교하여, 첫 번째 데이터와 제일 작은 값을 스왑 합니다.
다음 두 번째 데이터와 첫 번째를 제외한 전체 데이터와 비교하여 두 번째 데이터와 2번째로 작은 값을 스왑 합니다.
이것을 반복합니다.

예제


배열 arrData에 100, 20, 10, 12, 5 값이 있고, 최소값이 저장된 인덱스를 저장하기 위한 변수가 nIndex라면 다음과 같이 정렬됩니다.
nIndex의 초기값은 첫 번째 인덱스인 0입니다.

arrData[nIndex]의 값 100을 두 번째 값 20과 비교했을 때, 20이 더 작기 때문에 1을 nIndex에 저장합니다.
arrData[nIndex]의 값 20을 세 번째 값 10과 비교했을 때, 10이 더 작기 때문에 2를 nIndex에 저장합니다.
arrData[nIndex]의 값 10을 네 번째 값 12과 비교했을 때, 12이 더 크기 때문에 넘깁니다.
arrData[nIndex]의 값 10을 다섯 번째 값 5과 비교했을 때, 5가 더 작기 때문에 4를 nIndex에 저장합니다.
그 후 arrData[0]과 arrData[nIndex(=4)]를 스왑 합니다.(5, 20, 10, 12, 100)

다음으로 nIndex에 1을 넣고 비교를 합니다.
arrData[nIndex]의 값 20을 세 번째 값 10과 비교했을 때, 10이 더 작기 때문에 2를 nIndex에 저장합니다.
arrData[nIndex]의 값 10을 네 번째 값 12과 비교했을 때, 12이 더 크기 때문에 넘깁니다.
arrData[nIndex]의 값 10을 다섯 번째 값 100과 비교했을 때, 100이 더 크기 때문에 넘깁니다.
그 후 arrData[1]과 arrData[nIndex(=2)]를 스왑 합니다.(5, 10, 20, 12, 100)

다음으로 nIndex에 2를 넣고 비교를 합니다.
arrData[nIndex]의 값 20을 네 번째 값 12과 비교했을 때, 12이 더 작기 때문에 3을 nIndex에 저장합니다.
arrData[nIndex]의 값 12를 다섯 번째 값 100과 비교했을 때, 100이 더 크기 때문에 넘깁니다.
그 후 arrData[2]과 arrData[nIndex(=3)]를 스왑 합니다.(5, 10, 12, 20, 100)

다음으로 nIndex에 3을 넣고 비교를 합니다.
arrData[nIndex]의 값 20을 다섯 번째 값 100과 비교했을 때, 100이 더 크기 때문에 넘깁니다.
그 후 arrData[3]과 arrData[nIndex(=3)]를 스왑 하는 건 의미가 없으므로 최종 정렬이 됩니다.

 

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <iostream>
using namespace std;
 
void main()
{
    int arrData[5= { 1002010125 };
    int nTemp;
    int nIndex;
    int nSize = sizeof(arrData) / sizeof(int);
 
    cout << "before : ";
    forint i = 0; i < 5; i++ )
        cout << arrData[i] << " ";
    cout << endl;
 
    forint i = 0; i < nSize; i++ )
    {
        nIndex = i;
        forint j = i; j < nSize; j++ )
        {
            if( arrData[nIndex] > arrData[j] )
            {
                nIndex = j;
            }
        }
 
        nTemp = arrData[i];
        arrData[i] = arrData[nIndex];
        arrData[nIndex] = nTemp;
        forint k = 0; k < 5; k++ )
            cout << arrData[k] << " ";
        cout << endl;
    }
    cout << "after : ";
    forint i = 0; i < 5; i++ )
        cout << arrData[i] << " ";
    cout << endl;
}
 
cs
반응형
반응형

 

안녕하세요

정렬 알고리즘 중 가장 구현하기 쉬운 버블 정렬 알고리즘에 대해 알아보도록 하겠습니다.

 

버블 정렬 알고리즘

배열등 리스트에서 인접한 데이터들을 비교하여 정렬하는 알고리즘

 

구현 방법

오름차순 기준(제일 작은 값이 앞으로, 제일 큰 값이 뒤로 정렬)으로 설명하면,
첫 번째 데이터를 모든 데이터와 비교하면서 첫 번째 데이터가 더 크면 서로 스왑 하고,
다음 두 번째 데이터를 모든 데이터와 비교하면서 두 번째 데이터가 더 크면 서로 스왑 하는 과정을
마지막 데이터-1까지 계속 반복합니다.

 

예제


배열 arrData에 100, 20, 10, 12, 5 값이 있다면, 이 배열 데이터를 정렬하면 다음과 같이할 수 있습니다.


arrData의 첫번째 값 100을 두 번째 값 20과 비교했을 때, 100이 더 크기 때문에 두 값을 스왑 합니다.(20, 100, 10, 12, 5)
arrData의 두번째 값 100을 세 번째 값 10과 비교했을 때, 100이 더 크기 때문에 두 값을 스왑 합니다.(20, 10, 100, 12, 5)
arrData의 세번째 값 100을 네 번째 값 12과 비교했을 때, 100이 더 크기 때문에 두 값을 스왑 합니다.(20, 10, 12, 100, 5)
arrData의 네번째 값 100을 다섯 번째 값 5과 비교했을 때, 100이 더 크기 때문에 두 값을 스왑 합니다.(20, 10, 12,  5, 100)

 



arrData의 첫번째 값 20을 두 번째 값 10과 비교했을 때, 20이 더 크기 때문에 두 값을 스왑 합니다.(10, 20, 12,  5, 100)
arrData의 두번째 값 20을 세 번째 값 12과 비교했을 때, 20이 더 크기 때문에 두 값을 스왑 합니다.(10, 12, 20, 5, 100)
arrData의 세번째 값 20을 네 번째 값 5과 비교했을 때, 20이 더 크기 때문에 두 값을 스왑 합니다.(10, 12, 5, 20, 100)

 



arrData의 첫번째 값 10을 두 번째 값 12과 비교했을 때, 10이 더 작기 때문에 두 값을 스왑 하지 않습니다.(10, 12, 5, 20, 100)
arrData의 두번째 값 12를 세 번째 값 5과 비교했을 때, 12이 더 크기 때문에 두 값을 스왑 합니다.(10, 5, 12, 20, 100)

 


arrData의 첫번째 값 10을 두 번째 값 5과 비교했을 때, 10이 더 크기 때문에 두 값을 스왑 합니다.(5, 10, 12, 20, 100)

 

C++로 구현

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
using namespace std;
 
void main()
{
    int arrData[5= { 1002010125 };
    int nTemp;
    int nSize = sizeof(arrData) / sizeof(int);
 
    cout << "before : ";
    forint i = 0; i < 5; i++ )
        cout << arrData[i] << " ";
    cout << endl;
 
    forint i = 0; i < nSize-1; i++ )
    {
        forint j = 0; j < nSize-i-1; j++ )
        {
            if( arrData[j] > arrData[j+1] )
            {
                nTemp = arrData[j];
                arrData[j] = arrData[j+1];
                arrData[j+1= nTemp;
            }
        }
    }
    cout << "after : ";
    forint i = 0; i < 5; i++ )
        cout << arrData[i] << " ";
    cout << endl;
}
 
cs

반응형
반응형

순차 탐색 알고리즘이란?
순차 탐색 알고리즘(Sequential Search Algorithm)은 단순히 배 열등의 데이터 리스트에서 순차적으로 데이터를 비교하여 원하는 데이터를 찾아내는 알고리즘입니다.
특별히 이진탐색 알고리즘 등과 같이 정렬을 우선해야 하는 번거로움이 없이 사용이 가능하며, 단순하며 구현이 쉬운 장점을 갖고 있습니다.
하지만 데이터가 많은 경우에는 비효율적인 알고리즘입니다.
단방향으로 검색하기 때문에 선형 알고리즘(Linear Search Algorithm)이라고도 합니다.

예시
10개의 데이터를 가진 배열 arr 값이 10, 30, 50, ,80, 100, 120, 150, 180, 220, 250를 가지고 있으며,
찾을 데이터가 180인 경우,
순차적으로 

1번째에는 10과 비교하고, 

2번째는 30과 비교하고,

3번째는 50과 비교하고,

4번째는 80과 비교하고,

5번째는 100과 비교하고,

6번째는 120과 비교하고,

7번째는 150과 비교하고,

180을 가진 8번째 값(배열인덱스는 7)인 값을 찾게 됩니다.

C++ 코드로는 다음과 같습니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
using namespace std;
 
void main()
{
    int arrData[10= { 10305080100120150180220250 };
    int nNum;
    cout << "input data : ";
    cin >> nNum;
 
    forint i = 0; i < 10; i++ )
    {
        if( arrData[i] == nNum )
        {
            cout << "Find Index : " << i << endl;
            return;
        }
    }
    cout << "Not Find" << endl;
}
 
cs

반응형
반응형


이진 탐색이란?
이진 탐색(Binary Search)은 데이터로 정렬되어 있는 경우, 정렬된 값의 반에 해당되는 값과 계속 비교를 해서 검색 범위를 줄여, 원하는 값을 빠르게 찾아나가는 알고리즘을 말합니다.


예시
배열인 arr값이 10, 30, 50, ,80, 100, 120, 150, 180, 220, 250으로 배열에 저장되어있고,

여기서 50이 배열 어느 인덱스에 위치하는지 알고자 한다고 합시다.

배열의 최소 인덱스(nLow)는 0이고, 최대 인덱스(nHigh)는 9입니다.

최소 인덱스(nLow)와 최대 인덱스(nHigh)를 더한 후 2로 나눕니다.

그럼 중간값(nMid)이 나오게 됩니다.

입력값과 같은 값이 나올 때까지 이 과정을 반복하게 됩니다.

첫 번째에서는 

nLow = 0, nHigh = 9, nMid = (nLow + nHigh) / 2 = 4

arr[nMid]는 100이 나오게 되는데, 입력값보다 100은 큰 값이므로,

nHigh에 nMid에 1을 뺀 값을 넣습니다.(nHigh = nMid - 1)

두 번째에서는

nLow = 0, nHigh = 3, nMid = (nLow + nHigh) / 2 = 1

arr[nMid]는 30이 나오는데, 입력값보다 30은 작기 때문에

nLow에 nMid에 1 더한 값을 넣습니다.(nLow = nMid + 1)

세 번째에서는

nLow = 2, nHigh = 3, nMid = (nLow + nHigh) / 2 = 2

arr[nMid]는 50이므로, 입력값과 같은 값이 나오게 됩니다.

2번째 인덱스에 50 값을 찾았습니다.

C++ 코드로는 다음과 같습니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <iostream>
using namespace std;
 
void main()
{
    int arrData[10= { 10305080100120150180220250 };
 
    int nLow = 0;
    int nHigh = 9;
    int nMid = (nLow + nHigh) / 2;
    int nNum;
 
    cout << "input data : ";
    cin >> nNum;
 
    while( nLow <= nHigh )
    {
        nMid = (nLow + nHigh) / 2;
        cout << "nMid : " << nMid << endl;
        if ( arrData[nMid] == nNum )
        {
            cout << "Find Index : " << nMid << endl;
            return;
        }
        else if( arrData[nMid] < nNum )
        {
            nLow = nMid + 1;
        }
        else
        {
            nHigh = nMid - 1;
        }
    }
 
    cout << "Not Find" << endl;
}
 
cs

반응형
반응형

안녕하세요.

오늘은 16진수 문자열을 10진수로 변경하는 방법에 대해 알아보도록 하겠습니다.

일단 간단하게 strtol함수를 이용할 수 있습니다.

stdlib.h헤더 파일만 추가하고 사용하면 됩니다.

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <stdlib.h>
 
void main()
{
    char chHex[] = "9B";
    unsigned int nResult = 0;
    
    nResult = strtol(chHex, NULL16);
 
    printf ( "%s => %d\n", chHex, nResult );
}
cs

 

직접 구현할 수도 있습니다.

보통 코딩문제에서도 많이 나오는 경우가 있는데, 다음과 같이 구현할 수 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <string.h>
 
void main()
{
    char chHex[] = "9b";
    unsigned int nResult = 0;
    
    for ( int i = 0; i <= strlen(chHex); i++ )
    {
        if ( chHex[i] >= 'A' && chHex[i] <= 'F' )                // chHex값이 'A'(65)~'F'(70) 일때
            nResult = nResult * 16 + chHex[i] - 'A' + 10;
        else if ( chHex[i] >= 'a' && chHex[i] <= 'f' )                // chHex값이 'a'(97)~'f'(102) 일때
            nResult = nResult * 16 + chHex[i] - 'a' + 10;
        else if ( chHex[i] >= '0' && chHex[i] <= '9' )            // chHex값이 '0'(48)~'9'(57) 일때
            nResult = nResult * 16 + chHex[i] - '0';
    }
 
    printf ( "%s => %d\n", chHex, nResult );
}
cs

코드 설명을 하자면, 자릿수에 따라 16을 곱하고 0~F(16)을 더합니다.

0~F값을 더하기 위해서는 문자열의 각각 문자에 대해 'A'~'F' 일 경우에는 'A'값을 빼고 10을 더해줘서 10~F(16) 값을 만들어주고, 'a'~'f' 일경우에는 'a'값을 빼고 10을 더해줘서 10~F(16) 값을 만들어주고, '0'~'9' 일경우에는 '0'값을 빼서 0~9 값을 만들어줍니다.

예를 들면 9b 같은 경우에는 일단 chHex[0]값이 '9'를 계산해서 nResult에 넣습니다.

nResult = 0(nResult) * 16 + 57('9') - 48('0') = 9

그리고 다음 chHex[1]값 'b'를 nResult에 더해줍니다.

nResult = 9(nResult) * 16 + 98('b') - 97('a') + 10 = 155

 

출력값은 다음과 같습니다.

9b => 155

반응형
반응형

안녕하세요.

특정 폴더의 파일리스트를 받아와야하는 경우가 있습니다.

검색이 수월하지 않는 것 같아서, 제가 구현한 내용을 정리하면서 올립니다.

테스트를 많이하지 않아서 오류나 버그가 있을 수 있으니, 참고 부탁드립니다.

그리고 컴파일러는(Visual Studio)는 관리자권한으로 실행해야합니다.

실행파일도 마찬가지로 관리자권한으로 실행해야 제대로 파일리스트를 얻을 수 있습니다.

이렇게 구현했습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <Windows.h>
#include <string>
#include <stdio.h>
using namespace std;
 
FILE *fp;
 
void FindFile(wchar_t* path);
void main()
{
    // 파일리스트를 파일로 저장합니다.
    fp = _wfopen(L"filelist.txt", L"w+");
    // 특정경로지정
    wchar_t path[256= L"C:\\Patch\\";
 
    FindFile(path);
    fclose(fp);
    
}
void FindFile(wchar_t* path)
{
    WIN32_FIND_DATA fd;
 
    wchar_t path2[256];
    wsprintf(path2, L"%s%s", path, L"*.*" );
 
    HANDLE hFind = ::FindFirstFile(path2, &fd);
 
    if( hFind != INVALID_HANDLE_VALUE )
    {
        do
        {
            if(!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
            {
                // 콘솔창에서 출력
                //wprintf(L"%s\n", fd.cFileName);
                // 파일로 저장
                fwprintf(fp, L"%s\n", fd.cFileName);
            }
            else
            {
                if( fd.cFileName[0!= '.')
                {
 
                wchar_t path3[256];
                wsprintf(path3, L"%s%s\\", path, fd.cFileName );
                //재귀호출합니다.
                FindFile(path3);
                }
            }
        }while(::FindNextFile(hFind,&fd));
        ::FindClose(hFind);
    }
}
cs

C드라이브의 Patch폴더에 있는 모든 파일들을 얻어오는 코드입니다.

재귀호출을 이용하여 하위 폴더에 있는 파일까지 얻어올 수 있습니다.

콘솔로 띄우면 파일이 많아질 경우 확인이 어렵기 때문에 파일로 저장되도록 처리했습니다.

프로젝트 폴더에서 확인하면 filelist.txt파일로 확인할 수 있습니다.

만약 경로까지 파일에 저장하려면,

38줄의 fwprintf(fp, L"%s\n", fd.cFileName); 부분을

fwprintf(fp, L"%s%s\n", path, fd.cFileName);  이렇게 변경해주면,

경로가 같이 저장됩니다.

 

wchar_t 대신 char형으로 사용해야하는 경우는 다음과 같이 구현할 수 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include <Windows.h>
#include <string>
#include <stdio.h>
#include <io.h>
#include <conio.h>
using namespace std;
 
FILE *fp;
 
void FindFile(char* path);
void main()
{
    // 파일리스트를 파일로 저장합니다.
    fp = fopen("filelist.txt""wb");
    // 특정경로지정
    char path[256= "C:\\Patch\\";
 
    FindFile(path);
    fclose(fp);
    
}
void FindFile(char* path)
{
    _finddata_t fd;
 
    char path2[256];
    sprintf(path2, "%s%s", path, "*.*" );
 
    long hFind = _findfirst(path2, &fd);
 
    if( hFind != -1 )
    {
        do
        {
            if(!(fd.attrib & FILE_ATTRIBUTE_DIRECTORY))
            {
                // 콘솔창에서 출력
                //wprintf(L"%s\n", fd.cFileName);
                // 파일로 저장
                fprintf(fp, "%s\n", fd.name);
            }
            else
            {
                if( fd.name[0!= '.')
                {
 
                char path3[256];
                sprintf(path3, "%s%s\\", path, fd.name );
                //재귀호출합니다.
                FindFile(path3);
                }
            }
        }while(_findnext(hFind,&fd) != -1);
        _findclose(hFind);
    }
}
cs
반응형
반응형

안녕하세요

유니티 안드로이드 플랫폼에서 화면 회전을 설정하는 법에 대해 알아보도록 하겠습니다.

설정을 위해서는 플랫폼을 Android로 변경해야 합니다.

Build Settings(Ctrl+Shift+B)에서 Platform을 Android로 설정하고 Switch Platform으로 설정합니다.

 

Android로 바뀌었으면 Player Settings버튼을 클릭합니다.

 

Project Settings창이 뜨는데, Player에 Resolution and Presentation을 선택합니다.

 

여기서 Default Orientation설정을 이용하여 화면을 회전하거나 고정할 수 있습니다.

 

설정은 5가지로 할 수 있습니다.

Portratit, Portrait Upside Down, Landscape Right, Landscape Left는 게임 시작 시 해당 방향으로 화면이 고정됩니다.

Auto Rotation은 휴대폰의 방향에 따라 화면을 회전합니다.

Portrait - 디바이스 홈버튼이 아래에 있는 세로 모드로 고정

PortraitUpsideDown - 디바이스 홈 버튼이 위에 있는 세로 모드로 고정

LandscapeLeft - 디바이스 홈 버튼이 오른쪽에 있는 가로모드로 고정

LandscapeRight - 디바이스 홈버튼이 왼쪽에 있는 가로모드로 고정

AutoRotation - 휴대폰 방향에 따라 화면이 변경됩니다.

AutoRotation을 선택하면 세부 옵션들이 생기는데, 휴대폰의 해당 방향에 따라 화면이 자동으로 회전될 것인지 설정하는 것입니다.

체크를 해제하면 휴대폰의 방향을 변경해도 화면이 회전되지 않습니다.

예를 들면 Protratit Upside Down을 체크를 해제하면 홈버튼을 위로 향하게 휴대폰 방향을 변경해도 화면을 그대로 유지됩니다.

 

참고로 코드로 직접 셋팅도 가능합니다.

Screen.orientation = ScreenOrientation.Portrait; //세로 방향을 나타냅니다.
Screen.orientation = ScreenOrientation.PortraitUpsideDown; //장치의 윗부분이 아래를 향하는, 세로 방향을 나타냅니다.
Screen.orientation = ScreenOrientation.LandscapeLeft; //가로 방향을 나타내며, 세로 방향으로부터 반 시계방향으로 회전한 상태를 나타냅니다.
Screen.orientation = ScreenOrientation.LandscapeRight; //가로 방향을 나타내며, 세로 방향으로부터 시계방향으로 회전한 상태를 나타냅니다.
Screen.orientation = ScreenOrientation.AutoRotation; //활성화된 방향으로 자동 회전 하도록 설정합니다.

 

"ScreenOrientation.AutoRotation"설정한 후 세부설정은 다음과 같이합니다.

Screen.autorotateToPortrait = false;
Screen.autorotateToPortraitUpsideDown = false;
Screen.autorotateToLandscapeLeft = true;
Screen.autorotateToLandscapeRight = true;

 

추가로 Scene별로 다르게 설정을 하려면 Scene별로 스크립트를 생성하여 GameObject에 생성해준 후 Start 함수에 위 코드를 넣어주면 될 것 같습니다.

Scene1, Scene2가 있다면 

Scene1에는 다음과 같이 넣습니다.

public class SceneManager1 : MonoBehaviour
{
    void Start()
    {
        Screen.orientation = ScreenOrientation.Landscape;
    }
}

그리고 Scene2에는 다음과 같이 코드를 작성합니다.

public class SceneManager2 : MonoBehaviour
{
    void Start()
    {
        Screen.orientation = ScreenOrientation.Portrait;
    }
}

 

조금 더 자세한 예제는 다음 글에서 확인해주세요.

https://scvtwo.tistory.com/220

 

[Unity] 씬(Scene) 별로 화면 고정하기

씬마다 다른 화면 고정을 적용하려면 다음과 같이 합니다. 직접 프로젝트를 만들면서 알아보도록 하겠습니다. 1. 어떤 씬인지 확인을 위해서 텍스트 오브젝트, 그리고 씬 이동을 위해서 버튼 오

scvtwo.tistory.com

 

반응형
반응형

안녕하세요.

오늘은 모바일 게임에서 멀티터치로 카메라 줌인 / 줌아웃을 구현해보도록 하겠습니다.

줌인/줌아웃이 되는지 확인할 수 있도록 아무 객체나 생성합니다.

저는 큐브를 하나 생성하도록 하겠습니다.

그리고 빈프로젝트를 생성해서 스크립트를 추가하겠습니다.

생성한 스크립트에 다음과 같은 코드를 추가하겠습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class TouchManager : MonoBehaviour
{
 
    float m_fSpeed = 0.1f;       // 변경 속도를 설정합니다 
    float m_fFieldOfView = 60f;     // 카메라의 FieldOfView의 기본값을 60으로 정합니다.
 
    void Update()
    {
        CheckTouch();
    }
 
    void CheckTouch()
    {
        if (Input.touchCount == 2)
        {
            Vector2 vecPreTouchPos0 = Input.touches[0].position - Input.touches[0].deltaPosition;
            Vector2 vecPreTouchPos1 = Input.touches[1].position - Input.touches[1].deltaPosition;
 
            // 이전 두 터치의 차이 
            float fPreDis = (vecPreTouchPos0 - vecPreTouchPos1).magnitude;
            // 현재 두 터치의 차
            float fToucDis = (Input.touches[0].position - Input.touches[1].position).magnitude;
 
 
            // 이전 두 터치의 거리와 지금 두 터치의 거리의 차이
            float fDis = fPreDis - fToucDis;
 
            // 이전 두 터치의 거리와 지금 두 터치의 거리의 차이를 FleldOfView를 차감합니다.
            m_fFieldOfView += (fDis * m_fSpeed);
 
            // 최대는 100, 최소는 20으로 더이상 증가 혹은 감소가 되지 않도록 합니다.
            m_fFieldOfView = Mathf.Clamp(m_fFieldOfView, 20.0f, 100.0f);
 
            Camera.main.fieldOfView = m_fFieldOfView;
 
        }
    }
}
 
cs

 

 

유니티에서 테스트가 안되기 때문에(테스트하는 방법을 아신다면 댓글 남겨주시면 감사하겠습니다.) 애뮬레이터로 테스트했습니다.

저는 미뮤를 이용하여 테스트했습니다.

가상 키로 터치하는 위치를 정하고 마우스 터치를 하면서 줌인/줌아웃을 확인했습니다.

실행하면 줌인/줌아웃이 제대로 실행되는 것을 확인할 수 있습니다.

 

 

반응형

+ Recent posts