'2018-02/c++'에 해당되는 글 24건

 [ 1 ]  [ 2 ]  [ 3 ] 
2018-02/c++

STL Queues

queue나 priority queue는 둘다 iterator가 없다.

priority queue는 max heap / min heap 사용 가능.

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 "stdafx.h"
#include <iostream>
#include <map>
#include <unordered_set>
#include <string>
#include <algorithm>
#include <queue>
#include <functional>
 
using namespace std;
 
 
int main() {
    priority_queue<pair<intint>,vector<pair<int,int>>,greater<pair<int,int>>> tmp;
    tmp.push(pair<intint>(14));
    tmp.push(pair<intint>(13));
    tmp.push(pair<intint>(12));
    tmp.push(pair<intint>(11));
    tmp.push(pair<intint>(22));
    tmp.push(pair<intint>(32));
    tmp.push(pair<intint>(42));
    tmp.push(pair<intint>(52));
    while (tmp.size() != 0) {
        cout << tmp.top().first << " " << tmp.top().second << endl;
        tmp.pop();
    }
    while(1){}
    queue<int> sam;
    for (int i = 0; i < 10; i++) {
        sam.push(i);
    }
    int t = sam.front();
    t--;
    sam.front() -= 10;
    cout << sam.front() << endl;
    // 특이하게 int & 형태의 값을 리턴해서 이 값대로 바로 변경하면 값이 바뀐다.
    cout << sam.front() << endl;
    for (int i = 0; i < 5; i++) {
        sam.pop();
    }
    while(1){}
    return 0;
}
cs


'2018-02 > c++' 카테고리의 다른 글

IO  (0) 2018.03.30
File I/O  (0) 2018.03.30
STL Queues  (0) 2018.03.28
SORTING  (0) 2018.03.26
maps STL  (0) 2018.03.25
variables and memory, declaration  (0) 2018.03.24
2018-02/c++

SORTING

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
bool comparator(int a, int b){
    return a>b;
}
 
int main(){
    vector<int> v = {5,1,4,8,7,4,9,2};
    sort(v.begin(),v.end(),comparator);
    for(int i : v){
        cout << i << " ";
    }
    cout << endl;
    string s = "hello world";
    sort(begin(s),end(s));
    cout << s;
    while(1){}
    return 0;
}
cs


'2018-02 > c++' 카테고리의 다른 글

File I/O  (0) 2018.03.30
STL Queues  (0) 2018.03.28
SORTING  (0) 2018.03.26
maps STL  (0) 2018.03.25
variables and memory, declaration  (0) 2018.03.24
list inserts and deletes  (0) 2018.03.24
2018-02/c++

maps STL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
int main() {
    unordered_multimap<int, int> yeah;
    multimap<int, int> test3;
    // test3[1] = 2; 불가능
    //test3.insert(pair<int, int>(1, 2));
    test3.insert(pair<int, int>(1, 3));
    test3.insert(pair<int, int>(1, 4));
    test3.insert(pair<int, int>(1, 5));
    test3.insert(pair<int, int>(1, 2));
    cout << (*test3.find(1)).second << endl;
    cout << (*test3.begin()).second << endl;
    unordered_map<int, int> test2;
    test2[1] = 1;
    test2[2] = 2;
    test2[3] = 3;
    cout << test2[2] << endl;
    map<int, int> test;
    test[1] = 2;
    test[2] = 3;
    test[3] = 4;
    cout << test[2] << endl;
    while (1) {}
    return 0;
}
cs



sets
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int main() {
    unordered_set<int> test;
    test.insert(5);
    test.insert(4);
    test.insert(3);
    test.insert(2);
    test.insert(1);
    //unordered_set<int>::iterator it2 = test.begin() + 4; 덧셈 안됨.
    for (unordered_set<int>::iterator it = test.begin(); it != test.end(); it++) {
        cout << *it << endl;
    }
    unordered_multiset<int> sma;
    sma.insert(1);
    sma.insert(2);
    sma.insert(5);
    sma.insert(5);
    sma.insert(1);
    for (unordered_multiset<int>::iterator it = sma.begin(); it != sma.end(); it++) {
        cout << *it << endl;
    }
    while (1) {}
    return 0;
}
cs


'2018-02 > c++' 카테고리의 다른 글

STL Queues  (0) 2018.03.28
SORTING  (0) 2018.03.26
maps STL  (0) 2018.03.25
variables and memory, declaration  (0) 2018.03.24
list inserts and deletes  (0) 2018.03.24
string manipulations ( pointers )  (0) 2018.03.22
2018-02/c++

variables and memory, declaration

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
#include "stdafx.h"
#include <iostream>
#include <cstdio>
#include <vector>
 
using namespace std;
 
class sam {
public:
    int a;
    int b;
    sam(int z, int w) {
        a = z;
        b = w;
    }
};
 
int main2() {
    sam * test = new sam(12);
    return 0;
}
 
struct node {
    int data;
    node * next;
};
 
void append(int data, node * head) {
    node * hello = new node;
    hello->data = data;
    hello->next = NULL;
    node * tmp = head;
    while (tmp->next != NULL) {
        tmp = tmp->next;
    }
    tmp->next = hello;
}
 
void print(node * head) {
    while (head != NULL) {
        cout << head->data << endl;
        head = head->next;
    }
}
 
int main() {
    vector<int> * v1 = new vector<int>;
    vector<int> v2;
    v1->push_back(1);
    v1->push_back(2);
    v1->push_back(3);
    cout << &v1 << " " << &v2 << endl;
    v2 = *v1;
    cout << &v1 << " " << &v2 << endl;
    cout << v2.at(1<< endl;
    while(1){}
    node head = { 1,NULL };
    append(2&head);
    append(3&head);
    append(4&head);
    append(5&head);
    print(&head);
    while (1) {}
    return 0;
}
cs


'2018-02 > c++' 카테고리의 다른 글

SORTING  (0) 2018.03.26
maps STL  (0) 2018.03.25
variables and memory, declaration  (0) 2018.03.24
list inserts and deletes  (0) 2018.03.24
string manipulations ( pointers )  (0) 2018.03.22
strings(3)  (0) 2018.03.22
2018-02/c++

list inserts and deletes



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
void splitx(list<int> &data, int x) {
    list<int>::iterator low, high, it, tmp;    
    for (low = data.begin(); low != data.end(); low++) {
        if (*low == x) {
            high = low;
            break;
        }
    }
    if (low == data.end()) {
        return;
    }
    it = data.begin();
    while (it != low) {
        if (*it < x) {
            it++;
        }
        else if (*it == x) {
            data.insert(low--,x);
            data.erase(it--);
            it++;
        }
        else {
            tmp = high;
            tmp++;
            data.insert(tmp, *it);
            //tmp = it;
            //tmp++;
            //data.erase(it);
            //it = tmp;
            if (it == data.begin()) {
                data.erase(data.begin()); it = data.begin();
            }
            else { data.erase(it--); }
            it++;
        }
    }
    it = high;
    it++;
    while (it != data.end()) {
        if (*it > x) {
            it++;
        }
        else if (*it == x) {
            data.insert(low, x);
            if (low != data.begin()) low--;
            tmp = it;
            tmp++;
            data.erase(it);
            it = tmp;
        }
        else {
            data.insert(low, *it);
            tmp = it;
            tmp++;
            data.erase(it);
            it = tmp;
        }
    }
}
cs


'2018-02 > c++' 카테고리의 다른 글

maps STL  (0) 2018.03.25
variables and memory, declaration  (0) 2018.03.24
list inserts and deletes  (0) 2018.03.24
string manipulations ( pointers )  (0) 2018.03.22
strings(3)  (0) 2018.03.22
Strings(2)  (0) 2018.03.22
2018-02/c++

string manipulations ( pointers )

string append 할 일이 생기는 경우:

vector<char> 을 사용해 reserve 후 append 해서 string sam(t.begin(),t.end()) 해도 되고

후에 복사하는 시간 아끼려면

string sam = ""

sam.reserve(100)

// 될꺼 같았는데 안돔 ㅜㅜ

// 걍 벡터에 옮겨서 작업해야될지도?


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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
#include "stdafx.h"
#include <cstdio>
//#include <string>
#include <iostream>
#include <vector>
 
using namespace std;
 
void spaceconverter(string & data) {
    char * tmp = &data[0];
    while (*tmp) {
        if (*tmp == ' ') {
            char * end = tmp;
            while (*end) {
                end++;
            }
            while (tmp<end) {
                *(end + 2= *end;
                end--;
            }
            *tmp = '%';
            *(tmp + 1= '2';
            *(tmp + 2= '0';
        }
        tmp++;
    }
}
 
string compress2(string & data) {
    vector<char> result;
    int count = 1;
    char target = data[0];
    for (int i = 1; i < data.size(); i++) {
        if (data[i] == target) {
            count++;
        }
        else {
            result.push_back(target);
            result.push_back(count + '0');
            target = data[i];
            count = 1;
        }
    }
    result.push_back(target);
    result.push_back(count + '0');
    string ret(result.begin(), result.end());
    return ret;
}
 
void undo(char * data) {
    char * tmp = data;
    while (*tmp) {
        char target = *tmp;
        tmp++;
        int count = *tmp - '0';
        tmp++;
        char * end;
        if (count == 1) {
            end = tmp;
            while (*end) {
                *(end - 1= *end;
                end++;
            }
            *(end - 1= '\0';
            tmp--;
        }
        else if (count == 2) {
            *(tmp - 1= target;
        }
        else {
            end = tmp;
            while (*end) {
                end++;
            }
            while (tmp<=end) {
                *(end + (count - 2)) = *end;
                end--;
            }
            for (int i = 0; i < count - 1; i++) {
                *(tmp - 1 + i) = target;
            }
            tmp = tmp + count - 2;
        }
    }
    return;
}
 
 
void compress(char * data) {
    int o = 0;
    while (data[o] != '\0') {
        o++;
    }
    char * tmp = data;
    int count = 1;
    int target = data[0];
    tmp++;
    int flag = 0;
    while (*tmp || flag == 0) {
        if (!*tmp) {
            flag++;
        }
        if (*tmp == target) {
            count++;
            tmp++;
        }
        else {
            if (count == 1) {
                char * end = tmp;
                while (*end) {
                    end++;
                }
                while (tmp <= end) {
                    *(end + 1= *end;
                    end--;
                }
                *(tmp) = '0' + 1;
                tmp = tmp + 1;
            }
            else if (count == 2) {
                *(tmp - 1= '0' + 2;
            }
            else {
                int d = count - 2;
                char * end = tmp;
                while (*end) {
                    *(end - d) = *end;
                    end++;
                }
                *(end - d) = '\0';
                tmp = tmp - d;
                *(tmp - 1= count + '0';
            }
            
                target = *tmp;
                count = 1;
                
                if (flag == 0) {
                tmp++;
            }
        }
        printf("%c %d\n", target, count);
    }
    int c = 0;
    while (data[c] != '\0') {
        c++;
    }
        if (o > c) {
            return;
        }
        else {
            undo(data);
            return;
        }
    
}
 
void testfunc() {
    string s = "sam hamington";
    cout << s.size() << endl;
    s[3= '\0';
    cout << s.size() << endl;
}
 
int main() {
    string fuck = "hello world";
    fuck.insert(fuck.begin() + 3'c');
    cout << fuck.at(1<< endl;
    while (1) {}
    //testfunc();
    //string sam = "abcdef";
    string data = "abcdefcccccddddddd";
    char * sam = new char[100];
    for (int i = 0; i < data.size(); i++) {
        sam[i] = data[i];
        if (i == data.size() - 1) {
            sam[i + 1= '\0';
        }
    }
    
    compress(sam);
    printf("%s\n", sam);
    string jin = "hello world sma";
    spaceconverter(jin);
    printf("%s\n", jin.c_str());
    while (1) {}
    return 0;
}
cs


'2018-02 > c++' 카테고리의 다른 글

variables and memory, declaration  (0) 2018.03.24
list inserts and deletes  (0) 2018.03.24
string manipulations ( pointers )  (0) 2018.03.22
strings(3)  (0) 2018.03.22
Strings(2)  (0) 2018.03.22
relational data structures & strings (C++ STL)  (0) 2018.03.21
2018-02/c++

strings(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
#include "stdafx.h"
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
 
using namespace std;
 
void reverse(char * tmp) {
    char * end = tmp;
    while (*end) {
        end++;
    }
    end--;
    while (tmp < end) {
        char t = *tmp;
        *tmp = *end;
        *end = t;
        tmp++;
        end--;
    }
}
 
int main() {
    string s1 = "hello meme";
    char * tmp = &s1[0];
    reverse(tmp);
    //sort(s1.begin(), s1.end());
    printf("%s\n", s1.c_str());
    while (1) {}
    return 0;
}
cs


'2018-02 > c++' 카테고리의 다른 글

list inserts and deletes  (0) 2018.03.24
string manipulations ( pointers )  (0) 2018.03.22
strings(3)  (0) 2018.03.22
Strings(2)  (0) 2018.03.22
relational data structures & strings (C++ STL)  (0) 2018.03.21
dynamic allocation of 2-dimension array  (0) 2018.03.20
2018-02/c++

Strings(2)

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
#include "stdafx.h"
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
 
using namespace std;
 
void touppercase(char * sam) {
    while (*sam) {
        if (*sam >= 'a' && *sam <= 'z') {
            *sam = *sam - 'a' + 'A';
        }
        sam++;
    }
    //sam 포인터는 원본 포인터 주소값을 변경하지는 않는다. *sam은 원본 값을 변경하기는한다.
}
 
void reverse(char * sam) {
    char * end = sam;
    while (*end) {
        end++;
    }
    end--;
    while (end > sam) {
        char tmp = *end;
        *end = *sam;
        *sam = tmp;
        sam++;
        end--;
    }
}
 
bool duplicate(string s) {
    vector<char> my(s.begin(), s.end());
    sort(my.begin(),my.end());
    for (int i = 0; i < my.size(); i++) {
        if (i != my.size() - 1 && my.at(i) == my.at(i + 1)) {
            return true;
        }
    }
    return false;
}
 
string addhello(string s) {
    cout << *(s.end() - 1<< endl;
    vector<char> my(s.begin(), s.end()); // NULL은 생략한다.
    vector<char>::iterator it;
    for (it = my.begin(); it != my.end(); it++) {
        if (*it == '\0') {
            printf("null found\n");
        }
    }
    my.push_back('h');
    my.push_back('e');
    my.push_back('l');
    my.push_back('l');
    my.push_back('o');
    my.push_back('\0');
    string s1(my.begin(), my.end());
    return s1;
}
 
int main() {
string sss = "hello world;
char * tmp = &sss[0];
printf("%s",tmp);
    string s2 = "junho";
    s2 = addhello(s2);
    printf("%s", s2.c_str());
    while (1) {}
    char sam[50= "hello world";
    char * junho = sam;
    string s = "helo junho";
    if (duplicate(s)) {
        printf("duplicated\n");
    }
    sam[3= 'z';
    const char * yy = "alphabet";
    //yy[3] = 'z'; const 선언 때문에 불가능
    printf("%s\n", junho);
    printf("%s\n", yy);
    touppercase(junho);
    reverse(junho);
    printf("%s\n", junho);
    while (1) {}
    return 0;
}
scs


'2018-02 > c++' 카테고리의 다른 글

string manipulations ( pointers )  (0) 2018.03.22
strings(3)  (0) 2018.03.22
Strings(2)  (0) 2018.03.22
relational data structures & strings (C++ STL)  (0) 2018.03.21
dynamic allocation of 2-dimension array  (0) 2018.03.20
c++ reference variables  (0) 2018.03.18
2018-02/c++

relational data structures & strings (C++ STL)

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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
#include "stdafx.h"
#include <cstdio>
 
#include "stdafx.h"
#include <cstdio>
#include <unordered_set>
#include <set>
#include <unordered_map>
#include <map>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
 
using namespace std;
 
template<class T>
class test {
public:
    T a;
    T b;
};
 
string func(string sam) {
    sam += " world";
    return sam;
}
 
int main() {
 
    // pair은 대소비교 및 각 원소 접근이 가능하다. STL 원소로도 사용 가능.
    pair<intint> p(100101);
    pair<intint> p2(99101);
    pair<intint> p3(100102);
    vector<pair<intint>> v1;
    v1.push_back(p);
    v1.push_back(p2);
    v1.push_back(p3);
    sort(v1.begin(), v1.end()); // #include <algorithm>
    vector<pair<intint>>::iterator it1;
    for (it1 = v1.begin(); it1 != v1.end(); it1++) {
        cout << it1->first << " " << (*it1).second << endl;
    }
 
    
    //map은 red black tree를 사용해서 insert delete search가 O(logN)이다. 자동정렬된다.
    map<stringint> data;
//INSERT
    data.insert(map<stringint>::value_type("void knife"400));
    data.insert(map<stringint>::value_type("void knife"10)); // 먼저온놈만 남는다!!
    data.insert(map<stringint>::value_type("killer sword"330));
    data.insert(map<stringint>::value_type("gorgon hammer"220));
    data.insert(map<stringint>::value_type("wand"90));
    data.insert(data.begin(), map<stringint>::value_type("zsword"550)); // 영향 없음..
    map<stringint>::iterator i1;
    for (i1 = data.begin(); i1 != data.end(); i1++) {
        cout << i1->first << " " << i1->second << endl;
    }
//FIND
    i1 = data.find("wand");
    if (i1 != data.end()) {
        cout << "found" << endl;
        //i1->first = s1; 키값은 바꿀 수 없다!! 다시 insert 해줘야됨. erase 하고
        i1->second = 1000;
    }
//ERASE
    data.erase("wand");
    i1 = data.begin();
    for (int i = 0; i < 3; i++) {
        i1++;
    }
    data.erase(i1);
    for (i1 = data.begin(); i1 != data.end(); i1++) {
        cout << i1->first << " " << i1->second << endl;
    }
 
//UPPER BOUNDS
    map<int,string> students;
    for (int i = 0; i < 10; i++) {
        string z1 = "sam hamington";
        z1.append(1, i + '0');
        students.insert(map<int,string>::value_type(i*10,z1));
    }
    map<intstring>::iterator im;
    im = students.upper_bound(23);
    for (map<intstring>::iterator im2 = im; im2 != students.end(); im2++) {
        cout << im2->first << " " << im2->second << endl;
    }
    
    //set은 red black tree를 사용해서 insert delete search가 O(logN)이다.
    
    set<string> jset;
//INSERT
    jset.insert("lexiographically");
    jset.insert("japan");
    jset.insert("jaPan");
    jset.insert("jApan");
    jset.insert("adam");
//ERASE
    jset.erase(jset.begin());
    jset.erase("jApan");
//FIND
    if (jset.find("japan"!= jset.end()) {
        cout << "found" << endl;
    }
//ITERATE
    set<string>::iterator itr;
    for (itr = jset.begin(); itr != jset.end(); itr++) {
        cout << *itr << endl;
    }
//BOUNDS
    set<int> sset;
    for (int i = 1; i < 20; i++) sset.insert(i*10);
    set<int>::iterator sl, su;
    sl = sset.upper_bound(31);
    su = sset.upper_bound(122);
    for (set<int>::iterator sss = sl; sss != su; sss++) {
        cout << *sss << endl;
    }
 
    //unordered map이 우리가 기대하는 그 hash table이다..
    //insert delete index가 모두 상수이다. space complexity는 O(n)
    unordered_map<stringint> characters;
//INSERT
    characters.insert(unordered_map<stringint>::value_type("john doe"10000));
    characters.insert(unordered_map<stringint>::value_type("jinhyuk jeon"1990000));
    characters.insert(unordered_map<stringint>::value_type("sam white"1000880));
    characters.insert(unordered_map<stringint>::value_type("baeyean whang"10887000));
    characters.insert(unordered_map<stringint>::value_type("junho kim"1000550));
    characters.insert(unordered_map<stringint>::value_type("junyong kim"1003300));
    unordered_map<stringint>::iterator j1;
    for (j1 = characters.begin(); j1 != characters.end(); j1++) {
        cout << j1->first << " " << j1->second << endl;
    }
 
//FIND
    j1 = characters.find("sam white");
    if ( j1 != characters.end()) {
        cout << "founddd" << endl;
        j1->second = 111;
    }
 
//DELETE
    j1 = characters.begin();
    for (int i = 0; i < 3; i++) {
        j1++;
    }
    characters.erase(j1);
    characters.erase("john doe");
    for (j1 = characters.begin(); j1 != characters.end(); j1++) {
        cout << j1->first << " " << j1->second << endl;
    }
 
//SIZE, CLEAR
    cout << "size" << characters.size() << endl;
    characters.clear();
 
 
    //unordered set은 hash table을 사용해서 average index time이 constant이다.
    unordered_set<string> stringset;
// INSERT
    stringset.insert("hello world");
    stringset.insert("bye");
    stringset.insert("bye"); // 아무 일도 일어나지 않음
    // insert나 초기화의 순서가 iterator 순서를 보장하지 않는다!!
    unordered_set<int> jack;
    for (int i = 0; i < 100; i++) {
        jack.insert(i);
    }
    unordered_set<int>::iterator it2;
    for (it2 = jack.begin(); it2 != jack.end(); it2++) {
        cout << *it2 << " ";
    }
    cout << endl;
 
// FIND
    if (stringset.find("hello world"== stringset.end()) {
        cout << "not found" << endl;
    }
    else {
        cout << "found" << endl;
    }
    cout << stringset.size() << endl;
// ITERATE
    unordered_set<string>::iterator it;
    for (it = stringset.begin(); it != stringset.end(); it++) {
        cout << *it << endl;
    }
// ERASE
    std::unordered_set<std::string> myset =
    { "USA","Canada","France","UK","Japan","Germany","Italy""jinhyuk" };
 
    myset.erase(myset.begin());                    // erasing by iterator
    myset.erase("France");                         // erasing by key
    myset.erase(myset.find("Japan"), myset.end()); // erasing by range
    for (it = myset.begin(); it != myset.end(); it++) {
        cout << *it << endl;
    }
// CLEAR
    myset.clear();
 
    //multiset
    cout << "start here" << endl << endl;
    multiset<int> mms;
    mms.insert(1);
    mms.insert(2);
    mms.insert(1);
    mms.insert(3);
    mms.insert(1);
    for (multiset<int>::iterator iii = mms.begin(); iii != mms.end(); iii++) {
        cout << *iii << endl;
    }
    if (mms.find(1!= mms.end()) {
        cout << "found" << endl;
    }
 
    // O(logN)
    cout << "counts " << mms.count(1<< endl;
 
    // strings
    string sam = "hi im string";
    char * sam3 = new char[50]; // char sam3[50] 도 똑같이 동작한다
    scanf("%[^\n]", sam3);
    //char 배열을 string에 대입 가능
    sam = sam3;
    //string sam4 = sam3;
    cout << "ss4 " << sam << endl;
    //scanf("%s", &sam); 스트링 입력 안된다
    cout << sam[3<< endl;
    cout << sam.size() << endl;
    int i = 0;
    while (sam[i] != '\0') {
        cout << sam[i] << endl;
        i++;
    }
    sam = func("hello");
    cout << sam.c_str() << endl;
    string sam2 = "what is this";
    cout << sam2 << endl// need to include <string>
    vector<string> v2;
    v2.push_back("hello");
    v2.push_back("world");
    cout << v1.size() << " " << v2.at(0<< " " << v2.at(1<< endl;
    while (1) {}
    return 0;
}
cs


'2018-02 > c++' 카테고리의 다른 글

strings(3)  (0) 2018.03.22
Strings(2)  (0) 2018.03.22
relational data structures & strings (C++ STL)  (0) 2018.03.21
dynamic allocation of 2-dimension array  (0) 2018.03.20
c++ reference variables  (0) 2018.03.18
Template classes, operator overloading  (0) 2018.03.18
2018-02/c++

dynamic allocation of 2-dimension array

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 "stdafx.h"
#include <cstdio>
 
using namespace std;
 
int main() {
    int ** tmp;
    tmp = new int *[10];
    for (int i = 0; i < 10; i++) {
        tmp[i] = new int[10];
    }
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            tmp[i][j] = i + j;
        }
    }
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            printf("%d ", tmp[i][j]);
        }
        printf("\n");
    }
    while (1) {}
    return 0;
}
cs


'2018-02 > c++' 카테고리의 다른 글

Strings(2)  (0) 2018.03.22
relational data structures & strings (C++ STL)  (0) 2018.03.21
dynamic allocation of 2-dimension array  (0) 2018.03.20
c++ reference variables  (0) 2018.03.18
Template classes, operator overloading  (0) 2018.03.18
time&chronos  (0) 2018.03.17