minos

1) 입력된 수만큼 키판 움직임 

   -  입력문자열  :  1U4D2R1L2D

   -  4*4 키판을 위에 입력 문자열 만큼 이동

void rotateNumberPad(int numberPad[MAX_ARRAY_SIZE][MAX_ARRAY_SIZE], int arraySize, char rotationStr[MAX_DATA_LENGTH] {
	
	for(int i=0; i<strlen(rotationStr); i+=2 ) {
		char tmpStr[3] = {0,};
		strncpy(tmpStr, rotationStr+i, sizeof(char)*2);
		int direction = tmpStr[0] - '0';
		int isUpAndDown = 0;
		if(tmpStr[1] == 'U' || tmpStr[i] == 'D') {
			isUpAndDown =1;
			if(tmpStr[1] == 'U') direction *= -1;
		}else {
			isUpAndDown = 0;
			if(tmpStr[1] == 'L') direction *= -1;
		}
		rotateArr(numberPad, arraySize, direction,isUpAndDown);
	}
}

void rotateArr(int numberPad[MAX_ARRAY_SIZE][MAX_ARRAY_SIZE], int arraySize, int direction, int isUpAndDown) {

	int tmpNumberPad[MAX_ARRAY_SIZE][MAX_ARRAY_SIZE];
	memcpy(tmpNumberPad, numberPad, sizeof(int)*MAX_ARRAY_SIZE*MAX_ARRAY_SIZE);
	for(int i=0; i<arraySize; i++) {
		for(int j=0; j<arraySize; j++) {
			if(isUpAndDown == 1)  numberPad[(arraySize*arraySize+direction+i)%arraySize][j] = tmpNumberPad[i][j];
			else numberPad[i][(arraySize*arraySize+direction+j)%arraySize] = tmpNumberPad[i][j];
		}
	}
}

2) 배열 접기 

   -. 가로접기는 더하기, 세로접기는 곱하기로 마지막까지 접는 것 

   -. 짝수면 접고, 홀수면 가운데 제거 

   -. 가로 세로 접기 

void getFoldingArr(int foldingArr[MAX_ARRAY_SIZE][MAX_ARRAY_SIZE], int *foldingArrCnt, int iniArr[MAX_ARRAY_SIZE][MAX_ARRAY_SIZE], int arraySize) {

	memset(foldingArr,0, sizeof(int)*MAX_ARRAY_SIZE*MAX_ARRAY_SIZE); 
	*foldingArrCnt = 0;
	
	int center = arraySize/2; 
	
	//가로 접기
	for(int i=0; i<center; i++) {
		for(int j=0; j<arraySize; j++) {
			foldingArr[i][j] = iniArr[i][j] + iniArr[ArraySize-1-i][j];			
		}
	}
	
	//세로접기
	for(int i=0; i<center; i++) {
		for(int j=0; j<center; j++) {
			foldingArr[i][j] = foldingArr[i][j] * foldingArr[i][ArraySize-1-j];			
		}
	}
	*foldingArrCnt = center;
}

   - 배열크기가 홀수면 가운데 제거하고 다시 가로 세로 접기.. 최후 한개만 남을때까지 

void getFinalValue(int foldingArr[MAX_ARRAY_SIZE][MAX_ARRAY_SIZE], int foldingArrCnt) {
	int arrSize =foldingArrCnt;
	while(1) {
		int tmpFoldingArr[MAX_ARRAY_SIZE][MAX_ARRAY_SIZE];
		memset(tmpFoldingArr, 0, sizeof(int)*MAX_ARRAY_SIZE*MAX_ARRAY_SIZE);
		int newArr[MAX_ARRAY_SIZE][MAX_ARRAY_SIZE];
		int newArrCnt=0;
		
		//홀수면 가운데 삭제 
		if(arrSize%2 == 1) {
			int center = round(arrSize/2);
			int indexI=0;
			int indexJ=0;
			for(int i=0; i<arrSize; i++) {
				if(i != center) {
					for(int j=0; j<arrSize; j++) {
						if(j != center) {
							tmpFoldingArr[indexI][indexJ] = foldingArr[i][j];
							indexJ++;
						}
					}
					indexI++;
					indexJ=0;
				}
			}
			memcpy(foldingArr,tmpFoldingArr, sizeof(int)*MAX_ARRAY_SIZE*MAX_ARRAY_SIZE);
			arrSize -= 1;
		}
		getFoldingArr(newArr, &newArrCnt, foldingArr, arrSize);
		arrSize = newArrCnt; 
		for(int i=0; i<newArrCnt; i++) {
			for(int i=0; i<newArrCnt; i++) {
				folding[i][j] = newArr[i][j];
			}
		}
		if(arrSize == 1) {
			finalValue = foldingArr[0][0];
			break;
		}
	}
}

3) 이차원배열 행렬 기준 오름차순 정렬 

//가로 오름차순 정렬
for(int i=0; i<arrSize; i++) {
	for(int j=0; j<arrSize; j++) {
		for(int k=j+1; k<arrSize; k++) {
			if(arr[i][j] > arr[i][k]) {
				int tmp = arr[i][j];
				arr[i][j] = arr[i][k];
				arr[i][k] = tmp;
			}
		}
	}
}

//세로 오름차순 정렬 
for(int i=0; i<arrSize; i++) {
	for(int j=0; j<arrSize; j++) {
		for(int k=j+1; k<arrSize; k++) {
			if(arr[j][i] > arr[k][i]) {
				int tmp = arr[j][i];
				arr[j][i] = arr[k][i];
				arr[k][i] = tmp;
			}
		}
	}
}

4) 이차원 배열 - 특정 지점에서 인접한 수가 동일하지 않는 경우만 합산 

int dx[4] = {-1,0,1,0};
int dy[4] = {0,1,0,-1};

//인접한 곳에 같은 수가 없는 경우만 합산
for(int i=0; i<arrSize; i++) {
	for(int j=0; j<arrSize; j++) {
		if(arr[i][j] != 0) {
			int flag=0;
			for(int k=0; k<4; k++) {
				int nx = i+dx[k];
				int ny = j+dy[k]; 
				if(nx<arrSize && nx>=0 && ny<arrSize ny>=0 )  {
					if(arr[i][j] == arr[nx][ny]) {
						flag=1;
						break;
					}
				}
			}
			if(flag == 0) arrSum += arr[i][j];
		}
	}
}

5. 이차원배열 달팽이 채우기 

void snale_matrix(){
    int matrix[5][5];
    int num=1;
    int delta=1;
    int limit=5;
    int i=0,j=-1;
 
    int p,q;
 
    while(1){
 
        //가로로 이동하면서 하나씩 할당
        for(p=0; p<limit; p++){
            j=j+delta;
            matrix[i][j]=num;
            num++;
        }
 
        //횟수 줄이고
        limit--;
 
        if(limit<0) break;
 
        //세로로 이동하면서 하나씩 할당
        for(p=0; p<limit; p++){
            i=i+delta;
            matrix[i][j]=num;
            num++;
        }
 
        //이동방향의 양음이 바뀜
        delta=-delta;
    }
 
    //2차원 배열 출력
    for(p=0; p<5; p++){
        for(q=0; q<5; q++){
            printf("%d\t",matrix[p][q]);
        }
        printf("\n");
    }
 
}

6) 이차원배열내 특정 위치에서 '1'이 연속하여 이어진 갯수 

size =0, copiedData: 이차원배열, x/y : 특정 위치 
int checkTerritory(copiedData, x, y, size) {
	if(copiedData[x][y] == '1') {
		copiedData[x][y] == '2';
		size++;
		
		if(x>0) size = checkTerritory(copiedData, x-1, y, size);
		if(y>0) size = checkTerritory(copiedData, x, y-1, size);
		if(x<MAX-1) size = checkTerritory(copiedData, x+1, y, size);
		if(y< MAX-1) size = checkTerritory(copiedData, x, y+1, size);
		
		return size;		
	}else 
		return size;
}

7) 이차원 배열 전 구간에 영역별 크기 계산 (위의 6번 함수 이용)

만약 전체 경로에서 "1"이 연속된 곳의 위치를 계산하고, 크기순으로 오름차순으로 하면 
for(int i=0; i<MAX; i++) {
	for(int j=0; j<MAX; j++) {
		int tmpSize =0;
		tmpSize = checkTerritory(copiedData, i, j, tmpSize);		
		if(tmpSize) {
			terrSize[(*terrCnt)++] = tmpSize;
		}
	}
} 

//크기순으로 오름차순 정렬
for(int i=0; i<*terrCnt; i++) {
	for(int j=0; j<*terrCnt; j++) {
		if(terrSize[i] > terrSize[j]) {
			int tmp = terrSize[i];
			terrSize[i] = terrSize[j];
			terrSize[j] = tmp;
		}
	}
}

1) 홀수 짝수 번갈아 입력 시 : if(i%2) ... else .. . 형식으로 사용 

2) 함수 매개변수로 포인터 받아 그 값을 증가 할 때 : terry[ (*terrCnt)++]

3) 반올림 : 

   예) 10자리 반올림 : (number + 50)/100*100

4) 부호 있는 정수 / 부호없는 정수 최대 / 최소 값 (limit.h)    

    int INT_MIN INT_MAX

    unsigned int 0 UINT_MAX

5) 배열 count 없이 strlen으로 값을 계속 입력 

char arrStr[MAX] = {0,};
arrStr[strlen(arrStr)] = input[i];

stdio.h 에서도 지원하나, ctype.h도 포함한다. 

1) isdigit(char c) : 숫자면 1, 그외는 0 리턴 

2) isalpha(char c) : 알파벳 1, 그외 0 리턴 

3) islower(char c), isuper(char c) : 0은 대소문자 아님, !=0 대소문자

4) 문자 숫자에서 '0'을 빼면 실제 숫자가 된다

     '숫자' - '0' = 숫자 (예) '4' - '0' = 4 

5) 문자 -> 숫자 변경은 atoi() 사용

6) 숫자 -> 문자 변환은 sprintf() 사용 

int main()
{
    char s1[10];       // 변환한 문자열을 저장할 배열
    int num1 = 283;    // 283은 정수
    sprintf(s1, "%d", num1);    // %d를 지정하여 정수를 문자열로 저장
    printf("%s\n", s1);         // 283
    return 0;
}

7) int toupper(int ch), int tolower(int ch) : 한 문자를 대소문자로 변환 

int main(void) 
{
 char ch1, ch2;
 ch1 = 'a';
 ch2 = 'X';
 printf("%c\n", toupper(ch1));
 printf("%c\n", tolower(ch2));
 return 0;
}

8) 문자열을 대소문자로 바꿔주는 함수 :  char *strupr(char *str) , char *strlwr(char *str)

int main(void) {
	char str1[10] = "sTudEnt";
	char str2[10] = "sTudEnt";
	char *ptr1=NULL;
	cahr *ptr2=NULL;	
	ptr1 = strupr(str1);
	ptr2 = strlwr(str2);	
	return 0;
}

ctype.h 에서 지원하는 함수 목록 

https://m.blog.naver.com/PostView.nhn?blogId=ahalinux&logNo=220641724329&proxyReferer=https%3A%2F%2Fwww.google.com%2F

1) 버블 - 오름차순 

//오름차순 정렬
for (int i = 0; i < COUNT - 1; i++)
{
    for (int j = 0; j < COUNT - 1 - i; j++)
    {
        if (data[j] > data[j + 1])
        {
            temp        = data[j];
            data[j]     = data[j + 1];
            data[j + 1] = temp;
        }
    }
}

2) 버블 - 내림차순 

//내림차순 정렬
for (int i = 0; i < COUNT - 1; i++)
{
    for (int j = 0; j < COUNT - 1 - i; j++)
    {
        if (data[j] < data[j + 1])
        {
            temp        = data[j];
            data[j]     = data[j + 1];
            data[j + 1] = temp;
        }
    }
}

3)  내림차순 다른 방법 

for(int i=0; i<NUM_SIZE; i++) {
	for(int j=i+1; j<NUM_SIZE; j++) {
		if(strcmp(sortedNumber[i],sortedNumber[i]) < 0) {
			char tmpNumbers[MAX_DATA_LEN] = {0,};
			strcpy(tmpNumbers, sortedNumber[i]);
			strcpy(sortedNumber[i], sortedNumber[j]);
			strcpy(sortedNumber[j], tmpNumbers);
		}
	}
}

• 십진수 -> 이진수 

void convertDecimalToBinary(int n, char *bin) {
	int count =0;
	for(int i=31 ; i>=0; i--) {
		int k = n>>i;
		if(k&1) {
//			printf("1");
			bin[count] = 1 + '0';
		} else {
//			printf("0");
			bin[count] = 0 + '0';
		}
		count++;
	}
//	printf(" ");
	bin[count] = '\0';
}

•  

1. 실수 소수점 2자리 반올림 방법

• printf 이용

#include <math.h>
1)
float val = 12.98765;
printf("%.2f \n",val);
2)
float f = 0.1553846;
f = floor((f * 100)+0.5) / 100;
printf("%f \n",f);
3)
double x = 0.1553846;
double rx = round (x * 1e2) * 1.e-2;
printf("%f \n",f);

• math.h 이용 

2. 실수 올림 및 내림 

#include <math.h>
float rounded_down = floorf(val * 100) / 100;   /* 내림: 37.77 */
float nearest = roundf(val * 100) / 100;  /* 반올림: 37.78 */
float rounded_up = ceilf(val * 100) / 100;      /* 올림: 37.78 */

3. 백단위 반올림 

   (val + 500) / 100 * 100 

1) strstr , strchr, strrchr

#include <string.h> 
void main()
{
    char s1[30] = "qazwsxedcrfvtgbyhn";
    char *ptr = strchr(s1, 'a');  //from left
    char *ptr2 = strrchr(s1, 'a'); //from right 
    char *ptr3 = strstr(s1, 'az'); 
    while (ptr != NULL) {
        printf("%s\n", ptr);         
        ptr = strchr(ptr + 1, 'a');  
    }
}

2) strtok

   strtok 사용 시 원본 문자열이 변형되므로 주의할 것 

char s1[30] = "2015-06-10T15:32:19"; 
    char *ptr = strtok(s1, "-T:");
    while (ptr != NULL) {
        printf("%s\n", ptr);          
        ptr = strtok(NULL, "-T:");   
    }
 

3) 문자열 숫자 변환 

https://dojang.io/mod/page/view.php?id=386 

4) 그외 문자열 변환 처리

https://btyy.tistory.com/222

5) 두문자열이 교차하면서 유사도 확인 ( 동일 글자가 몇개 있는지 확인 )

firstStr:  GTTAG ->
secondStr:  <- AGTCATG  

same : 문자열 교차시 같은 글자가 가장 많은 것 
swapIndex : 첫번째 문자열이 모두 이동되어 두번째 문자열이 왼쪽으로 이동 
firstStr, secondStr : 교차할 문자열

for(int swapindex=0; swapIndex<2; swapIndex++) {
	int len1 = strlen(firstStr);
	int len2 = strlen(secondStr); 
	
	char tmpStr[MAX];
	int pos=0;
	for(int i=0; i<len1; i++) {
		int similarity =0;
		memset(tmpStr, 0, sizeof(char)*MAX);
		strncpy(tmpStr, firstStr, sizeof(char) * (++pos));
		for(int j=0; j<strlen(tmpStr); j++) {
			if(tmpStr[j] == secondStr[len2 - pos +j]) similarity++;
		}
		if(same < similarity) same = similarity;
	}
	
	memset(tmpStr, 0, sizeof(char) * MAX);
	strcpy(tmpStr, firstStr);
	strcpy(firstStr, secondStr);
	strcpy(secondStr,tmpStr);
}