C Language

Step by step

My diary

...

Search
breakinformation. Powered by Blogger.

2018년 11월 28일 수요일

string compare

  11월 28, 2018    

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
#include <stdio.h>
#include <stdlib.h>
 
int String_Compare (const char* _First_String_, const char* _Second_String_);
 
int main (void) {
    
    char* _String[2] = { _String[0] = "apple", _String[1] = "apple"};
    
    printf ("%d\n", strcmp (_String[0], _String[1]));
    printf ("%d\n", String_Compare (_String[0], _String[1]));
    
    return 0;
}
 
int String_Compare (const char* _First_String_, const char* _Second_String_) {
    
    int result = 0;
    while (!(result = *(unsigned char*) _First_String_ - *(unsigned char*) _Second_String_) && *_Second_String_)
        ++_First_String_, ++_Second_String_;
        
    if (result < 0) return -1;
    else if (result > 0) return 1;
    return 0;
}
cs

  No Comments

realloc

  11월 28, 2018    

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#include <stdio.h>
#include <stdlib.h>
 
char** Create_Array(int horizon, int vertical);
void Delete_Array(char** _Array, int vertical);
int Optimize_Vertical_Size(char*** _Array, int vertical);
 
void Display_Array(char** _Array);
int Input_Array(char** _Array, int vertical);
 
void bubble_sort(char** array, int size);
void swapping(char** current, char** next);
 
int main(void) {
 
    int horizon = 30, vertical = 10;
    char** _Array = (char**)Create_Array(horizon, vertical); // Dynamic memory allocation
 
    int Number_Of_Input = Input_Array(_Array, vertical);
    if (Number_Of_Input < 0) return -1;
 
    bubble_sort(_Array, Number_Of_Input);
    Display_Array(_Array);
 
    Delete_Array(_Array, Number_Of_Input + 1); // free memory
 
    return 0;
}
 
void bubble_sort(char** array, int size) {
 
    int allElement = 0, partialElement = 0;
 
    for (allElement = 0; allElement < size; allElement++) {
        for (partialElement = 0; partialElement < size - 1; partialElement++) {
            if (strcmp(*(array + partialElement), *(array + partialElement + 1)) > 0) {
 
                swapping(&(*(array + partialElement)), &(*(array + partialElement + 1)));
            }
        }
        partialElement++;
    }
 
    return;
}
void swapping(char** current, char** next) {
 
    char* temporary = (char)0;
 
    temporary = *current;
    *current = *next;
    *next = temporary;
 
    return;
}
 
 
int Input_Array(char** _Array, int vertical) {
 
    if (_Array == (char)0) {
 
        printf("Error! The array is null. Input_Array()\n");
        return -1;
    }
 
    int index = 0;
    for (index = 0; index < vertical; index++) {
 
        scanf("%s", *(_Array + index));
        getchar();
        if (*(*(_Array + index) + 0) == '0') break;
    }
 
    if (index == vertical) return index;
 
    *(*(_Array + index) + 0) = (char)0;
    int result = Optimize_Vertical_Size(&_Array, index);
    if (result < 0) return -2;
 
    return index;
}
 
void Display_Array(char** _Array) {
 
    int index = 0;
    for (index = 0; *(*(_Array + index) + 0) != (char)0; index++) {
 
        printf("%s\n", *(_Array + index));
    }
 
    return;
}
 
void Delete_Array(char** _Array, int vertical) {
 
    int index = 0;
    for (index = 0; index < vertical; index++) {
 
        free(*(_Array + index));
    }
    free(_Array);
 
    return;
}
 
int Optimize_Vertical_Size(char*** _Array, int vertical) {
 
    if (*_Array == (char)0) {
 
        printf("Error! The array is null. Optimize_Vertical_Size()\n");
        return -1;
    }
 
    *_Array = (char**)realloc(*_Array, (vertical + 1) * sizeof(char*));
    if (_Array == (char)0) {
 
        printf("Error! Dynamic memory allocation. Optimize_Vertical_Size()\n");
        return -2;
    }
 
    return 1;
}
 
char** Create_Array(int horizon, int vertical) {
 
    if (horizon < 1 || vertical < 1) {
 
        printf("Error! Input zero or more. Create_Array()\n");
        return (char)0;
    }
 
    vertical++;
    char** Return_Array = (char**)calloc(vertical, sizeof(char*));
    if (Return_Array == (char)0) {
 
        printf("Error! Dynamic memory allocation(1). Create_Array()\n");
        return (char)0;
    }
 
    int index = 0;
    for (index = 0; index < vertical; index++) {
 
        *(Return_Array + index) = (char*)calloc(horizon, sizeof(char));
        if (*(Return_Array + index) == NULL) {
 
            printf("Error! Dynamic memory allocation(2). Create_Array()\n");
            return (char)0;
        }
    }
 
    return (char**)Return_Array;
}
cs

  No Comments

2018년 11월 27일 화요일

testing structure

  11월 27, 2018    

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
#include <stdio.h>
#include <stdlib.h>
#define NUMBER_OF_CLASS 2
 
struct Student {
    
    char name[20];
    int korean;
    int english;
    int math;
};
 
void input (struct Student* _Class[], int Number_Of_Class);
void _input (struct Student* __Class);
void __input (struct Student ___Class);
 
void Display_Class (struct Student* _Class[], int Number_Of_Class, int Number_Of_Student);
 
int main(void) {
    
    struct Student* _Class[NUMBER_OF_CLASS] = { 0, };
    int Maximum_Number_Of_Student = 50;
    
    // Dynamic memory allocation
    int index = 0;
    for (index = 0; index < NUMBER_OF_CLASS; index++) {
        
        _Class[index] = (struct Student*) calloc (Maximum_Number_Of_Student, sizeof (struct Student));
        if ((struct Student*)_Class[index] == (char) 0) {
            
            printf ("Error! Dynamic memory allocation, main()\n");
            return -1;
        }
    }
    
    //print
    Display_Class (_Class, NUMBER_OF_CLASS, Maximum_Number_Of_Student);
    
    input ((struct Student**) _Class, NUMBER_OF_CLASS); // class, student
    //_input ((struct Student*)* _Class); // student
    //__input(** _Class); // value
    
    //print
    Display_Class (_Class, NUMBER_OF_CLASS, Maximum_Number_Of_Student);
    
    // free ()
    for (index = 0; index < NUMBER_OF_CLASS; index++) {
        
        if ((struct Student*) _Class[index] != (char) 0) _Class[index] = (char) 0;
        free ((struct Student*) _Class[index]);
    }
    
    return 0;
}
 
void Display_Class (struct Student* _Class[], int Number_Of_Class, int Number_Of_Student) {
    
    int _class = 0, student = 0;
    for (_class = 0; _class < NUMBER_OF_CLASS; _class++) {
        for (student = 0; student < Number_Of_Student; student++) {
            
            printf ("<< [%2d] Class >> [%2d]", _class + 1, student + 1);
            printf ("%s %d %d %d\n",(*(*(_Class + _class) + student)).name,
                                    (*(*(_Class + _class) + student)).korean,
                                    (*(*(_Class + _class) + student)).english,
                                    (*(*(_Class + _class) + student)).math);
        }
        printf ("\n");
    }
}
 
void input (struct Student* _Class[], int Number_Of_Class) { // Call by adress or call by reference, call by value
    
    int Number_Of_Student = 3;
    int _class = 0, student = 0;
    for (_class = 0; _class < NUMBER_OF_CLASS; _class++) {
        for (student = 0; student < Number_Of_Student; student++) {
            
            printf (">> [%2d] Class << [%2d]", _class + 1, student + 1);
            (char*) gets ((char*) (*(*(_Class + _class) + student)).name);
        }
        printf("\n");
    }
    printf ("=============\n\n");
    
    return;
}
void _input (struct Student* __Class) { // call by adress or call by reference, call by value
    
    int Number_Of_Student = 3;
    int student = 0;
    for (student = 0; student < Number_Of_Student; student++) {
        
        printf (">> [%2d] Class << [%2d]", 1, student + 1);
        (char*) gets ((char*) (*(__Class + student)).name);
    }
    printf("\n");
    
    return;
}
 
void __input (struct Student ___Class) { // call by value
    
    int Number_Of_Student = 1;
    
    printf (">> [%2d] Class << [%2d]", 1, 1);
    (char*) gets ((char*) ___Class.name);
    printf("\n");
    
    return;
}
cs

  No Comments

2018년 11월 25일 일요일

array stack

  11월 25, 2018    

"arraystack.h"
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
#ifndef _ARRAY_STACK_
#define _ARRAY_STACK_
 
typedef struct Array_Stack_Node_Type {
 
    char data;
    int _Number;
} Array_Stack_Node;
 
typedef struct Array_Stack_Type {
 
    int Maximum_Element_Count;
    int Current_Element_Count;
    Array_Stack_Node* Pointer_Element;
} Array_Stack;
 
Array_Stack* Create_Array_Stack(int Maximum_Element_Count);
int Push_Array_Stack(Array_Stack* Pointer_Stack, Array_Stack_Node element);
Array_Stack_Node* Pop_Array_Stack(Array_Stack* Pointer_Stack);
Array_Stack_Node* Peek_Array_Stack(Array_Stack* Pointer_Stack);
void Delete_Array_Stack(Array_Stack* Pointer_Stack);
int Is_Array_Stack_Full(Array_Stack* Pointer_Stack);
int Is_Array_Stack_Empty(Array_Stack* Pointer_Stack);
 
#endif // !_ARRAY_STACK_
 
#ifndef _COMMON_STACK_DEFAULT
#define _COMMON_STACK_DEFAULT
 
#define TRUE    1
#define FALSE    0
 
#endif // !_COMMON_STACK_DEFAULT
cs
"display.h"
1
2
3
4
5
6
7
8
#ifndef _DISPLAY_
#define _DISPLAY_
 
#include "arraystack.h"
 
void Display_Array_Stack(Array_Stack* Pointer_Stack);
 
#endif // !_DISPLAY_
cs
"arraystack.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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "arraystack.h"
 
Array_Stack* Create_Array_Stack(int size) {
 
    if (size < 0) {
 
        printf("Error! Underflow. Create_Array_Stack()\n");
        return NULL;
    }
 
    Array_Stack* Pointer_Return = (Array_Stack*)malloc(1 * sizeof(Array_Stack));
    if ((Array_Stack*) Pointer_Return == NULL) {
 
        printf("Error! Dynamic memory allocation (1), Create_Array_Stack()\n");
        return NULL;
    }
    (void*)memset((Array_Stack*)Pointer_Return, 0, sizeof(Array_Stack));
    (Array_Stack*)Pointer_Return->Maximum_Element_Count = size;
 
    (Array_Stack*)Pointer_Return->Pointer_Element = (Array_Stack_Node*)malloc(size * sizeof(Array_Stack_Node));
    if ((Array_Stack*)Pointer_Return->Pointer_Element == NULL) {
 
        printf("Error! Dynamic memory allocation (2), Create_Array_Stack()\n");
        free((Array_Stack*)Pointer_Return);
        return NULL;
    }
    (void*)memset((Array_Stack*)Pointer_Return->Pointer_Element, 0, size * sizeof(Array_Stack_Node));
 
    return (Array_Stack*)Pointer_Return;
}
 
int Push_Array_Stack(Array_Stack* Pointer_Stack, Array_Stack_Node element) {
 
    if ((Array_Stack*)Pointer_Stack == NULL) {
 
        printf("Error! The array is null. Push_Array_Stack()\n");
        return FALSE;
    }
    else if (Is_Array_Stack_Full((Array_Stack*)Pointer_Stack) != FALSE) {
 
        printf("Error! Overflow, Push_Array_Stack()\n");
        return FALSE;
    }
 
    *(Pointer_Stack->Pointer_Element + (int)Pointer_Stack->Current_Element_Count) = element;
    (Array_Stack*)Pointer_Stack->Current_Element_Count++;
 
    return TRUE;
}
 
Array_Stack_Node* Pop_Array_Stack(Array_Stack* Pointer_Stack) {
 
    if ((Array_Stack*)Pointer_Stack == NULL) {
 
        printf("Error! The array is null. Pop_Array_Stack()\n");
        return FALSE;
    }
    else if (Is_Array_Stack_Empty((Array_Stack*)Pointer_Stack) != FALSE) {
 
        printf("Error! Underflow, Pop_Array_Stack()\n");
        return FALSE;
    }
 
    Array_Stack_Node* Pointer_Return = (Array_Stack_Node*)malloc(1 * sizeof(Array_Stack_Node)); // Dynamic memory allocation
    if (Pointer_Return == NULL) {
 
        printf("Error! Dynamic memory allocation, Pop_Array_Stack()\n");
        return FALSE;
    }
 
    *(Array_Stack_Node*)Pointer_Return = *(Array_Stack_Node*)(Pointer_Stack->Pointer_Element + (int)Pointer_Stack->Current_Element_Count - 1);
    (Array_Stack*)Pointer_Stack->Current_Element_Count--;
 
    return (Array_Stack_Node*)Pointer_Return;
}
 
Array_Stack_Node* Peek_Array_Stack(Array_Stack* Pointer_Stack) {
 
    if ((Array_Stack*)Pointer_Stack == NULL) {
 
        printf("Error! The array is null. Peek_Array_Stack()");
        return NULL;
    }
    else if (Is_Array_Stack_Empty((Array_Stack*)Pointer_Stack) != FALSE) {
 
        printf("Error! Underflow, Peek_Array_Stack()\n");
        return NULL;
    }
 
    Array_Stack_Node* Pointer_Return = NULL; // non dynamic memory allocation
    Pointer_Return = &(*(Array_Stack*)(Pointer_Stack->Pointer_Element + (int)Pointer_Stack->Current_Element_Count - 1));
    //*(Array_Stack_Node*)Pointer_Return = *(Array_Stack_Node*)(Pointer_Stack->Pointer_Element + (int)Pointer_Stack->Current_Element_Count - 1); // run time error
 
    return (Array_Stack_Node*)Pointer_Return;
}
 
void Delete_Array_Stack(Array_Stack* Pointer_Stack) {
 
    if ((Array_Stack*)Pointer_Stack == NULL) {
 
        printf("Error! The array is null. Delete_Array_Stack()\n");
        return;
    }
 
    if ((Array_Stack*)Pointer_Stack->Pointer_Element != NULL) {
 
        free((Array_Stack*)Pointer_Stack->Pointer_Element);
    }
    free((Array_Stack*)Pointer_Stack);
 
    return;
}
 
int Is_Array_Stack_Full(Array_Stack* Pointer_Stack) {
 
    if ((Array_Stack*)Pointer_Stack == NULL) {
 
        printf("Error! The array is null. Is_Array_Stack_Full()\n");
        return FALSE;
    }
 
    if ((Array_Stack*)Pointer_Stack->Current_Element_Count == (Array_Stack*)Pointer_Stack->Maximum_Element_Count) {
 
        return TRUE;
    }
 
    return FALSE;
}
 
int Is_Array_Stack_Empty(Array_Stack* Pointer_Stack) {
 
    if ((Array_Stack*)Pointer_Stack == NULL) {
 
        printf("Error! The array is null. Is_Array_Stack_Empty()\n");
        return FALSE;
    }
 
    if ((Array_Stack*)Pointer_Stack->Current_Element_Count == 0) {
 
        return TRUE;
    }
 
    return FALSE;
}
cs
"display.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
#include <stdio.h>
#include "display.h"
 
void Display_Array_Stack(Array_Stack* Pointer_Stack) {
 
    if ((Array_Stack*)Pointer_Stack == NULL) {
 
        printf("Error! The array is null. Display_Array_Stack()\n");
        return;
    }
    printf("Stack size : %d, Number of current node : %d\n",
        (Array_Stack*)Pointer_Stack->Maximum_Element_Count,
        (Array_Stack*)Pointer_Stack->Current_Element_Count);
 
    int size = (Array_Stack*)Pointer_Stack->Maximum_Element_Count,
        top = (Array_Stack*)Pointer_Stack->Current_Element_Count;
 
    int loop = 0;
    for (loop = size - 1; loop > top - 1; loop--) {
 
        printf("[%d]-[Empty]\n", loop);
    }
 
    int index = 0;
    for (index = top - 1; index > 0 - 1; index--) {
 
        printf("[%d]-[%c][%d]\n", index, (Array_Stack*)Pointer_Stack->Pointer_Element[index].data, (Array_Stack*)(*(Pointer_Stack->Pointer_Element + index))._Number);
    }
 
    return;
}
cs
"main.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
44
45
46
47
48
49
50
51
52
53
#include <stdio.h>
#include <stdlib.h>
#include "arraystack.h"
#include "display.h"
 
int main(int argc, char* argv[]) {
 
    Array_Stack* Pointer_Stack = NULL;
    Array_Stack_Node* Pointer_Node = NULL;
 
    (Array_Stack*)Pointer_Stack = (Array_Stack*)Create_Array_Stack(6);
    if ((Array_Stack*)Pointer_Stack == NULL) {
 
        return -1;
    }
    Array_Stack_Node node[4] = {    'A', 10,
                                    'B', 20,
                                    'C', 30,
                                    'D', 40 };
 
    (int)Push_Array_Stack((Array_Stack*)Pointer_Stack, node[0]);
    (int)Push_Array_Stack((Array_Stack*)Pointer_Stack, node[1]);
    (int)Push_Array_Stack((Array_Stack*)Pointer_Stack, node[2]);
    (int)Push_Array_Stack((Array_Stack*)Pointer_Stack, node[3]);
 
    Display_Array_Stack((Array_Stack*)Pointer_Stack);
 
    (Array_Stack_Node*)Pointer_Node = Pop_Array_Stack((Array_Stack*)Pointer_Stack);
    if ((Array_Stack_Node*)Pointer_Node != NULL) {
 
        printf("Pop Value-[%c][%d]\n", (Array_Stack_Node*)Pointer_Node->data, (Array_Stack_Node*) Pointer_Node->_Number);
        free((Array_Stack_Node*)Pointer_Node);
    }
    else {
 
        printf("Empty stack\n");
    }
    Display_Array_Stack((Array_Stack*)Pointer_Stack);
 
    (Array_Stack_Node*)Pointer_Node = Peek_Array_Stack((Array_Stack*)Pointer_Stack);
    if ((Array_Stack_Node*)Pointer_Node != NULL) {
 
        printf("Peek Value-[%c][%d]\n", (Array_Stack_Node*)Pointer_Node->data, (Array_Stack_Node*)Pointer_Node->_Number);
    }
    else {
 
        printf("Empty stack\n");
    }
    Display_Array_Stack((Array_Stack*)Pointer_Stack);
    Delete_Array_Stack((Array_Stack*)Pointer_Stack);
 
    return 0;
}
cs

  No Comments

피드 구독하기: 글 (Atom)