코드 노트

(Lab 9-1) 난수

- 난수 범위(a~b): a + rand() % (b - a + 1)

- 난수 시드 설정: srand(time(NULL))

시드 설정을 하지 않으면 프로그램을 몇번을 시도해도 똑같은 패턴의 값이 나옴

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
	srand(time(NULL));
	int n, r, st, en, sum = 0;

	printf("난수의 개수: ");
	scanf("%d", &n);
	printf("시작과 끝 : ");
	scanf("%d %d", &st, &en);
	for (int i = 0; i < n; i++) {
		r = st + rand() % (en - st + 1);
		printf("%d ", r);
		sum += r;
	}
	printf("\n");
	printf("sum=%d ", sum);
	printf("avg=%d\n", sum / n);
}

(Lab 9-2)(1): 확률 계산(주사위)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
	srand(time(NULL));
	int i, n, sum[7] = { 0 };
	int r, st, en;

	printf("주사위 횟수 : ");
	scanf("%d", &n);

	st = 1, en = 6;
	for (int i = 0; i < n; i++) {
		r = st + rand() % (en - st + 1);
		sum[r]++;
	}

	for (i = 1; i < sizeof(sum)/sizeof(int); i++) {
		printf("%d : %d (%.2f%%)\n", i, sum[i], sum[i]*100./n);  // %표시 -> %%
	}
}

(Lab 9-2)(2): 주사위 확률 조작 

r = rand() % 100;
if (r <= 9) dice = 1;
else if (r <= 19) dice = 2;
else if (r <= 29) dice = 3;
else dice = 6;

- 확률을 조작하는 방법

 1, 2, 3, 4, 5, 6을 구간으로 변경한다

1: 0~9

2: 10~19

3: 20~29

4: 30~39

5: 40~49

6: 50~99   (6: 50% 이상)

특정 확률로 조작하려는 값을 else 부분에 배치한다 

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
	srand(time(NULL));
	int i, n, sum[7] = { 0 };
	int r, st, en;

	printf("주사위 횟수 : ");
	scanf("%d", &n);

	printf("정상적인 주사위\n");
	st = 1, en = 6;
	for (int i = 0; i < n; i++) {
		r = st + rand() % (en - st + 1);
		sum[r]++;
	}
	for (i = 1; i < sizeof(sum) / sizeof(int); i++) {
		printf("%d : %d (%.2f%%)\n", i, sum[i], sum[i] * 100. / n);
	}


	printf("\n이상한 주사위\n");
	for (i = 0; i < sizeof(sum) / sizeof(int); i++) {
		sum[i] = 0;
	}
	st = 0, en = 99; // 범위 0~99
	for (int i = 0; i < n; i++) {
		r = st + rand() % (en - st + 1);
		if (r <= 9) r = 1;
		else if (r <= 19) r = 2;
		else if (r <= 29) r = 3;
		else if (r <= 39) r = 4;
		else if (r <= 49) r = 5;
		else r = 6;
		sum[r]++;
	}
	for (i = 1; i < sizeof(sum) / sizeof(int); i++) {
		printf("%d : %d (%.2f%%)\n", i, sum[i], sum[i] * 100. / n);
	}
}

(Lab 9-3): 모의 성적 데이터 발생1 

- 단순히 0~100을 동일한 확률로 발생 -> 테스트 데이터로 적합하지 않음

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
	int i, n, sum[9] = { 0 };
	int r, st, en, hap = 0;
	char* score[] = { "A+","A","B+","B","C+","C", "D+","D", "F" };

	srand(time(NULL));
	printf("학생 수 : ");
	scanf("%d", &n);

	st = 0, en = 100; // 100점은?
	for (i = 0; i < n; i++) {
		r = st + rand() % (en - st + 1);
        // r = rand() % 101;
        
		printf("%d ", r);
		if (r >= 95) r = 0;		    //A+
		else if (r >= 90) r = 1;	//A
		else if (r >= 85) r = 2;	//B+
		else if (r >= 80) r = 3;	//B
		else if (r >= 75) r = 4;	//C+
		else if (r >= 70) r = 5;	//C
		else if (r >= 65) r = 6;	//D+
		else if (r >= 60) r = 7;	//D
		else r = 8;			        // F
		sum[r]++;
		hap += r;
	}

	printf("\n\n");
	printf("n = %d 평균 = %.2f\n", n, (double)hap / n);
	for (i = 0; i < 9; i++) {
		printf("%-3s: %5d (%6.2f%%)\n",score[i], sum[i], sum[i] * 100. / n); // 형식 지정자 주의
	}
}

(Lab 9-4): 모의 성적 데이터 발생2 (성적 분포가 주어졌을 때 모의 데이터 발생시키기)

A+ : 10%, A : 10%, B+: 20%, B:25%, C+: 15%, C:10%, D+:5%, D:3%, F:2%

- 주사위 확률 조작 방법과 같은 방법으로 A+ ~ F에 해당하는 점수 설정

- 각 학점별 % 분포가 학생수(정수)로 환산할 때 정확하게 일치하지 않을 수 있음
    각 학점별 배정 가능한 최대 인원수를 미리 계산해 놓고 성적을 발생시킬때 인원 체크를 한다

    소수점으로 나오는 경우 정수에서 모자라는 부분을 조정함 

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
	int i, nstudents, r, sum = 0, j = 0;
	double temp;
	int grade;// 0~8, A+ ~ F
	int count[9] = { 0 }; // 0 ~ 8, A+ ~ F 인원수
	int compensaton[9]; // 보정해야할 위치
	char* score[] = { "A+","A","B+","B","C+","C", "D+","D", "F" };
	// A+:10%, A:10%, B+:20%, B:25%, C+:15%, C:10%, D+:5%, D:3%, F:2%
	int maxcount[9] = { 10,10,20,25,15,10,5,3,2 }; //미리 계산된 최대 인원: 100명 기준
	int start[9] = { 95,90,85,80,75,70,65,60,0 }; // 점수 시작
	int end[9] = { 100,94,89,84,79,74,67,64,59 }; // 점수 끝


	srand(time(NULL));
	scanf("%d", &nstudents);

	//maxcount[i]를 계산한다
	for (i = 0; i < 9; i++) {
		temp = maxcount[i] * nstudents / 100.;

		if (temp != (int)temp) // 소수점이 있다면
			compensaton[j++] = i;  // 보정이 필요한 배열에 저장, 내림 연산

		maxcount[i] = (int)temp;
		sum += maxcount[i];
	}

	// 소수점 보정
	for (i = 0; i < nstudents - sum; i++) {
		maxcount[compensaton[i]]++;
	}


	sum = 0;
	for (i = 0; i < nstudents; i++) {
		do {
			r = rand() % 101;
			for (j = 0; j < 9; j++) {
				if (r >= start[j] && r <= end[j]) {
					grade = j;
					break;
				}
			}  // 이미 해당 학점의 점수가 모두 발생되었다면
			   //  다른 학점을 발생할 때까지 반복
		} while (count[grade] + 1 > maxcount[grade]);  //인원 체크

		count[grade]++; //학점 별 count를 증가시킨다
		printf("%d ", r);
		sum += r;
	}

	printf("\n\n");
	printf("n = %d 평균 = %.2f\n", nstudents, (double)sum / nstudents);
	for (i = 0; i < 9; i++) {
		printf("%-3s: %5d (%6.2f%%)\n", score[i], count[i], count[i] * 100. / nstudents); // 형식 지정자 주의
	}
}

(Lab 9-5) 문장의 알파벳 분포 조사

- 디버그 -> 속성 -> 명령 인수 => input.txt

- 파일의 끝(EOF)을 검사하는 방법: 파일의 끝 or (입력시)CTRL + Z

int count[26] 
while ((c = getchar()) != EOF) {
	total++;
	if (isalpha(c))
		alpha++
		count[toupper(c) - 'A']++;
}

방법1) 속성 - 디버그 - 명령인수 : < input.txt

방법2) 커맨드창(cmd): cmd창을 활용할때는 디버그의 명령인수에 아무것도 안적혀 있어야함, 그리고 input.txt의 내용 직접입력 후 ctrl + z

방법3) 윈도우 창

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <ctype.h>

int main() {
	int count[26] = { 0 };
	int c, alpha, total;
	alpha = 0;
	total = 0;

	while ((c = getchar()) != EOF) {
		total++;
		if (isalpha(c)) {
			alpha++;
			count[toupper(c) - 'A']++;
		}
	}
	printf("전체문자수=%d 알파벳수=%d\n", total, alpha);
	for (int i = 0; i < sizeof(count) / sizeof(int); i++) {
		if (i != 0 && i % 5 == 0)
			printf("\n");
		printf("%c: %d (%.2f%%) ", 'A' + i, count[i], count[i] * 100. / alpha);
	}
}

(Lab 9-ACM) 괄호 검증 - VPS ( https://www.acmicpc.net/problem/9012)

- 괄호 문자열에서 '('와')'의 개수는 같아야 한다.

- 문자열을 앞에서부터 하나씩 보면서 '('와')'의 개수를 비교할 때 (의 개수가 항상 많거나 같아야 한다.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <ctype.h>

int main() {
	char buf[51];
	int t, i, j, k, result = 1;
	int c;

	scanf("%d", &t);
	//getchar();

	for (i = 0; i < t; i++) {
		//gets(buf);// 이전에 getchar() 버퍼 비우기
		//gets_s(buf,sizeof(buf)); // 이전에 getchar()로 버퍼 비워야함
		scanf(" %[^\n]s", buf); // %앞에 공백 두어서 공백문자 무시해야함 or getchar()로 버퍼 비우기
		//scanf("%s", buf); // 이전에 버퍼 비울 필요 없음

		result = 1;
		k = 0;
		for (j = 0; buf[j] != '\0'; j++) {
			if (buf[j] == '(')
				k++;
			else if (buf[j] == ')')
				k--;

			if (k < 0) {
				result = 0;
				break;
			}
		}
		if (k != 0)
			result = 0;

		if (result)
			printf("YES\n");
		else
			printf("NO\n");
	
	}
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <windows.h>

#define MESG_LEN	100
#define DELAY		50

void delayPrint(char mesg[])
{
	for (int i = 0; i < strlen(mesg); i++) {
		fprintf(stdout, "%c", mesg[i]);
		fflush(stdout);
		Sleep(DELAY);		// milliseconds
	}
	printf("\n");
}

void main()
{
	char mesg[MESG_LEN];

	printf("Type the message to be displayed in drawing a character: ");
	gets(mesg);
	if (strlen(mesg) < 2)
		strcpy(mesg, "Welcome to the delayed printing world!");
	delayPrint(mesg);
}

https://duua-coding.tistory.com/15

(Lab 7-7)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int nplates[3]; // 탑에 몇개의 원판이 있는지 변수
int tower[3][100]; // 어떤 원판들이 있는지 보관
int count = 0;

//타워의 내용 초기화, start 위치에 n개의 원판(n~1)이 있다.
void init_tower(int n, char start) {
	int i, tower_no;

	//탑의 번호 A, B, C -> 0,1,2
	tower_no = start - 'A'; 

	//tower[][] 내용과 nplates[]를 초기화 한다
	// nplates[]에 원판의 수를 저장함
	for (i = 0; i < 3; i++) {
		nplates[i] = 0;
		if (i == tower_no)
			nplates[i] = n;
	}

	//tower[0][0] ~ [0][3] = 4, 3, 2, 1 식으로 기억시킨다.
	for (i = n; i > 0; i--) { 
		tower[tower_no][n - i] = i;
	}
}

//탑의 현재 상태 표시
void print_tower() {
	//tower[][] 내용을 보여준다 
	for (int i = 0; i < 3; i++) {
		printf("%c: ", 'A' + i);
		for (int j = 0; j < nplates[i]; j++)
			printf("%d ", tower[i][j]);
		printf("\n");
	}

	printf("\n");
	printf("다음 Enter :");
	getchar();
	fflush(stdin); // 버퍼 완전히 비우기
}

void move_one(int n, char from, char to) {
	printf("\n원판 %d을 %c에서 %c로 옮긴다.\n", n, from, to);
	// nplates[] 와 tower[][] 내용을 수정한다
	// from에서는 제일 위의 원판을 빼고
	// to 에는 제일 끝에 원판을 추가하고
	// nplates[] 값ㅇ르 감소/증가 한다.
	// 이동이 발생할 때 마다 print_tower() 호출
	int f = from - 'A';
	int t = to - 'A';
	tower[t][nplates[t]] = tower[f][nplates[f] - 1];
	nplates[t]++;
	nplates[f]--;
	count++;

	print_tower();
}

void hanoi_tower(int n, char from, char tmp, char to) {
	if (n == 1)
		move_one(1, from, to);
	else {
		hanoi_tower(n - 1, from, to, tmp);
		move_one(n, from, to);
		hanoi_tower(n-1, tmp, from, to);
		
	}
}


void main() {
	init_tower(4, 'A');
	printf("초기 상태\n");
	print_tower();
	hanoi_tower(4, 'A', 'B', 'C');
	printf("원판을 모두 옮겼습니다. \n");
	printf("원판을 옮긴 횟수: %d\n", count);
	
}

(Lab7-ACM1)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>


void find_fibos(int n);
int find_max_fibo(int n);

void main() {
	int nT, num;

	scanf("%d", &nT);
	for (int i = 0; i < nT; i++) {
		scanf("%d", &num);
		find_fibos(num);
	}

	
}

void find_fibos(int n) {
	if (n == 1) {
		printf("%d ", n);
		return;
	}
	else {
		int f;
		f = find_max_fibo(n);
		if (f == n) {
			printf("%d ", f);
			return;
		}
		else {
			find_fibos(n - f);
			printf("%d ", f);
		}
	}
}

int find_max_fibo(int n) {
	int n0 = 0, n1 = 1, n2 = n0 + n1;
	
	if (n == 0) return n0;
	else if (n == 1) return n1;
	else {
		while (n2 <= n) {
			n0 = n1;
			n1 = n2;
			n2 = n0 + n1;
		}
		return n1;
	}
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int fibo(int n) {
	int a, b, c;
	a = 0;
	b = 1;

	if (n <= 1) {
		return n;
	}

	else {
		for (int i = 2; i <= n; i++) {
			c = a + b;
			a = b;
			b = c;

		}
		return c;
	}
	
}

void print_fibo(int* p, int count) {
	for (int i = count; i >= 0; i--)
		printf("%d ", p[i]);
	printf("\n");
}

void main() {
	
	int t, n, sum, j;
	int size = 10, count;
	int* p;

	scanf("%d", &t);
	for (int i = 0; i < t; i++) {
		sum = 0;
		count = 0;
		size = 10;
		p = (int*)malloc(sizeof(int) * size);
		scanf("%d", &n);

		while (sum != n) {
			j = 0;
			while (fibo(j) <= (n - sum) )
				j++;

			j--;
			if (count >= size) {
				size *= 2;
				p = (int*)realloc(p, sizeof(int)*size);
			}
			p[count++] = fibo(j);
			sum += fibo(j);
		}
		print_fibo(p, count-1);
	}
	
}

(Lab 7- ACM2(1))

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void find_henry(int a, int b);

int main() {
	int nT, a, b;
	scanf("%d", &nT);
	for (int i = 0; i < nT; i++) {
		scanf("%d %d", &a, &b);
		find_henry(a, b);
	}
}



void find_henry(int a, int b) {
	if (a == 1) {
		printf("%d\n", b);
		return;
	}
	else {
		int x = (b + a - 1) / a; 
		a = a * x - b;
		b = b * x;
		find_henry(a, b);
	}
}

(Lab 7- ACM2(2))

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void find_henry(int a, int b);

int main() {
	int nT, a, b;
	scanf("%d", &nT);
	for (int i = 0; i < nT; i++) {
		scanf("%d %d", &a, &b);
		printf("%d/%d = ", a, b);
		find_henry(a, b);

	}
}

void find_henry(int a, int b) {
	if (a == 1) {
		printf("1/%d\n", b);
		return;
	}
	else {
		int x = (b + a - 1) / a;
		printf("1/%d + ", x);
		a = a * x - b;
		b = b * x;
		find_henry(a, b);
	}
}

(Lab 7-1) 현재시간 

*tm_sec 범위 ( 0 - 59)

tm_year 의 경우 출력 시: +1900 해야함

tm_mon 의 경우 출력 시: +1 해야함

tm_wday 는 일요일 부터 시작함 (일 ~ 토)

ctime()는 문자열 내에 '\n'을 포함시켜 자동 줄바꿈이 됨 -> 추가로 printf()에 '\n'을 적을 필요 없음

time_t 자료형(정수형)- 시간을 나타내는 변수를 사용할때 사용

clock_t 자료형(정수형)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <time.h>

int main() {
	char* wday[] = { "일","월","화","수","목","금","토" };
	time_t now;


	time(&now); // 1970년 이후 1초 단위로 증가
	printf("now = %llu\n", now);


	//char* ctime(&now); // 시간을 문자열로 반환
	printf("ctime() : %s", ctime(&now));

	//struct tm* localtime(const time_t*);
	struct tm* tp = localtime(&now);
	printf("%d년 %d월 %d일 %s요일 %d시 %d분 %d초\n", tp->tm_year+1900, tp->tm_mon+1, tp->tm_mday,wday[tp->tm_wday], tp->tm_hour, tp->tm_min, tp->tm_sec);
}

#if 0
	struct tm { /* a broken-down time */
		int tm_sec; /* seconds after the minute: [0 - 60] */
		int tm_min; /* minutes after the hour: [0 - 59] */
		int tm_hour; /* hours after midnight: [0 - 23] */
		int tm_mday; /* day of the month: [1 - 31] */
		int tm_mon; /* months since January: [0 - 11] */
		int tm_year; /* years since 1900 */
		int tm_wday; /* days since Sunday: [0 - 6] */
		int tm_yday; /* days since January 1: [0 - 365] */
		int tm_isdst; /* daylight saving time flag: <0, 0, >0 */
	};
#endif

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <time.h>

int main() {
	char* wday[] = { "일","월","화","수","목","금","토" };
	time_t now;
	
	time(&now);
	printf("now = %llu\n", now);

	printf("ctime() : %s", ctime(&now));
	
	struct tm* tp = localtime(&now);
	printf("%d년 %d월 %d일 %s요일 %d시 %d분 %d초\n", tp->tm_year + 1900, tp->tm_mon + 1, tp->tm_mday, wday[tp->tm_wday], tp->tm_hour, tp->tm_min, tp->tm_sec);

}

 (Lab 7-2) 움직이는 시계 - '/r' 활용

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <time.h>

int main() {
	char* wday[] = { "일","월","화","수","목","금","토" };
	time_t now;
    struct tm* tp;

	while (1) {
		time(&now); 
        
		//printf("now = %llu\r", now);
		//printf("ctime() : %s\r", ctime(&now)); // ctime() 문자열은 문자열 내에 '\n'이 포함되어있어서 '\r'을 사용해도 줄바꿈이 일어남

		tp = localtime(&now);
		printf("%d년 %d월 %d일 %s요일 %d시 %d분 %d초\r", tp->tm_year + 1900, tp->tm_mon + 1, tp->tm_mday, wday[tp->tm_wday], tp->tm_hour, tp->tm_min, tp->tm_sec);

	}

}

(Lab 7-3) 실행 시간 측정

clock_t 자료형 - clock() 함수 사용할때 사용

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>


void main(void)
{
	clock_t start, finish;
	double duration;
	int i, j, k = 0;

	start = clock();

	// 수행시간을 측정하고자 하는 코드....
	for (i = 1; i <= 10000; i++)
		for (j = 1; j < 10000; j++)
			k++;

	finish = clock();

	duration = (double)(finish - start) / CLOCKS_PER_SEC;
	printf("%f 초입니다.\n", duration);

}

(Lab 7-4) 시작/종료시간 표시 및 시간측정

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>


void main(void)
{
	clock_t start, finish;
	time_t now;
	double duration;
	int i, j, k = 0;
	struct tm* p;;

	
	time(&now); //now = time(NULL);
	start = clock();
	printf("시작 : %s", ctime(&now));

	// 수행시간을 측정하고자 하는 코드
	for (i = 1; i <= 100000; i++)
		for (j = 1; j < 100000; j++)
			k++;

	time(&now); //now = time(NULL);
	finish = clock();
	printf("종료 : %s", ctime(&now));
	

	duration = (double)(finish - start) / CLOCKS_PER_SEC;
	printf("실행시간 = %lf초입니다. \n\n", duration);


	time(&now);
	p = localtime(&now);
	printf("시작 : %d:%d:%d \n", p->tm_hour, p->tm_min, p->tm_sec);
	start = clock();

	// 수행시간을 측정하고자 하는 코드
	for (i = 1; i <= 100000; i++)
		for (j = 1; j < 100000; j++)
			k++;

	time(&now);
	p = localtime(&now);
	printf("종료 : %d:%d:%d \n", p->tm_hour, p->tm_min, p->tm_sec);
	finish = clock();

	duration = (double)(finish - start) / CLOCKS_PER_SEC;
	printf("실행시간 = %lf초입니다. \n\n", duration);

}

( Lab 7-5) 스톱워치

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>

int main() {
	clock_t start, now;
	clock_t duration, sec, min, hour, milsec;
	int ch1, ch2;

	printf("Enter 로 시작 CTRL-C누르면 종료 \n");
	while (getchar() != '\n');
	start = clock();

	while (1) {
		now = clock();
		duration = now - start;
		sec = duration / CLOCKS_PER_SEC;
		milsec = duration % CLOCKS_PER_SEC;
		hour = sec / 3600;
		min = (sec / 60) % 60;
		sec = sec % 60;
		printf("%d:%02d:%02d.%03d\r", hour, min, sec, milsec);

		if (_kbhit()) {
			ch1 = _getch();

			if (ch1 == 0xe0 || ch1 == 0x0) {
				ch2 = _getch();
				if (ch2 == 75)
					break;
			}
			else if (ch1 <= 26)
				break;
		}
	}
	printf("\n");
}

(Lab 7-6) 재귀함수 Sum, Factorial, Fibonacci, Binary

facotrial(0) = 1 이라는 것에 유의하라

#include <stdio.h>

int sum(int n) {
	if (n <= 1)
		return n; // 1도 가능
	else
		return n + sum(n - 1);
}

int factorial(int n) {
	if (n <= 1)
		return 1;
	else
		return n * factorial(n - 1);
}

int fibo(int n) {
	if (n <= 1)
		return n;
	else
		return fibo(n - 1) + fibo(n - 2);
}

//방법1
void binary(int n) {
	if (n > 0) {
		binary(n / 2);
		printf("%d", n % 2);
	}
}

////방법2
//void binary(int n) {
//	if (n < 2)
//		printf("%d", n);
//
//	else { 
//		binary(n / 2);
//		printf("%d", n % 2);
//	}
//}

int main() {
	int n = 10;
	int bi = 12345;

	printf("sum(%d) = %d\n",n, sum(n));
	printf("factorial(%d) = %d\n", n, factorial(n));
	printf("fibonacci(%d) = ", n);
	for (int i = 0; i <= 10; i++) {
		printf("%d ", fibo(i));
	}
	printf("\n");
	printf("binary(%d) = ", bi);
	binary(bi);
}

+8진수 출력 재귀 함수

//방법 1
void hexa(int n) {
	if (n > 0)
	{
		hexa(n / 8);
		printf("%d", n % 8);
	}
}

//방법2
void hexa(int n) {
	if (n < 8)
		printf("%d", n);
	else {
		hexa(n / 8);
		printf("%d", n % 8);
	}
}

+16진수 출력 재귀 함수

//방법1
void octal(int n) {
	int k;
	if (n > 0) {
		octal(n / 16);
		k = n % 16;
		if (k < 10)
			printf("%d", k);
		else
			printf("%c", 'a' + (k - 10));
	}
}

//방법2
void octal(int n) {
	int k;
	if (n < 16) {
		if (n < 10)
			printf("%d", n);
		else 
			printf("%c", 'a' + (n- 10));
	}

	else {
		octal(n / 16);
		k = n % 16;
		if (k < 10)
			printf("%d", k);
		else
			printf("%c", 'a' + (k - 10));
	}
}

01. 행렬연산

#define _CRT_SEUCRE_NO_WARNINGS
#include <stdio.h>

#define ROWS 3
#define COLS 3

void print_matrix(int arr[ROWS][COLS]);
void add_matrix(int a[ROWS][COLS], int b[ROWS][COLS], int c[ROWS][COLS]);
void sub_matrix(int a[ROWS][COLS], int b[ROWS][COLS], int c[ROWS][COLS]);

int main() {
	int A[ROWS][COLS] = { {1,2,3},{4,5,6},{7,8,9} };
	int B[ROWS][COLS] = { {11,12,13},{14,15,16},{17,18,19} };
	int C[ROWS][COLS] = { 0 };
	
	printf("A = \n");
	print_matrix(A);
	printf("B = \n");
	print_matrix(B);
	
	add_matrix(A, B, C);
	printf("A + B =\n");
	print_matrix(C);
	sub_matrix(B, A, C);
	printf("B - A =\n");
	print_matrix(C);


}

void print_matrix(int arr[ROWS][COLS]) {
	for (int i = 0; i < ROWS; i++) {
		for (int j = 0; j < COLS; j++) {
			printf("%2d ", arr[i][j]);
		}
		puts("");
	}
}

void add_matrix(int a[ROWS][COLS], int b[ROWS][COLS], int c[ROWS][COLS]) {
	for (int i = 0; i < ROWS; i++) {
		for (int j = 0; j < COLS; j++) {
			c[i][j] = a[i][j] + b[i][j];
		}
	}
}
void sub_matrix(int a[ROWS][COLS], int b[ROWS][COLS], int c[ROWS][COLS]) {
	for (int i = 0; i < ROWS; i++) {
		for (int j = 0; j < COLS; j++) {
			c[i][j] = a[i][j] - b[i][j];
		}
	}
}

02.

#define _CRT_SEUCRE_NO_WARNINGS
#include <stdio.h>

#define MAXROWS 100
#define MAXCOLS 100
 
typedef struct matrix {
	int rows, cols;
	int data[MAXROWS][MAXCOLS];
}Matrix;

void print_matrix(Matrix* m);
void add_matrix(Matrix* a, Matrix* b, Matrix* c);
void sub_matrix(Matrix* a, Matrix* b, Matrix* c);

int main() {
	Matrix A = { 3,3, {{1,2,3},{4,5,6},{7,8,9}} };
	Matrix B = { 3,3, { {11,12,13},{14,15,16},{17,18,19} } };
	Matrix C;

	printf("A = \n");
	print_matrix(&A);
	printf("B = \n");
	print_matrix(&B);

	add_matrix(&A, &B, &C);
	printf("A + B =\n");
	print_matrix(&C);
	sub_matrix(&B, &A, &C);
	printf("B - A =\n");
	print_matrix(&C);
	

}

void print_matrix(Matrix* m) {
	for (int i = 0; i < m->rows; i++) {
		for (int j = 0; j < m->cols; j++) {
			printf("%2d ", (*m).data[i][j]);
		}
		puts("");
	}
}

void add_matrix(Matrix* a, Matrix* b, Matrix* c) {
	c->rows = a->rows;
	c->cols = a->cols;
	for (int i = 0; i < a->rows; i++) {
		for (int j = 0; j < a->cols; j++) {
			c->data[i][j] = a->data[i][j] + b->data[i][j];
		}
	}
}
void sub_matrix(Matrix* a, Matrix* b, Matrix* c) {
	c->rows = a->rows;
	c->cols = a->cols;
	for (int i = 0; i < a->rows; i++) {
		for (int j = 0; j < a->cols; j++) {
			c->data[i][j] =a->data[i][j] - b->data[i][j];
		}
	}
}

03. 구조체 연습(img 가 음수인 경우 처리 주의)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

typedef struct complex {
	int real;
	int img;
}COMPLEX;

void print_complex(COMPLEX* c);
COMPLEX add(COMPLEX x, COMPLEX y);
COMPLEX sub(COMPLEX x, COMPLEX y);


void main() {
	COMPLEX x, y, z;
	scanf("%d %d", &x.real, &x.img);
	scanf("%d %d", &y.real, &y.img);

	z = add(x, y);
	print_complex(&x);
	printf(" + ");
	print_complex(&y);
	printf(" = ");
	print_complex(&z);
	printf("\n");

	z = sub(x, y);
	print_complex(&x);
	printf(" - ");
	print_complex(&y);
	printf(" = ");
	print_complex(&z);
}

void print_complex(COMPLEX* c) {  // img 범위 
	printf("(%d ", c->real);
	if (c->img > 0)
		printf("+ %di)", c->img);
	else if (c->img < 0)
		printf("- %di)", -c->img);
	else
		printf(")");
}

COMPLEX add(COMPLEX x, COMPLEX y) {
	COMPLEX z;
	z.real = x.real + y.real;
	z.img = x.img + y.img;
	return z;
}

COMPLEX sub(COMPLEX x, COMPLEX y) {
	COMPLEX z;
	z.real = x.real - y.real;
	z.img = x.img - y.img;
	return z;
}

04. 구조체 선언과 입출력

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct student {
    char name[20];
    int year;
    char no[20];
    char phone[20];
}Student;

void PrintStudent(Student* s);
void InputStudent(Student* s);

void main() {
    int i, count, found;
    char name[20];
    Student* p = NULL;

    printf("몇명: ");
    scanf("%d", &count);

    p = (Student*)malloc(sizeof(Student) * count);

    for (i = 0; i < count; i++) {
        printf("\n자료번호 %d 입력\n", i + 1);
        InputStudent(p + i);
    }

    printf("\n");
    for (i = 0; i < count; i++) {
        PrintStudent(p + i);
    }

    printf("찾을 이름: ");
    scanf("%s", name);
    found = 0;
    for (i = 0; i < count; i++) { // i를 전역 변수로
        if (strcmp(name, p[i].name) == 0) 
            break;
    }
    if (i < count) // 주의
        PrintStudent(p+i); 
    else
        printf("찾는 데이타가 없습니다.\n");

}

void PrintStudent(Student* s) {
    printf("이름:%s ", s->name);
    printf("학년: %d ", s->year);
    printf("학번: %s ", s->no);
    printf("전화: %s\n", s->phone);
}
void InputStudent(Student* s) {
    printf("이름: ");
    scanf("%s", s->name);
    printf("학년: ");
    scanf("%d", &s->year);
    printf("학번: ");
    scanf("%s", s->no);
    printf("전화: ");
    scanf("%s", s->phone);
}

05.  한글을 고려한 reverse()함수 작성하기

한글 조건 : (unsigned char)str[i] >= 0x80 && (unsigned char)str[i+1] >= 0x80) 

정확히는 AC00~D7AF

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

void reverse(char to[], char from[]) {
	//int i;
	int len = strlen(from);
	for (int i = 0; i < len; i++) {
		if ((unsigned char)from[len - 1 - i] >= 0x80 && (unsigned char)from[len - 2 - i] >= 0x80) {
			to[i] = from[len - 2 - i];
			to[i + 1] = from[len - 1 - i];
			i++;
		}
		else
			to[i] = from[len - i - 1];
	}
	to[len] = '\0';  // i가 전역변수인 경우 to[i] = '\0'도 가능
}


void main()
{
	char str1[100] = "한성대학교";
	char str2[100] = "University";
	char str3[100] = "Computer";
	char str4[100] = "Engineering";
	char str5[100];
	char str6[100];
	int ret;
	ret = strlen(str1);
	printf("strlen(%s)=%d\n", str1, ret);
	ret = strcmp(str1, str1);
	printf("strcmp(%s, %s) = %d\n", str1, str1, ret);
	ret = strcmp(str1, str2);
	printf("strcmp(%s, %s) = %d\n", str1, str2, ret);
	ret = strcmp(str1, str3);
	printf("strcmp(%s, %s) = %d\n", str1, str3, ret);
	strcpy(str5, str1);
	printf("strcpy str5 = %s\n", str5);
	strcat(str5, " ");
	strcat(str5, str2);
	printf("strcat str5, str2 = %s\n", str5);
	reverse(str6, str5);
	printf("reverse str5 = %s\n", str6);
}

06.

int mystrlen(char* str) {
    char* s = str;
    while (*s)
        s++;
    return (s - str);
}

int mystrlen(char* str) {
    char* s = str;
    int count = 0;
    while (*str++ != '\0') {
        count++;
    }
    return count;
}

int mystrlen(char* str) {
    char* s = str;
    int len = 0;
    while (s[len] != '\0') 
        len++;    
        return len;
}

int mystrcmp(char* s1, char* s2) {
    unsigned char *p1 = (unsigned char *)s1; // 한글 고려 안하면 unsigned 빼면됨
    unsigned char *p2 = (unsigned char *)s2; // unsigned char* 선언 대신, (unsigned char)*s1 방식 사용 가능
    while (*p1 || *p2) {
        if (*p1 < *p2)
            return -1;
        else if (*p1 > *p2)
            return 1;
        p1++;
        p2++;
    }
    return 0;
}


int mystrcmp(char* s1, char* s2) // 한글 고려시, (unsigned char)s1[i]과 같은 방법 쓰면 됨
{
    int len1, len2, i;
    len1 = mystrlen(s1);
    len2 = mystrlen(s2);
    for (i = 0; i <= len1 && i <= len2; i++) {
        if (s1[i] > s2[i])
            return 1;
        else if (s1[i] < s2[i])
            return -1;
    }
    return 0;
}

char* mystrcpy(char* to, char* from) {
    int i, len;
    len = mystrlen(from);
    for (i = 0; i <= len; i++) {
        to[i] = from[i];
    }
    return to;
}

char* mystrcpy(char* to, char* from) {
    char* fp = from;
    char* tp = to;
    while (*fp) {// *fp != '\0'도 가능
        *tp++ = *fp++;
    }
    *tp = '\0';

    return to;
}

char* mystrcat(char* to, char* from) {
    while (*to) {
        to++;
    }
    while (*from) {
        *to++ = *from++;
    }
    *to = '\0';
}

char* mystrcat(char* to, char* from) {
    int i, len1, len2;
    len1 = mystrlen(to);
    len2 = mystrlen(from);
    for (i = 0; i <= len2; i++) {
        to[len1 + i] = from[i];
    }
}

void reverse(char to[], char from[]) {
    unsigned char* p1 = (unsigned char *)to;
    unsigned char* p2 = (unsigned char *)from;
    int len = mystrlen(p2);
    for (int i = 0; i < len; i++) {
        if (p2[len - 1 - i] >= 0x80 && p2[len - 2 - i]) {
            p1[i] = p2[len - 2 - i];
            p1[i + 2] = p2[len - 1 - i];
            i++;
        }
        else
            p1[i] = p2[len - 1 - i];
    }
}


void reverse(char* to, char* from)
{
    char* p;
    p = from + mystrlen(from) - 1; // from 의 끝으로 이동
    while (p >= from) {
        if (*p & 0x80) { // 한글인 경우
            *to = *(p - 1); // two bytes씩 copy
            *(to + 1) = *p;
            to += 2; // two byte 씩 이동
            p -= 2;
        }
        else { // 영문인 경우
            *to = *p;
            to++;
            p--;
        }
    }
    *to = '\0';

}

void main() {
    char str1[100] = "한성대학교";
    char str2[100] = "University";
    char str3[100] = "Computer";
    char str4[100] = "Engineering";
    char str5[100];
    char str6[100];
    int ret;
    ret = mystrlen(str1);
    printf("mystrlen(%s)=%d\n", str1, ret);
    ret = mystrcmp(str1, str1);
    printf("mystrcmp(%s, %s) = %d\n", str1, str1, ret);
    ret = mystrcmp(str1, str2);
    printf("mystrcmp(%s, %s) = %d\n", str1, str2, ret);
    ret = mystrcmp(str1, str3);
    printf("mystrcmp(%s, %s) = %d\n", str1, str3, ret);
    mystrcpy(str5, str1);
    printf("mystrcpy str5 = %s\n", str5);
    mystrcat(str5, " ");
    mystrcat(str5, str2);
    printf("mystrcat str5 = %s\n", str5);
    reverse(str6, str5);
    printf("reverse str5 = %s\n", str6);
}

표준 입출력과 파일 입출력

표준 입출력의 문제점:

1) 키보드 입력: 실행 마다 똑같은 데이터를 입력

2) 모니터 출력: 실행 결과 창 스크롤링, 결과 창을 닫으면 출력 내용이 사라짐

해결: 데이터를 저장한 파일로부터 입력을 받고 결과를 파일로 저장하기(파일 입출력)

07.  FILE *fp 이용 입/출력

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void main() {
	FILE* fp;
	char buf[100], filename[100];
	int id = 1492001;
	char name[20] = "홍길동";
	char phone[20] = "010-1234-5678";


	fp = fopen("data.txt", "w"); // w를 write mode, a는 추가(append)
	fprintf(fp, "%d\n", id);
	fprintf(fp, "%s\n", name);
	fprintf(fp, "%s\n", phone);
	fclose(fp);
	// 파일에서 입력(read)
	printf("입력 파일 명 : ");
	scanf("%s", filename);
	fp = fopen(filename, "r"); // r은 read mode
	fscanf(fp, "%d", &id);
	printf("학번=%d\n", id);
	fscanf(fp, "%s", buf);
	printf("이름=%s\n", buf);
	fscanf(fp, "%s", buf);
	printf("전화=%s\n", buf);
	fclose(fp);

}

08.  구조체(레코드 저장) -> binary (이진) 모드, fread와 fwrite 사용

파일 열기:

 1) fp = fopen(filename, "r+b");

 2) fp = fopen(filename, "w+b");

구조체 저장 (data 부분은 항상 주소 형태)

 1) fwrite(void *data, size, n fp);

 2) fread(void *data, size, n fp); 

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

void main() {
	FILE* fp;
	char buf[100], filename[100];
	int id = 1492001;
	char name[20] = "홍길동";
	char phone[20] = "010-1234-5678";


	fp = fopen("data.txt", "w+b"); 
	fwrite(&id, sizeof(int), 1, fp);
	fwrite(name, sizeof(char), strlen(name), fp);
	fwrite(phone, sizeof(char), strlen(phone), fp);
	fclose(fp);

	printf("입력 파일 명 : ");
	scanf("%s", filename);
	fp = fopen(filename, "r+b"); 
	fread(&id, sizeof(int), 1, fp);
	printf("학번=%d\n", id);
	fread(name, sizeof(char), strlen(name), fp);
	printf("이름=%s\n", name);
	fread(phone, sizeof(char), strlen(phone), fp);
	printf("전화=%s\n", phone);
	fclose(fp);

}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>


int main() {
	FILE* fp;
	char file[20];
	int id = 1492001;
	char name[20] = "홍길동";
	char tel[20] = "010-1234-5678";
	int temp;
	char buffer[100];

	printf("입력 파일 명: ");
	scanf("%s", file);
	fp = fopen(file, "w+b");
	fwrite(&id, sizeof(int), 1, fp);
	fwrite(name, sizeof(char), strlen(name)+1, fp); // sizeof(name)
	fwrite(tel, sizeof(char), strlen(tel)+1, fp);
	fclose(fp);

	fp = fopen(file, "r+b");
	fread(&temp, sizeof(int), 1, fp);
	printf("학번=%d\n", temp);
	fread(buffer, sizeof(char), strlen(name)+1, fp);
	printf("이름=%s\n", buffer);
	fread(buffer, sizeof(char), strlen(tel)+1, fp);
	printf("전화=%s\n", buffer);
	fclose(fp);


}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

typedef struct student {
	int id;
	char name[20];
	char phone[20];

}Student;

int main() {
	FILE* fp;
	Student s = { 1492001, "홍길동", "010-1234-5678" };
	Student s1;
	char file[20];


	printf("입력 파일 명: ");
	scanf("%s", file);
	fp = fopen(file, "w+b");

	fwrite(&s, sizeof(Student), 1, fp);
    
	fseek(fp,0,SEEK_SET); // 파일 포인터 위치 다시 초기화
	fread(&s1, sizeof(Student), 1, fp);
 
	printf("학번 = %d\n", s1.id);
	printf("이름 = %s\n", s1.name);
	printf("전화 = %s\n", s1.phone);
	fclose(fp);

}

09. Random Access 파일

Random Access

• 순차(Sequential) 파일 -> 처음부터 읽어야 함
• 랜덤 파일: 원하는 위치에서 읽고/쓸수 있다.

fssek(fp, offset, whence) 사용

• 파일 입/출력 위치를 whence + offset으로 이동
• whence 기준점:
• SEEK_SET: 0 -> 파일 시작지점
• SEEK_CUR: 1-> 파일의 현재 지점
• SEEK_END: 2 -> 파일의 끝 지점

fseek(fp, n * sizeof(struct Student), 0);

n번 record로 입/출력 위치를 이동한다.

10.

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZE 24
typedef struct Phone {
	char name[SIZE];
	char phone[SIZE];
} Phone;

void menu()
{
	printf("\n*** 전화번호 ***\n");
	printf("(1) 목록\n");
	printf("(2) 검색\n");
	printf("(3) 추가\n");
	printf("(4) 종료\n");
	printf("--------------\n");
	printf("선택하세요 : ");
}

int main(void) {
	FILE* fp;
	int i, n, filesize, ndata;
	char filename[100], buf[100], buf2[100];
	struct Phone ph;

	fp = fopen("phone_b", "w+b");
	while (1) {
		menu();
		scanf("%d", &n);
		switch (n) {
		case 1:
			printf("\n** 자료 목록 **\n");
			fseek(fp, 0, SEEK_END); 
			filesize = ftell(fp);
			ndata = filesize / sizeof(struct Phone);
			fseek(fp, 0, SEEK_SET);
			for (int i = 0; i < ndata; i++) {
				fread(&ph, sizeof(struct Phone), 1, fp);
				printf("이름: %s \t 전화: %s\n", ph.name, ph.phone);
			}
			break;
		case 2:
			printf("\n** 자료 찾기 **\n");
			printf("찾을 이름 : ");
			scanf("%s", buf);
			fseek(fp, 0, SEEK_END); 
			filesize = ftell(fp);
			ndata = filesize / sizeof(struct Phone);
			fseek(fp, 0, SEEK_SET);
			for (int i = 0; i < ndata; i++) {
				fread(&ph, sizeof(struct Phone), 1, fp);
				if (strcmp(ph.name, buf) == 0) {
					printf("이름: %s \t 전화: %s\n", ph.name, ph.phone);
					break;
				}
			}
			if (strcmp(ph.name, buf) != 0)
				printf("찾는 데이터가 없습니다.\n");
			break;
		case 3:
			printf("\n** 자료 추가 **\n");
			printf("이름: ");
			scanf("%s", ph.name);
			printf("전화 : ");
			scanf("%s", ph.phone);
			fseek(fp, 0, SEEK_END); // ?????? ???
			fwrite(&ph, sizeof(struct Phone), 1, fp);
			break;
		case 4: printf("\n** 자료 종료 **\n");
			break;
		}
		if (n == 4)
			break;
	}
	fclose(fp);
	return 0;
}

printf("\n** 자료 변경**\n");
if (sel == -1) {
	printf("자료를 선택하시오\n");
	continue;
}
fseek(fp, sizeof(Phone) * sel, SEEK_SET);
fread(&p, sizeof(Phone), 1, fp);
printf("이름: %s \t 전화: %s\n", p.name, p.tel);
printf("새로운 데이터 입력\n");
printf("이름: ");
scanf("%s", p.name);
printf("전화: ");
scanf("%s", p.tel);
fseek(fp, sizeof(Phone) * sel, SEEK_SET);
fwrite(&p, sizeof(Phone), 1, fp);

            #define DELETED "DELETED"
            Phone deleted = {DELETED, DELETED};
            
            printf("\n** 자료 삭제**\n");
            if (sel == -1) {
                printf("자료를 선택하시오\n");
                continue;
            }
            fseek(fp, sizeof(Phone) * sel, SEEK_SET);
            fread(&p, sizeof(Phone), 1, fp);
            printf("이름: %s \t 전화: %s\n", p.name, p.tel);
            printf("진짜 삭제?:\n");
            scanf("%d", &del);
            if (del) {
                fseek(fp, sizeof(Phone) * sel, SEEK_SET);
                fwrite(&deleted, sizeof(Phone), 1, fp);
            }
            
            // 자료찾기와 자료 목록 반복문 안에
             if (strcmp(DELETED, p.name) == 0 && strcmp(DELETED, p.tel) == 0)
     			continue;

11.

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define SIZE	24
typedef struct phone {
	char name[SIZE];
	char phone[SIZE];
} Phone;

#define FILENAME "phone.txt"
#define DELETED	"DELETED" 

void displaymenu()
{
	printf("\n*** 전화번호 ***\n");
	printf("(1) 목록\n");
	printf("(2) 검색\n");
	printf("(3) 추가\n");
	printf("(4) 변경\n");
	printf("(5) 삭제\n");
	printf("(99) 종류\n");
	printf("---------------\n");
	printf("선택하세요 : ");
}


int getnumberofdata(FILE* fp)
{
	int filesize;
	int n;
	fseek(fp, 0, SEEK_END);
	filesize = ftell(fp); 
	n = filesize / sizeof(Phone);
	return n;

}


void disp_one(Phone* data)
{
	printf("이름: %s   전화: %s\n", data->name, data->phone);
}

void list(FILE* fp)
{
	Phone data;
	int ndata;

	printf("\n** 전체 목록 **\n");
	ndata = getnumberofdata(fp);
	if (ndata == 0) {
		printf("데이터가 없습니다.\n");
		return;
	}
	fseek(fp, 0, SEEK_SET); 
	while (ndata--) {
		fread(&data, sizeof(data), 1, fp);
		if (strcmp(data.name, DELETED) == 0 &&
			strcmp(data.phone, DELETED) == 0)
			continue;
		disp_one(&data);
	}
}


int search(FILE* fp)
{
	Phone data;
	char name[20];
	int n;
	int ndata; 

	printf("\n** 자료 찾기 **\n");
	ndata = getnumberofdata(fp); 
	if (ndata == 0) {
		printf("Data가 없습니다.\n");
		return -1;
	}

	printf("찾을 이름 : ");
	scanf("%s", name);

	fseek(fp, 0, SEEK_SET); 
	for (n = 0; n < ndata; n++) {
		fread(&data, sizeof(data), 1, fp);
		if (strcmp(data.name, DELETED) == 0 &&
			strcmp(data.phone, DELETED) == 0)
			continue;
		if (strcmp(data.name, name) == 0)
			break;
	}
	if (n >= ndata) {
		printf("찾는 데이터가 없습니다.\n");
		return -1;
	}
	disp_one(&data);
	return n;
}

void inputone(Phone* data)
{
	printf("이름 : ");
	scanf("%s", data->name);
	printf("번호 : ");
	scanf("%s", data->phone);
}

int getblank(FILE* fp)
{
	Phone data;
	int n;
	int ndata;

	ndata = getnumberofdata(fp); 
	if (ndata == 0) {
		return -1;
	}
	fseek(fp, 0, SEEK_SET); 
	for (n = 0; n < ndata; n++) {
		fread(&data, sizeof(data), 1, fp);
		if (strcmp(data.name, DELETED) == 0 &&
			strcmp(data.phone, DELETED) == 0)
			return n;
	}
	return -1;
}


void add(FILE* fp)
{
	Phone data;
	int blank_n; 
	printf("\n** 자료 추가 **\n");
	inputone(&data);
	blank_n = getblank(fp);
	if ((blank_n = getblank(fp)) == -1) { 
		fseek(fp, 0, SEEK_END);
	}
	else
		fseek(fp, blank_n * sizeof(Phone), SEEK_SET);
	fwrite(&data, sizeof(data), 1, fp);
}

void updateone(FILE* fp, int n)
{
	Phone data;
	printf("\n** 변경 **\n");
	if (n == -1) {
		printf("변경할 데이터를 찾으세요.\n");
		return;
	}
	printf("변경할 데이터");
	fseek(fp, n * sizeof(Phone), SEEK_SET);
	fread(&data, sizeof(Phone), 1, fp);
	disp_one(&data);
	printf("새로운 데이터 입력\n");
	inputone(&data); // data ???
	fseek(fp, n * sizeof(Phone), SEEK_SET);
	fwrite(&data, sizeof(Phone), 1, fp);
}

void deleteone(FILE* fp, int n)
{
	Phone deletedata = { DELETED, DELETED };
	Phone data;
	int ans;
	int ndata;

	printf("\n** 삭제 **\n");
	ndata = getnumberofdata(fp); //record number
	if (ndata == 0) {
		printf("데이터가 없습니다.\n");
		return;
	}
	if (n == -1) {
		printf("삭제할 데이터를 찾으세요.\n");
		return;
	}
	printf("삭제할 데이터\n");
	fseek(fp, n * sizeof(Phone), SEEK_SET);
	fread(&data, sizeof(Phone), 1, fp);
	disp_one(&data);
	printf("삭제? (1/0) : ");
	scanf("%d", &ans);
	if (ans == 1) {
		fseek(fp, n * sizeof(Phone), SEEK_SET);
		fwrite(&deletedata, sizeof(Phone), 1, fp); // shift down
		printf("삭제되었습니다.\n");
	}
	else
		printf("취소되었습니다.\n");
}
void main()
{
	//Phone data;
	FILE* fp;
	//int i;
	int record_number; // ???? ??? record ???
	int menu;

	record_number = -1; // ????/???? ??? record ???

	// ?????? open, ???ο? ??????? w?? ????
	if ((fp = fopen(FILENAME, "r+b")) == NULL) { // ?????? ??????
		fp = fopen(FILENAME, "w+b"); // ???? ????
		if (fp == NULL) {
			printf("파일을 열 수 없습니다.\n");
			exit(0);
		}
	}

	while (1) {
		do {
			displaymenu();
			scanf("%d", &menu);
		} while (menu != 99 && (menu < 1 || menu>5));
		if (menu == 99) 
			break;
		switch (menu) {
		case 1: list(fp);
			break;
		case 2: record_number = search(fp);
			break;
		case 3: add(fp);
			record_number = -1;
			break;
		case 4: updateone(fp, record_number);
			record_number = -1;
			break;
		case 5: deleteone(fp, record_number);
			record_number = -1;
			break;
		}
	}

	fclose(fp);
}

ACM

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

void make_even(int* p, int n) {
	for (int i = 0; i < n; i++) {
		if (p[i] % 2 == 1) {
			p[i] += 1;
		}
	}
}

void print_arr(int* p, int n) {
	for (int i = 0; i < n; i++) {
		printf("%d ", p[i]);
	}
	printf("\n");
}

void give_arr(int* p, int n) {
	int* temp = (int*)malloc(sizeof(int) * n);
	for (int i = 0; i < n; i++) {
		temp[i] = p[i] / 2;
		p[i] -= temp[i];
	}
	for (int i = 0; i < n; i++) {
		p[(i + 1) % n] += temp[i]; 
	}
	free(temp);
}

int is_equl(int* p, int n) {
	for (int i = 1; i < n; i++) {
		if (p[0] != p[i])
			return 0;
	}
	return 1;
}

int main() { // + 사탕갯수 출력
	int t, n; // 테스트케이스, 인원수
	int* p;
	int count;
	int k;

	printf("중간과정 출력(1/0) : ");
	scanf("%d", &k);
	scanf("%d", &t);

	for (int i = 0; i < t; i++) {
		count = 0;
		scanf("%d", &n);
		p = (int*)malloc(sizeof(int) * n);
		for (int j = 0; j < n; j++) {
			scanf("%d", &p[j]);
		}

		if (k == 1) {
			printf("시작 %d: ", count);
			print_arr(p, n);
		}

		make_even(p, n);
		if (k == 1) {
			printf("짝수 %d: ", count);
			print_arr(p, n);
		}

		while (is_equl(p, n) == 0) {
			count++;
			give_arr(p, n);
			if (k == 1) {
				printf("전달 %d: ", count);
				print_arr(p, n);
			}

			make_even(p, n);
			if (k == 1) {
				printf("짝수 %d: ", count);
				print_arr(p, n);
			}
		}
		printf("%d\n", count);

		free(p);
	}

}

01. 소수 구하기( <-> 합성수)

소수 : 1과 자기 자신 외에 약수가 없는 수

int isPrime(int n) {
	for (int i = 2; i <= n / 2; i++) 
		if (n % i == 0)
			return 0;
	return 1;
}

(Lab 5-1) 화면과 같이 2 ~ 100 까지 수 중에서 솟수(1과 자기 자신 외에 약수가 없는 수)를 모두 출력하고, 그 소수들의 합을 구하는 프로그램을 작성하시오. 솟수인지 아닌지 판단하는 함수 isPrime(int n)을 작성해서 이용할 것. isPrime(int n) 는 n이 솟수이면 1, 솟수가 아니면 0을 return 한다.

#include <stdio.h>

int isPrime(int n) {
	for (int i = 2; i <= n / 2; i++) 
		if (n % i == 0)
			return 0;
	return 1;
}

void main() {
	int i, sum = 0;
	for (i = 2; i <= 100; i++) {
		if (isPrime(i)) {
			printf("%d ", i);
			sum += i;
		}
	}
		printf("\n");
		printf("sum=%d\n", sum);
}

+범위를 입력받을경우 

• 입력받은 값이 2보다 작을 경우
  기존 함수의 경우 ~ 1 도 소수 인정하기 때문에
  if ( n < 2) return 0; 을 추가해야함
  
  
• n1 > n2일 경우
  n1과 n2의 값을 바꿔줘야 함

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>


void swap(int* a, int* b);
int isPrime(int n);

void main() {
	int i, sum = 0, n1, n2, temp;

	printf("소수를 구할 정수의 범위를 작은 수와 큰 수의 순서로 입력(예: 2 100): ");
	scanf("%d %d", &n1, &n2);

	if (n1 > n2) { // n1의 값이 n2의 값보다 클 경우
		swap(&n1, &n2);
	}


	for (i = n1; i <= n2; i++) {
		if (isPrime(i)) {
			printf("%d ", i);
			sum += i;
		}
	}
	printf("\n");
	printf("sum((%d ~ %d)의 소수 합)=%d\n", n1, n2, sum);
}

void swap(int* a, int* b) {
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

int isPrime(int n) {
	if (n < 2) return 0; // n이 2보다 작으면 소수가 아니므로 0을 반환

	for (int i = 2; i <= n / 2; i++)
		if (n % i == 0)
			return 0;
	return 1;
}

01-1.합성수 구하기  (<-> 소수)

합성수: 약수가 3개 이상인 자연수, 즉 1과 자기 자신 외에도 다른 약수를 가지는 자연수

int isComposite(int n) {
	for (int i = 2; i <= n / 2; i++) 
		if (n % i == 0)
			return 1;
	return 0;
}

02. 완전수 찾기 (+ 동적 할당 활용해보기)

완전수: 자기 자신을 제외한 약수(진 약수)의 합이 자기 자신과 같은 자연수

과정

• 1~ n/2 사이의 수 중에서 n의 약수이면 sum에 더한다
• sum == n 이면 완전수 임

• 어떤 수가 완전수인지 판단하는 것 + 완전수의 공약수 출력 
  문제: 화면과 같이 출력하려면?
              6 = 1+2+3
  ->약수들을 int divisors[]에 보관한다.

(Lab 5-2) 완전수란 어떤 정수의 약수를 모두 더했을 때 자기 자신과 같은 수를 말한다. 예를 들어 6의 약수 1, 2, 3을 더하면 6으로 정수 자신이 되는 수이다. 다음 화면과 같이 1 ~ 10,000 사이의 수 중에서 완전수를 구해서 출력하는 프로그램을 작성하시오. (화면과 같이 나와야 함)

#include <stdio.h>

#define SIZE 100

void print_array(int divisor[], int count);


void main() { 
	int i, j, sum, temp;
	int divisor[SIZE], count = 0;

	for (i = 1; i <= 10000; i++) {
		sum = 0;
		for (j = 1; j <= i / 2; j++) {
			if (i % j == 0){
				sum += j;
			}
		}
		if (i == sum) {
			for (j = 1, count = 0; j <= i / 2; j++) {
				if (i % j == 0)
					divisor[count++] = j;
			}
			printf("%d = ", i);
			print_array(divisor, count);

		}
	}
}

void print_array(int divisor[], int count) {
	for (int i = 0; i < count; i++) {
		printf("%d ", divisor[i]);
		if (i < count - 1) // 마지막을 제외하고 + 출력
			printf("+ ");
	}
	printf("\n");
}

함수로 정리

#include <stdio.h>

#define SIZE 100

int sum_properdivisor(int n);
int insert_divisor(int* divisor, int n);
void print_array(int divisor[], int count);


void main() {
	int i, j, sum, temp;
	int divisor[SIZE], count = 0;

	for (i = 1; i <= 10000; i++) {
		sum = sum_properdivisor(i);

		if (i == sum) {
			count = insert_divisor(divisor, i);
			printf("%d = ", i);
			print_array(divisor, count);

		}
	}
}
int sum_properdivisor(int n) {
	int sum = 0;
	for (int i = 1; i <= n / 2; i++) {
		if (n % i == 0) {
			sum += i;
		}
	}

	return sum;
}

int insert_divisor(int* divisor, int n) {
	int count = 0;
	for (int i = 1; i <= n / 2; i++) 
		if (n % i == 0) 
			divisor[count++] = i;

	return count;
}

void print_array(int divisor[], int count) {
	for (int i = 0; i < count; i++) {
		printf("%d ", divisor[i]);

		if (i < count - 1) // 마지막을 제외하고 + 출력
			printf("+ ");
	}
	printf("\n");
}

+범위를 입력 받는 경우

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

#define SIZE 100

void swap(int* a, int* b);
void print_array(int divisor[], int count);


void main() { 
	int i, j, sum, temp;
	int n1, n2;
	int divisor[SIZE], count = 0;

	printf("완전수를 구할 정수의 범위를 작은 수와 큰 수의 순서로 입력(예:1 10000): ");
	scanf("%d %d", &n1, &n2);
    
    if (n1 < 1 || n2 < 1) { // 값이 1미만일 경우
		return;
	}

	if (n1 > n2) { //n1의 값이 n2의 값보다 클 경우
		swap(&n1, &n2);
	}

	for (i = n1; i <= n2; i++) {
		sum = 0;
		for (j = 1; j <= i / 2; j++) {
			if (i % j == 0){
				sum += j;
			}
		}
		if (i == sum) {
			for (j = 1, count = 0; j <= i / 2; j++) {
				if (i % j == 0)
					divisor[count++] = j;
			}
			printf("%d = ", i);
			print_array(divisor, count);

		}
	}
}

void swap(int* a, int* b) {
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}


void print_array(int divisor[], int count) {
	for (int i = 0; i < count; i++) {
		printf("%d ", divisor[i]);
		if (i < count - 1) // 마지막을 제외하고 + 출력
			printf("+ ");
	}
	printf("\n");
}

함수로 정리

#include <stdio.h>

#define SIZE 100

void swap(int* a, int* b);
int sum_properdivisor(int n);
int insert_divisor(int *divisor, int n);
void print_array(int *divisor, int count);



void main() { 
	int i, j, sum;
	int n1, n2;
	int divisor[SIZE], count;

	printf("완전수를 구할 정수의 범위를 작은 수와 큰 수의 순서로 입력(예:1 10000): ");
	scanf("%d %d", &n1, &n2);

	if (n1 < 1 || n2 < 1) // 값이 1미만일 경우
		return;


	if (n1 > n2) {
		swap(&n1, &n2); //n1의 값이 n2의 값보다 클 경우
	}

	for (i = n1; i <= n2; i++) {
		sum = sum_properdivisor(i);

		if (i == sum) {
			count = insert_divisor(divisor, i);
			printf("%d = ", i);
			print_array(divisor, count);

		}
	}
}

void swap(int* a, int* b) {
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

int sum_properdivisor(int n) {
	int sum = 0;
	for (int i = 1; i <= n / 2; i++) {
		if (n % i == 0)
			sum += i;
	}
	return sum;
}

int insert_divisor(int* divisor, int n) {
	int count = 0;
	for (int i = 1; i <= n / 2; i++) {
		if (n % i == 0)
		divisor[count++] = i;
	}

	return count;
}



void print_array(int *divisor, int count) {
	for (int i = 0; i < count; i++) {
		printf("%d ", divisor[i]);
		if (i < count - 1) // 마지막을 제외하고 + 출력
			printf("+ ");
	}
	printf("\n");
}

+ 동적할당

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h> 

void print_array(int* divisor, int count);
int get_sum(int n);

void main() {
    int i, j, sum, count;
    int size = 10; // 초기 크기 설정
    int* divisor;

    divisor = (int*)malloc(size * sizeof(int)); //

    for (i = 1; i <= 10000; i++) {
        sum = get_sum(i);

        if (i == sum) {
            for (j = 1,count = 0; j <= i / 2; j++) {
                if (i % j == 0) {
                    if (count >= size) { //
                        size *= 2;
                        divisor = (int*)realloc(divisor, size * sizeof(int));
                    }
                    divisor[count++] = j;
                }
            }
            printf("%d = ", i);
            print_array(divisor, count);
        }
    }

    free(divisor);
}

int get_sum(int n) {
    int sum = 0;
    for (int i = 1; i <= n / 2; i++) {
        if (n % i == 0)
            sum += i;
    }
    return sum;
}


void print_array(int* divisor, int count) {
    for (int i = 0; i < count; i++) {
        printf("%d ", divisor[i]);
        if (i < count - 1)
            printf("+ ");
    }
    printf("\n");
}

03. e^x 근사치 계산하기

Lab 5-3) e^x 는 수학적으로 다음과 같이 기술할 수 있다.

n 값을 증가시키면서 의 근사치를 구하는 myexp(int x) 함수를 작성하시오. 의 근사값 오차 범위는 1/10,000,000 로 정하고  값을 구하시오. 즉, (n)번째 합과 (n-1)번째 합의 차이가 0.0000001 이하일 때 까지 n 값을 증가하면서 합을 구한다 (n>12~25 정도에서 끝남). 화면과 같이  ~  값을 math.h 의 exp(x) 값을 호출하여 출력하고 myexp(x) 값을 출력하여 비교하시오.

#include <stdio.h>
#include <math.h>

double myexp(int x)
{
	int i;
	double term, sum, oldsum;
	oldsum = 0.0;
	sum = 1.0;
	term = 1.0;
	for (int i = 1; (sum - oldsum) > 0.0000001; i++) { 	// (sum – oldsum) > 0.0000001 일 때 까지 i를 증가시키면서
		term *= (double)x / i;   // term =  을 구한다.
		oldsum = sum;       // oldsum = sum 으로 기억하고
		sum += term;	    // sum = sum + term 으로 누적 값을 구한다.

	}
	return sum;
}

void main()
{
	int i;
	printf("  exp() : ");
	for (i = 1; i <= 5; i++)
		printf("%lf ", exp((double)i));
	printf("\n");

	printf("myexp() : ");
	for (i = 1; i <= 5; i++)
		printf("%lf ", myexp(i));
	printf("\n");
}

04. 파일을 이용한 데이터 입/출력

2가지 방법이 있음

1. (커맨드 창)  C:\>program < input.txt > output.txt 
2. (Visual Studio) 에서 설정 방법: 속성 - 디버그 - 명령 인수 => < input.txt > output.txt

(Lab 5-4) 파일을 이용한 입/출력 처리. 두 정수를 입력받아 합과 곱을 출력하는 프로그램을 입력은 input.txt, 츨력은 output.txt 를 이용하여 처리.　(입력/출력이 1 set 인 경우)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void main() {

	int x, y;
	scanf("%d %d", &x, &y);
	printf("%d %d\n", x + y, x * y);

}

(Lab 5-5) 파일 이용 입/출력, TEST　CASE 가 T set인 경우, TEST 마다 입력 DATA는 1 set 인 경우. 

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void main()
{
	int i, n_test, x, y;
	scanf("%d", &n_test);
	for (i = 0; i < n_test ; i++) {
		scanf("%d %d", &x, &y);
		printf("%d %d\n", x + y, x * y);
	}
}

(Lab 5-6) 정수 배열을 입력받아 총점, 최대값, 최소값을 출력하는 프로그램을 작성하시오. 입력과 출력은 다음과 같다. input.txt로 T 개의 test set 이 입력으로 주어지고 각각의 test case 에는 다시 k개의 정수가 주어진다. output.txt에는 매 test 마다 한줄씩 총점, 최대값, 최소값을 출력한다.
(Hint: k개의 data를 입력받기 위해 malloc(k * sizeof(int)) 로 메모리를 할당 받고, free로 메모리를 반환하여야 함)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int find_max(int* p, int n);
int find_min(int* p, int n);

void main(){
	int n_test, n_data, sum, min, max;
	int* p = NULL;

	scanf("%d", &n_test);
	for (int i = 0; i < n_test; i++) {
		sum = 0;
		scanf("%d", &n_data);
		p = (int*)malloc(sizeof(int)* n_data);
		for (int j = 0; j < n_data; j++) {
			scanf(" %d", &p[j]);
			sum += p[j];
		}
		max = find_max(p, n_data);
		min = find_min(p, n_data);

		printf("%d %d %d\n", sum, max, min);
		free(p);
	}
}

int find_max(int* p, int n) {
	int max = p[0];
	for (int i = 1; i < n; i++) {
		if (max < p[i])
			max = p[i];
	}
	return max;
}

int find_min(int* p, int n) {
	int min = p[0];
	for (int i = 1; i < n; i++) {
		if (min > p[i])
			min = p[i];
	}
	return min;
}

(Lab 5-7) ACM 프로그래밍 대회 2014 예선문제. 호텔 객실 배정 프로그램. T 개의 입력, H, W, N 입력 (H: Hotel의 층수, W: 층당 객실수, N 번째 도착한 손님). 출력은 각 입력에 해당되는 방 번호.(별지참조)

(방법 1)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main() {
	int T, H, W, N;
	int x, y;

	scanf("%d", &T);
	for (int i = 0; i < T; i++) {
		scanf("%d %d %d", &H, &W, &N);

		if (W * H <= N) {
			printf("수용 인원을 넘어섰습니다. \n");
			continue;
		}

		y = N % H;
		x = (N / H) + 1;

		if (y == 0) {
			y = H;   
			x = N / H;
		}

		printf("%d%02d\n", y, x);

	}

}

(방법 2)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int main() {
int T, H, W, N;
int** p = NULL;
int y, x;

scanf("%d", &T);
for (int i = 0; i < T; i++) {
scanf("%d %d %d", &H, &W, &N);


p = (int**)malloc(sizeof(int*) * H);
for (int j = 0; j < H; j++) {
p[j] = (int*)malloc(sizeof(int) * W);
}


for (int j = 0; j < H; j++) {
for (int k = 0; k < W; k++) 
p[j][k] = (j + 1) * 100 + (k + 1);
}


y = (N - 1) % H;
x = (N - 1) / H;

printf("%d\n", p[y][x]);


for (int j = 0; j < H; j++) {
free(p[j]);
}
free(p);
}
}

01. 다음과 같이 배열 arr[10]에 데이터가 있다. print_array(), compute_avg(), find_max(), find_min() 함수는 각각 배열을 출력, 평균값을 계산해서 return, 배열의 최대값과 최소값을 구해서 return 하는 함수들이다. 함수들을 완성하여 화면과 같이 출력되도록 하시오. 

#include <stdio.h>


void print_array(int arr[], int n) {
	for (int i = 0; i < n; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n");
}

double compute_avg(int arr[], int n) {
	int sum = 0;
	for (int i = 0; i < n; i++) {
		sum += arr[i];
	}
	return (double)sum / n;
}

int find_max(int arr[], int n) {
	int max = arr[0];
	for (int i = 1; i < n; i++) {
		if (max < arr[i])
			max = arr[i];
	}
	return max;
}

int find_min(int arr[], int n) {
	int min = arr[0];
	for (int i = 1; i < n; i++) {
		if (min > arr[i])
			min = arr[i];
	}
	return min;
}

void main() {
	int arr[10] = { 10, 30, 5, 20, 44, 3, 100, 88, 9, 101 };

	print_array(arr, 10);
	printf("평균 = %lf\n", compute_avg(arr, 10));
	printf("최대 = %d\n", find_max(arr, 10));
	printf("최소 = %d\n", find_min(arr, 10));
}

02. 프로그램에서처럼 구조체를 선언하여 N개의 점들의 좌표가 주어졌다. 그 점들을 둘러싸는 최소 크기의 사각형의 두 점 좌표 P1, P2를 구하고 사각형의 면적을 구하는 프로그램을 완성하시오.
(주의1) print_point() 함수는 좌표를 출력하는 함수이다. 화면과 main()에서 호출하는 형식을 참조할 것.
(주의2) main() 부분은 주어진 변수만을 이용하여 프로그램 할 것. (변수 추가하지 말 것)

#include <stdio.h>


#define N 4
#define ABS(x)    (((x)>0)?(x): -(x))   
struct Point {
    int   x;
    int   y;
};
void print_point(struct Point *p)
{
    printf("(%d, %d)", (*p).x, p->y);
}
void main()
{
    struct  Point p[N] = { {1,2}, {6, 1}, {3,4}, {4,5} };
    struct Point P1, P2;
    int area; // 면적
    int i;

    for (i = 0; i < N; i++) {
        printf("p[%d] =", i);
        print_point(&p[i]);
        printf("\n");
    }
    
    P1.x = p[0].x;
    P1.y = p[0].y;
    P2.x = p[0].x;
    P2.y = p[0].y;
    for (int i = 1; i < N; i++) {
        if (P1.x > p[i].x)
            P1.x = p[i].x;
        else if (P2.x < p[i].x)
            P2.x = p[i].x;

        if (P1.y > p[i].y)
            P1.y = p[i].y;
        else if (P2.y < p[i].y)
            P2.y = p[i].y;
    }

    printf("P1="); print_point(&P1); 
    printf(" P2="); print_point(&P2);

    area = (P2.x - P1.x) * (P2.y - P1.y);
    printf("  면적=%d\n", area);
}

01. 2차원 배열(2DNum)에 정수가 저장되어 있다고 가정한다. 우리가 가지고 있는 단 하나의 함수는 1차원 배열에 저장된 정수의 합을 구하는 int get_1Dsum(int array[], int size)라고 가정하자. 2차원 배열의 각 행에 대하여 get_1Dsum()을 호출하여 각 행의 합을 구한 후에, 이것들을 모두 합쳐서 전체 2차원 배열에 저장된 정수들의 합을 구하는 프로그램을 작성하시오. 2DNum 배열은 5x10 크기이며, 아래와 같이 정수가 저장되어 있다.

#include <stdio.h>
#define ROWS 5
#define COLS 10


int get_1Dsum(int array[], int size) {
	int sum = 0;
	for (int i = 0; i < size; i++) {
		sum += array[i];
	}
	return sum;
}

int main() {
	int _2DNum[][COLS] = {
	{10,21,32,43,54,65,76,87,98,109},
	{20,31,42,53,64,75,86,97,108,119},
	{30,41,52,63,74,85,96,107,118,129},
	{40,51,62,73,84,95,106,117,128,139},
	{50,61,72,83,94,105,116,127,138,149}
	};
	int sum_1D[ROWS], sum = 0;

	for (int i = 0; i < ROWS; i++) 
		sum_1D[i] = get_1Dsum(_2DNum[i], COLS); // _2DNum[i]: i번째 열의 배열

	for (int i = 0; i < ROWS; i++)
		sum += sum_1D[i];

	printf("%d", sum);
}

02. 문자열의 배열을 인수로 받아서 아래와 같이 저장된 3개 문자열들(msgString)을 전부 출력하는 pr_str_array() 함수를 작성하여 프로그램을 완성하시오, pr_str_array 함수는 void pr_str_array(char **dp); 원형을 지닌다고 가정한다.
A bad shearer never had a good sickle.
A bad workman (always) balmes his tools.
A bad thing never dies.

#include <stdio.h>

void pr_str_array(char** dp);


int main() {
	char* msgString[] = {
		{"A bad shearer never had a good sickle."},
		{"A bad workman (always) balmes his tools."},
		{"A bad thing never dies."} };
	pr_str_array(msgString);
}


void pr_str_array(char** dp) {
	for (int i = 0; i < 3; i++) {
		printf("%s\n", dp[i]); // *(dp+i)도 가능;
	}
}