기록

#include <stdio.h>
int n;
void f(int k)
{
   for (int i=1;i<=n-k;i++)
      printf (" ");
   for (int j=1;j<=k;j++)
      printf ("*");
   printf ("\n"); 
}
int main()
{
   scanf ("%d",&n);
   for (int i=1;i<=n;i++)
      f(i);
}

#include<stdio.h>

int plus(int a, int b){
	return a+b;
}
int minus(int a, int b){
	return a-b;
}
int mu(int a, int b){
	return a*b;
}
int di(int a, int b){
	return a/b;
}

int main()
{
	
	while(1){
		int a = 0;
		int b = 0;
		char c;
		printf("종료를 원하신다면 0 + 0 를 입력해주세요\n");
		printf("숫자를 입력하세요 : ");
		scanf("%d %c %d", &a, &c, &b);
		printf("결과를 출력합니다 : ");
		
		switch(c){
			case '+': 
				printf("%d %c %d = %d\n\n",a, c, b, plus(a,b)); break;
			case '-': 
				printf("%d %c %d = %d\n\n",a, c, b, minus(a,b)); break;
			case '*': 
				printf("%d %c %d = %d\n\n",a, c, b, mu(a,b)); break;
			case '/': 
				printf("%d %c %d = %d\n\n",a, c, b, di(a,b)); break; 
			default :
				printf("다시 입력하세요 :"); break;
		}
		if(a==0 && c == '+' && b==0){
			printf("계산기를 종료합니다."); 
			break;
		}
	}
}

먼저 연산자들을 함수로 선언해놨습니다.

그런 후에 switch-case문으로 경우를 나눠놨고, while문을 이용하여 계속 계산을 진행할 수 있게 해 두었습니다!

그리고 if문을 사용해 프로그램을 종료시켰습니다. 

scanf("%d", n);

%d뒤에 띄어쓰기 있으면 무한루프에 빠져서 절대 못나옵니다ㅠ 

(저는 이거 발견하는데 몇시간 걸렸습니다ㅠㅠ 처음에는 다 그런 거겠죠ㅜㅜ?)

#include<stdio.h>
struct point {float x; float y;};
point f(point p, point q)
{
	point t;
	t.x = (p.x + q.x)/2;
	t.y = (p.y + q.y)/2;
	
	return t;
}

int main(){
	point a,b,t;
	scanf("%f %f", &a.x, &a.y);
	scanf("%f %f", &b.x, &b.y);
	
	t = f(a,b);
	
	printf("%.3f %.3f\n", t.x, t.y);
}

/*
3.1 1.4
4.1 1.5
3.600 1.450

--------------------------------
Process exited after 10.97 seconds with return value 0
계속하려면 아무 키나 누르십시오 . . .
*/

/*
08/20 BFS(너비 우선 탐색)
큐의 순서대로 나타냄
*/
#include <stdio.h>

int n; // 정점의 최댓값 
int rear, front; // 앞쪽의 뒤쪽을 나타내는 변수 
int map[30][30]; // 인접 행렬 
int queue[30]; // 큐 
int visit[30]; // 방문 여부를 나타내는 배열 

void BFS(int v){
	int i;
	
	visit[v] = 1; // 정점 v를 방문했다고 표시  
	printf("%d에서 시작\n", v);
	queue[rear++] = v; // 큐에 v를 삽입하고 뒤쪽을 1 증가시킴 
	while (front < rear){ //뒤쪽이 앞쪽과 같거나 작으면 루프 탈출
	// 큐의 첫번째에 있는 데이터를 제외하고 제외된 값을 가져오며, 앞쪽 1증가  
		v = queue[front++];
		for (i = 1; i<=n; i++){
			// 정점 v와 정점 i가 만나고, 정점 i를 방분하지 않은 상태일 경우
			if (map[v][i] == 1 && !visit[i]){
				visit[i] = 1; // 정점 i를 방문했다고 표시 
				printf("%d 에서 %d로 이동 \n", v,i);
				queue[rear++] = i; //큐에 i를 삽입하고 후단을 1증가시킴  
			}  
		}
	}
}
int main(){
	int start;// 시작 정점
	int v1,v2;
	
	printf("정점의 총 개수와 시작 정점을 입력하세요. :");
	scanf("%d %d", &n, &start);
	
	while(1){
		printf("연결한 두 정점을 입력하세요. (예 3 4): ");
		scanf("%d %d", &v1, &v2);
		if(v1==-1 && v2==-1) break;
		map[v1][v2] = map[v2][v1] = 1;
	} 
	BFS(start); //DFS 시작! 
	
	return 0;
}
/*
정점의 총 개수와 시작 정점을 입력하세요. :7 0
연결한 두 정점을 입력하세요. (예 3 4): 0 1
연결한 두 정점을 입력하세요. (예 3 4): 0 2
연결한 두 정점을 입력하세요. (예 3 4): 1 3
연결한 두 정점을 입력하세요. (예 3 4): 1 4
연결한 두 정점을 입력하세요. (예 3 4): 2 5
연결한 두 정점을 입력하세요. (예 3 4): 2 6
연결한 두 정점을 입력하세요. (예 3 4): 3 7
연결한 두 정점을 입력하세요. (예 3 4): 4 7
연결한 두 정점을 입력하세요. (예 3 4): 5 7
연결한 두 정점을 입력하세요. (예 3 4): 6 7
연결한 두 정점을 입력하세요. (예 3 4): -1 -1
0에서 시작
0 에서 1로 이동
0 에서 2로 이동
1 에서 3로 이동
1 에서 4로 이동
2 에서 5로 이동
2 에서 6로 이동
3 에서 7로 이동

--------------------------------
Process exited after 70.57 seconds with return value 0
계속하려면 아무 키나 누르십시오 . . .
*/

#include <stdio.h>

int n;

void f(int k)
{
    int i, j;       
    for (i = 0; i < n; i++)        
    {
        for (j = 0; j < n-i; j++)  
        {
            printf(" ");
        }
        for (k = 0; k <=i; k++){
        	 printf("*");
		}      
        printf("\n");     
    }                  
}

int main()
{
	scanf("%d", &n);
	int i;
	for (i = 0; i < n; i++)        
    {
    	f(i);
    	break;
	}
}

/*
08/16 DFS
*/
#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTICES 8 // 노드의 최고 개수  
#define FALSE 0 // 매크로 상수 선언  
#define TRUE 1
typedef struct node *node_point; // 임시그래프  
typedef struct node //노드 정의  
{
	int vertex;
	node_point link;
};
node_point graph[MAX_VERTICES]; 
short int visited[MAX_VERTICES]; // 무방향임  
node_point createnode (int data);
void dfs (int vertex); // 함수 선언  
int main( )
{
	/*
	정점?우선순위는 작은 숫자부터  
	*/
	graph[0] = createnode(1); //정점과 연결  
	/* [0] = 정점을 의미 */
	graph[0] -> link = createnode(2); // 정점 1번과 2번 연결  
	graph[1] = createnode(0);
	graph[1] -> link = createnode(3);
	graph[1] -> link->link = createnode(4);
	graph[2] = createnode(0);
	graph[2] -> link = createnode(5);
	graph[2] -> link->link = createnode(6);
	graph[3] = createnode(1);
	graph[3] -> link = createnode(7); graph[4]=createnode(1);
	graph[4] -> link = createnode(7);
	graph[5] = createnode(2);
	graph[5] -> link = createnode(7);
	graph[6] = createnode(2);
	graph[6] -> link = createnode(7);
	graph[7] = createnode(3);
	graph[7] -> link = createnode(4);
	graph[7] -> link -> link = createnode(5);
	graph[7] -> link->link->link = createnode(6);
	printf(" : "); // 정점의 운행 순서 
	dfs (0); //dfs함수 호출  
	printf(" \n"); // 끝  
}

/*  노드 생성을 위한 함수 */
node_point createnode(int data)
{
	node_point ptr; // ptr는 공간  
	ptr = (node_point)malloc(sizeof(struct node)); // 메모리 확보  
	ptr -> vertex = data; // 공간에 data입력  
	ptr -> link = NULL;  
	return ptr;
}

void dfs(int v)
{
	/* v = 그래프의 정점에서 시작하는 깊이 우선 탐색 */
	node_point w;
	visited[v] = TRUE;
	printf("V%d -> ", v);
	for(w = graph[v]; w; w = w -> link) // 링크를 따라가는 반복문  
	// false(NULL)가 될때까지 w는 w링크로 따라감  
		if(!visited[w->vertex])
	dfs(w->vertex); //방문하지 않았다면 dfs호출하여 vertex로 돌아감  
}

/*
 : V0 -> V1 -> V3 -> V7 -> V4 -> V5 -> V2 -> V6 ->

--------------------------------
Process exited after 0.01584 seconds with return value 0
계속하려면 아무 키나 누르십시오 . . .
*/

(1) 깊이 우선 탐색 (DFS)

/*
08/12 그래프 탐색 
*/
#include<stdio.h>

int n; //정점의 총 개수 
int map[30][30]; // 인접행렬 
int visit[30]; //방문 여부를 나타내는 행렬 

void DFS(int v){  
	int i;
	
	visit[v] = 1; // 정점 v를 방문했다고 표시 
	for(i=1; i <= n; i++){
		// 정점 v와 정점 i가 연결 되었고, 정점 i를 방문하지 않는다면  
		if(map[v][i]==1 && !visit[i]){
			printf("%d에서 %d로 이동 \n",v,i);
			DFS(i); // 이동된 정점 i에서 다시 탐색 시작 
		}
	}
}

int main(){
	int start;// 시작 정점
	int v1,v2;
	
	printf("정점의 총 개수와 시작 정점을 입력하세요. :");
	scanf("%d %d", &n, &start);
	
	while(1){
		printf("연결한 두 정점을 입력하세요. (예 3 4): ");
		scanf("%d %d", &v1, &v2);
		if(v1==-1 && v2==-1) break;
		map[v1][v2] = map[v2][v1] = 1;
	} 
	DFS(start); //DFS 시작! 
	
	return 0;	
}

#include<stdio.h>
struct point
{
	int x;
	int y;
};

int main()
{
	point p1, p2;
	int d=0;
	
	scanf("%d %d", &p1.x, &p1.y);
	scanf("%d %d", &p2.x, &p2.y);
	
	d+=(p1.x>p2.x)?(p1.x-p2.x):(p2.x-p1.x);
	d+=(p1.y>p2.y)?(p1.y-p2.y):(p2.y-p1.y);
	
	printf("%d\n", d);
}
/*
1 2
3 5
5

--------------------------------
Process exited after 21.98 seconds with return value 0
계속하려면 아무 키나 누르십시오 . . .
*/

#include<stdio.h>
struct stu
{
	int num;
	char name[20];
	int score;
};

int main()
{
	stu p1, p2;
	
	scanf("%d %s %d", &p1.num, p1.name, p1.score);
	scanf("%d %s %d", &p2.num, p2.name, p2.score);
	
	if(p1.score >= p2.score)
		printf("%d %s %d", &p1.num, p1.name, &p1.score);
	if(p1.score <= p2.score)
		printf("%d %s %d\n", &p2.num, p2.name, &p2.score);
	
}

//이진 트리 탐색  
#include<stdio.h>
#include<stdlib.h>

typedef struct Node
{
	Node* Left;
	Node* Right;
	int Data;
} Node;

Node* createNode(int data)
{
	Node* newNode = (Node*)malloc(sizeof(Node));
	newNode->Left = NULL;
	newNode->Right = NULL;
	newNode->Data = data;
	
	return newNode;
}

Node* searchNode(Node* Tree, int findData)
{
	if (Tree == NULL) return NULL;
	if (Tree->Data == findData)
		return Tree;
	else if(Tree->Data > findData)
		searchNode(Tree->Left, findData);
	else
		searchNode(Tree->Right, findData);
}

void insertNode(Node* Tree, Node* newNode)
{
	if(newNode->Data > Tree->Data)
	{
		if (Tree->Right != NULL) insertNode(Tree->Right, newNode);
		else Tree->Right = newNode;
	}
	else if(newNode->Data < Tree->Data)
	{
		if (Tree->Left != NULL)insertNode(Tree->Left, newNode);
		else Tree->Left =  newNode;
	}	
}

Node* findMinNode(Node* Tree)
{
	if(Tree==NULL) return NULL;
	if(Tree->Left !=NULL) return findMinNode(Tree->Left);
	else return Tree;
}

Node* removeNode(Node* Tree, int data)
{
	Node* tempNode;
	if(Tree==NULL) printf("해당하는 노드를 찾을 수 없습니다.\n");
	else if(Tree->Data > data) Tree->Left = removeNode(Tree->Left, data);
	else if(Tree->Data < data) Tree->Right = removeNode(Tree->Right, data);
	else
	{
		if(Tree->Left !=NULL && Tree->Right !=NULL)
		{
			tempNode = findMinNode(Tree->Right);
			Tree->Data = tempNode->Data;
			
			Tree->Right = removeNode(Tree->Right, tempNode->Data);
		}
		else 
		{
			tempNode = Tree;
			if (Tree->Left == NULL) Tree = Tree->Right;
			else if (Tree->Right == NULL) Tree = Tree->Left;
			free(tempNode);
		}
	}
	return Tree;
}

void printTree(Node* Tree)
{
	if(Tree == NULL) return;
	printTree(Tree->Left);
	printf("%d ", Tree->Data);
	printTree(Tree->Right);
}

int main()
{
	Node* Tree = createNode(8);
	Node* findNode;
	int input;
	
	insertNode(Tree, createNode(3));
	insertNode(Tree, createNode(2));
	insertNode(Tree, createNode(5));
	insertNode(Tree, createNode(10));
	insertNode(Tree, createNode(14));
	insertNode(Tree, createNode(11));
	insertNode(Tree, createNode(16));
	
	while(1)
	{
		scanf("%d", &input);
		findNode = searchNode(Tree, input);
		
		if(findNode != NULL)
		{
			printf("해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 %#x 입니다.\n ", findNode);
			removeNode(Tree, input);
			{
				printf("현재 트리 출력 :");
				printTree(Tree); printf("\n"); 	
			}
		}
		else printf("노드를 찾을 수 없습니다. \n");
	}
	return 0;
}
/*
10
해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 0x151410 입니다.
 현재 트리 출력 :1 5 6 14 17 21
1
해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 0x151450 입니다.
 현재 트리 출력 :5 6 14 17 21
5
해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 0x151430 입니다.
 현재 트리 출력 :6 14 17 21
14
해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 0x151410 입니다.
 현재 트리 출력 :6 17 21
17
해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 0x151410 입니다.
 현재 트리 출력 :6 21
21
해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 0x151410 입니다.
 현재 트리 출력 :6
--------------------------------
Process exited after 14.78 seconds with return value 3221225725
계속하려면 아무 키나 누르십시오 . . .
*/