├── 3
    ├── pashello.pas
    ├── pasio.pas
    ├── chello.cpp
    ├── cio.cpp
    ├── cmatrix.cpp
    ├── pasrec.pas
    ├── pasmatrix.pas
    ├── pasproc.pas
    ├── crec.cpp
    ├── pasfunc.pas
    ├── cproc.cpp
    ├── pasref.pas
    ├── cref.cpp
    ├── cfunc.cpp
    ├── pastypes.pas
    ├── pasreftypes.pas
    ├── ctypes.cpp
    ├── passtring.pas
    ├── creftypes.cpp
    ├── cstring.cpp
    ├── creverse.cpp
    ├── pasreverse.pas
    └── table.wiki
├── 4
    ├── stack.cc
    ├── queue.cc
    └── pointers.cc
├── 5
    ├── new_delete_struct.cc
    ├── template_swap.cc
    ├── new_delete_array.cc
    ├── pair_template.cc
    ├── vector_sample.cc
    ├── point_class.cc
    └── stack_class.cc
├── 6
    └── max_stack_queue.cc
├── 7
    ├── Makefile
    ├── slist.cc
    └── list.cc
├── 8
    ├── Makefile
    ├── loop_enumeration.cc
    ├── bits.cc
    └── recursive_enumeration.cc
├── 9
    ├── Makefile
    ├── gcd.cc
    ├── sieve.cc
    ├── exp.cc
    └── div.cc
├── 10
    ├── Makefile
    ├── dsu.cc
    └── heap.cc
├── README
├── cpp_treap
    └── treap.cpp
├── java
    ├── Main.java
    ├── IO
    │   ├── IO.java
    │   └── FileIO.java
    └── data_structures
    │   ├── QueueTask.java
    │   ├── DequeTask.java
    │   └── ArrayListTask.java
└── cpp_rbtree
    └── RBtree.cpp


/README:
--------------------------------------------------------------------------------
1 | Course on Algorithms and Data structures at MePHI
2 | 


--------------------------------------------------------------------------------
/10/Makefile:
--------------------------------------------------------------------------------
1 | NAME=dsu
2 | ${NAME} : ${NAME}.cc
3 | 	c++ -o ${NAME} ${NAME}.cc


--------------------------------------------------------------------------------
/8/Makefile:
--------------------------------------------------------------------------------
1 | NAME=bits
2 | ${NAME} : ${NAME}.cc
3 | 	c++ -o ${NAME} ${NAME}.cc


--------------------------------------------------------------------------------
/9/Makefile:
--------------------------------------------------------------------------------
1 | NAME=sieve
2 | ${NAME} : ${NAME}.cc
3 | 	c++ -o ${NAME} ${NAME}.cc


--------------------------------------------------------------------------------
/3/pashello.pas:
--------------------------------------------------------------------------------
1 | program hello;
2 | begin
3 |   writeln('Hello, Pascal World!');
4 | end.
5 | 


--------------------------------------------------------------------------------
/3/pasio.pas:
--------------------------------------------------------------------------------
1 | program io;
2 | var
3 | a, b : integer;
4 | begin
5 |   readln(a, b);
6 |   writeln(a + b);
7 | end.
8 | 


--------------------------------------------------------------------------------
/3/chello.cpp:
--------------------------------------------------------------------------------
1 | #include <iostream>
2 | 
3 | int main() {
4 |   std::cout << "Hello, C++ World!" << std::endl;
5 |   return 0;
6 | }
7 | 


--------------------------------------------------------------------------------
/7/Makefile:
--------------------------------------------------------------------------------
1 | all : slist list
2 | 
3 | slist : slist.cc
4 | 	c++ -o slist slist.cc
5 | 
6 | list : list.cc
7 | 	c++ -o list list.cc
8 | 


--------------------------------------------------------------------------------
/3/cio.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using std::cin;
 4 | using std::cout;
 5 | using std::endl;
 6 | 
 7 | int main() {
 8 |   int a, b;
 9 |   cin >> a >> b;
10 |   cout << a + b << endl;
11 |   return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/3/cmatrix.cpp:
--------------------------------------------------------------------------------
 1 | const int N = 3;
 2 | const int M = 5;
 3 | 
 4 | int main() {
 5 |   int a[N][M];
 6 |   for (int i = 0; i < N; i++) 
 7 |     for (int j = 0; j < M; j++)
 8 |       a[i][j] = i + j;
 9 |   return 0;
10 | }
11 | 


--------------------------------------------------------------------------------
/3/pasrec.pas:
--------------------------------------------------------------------------------
 1 | program pasrec;
 2 | 
 3 | function f(n : integer) : integer;
 4 | begin
 5 |   if n = 0 then
 6 |     f := 1
 7 |   else
 8 |     f := n * f(n - 1);
 9 | end;
10 | 
11 | begin
12 |   writeln(f(3));
13 | end.
14 | 


--------------------------------------------------------------------------------
/3/pasmatrix.pas:
--------------------------------------------------------------------------------
 1 | program pasmatrix;
 2 | 
 3 | const
 4 |   N = 3;
 5 |   M = 5;
 6 | 
 7 | var
 8 |  a : array[1..N, 1..M] of integer;
 9 |  i, j : integer;
10 | 
11 | begin
12 |   for i := 1 to N do
13 |     for j := 1 to M do
14 |       a[i,j] := i + j;
15 | end.
16 | 


--------------------------------------------------------------------------------
/3/pasproc.pas:
--------------------------------------------------------------------------------
 1 | program pasproc;
 2 | 
 3 | procedure PrintSeparator(c : char; n : integer);
 4 | var
 5 |   i : integer;
 6 | begin
 7 |   for i := 1 to n do begin
 8 |     write(c);
 9 |   end;
10 |   writeln;
11 | end;
12 | 
13 | begin
14 |   PrintSeparator('#', 20);
15 | end.
16 | 


--------------------------------------------------------------------------------
/3/crec.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using std::cout;
 4 | using std::endl;
 5 | 
 6 | int f(int n) {
 7 |   if (n == 0) {
 8 |     return 1;
 9 |   } else {
10 |     return n * f(n - 1);
11 |   }
12 | }
13 | 
14 | int main() {
15 |   cout << f(3) << endl;
16 |   return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/3/pasfunc.pas:
--------------------------------------------------------------------------------
 1 | program pasfunc;
 2 | 
 3 | var
 4 | x, y : integer;
 5 | 
 6 | function Max(a : integer; b : integer): integer;
 7 | begin
 8 |   if (a > b) then 
 9 |     Max := a
10 |   else
11 |     Max := b;
12 | end;
13 | 
14 | begin
15 |   readln(x, y);
16 |   writeln(Max(x, y));
17 | end.
18 | 


--------------------------------------------------------------------------------
/3/cproc.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using std::cout;
 4 | using std::endl;
 5 | 
 6 | void PrintSeparator(char c, int n) {
 7 |   for (int i = 0; i < n; i++) {
 8 |     cout << c;
 9 |   }
10 |   cout << endl;
11 | }
12 | 
13 | int main() {
14 |   PrintSeparator('#', 20);
15 |   return 0;
16 | }
17 | 


--------------------------------------------------------------------------------
/3/pasref.pas:
--------------------------------------------------------------------------------
 1 | program pasref;
 2 | 
 3 | var
 4 | x, y : integer;
 5 | 
 6 | procedure Swap(var a : integer; var b : integer);
 7 | var
 8 |   c : integer;
 9 | begin
10 |   c := a;
11 |   a := b;
12 |   b := c;
13 | end;
14 | 
15 | begin
16 |   x := 1;
17 |   y := 2;
18 |   Swap(x, y);
19 |   writeln(x, ' ', y);
20 | end.
21 | 


--------------------------------------------------------------------------------
/3/cref.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using std::cout;
 4 | using std::endl;
 5 | 
 6 | void Swap(int& a, int& b) {
 7 |   int c;
 8 |   c = a;
 9 |   a = b;
10 |   b = c;
11 | }
12 | 
13 | int main() {
14 |   int x, y;
15 |   x = 1;
16 |   y = 2;
17 |   Swap(x, y);
18 |   cout << x << ' ' << y << endl;
19 |   return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/5/new_delete_struct.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | struct Point {
 6 |   int x;
 7 |   int y;
 8 | };
 9 | 
10 | int main() {
11 |   Point* p = new Point;
12 |   p->x = 0;
13 |   p->y = 0;
14 |   delete p;
15 |   
16 |   int* q = new int;
17 |   *q = 5;
18 |   delete q;
19 |  
20 |   return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/3/cfunc.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using std::cin;
 4 | using std::cout;
 5 | using std::endl;
 6 | 
 7 | int x, y;
 8 | 
 9 | int Max(int a, int b) {
10 |   if (a > b) {
11 |     return a;
12 |   } else {
13 |     return b;
14 |   }
15 | }
16 | 
17 | int main() {
18 |   cin >> x >> y;
19 |   cout << Max(x, y) << endl;
20 |   return 0;
21 | }
22 | 
23 | 
24 | 


--------------------------------------------------------------------------------
/5/template_swap.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | 
 4 | template <class T>
 5 | void swap(T& first, T& second) {
 6 |   T tmp;
 7 |   tmp = first;
 8 |   first = second;
 9 |   second = tmp;
10 | }
11 | 
12 | int main() {
13 |   int a = 1;
14 |   int b = 2;
15 |   swap(a, b);
16 |   
17 |   double x = 1.01;
18 |   double y = 0.99;
19 |   swap(a, b);
20 |   
21 |   return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/5/new_delete_array.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int main() {
 6 |   int n;
 7 |   cin >> n;
 8 |   
 9 |   int* a = new int[n]; // !!!
10 |   
11 |   for (int i = 0; i < n; ++i) {
12 |     cin >> a[i];
13 |   }
14 |   for (int i = 0; i < n; ++i) {
15 |     cout << a[i] << ' ';
16 |   }
17 |   cout << endl;
18 |   
19 |   delete[] a; // !!!
20 |  
21 |   return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/8/loop_enumeration.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cmath>
 3 | 
 4 | using namespace std;
 5 | 
 6 | int main() {
 7 |   int n;
 8 |   cin >> n;
 9 |   for (int msk = 0; msk < (1 << n); ++msk) {
10 |     for (int i = 0; i < n; ++i) {
11 |       if (msk & (1 << i)) {
12 |         cout << 1;
13 |       } else {
14 |         cout << 0;
15 |       }
16 |     }
17 |     cout << endl;
18 |   }
19 |   
20 |   return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/5/pair_template.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | 
 4 | using namespace std;
 5 | 
 6 | template <class T, class U>
 7 | class MyPair {
 8 |  public:
 9 | 	T first;
10 | 	U second;
11 | 	MyPair(T _first, U _second) :
12 | 		first(_first),
13 | 		second(_second)
14 |    { }
15 | };
16 | 
17 | int main() {
18 | 	MyPair<int, int> a(1, 2);
19 | 	
20 | 	cout << a.first << ' ' << a.second << endl;
21 | 	
22 | 	MyPair<string, double> b("answer", 42);
23 | 	cout << b.first << ' ' << b.second << endl;
24 | 	
25 | 	return 0;
26 | }
27 | 
28 | 
29 | 
30 | 
31 | 


--------------------------------------------------------------------------------
/10/dsu.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | 
 4 | using namespace std;
 5 | 
 6 | class DSU {
 7 |  public:
 8 |   DSU(int n);
 9 |   int Find(int x);
10 |   int Union(int x, int y);
11 | 
12 |  private:
13 |   vector<int> l;
14 | };
15 | 
16 | DSU::DSU(int n) {
17 |   l.resize(n);
18 |   for (int i = 0; i < n; ++i) {
19 |     l[i] = i;
20 |   }
21 | }
22 |  
23 | int DSU::Find(int x) {
24 |   return x == l[x] ? x : (l[x] = Find(l[x]));
25 | }
26 | 
27 | int DSU::Union(int x, int y) {
28 |   l[Find(x)] = Find(y);
29 | }
30 | 
31 | int main() {
32 |   
33 |   return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/8/bits.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int main() {
 6 |   int A = (1 << 1) + (1 << 3);
 7 |   int B = (1 << 2) + (1 << 3);
 8 |   int C = 0;
 9 | 
10 |   // union
11 |   C = A | B;
12 | 
13 |   // intersection
14 |   C = A & B;
15 | 
16 |   // subtruction
17 |   C = A & ~B;
18 | 
19 |   int bit = 2;
20 |   // set bit
21 |   A |= (1 << bit);
22 | 
23 |   // clear bit
24 |   A &= ~(1 << bit);
25 | 
26 |   // test bit
27 |   if (A & (1 << bit)) {
28 |     // bit is set
29 |   }
30 | 
31 |   // count bits
32 |   int c = __builtin_popcount(A);
33 |   
34 |   return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/3/pastypes.pas:
--------------------------------------------------------------------------------
 1 | program pastypes;
 2 | var
 3 | b : boolean; 
 4 | c : char;
 5 | n : integer;
 6 | m : longint;
 7 | x : real;
 8 | s : string;
 9 | a : array[1..10] of integer;
10 | begin
11 |   b := true;
12 |   c := 'a';
13 |   n := 1000;
14 |   m := 1000000000;
15 |   x := 3.14;
16 |   s := 'mnogo bykv';
17 |   a[1] := 5;
18 |   
19 |   // многострочная команда
20 |   writeln('b = ', b, #13, #10,
21 |           'c = ', c, #13, #10,
22 |           'n = ', n, #13, #10,
23 |           'm = ', m,  #13, #10,
24 |           'x = ', x,  #13, #10,
25 |           's = ', s,  #13, #10,
26 |           'a[1] = ', a[1]);
27 | end.
28 | 


--------------------------------------------------------------------------------
/9/gcd.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int gcd(int a, int b) {
 6 |   if (b == 0) {
 7 |     return a;
 8 |   } else {
 9 |     return gcd(b, a % b);
10 |   }
11 | }
12 | 
13 | int gcd_nonrec(int a, int b) {
14 |   while (b) {
15 |     int r = a % b;
16 |     a = b;
17 |     b = r;
18 |   }
19 |   return a;
20 | }
21 | 
22 | void gcd_extended(int a, int b, int& d, int& x, int& y) {
23 |   if (b == 0) {
24 |     d = a, x = 1, y = 0;
25 |   } else {
26 |     int x1, y1;
27 |     gcd_extended(b, a % b, d, x1, y1);
28 |     x = y1;
29 |     y = x1 - (a / b) * y1;
30 |   }
31 | }
32 | 
33 | int main() {
34 | 
35 |   return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/9/sieve.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | const int LIM = 100001;
 6 | 
 7 | bool prime[LIM];
 8 | 
 9 | void sieve(int n) {
10 |   prime[1] = false;
11 |   for (int i = 2; i <= n; ++i) {
12 |     prime[i] = true;
13 |   }
14 |   
15 |   for (int i = 2; i * i <= n; ++i) {
16 |     if (prime[i]) {
17 |       for (int j = i * i; j <= n; j += i) {
18 |         prime[j] = false;
19 |       }
20 |     }
21 |   }
22 | }
23 | 
24 | int main() {
25 |   int n = 100;
26 |   sieve(n);
27 |   for (int i = 1; i <= n; ++i) {
28 |     if (prime[i]) {
29 |       cout << i << ' ';
30 |     }
31 |   }
32 |   cout << endl;
33 | 
34 |   return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/3/pasreftypes.pas:
--------------------------------------------------------------------------------
 1 | program pasreftypes;
 2 | 
 3 | const 
 4 |   MIN_GRADE : real = 4.5;
 5 | 
 6 | type
 7 |   Student = record
 8 |     id : integer;
 9 |     name : string;
10 |     faculty : string;
11 |     grade : real;
12 |   end;
13 | 
14 | function Accept(var s : Student) : boolean;
15 | begin
16 |   if ((s.faculty = 'B') or (s.faculty = 'K')) 
17 |       and (s.grade >= MIN_GRADE) then
18 |     Accept := true
19 |   else
20 |     Accept := false;
21 | end;
22 | 
23 | var
24 |   x : Student;
25 | 
26 | begin
27 |   x.id := 1;
28 |   x.name := 'Dima';
29 |   x.faculty := 'B';
30 |   x.grade := 4.7;
31 |   
32 |   if Accept(x) then
33 |     writeln('Yahooo!');
34 | end.
35 | 


--------------------------------------------------------------------------------
/9/exp.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cmath>
 3 | 
 4 | using namespace std;
 5 | 
 6 | #if 0
 7 | double pow(double a, int n) {
 8 |   if (n == 0) {
 9 |     return 1;
10 |   }
11 |   if (n == 1) {
12 |     return a;
13 |   }
14 |   double t = pow(a, n / 2);
15 |   return t * t * pow(a, n % 2);
16 | }
17 | 
18 | double pow_nonrec(double a, int n) {
19 |   double r = 1;
20 |   while (n) {
21 |     if (n % 2 == 1) {
22 |       r *= a;
23 |     }
24 |     a *= a;
25 |     n /= 2;
26 |   }
27 |   return r;
28 | }
29 | #endif
30 | 
31 | 
32 | int main() {
33 |   int a, n;
34 |   cin >> a >> n;
35 |   cout << a << " = " << (a / n) << "*" << n << "+" << a % n << endl; 
36 |   return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/3/ctypes.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | 
 4 | using std::cout;
 5 | using std::endl;
 6 | using std::string;
 7 | 
 8 | bool b;
 9 | char c;
10 | int n;
11 | long long m;
12 | double x;
13 | string s;
14 | int a[10]; // a[0], ..., a[9]
15 | 
16 | int main() {
17 |   b = true;
18 |   c = 'a';
19 |   n = 1000;
20 |   m = 1000000000;
21 |   x = 3.14;
22 |   s = "mnogo bykv";
23 |   a[0] = 5;
24 |   
25 |   cout << "b = " << b << endl
26 |        << "c = " << c << endl
27 |        << "n = " << n << endl
28 |        << "m = " << m << endl
29 |        << "x = " << x << endl
30 |        << "s = " << s << endl
31 |        << "a[0] = " << a[0] << endl;
32 |   
33 |   return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/3/passtring.pas:
--------------------------------------------------------------------------------
 1 | program passtring;
 2 | 
 3 | var
 4 |   s, p : string;
 5 |   n, w : integer;
 6 |   
 7 | begin
 8 |   s := 'The quick brown fox jumps over the lazy dog';
 9 |   
10 |   // длина строки
11 |   n := length(s);
12 |   writeln('length = ', n);
13 |   
14 |   // выделение подстроки
15 |   p := copy(s, 1, 19); 
16 |   writeln(p);
17 |   
18 |   // удаление подстроки
19 |   delete(p, 5, 6);
20 |   writeln(p);
21 |   
22 |   // поиск подстроки
23 |   w := pos('brown', p);
24 |   writeln(w);
25 |   w := pos('red', p);
26 |   writeln(w);
27 |   
28 |   // вставка подстроки
29 |   insert(' and bear', p, length(p) + 1);
30 |   writeln(p);
31 |     
32 | end.
33 |                            
34 | 


--------------------------------------------------------------------------------
/3/creftypes.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | 
 4 | using std::cout;
 5 | using std::endl;
 6 | using std::string;
 7 | 
 8 | const double MIN_GRADE = 4.5;
 9 | 
10 | struct Student {
11 |   int id;
12 |   string name;
13 |   string faculty;
14 |   double grade;
15 | };
16 | 
17 | bool Accept(Student& s) {
18 |   if ((s.faculty == "B" || s.faculty == "K") 
19 |       && s.grade >= MIN_GRADE) {
20 |     return true;
21 |   } else {
22 |     return false;
23 |   }
24 | }
25 | 
26 | int main() {
27 |   Student x;
28 |   x.id = 1;
29 |   x.name = "Dima";
30 |   x.faculty = "B";
31 |   x.grade = 4.7;
32 |   
33 |   if (Accept(x))
34 |     cout << "Yahooo!" << endl;
35 |     
36 |   return 0;
37 | }
38 | 
39 | 
40 | 


--------------------------------------------------------------------------------
/3/cstring.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | 
 4 | using std::cout;
 5 | using std::endl;
 6 | using std::string;
 7 | 
 8 | int main() {
 9 |   string s = "The quick brown fox jumps over the lazy dog";
10 |   
11 |   int n = s.length();
12 |   cout << "length = " << n << endl;
13 |   
14 |   // выделение подстроки
15 |   string p = s.substr(0, 19);
16 |   cout << p << endl;
17 |   
18 |   // удаление подстроки
19 |   p.erase(4, 6);
20 |   cout << p << endl;
21 |   
22 |   // поиск подстроки
23 |   int w = p.find("brown");
24 |   cout << w << endl;
25 |   w = p.find("red");
26 |   cout << w << endl;
27 |   
28 |   // вставка подстроки
29 |   p.insert(p.length(), " and bear");
30 |   cout << p << endl;
31 |   
32 |   return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/3/creverse.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using std::cout;
 4 | using std::endl;
 5 | using std::cin;
 6 | 
 7 | void Swap(int& a, int& b) {
 8 |   int c;
 9 |   c = a;
10 |   a = b;
11 |   b = c;
12 | }
13 | 
14 | void InputArray(int* a, int& n) {
15 |   cin >> n;
16 |   for (int i = 0; i < n; i++) {
17 |     cin >> a[i];
18 |   }
19 | }
20 | 
21 | void OutputArray(int* a, int n) {
22 |   for (int i = 0; i < n; i++) {
23 |     cout << a[i] << ' ';
24 |   }
25 |   cout << endl;
26 | }
27 | 
28 | void Reverse(int* a, int n) {
29 |   for (int i = 0; i < n / 2; i++) {
30 |     Swap(a[i], a[n - i - 1]);
31 |   }
32 | }
33 | 
34 | int main() {
35 |   int data[100];
36 |   int n;
37 |   InputArray(data, n);
38 |   Reverse(data, n);
39 |   OutputArray(data, n);
40 |   return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/5/vector_sample.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector> // !!!
 3 | 
 4 | using std::cout;
 5 | using std::endl;
 6 | using std::cin;
 7 | using std::vector; // !!!
 8 | 
 9 | int main() {
10 |   // general use
11 |   {
12 |     int n = 10;
13 |     vector<int> a(n); // it's ctor, not a[n]!!!
14 |   
15 |     for (int i = 0; i < n; ++i) {
16 |       a[i] = i * i;
17 |     }
18 |   
19 |     a.push_back(3);
20 |     a.push_back(4);
21 |   
22 |     int elements_count = a.size();
23 |   }
24 |   
25 |   // empty check
26 |   {
27 |     vector<int> b;
28 |     bool is_empty = b.empty();
29 |   }
30 |   
31 |   // initialization
32 |   {
33 |     int n = 5;
34 |     vector<int> c(n, 42); // set all elements to 42
35 |     for (int i = 0; i < c.size(); ++i) {
36 |       if (c[i] != 42) {
37 |         cout << "should never happen" << endl;
38 |         return 1;
39 |       }
40 |     }
41 |   }
42 |   
43 |   return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/3/pasreverse.pas:
--------------------------------------------------------------------------------
 1 | program pasreverse;
 2 | type 
 3 |   FixedArray = array[1..100] of integer;
 4 | var 
 5 |   data : FixedArray;
 6 |   n : integer;
 7 |  
 8 | procedure Swap(var a : integer; var b : integer);
 9 | var
10 |   c : integer;
11 | begin
12 |   c := a;
13 |   a := b;
14 |   b := c;
15 | end; 
16 |  
17 | procedure InputArray(var a : FixedArray; var n : integer);
18 | var
19 |   i : integer;
20 | begin
21 |   readln(n);
22 |   for i := 1 to n do
23 |     read(a[i]);
24 |     
25 | end;
26 | 
27 | procedure OutputArray(var a : FixedArray; n : integer);
28 | var
29 |   i : integer;
30 | begin
31 |   for i := 1 to n do
32 |     write(a[i], ' ');
33 |   writeln;
34 | end;
35 | 
36 | procedure Reverse(var a : FixedArray; n : integer);
37 | var
38 |   i : integer;
39 | begin
40 |   for i := 1 to n div 2 do
41 |     Swap(a[i], a[n - i + 1]);
42 | end;
43 | 
44 | begin
45 |   InputArray(data, n);
46 |   Reverse(data, n);
47 |   OutputArray(data, n);
48 | end.
49 | 


--------------------------------------------------------------------------------
/8/recursive_enumeration.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | const int MAXN = 1000;
 6 | 
 7 | int a[MAXN];
 8 | int n, k;
 9 | 
10 | void output() {
11 |   for (int i = 0; i < n; ++i) {
12 |     cout << a[i];
13 |   }
14 |   cout << "\n";
15 | }
16 | 
17 | void enumerate_all(int pos) {
18 |   if (pos == n) {
19 |     output();
20 |   } else {
21 |     for (int i = 0; i < k; ++i) {
22 |       a[pos] = i;
23 |       enumerate_all(pos + 1);
24 |     }
25 |   }
26 | }
27 | 
28 | void enumerate_kry(int pos, int ones_left) {
29 |   if (ones_left == 0 || ones_left == n - pos) {
30 |     for (int i = pos; i < n; ++i) {
31 |       a[i] = (ones_left != 0);
32 |     }
33 |     output();
34 |   } else {
35 |     a[pos] = 0;
36 |     enumerate_kry(pos + 1, ones_left);
37 |     a[pos] = 1;
38 |     enumerate_kry(pos + 1, ones_left - 1);
39 |   }
40 | }
41 | 
42 | int main() {
43 |   cin >> n >> k;
44 |   enumerate_kry(0, k);
45 |   
46 |   cout << flush;
47 |   
48 |   return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/5/point_class.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cmath>
 3 | 
 4 | using namespace std;
 5 | 
 6 | class Point {
 7 |  public:
 8 |   
 9 |   // default constructor
10 |   Point() {
11 |     x = 0;
12 |     y = 0;
13 |   }
14 |  
15 |   // constructor with parameters
16 |   Point(int _x, int _y) {
17 |     x = _x;
18 |     y = _y;
19 |   };
20 |   
21 |   // TODO: show initialization list
22 |   
23 |   double distance() {
24 |     return sqrt(x * x + y * y);
25 |   }
26 |   
27 |   double x, y;
28 | };
29 | 
30 | bool operator==(const Point& first, const Point& second) {
31 |   return (first.x == second.x) && (first.y == second.y);
32 | }
33 | 
34 | ostream& operator<<(ostream& out, const Point& p) {
35 |   out << '(' << p.x << ';' << p.y << ')';
36 |   return out;
37 | }
38 | 
39 | istream& operator>>(istream& in, Point& p) {
40 |   in >> p.x >> p.y;
41 |   return in;
42 | } 
43 | 
44 | int main() {
45 |   Point a;
46 |   Point b(1, 2);
47 |   cin >> a;
48 |   if (a == b) {
49 |     cout << "point " << a << " is equal to  point " << b << endl;
50 |   } else {
51 |     cout << "point " << a << " is not equal to point " << b << endl;
52 |   }
53 |   return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/9/div.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cmath>
 3 | 
 4 | using namespace std;
 5 | 
 6 | #if 0
 7 | double pow(double a, int n) {
 8 |   if (n == 0) {
 9 |     return 1;
10 |   }
11 |   if (n == 1) {
12 |     return a;
13 |   }
14 |   double t = pow(a, n / 2);
15 |   return t * t * pow(a, n % 2);
16 | }
17 | 
18 | double pow_nonrec(double a, int n) {
19 |   double r = 1;
20 |   while (n) {
21 |     if (n % 2 == 1) {
22 |       r *= a;
23 |     }
24 |     a *= a;
25 |     n /= 2;
26 |   }
27 |   return r;
28 | }
29 | #endif
30 | 
31 | 
32 | int main() {
33 |   int n = 3;
34 |   for (int a = 0; a <= n + 1; ++a) {
35 |     cout << a << " = " << (a / n) << "*" << n << "+" << a % n << endl;
36 |   }
37 |   cout << "----" << endl;
38 |   for (int a = 0; a >= -(n + 1); --a) {
39 |     cout << a << " = " << (a / n) << "*" << n << "+" << a % n << endl;
40 |   }
41 | 
42 |   cout << "----" << endl;
43 |   n = -3;
44 |   for (int a = 0; a <= -(n - 1); ++a) {
45 |     cout << a << " = " << (a / n) << "*" << n << "+" << a % n << endl;
46 |   }
47 |   cout << "----" << endl;
48 |   for (int a = 0; a >= n - 1; --a) {
49 |     cout << a << " = " << (a / n) << "*" << n << "+" << a % n << endl;
50 |   }
51 |   
52 |   return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/6/max_stack_queue.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <stack>
 3 | 
 4 | using namespace std;
 5 | 
 6 | template <class T>
 7 | struct max_stack
 8 | {
 9 |   stack<T> s;
10 |   stack<T> mx;
11 | 
12 |   void push( const T& x ) {
13 |     s.push(x);
14 |     if (mx.empty()) {
15 |       mx.push(x);
16 |     } else {
17 |       mx.push(std::max(mx.top(), x));
18 |     }
19 |   }
20 | 
21 |   void pop() {
22 |     s.pop();
23 |     mx.pop();
24 |   }
25 | 
26 |   T top() {
27 |     return s.top();
28 |   }
29 | 
30 |   T max() {
31 |     return mx.top();
32 |   }
33 | 
34 |   bool empty() {
35 |     return s.empty();
36 |   }
37 | };
38 | 
39 | template <class T>
40 | struct max_queue
41 | {
42 |   max_stack<T> left;
43 |   max_stack<T> right;
44 | 
45 |   void push(const T& x) {
46 |     left.push(x);
47 |   }
48 | 
49 |   void pop() {
50 |     if (right.empty()) {
51 |       while (!left.empty()) {
52 |         right.push(left.top());
53 |         left.pop();
54 |       }
55 |     }
56 |     right.pop();
57 |   }
58 | 
59 |   T front() {
60 |     if (right.empty()) {
61 |       while (!left.empty()) {
62 |         right.push(left.top());
63 |         left.pop();
64 |       }
65 |     }
66 |     return right.top();
67 |   }
68 | 
69 |   T max() {
70 |     T res;
71 | 
72 |     if (!left.empty()) {
73 |       res = left.max();
74 |       if (!right.empty()) {
75 |         res = std::max(res, right.max());
76 |       }
77 |     }
78 | 
79 |     if ( !right.empty() ) {
80 |       res = right.max();
81 |       if ( !left.empty() ) {
82 |         res = std::max(res, left.max());
83 |       }
84 |     }
85 | 
86 |     return res;
87 |   }
88 | 
89 |   bool empty() {
90 |     return left.empty() && right.empty();
91 |   }
92 | };
93 | 
94 | int main() {
95 |   max_stack<int> s;
96 |   return 0;
97 | }
98 | 


--------------------------------------------------------------------------------
/4/stack.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using std::cin;
 4 | using std::cout;
 5 | using std::endl;
 6 | 
 7 | const int MAX_SIZE = 1000;
 8 | 
 9 | struct Stack {
10 |   int elements[MAX_SIZE];
11 |   int top_index;
12 | };
13 | 
14 | void Init(Stack* s) {
15 |   s->top_index = 0; // something->member <=> (*something).member
16 | }
17 | 
18 | void Clear(Stack* s) {
19 |   s->top_index = 0;
20 | }
21 | 
22 | int Size(Stack* s) {
23 |   return s->top_index;
24 | }
25 | 
26 | bool Empty(Stack* s) {
27 |   return Size(s) == 0;
28 | } 
29 | 
30 | // returns true if ok
31 | // returns false if stack is full 
32 | bool Push(Stack* s, int newbie) {
33 |   if (Size(s) == MAX_SIZE) {
34 |     return false;
35 |   } else {
36 |     s->elements[s->top_index] = newbie;
37 |     ++(s->top_index);
38 |     return true;
39 |   }
40 | }
41 | 
42 | // returns true if ok
43 | // return false if stack is empty
44 | bool Pop(Stack* s, int* result) {
45 |   if (Empty(s)) {
46 |     return false;
47 |   } else {
48 |     *result = s->elements[s->top_index - 1];
49 |     --(s->top_index);
50 |     return true;
51 |   }
52 | }
53 | 
54 | // returns true if ok
55 | // return false if stack is empty
56 | bool Top(Stack* s, int* result) {
57 |   if (Empty(s)) {
58 |     return false;
59 |   } else {
60 |     *result = s->elements[s->top_index - 1];
61 |     return true;
62 |   }
63 | }
64 | 
65 | int main() {
66 |   Stack s;
67 |   
68 |   Init(&s);
69 |   
70 |   for (int i = 0; i < 10; ++i) {
71 |     Push(&s, i);
72 |   }
73 |   
74 |   cout << Size(&s) << endl;
75 | 
76 |   for (int i = 0; i < 10; ++i) {
77 |     int top_element;
78 |     Pop(&s, &top_element);
79 |     cout << top_element << ' ';
80 |   }
81 |   cout << endl;
82 |    
83 |   cout << Size(&s) << endl;
84 |        
85 |   return 0;
86 | }
87 | 
88 | 
89 | 
90 | 


--------------------------------------------------------------------------------
/cpp_treap/treap.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <algorithm>
 3 | 
 4 | using namespace std;
 5 | 
 6 | struct treap {
 7 |   int key, prior;
 8 |   treap *l, *r;
 9 |   
10 |   treap() :
11 |     prior(rand()),
12 |     l(0), r(0)
13 |   { }
14 |   
15 |   treap(int new_key) :
16 |     key(new_key),
17 |     prior(rand()),
18 |     l(0), r(0)
19 |   { }
20 | };
21 | 
22 | typedef treap* tree;
23 | 
24 | void split(tree t, int key, tree &l, tree &r) {
25 |   if (!t)
26 |     return void(l = r = 0);
27 |   if (t->key < key) {
28 |     split(t->r, key, t->r, r);
29 |     l = t;
30 |   } else {
31 |     split(t->l, key, l, t->l);
32 |     r = t;
33 |   }
34 | }
35 | 
36 | tree merge(tree l, tree r) {
37 |   if (!l || !r)
38 |     return l ? l : r;
39 |   if (l->prior > r->prior) {
40 |     l->r = merge(l->r, r);
41 |     return l;
42 |   } else {
43 |     r->l = merge(l, r->l);
44 |     return r;
45 |   }
46 | }
47 | 
48 | /* example */
49 | 
50 | void print_tree(tree t, int n = 0) {
51 |   if (t) {
52 |     print_tree(t->r, n + 1);
53 |     for (int i = 0; i < n; i++)
54 |       cout << "    ";
55 |     cout << t->key << endl;
56 |     print_tree(t->l, n + 1);
57 |   }
58 | }
59 | 
60 | int main() {
61 |   tree t = 0;
62 |   int n;
63 |   cin >> n;
64 |   for (int i = 1; i <= n; i++) {
65 |     tree newbie = new treap(i);
66 |     t = merge(t, newbie);
67 |   }
68 |   print_tree(t);
69 |   return 0;
70 | }
71 | 
72 | /*  input:
73 | 20
74 | 
75 |     output:
76 |             20
77 |                 19
78 |         18
79 |             17
80 |     16
81 | 15
82 |                 14
83 |                     13
84 |             12
85 |                     11
86 |                 10
87 |                     9
88 |         8
89 |             7
90 |                 6
91 |     5
92 |             4
93 |                 3
94 |                     2
95 |         1
96 | */
97 | 


--------------------------------------------------------------------------------
/4/queue.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using std::cin;
 4 | using std::cout;
 5 | using std::endl;
 6 | 
 7 | const int MAX_SIZE = 10000;
 8 | 
 9 | struct Queue {
10 |   int elements[MAX_SIZE];
11 |   int elements_count;
12 |   int head_index;
13 |   int tail_index;
14 | };
15 | 
16 | void Init(Queue* q) {
17 |   q->elements_count = 0;
18 |   q->head_index = 0;
19 |   q->tail_index = 0;
20 | }
21 | 
22 | void Clear(Queue* q) {
23 |   q->elements_count = 0;
24 |   q->head_index = 0; 
25 |   q->tail_index = 0;
26 | }
27 | 
28 | int Size(Queue* q) {
29 |   return q->elements_count;
30 | }
31 | 
32 | bool Empty(Queue* q) {
33 |   return Size(q) == 0;
34 | }
35 | 
36 | bool Enqueue(Queue* q, int newbie) {
37 |   if (Size(q) == MAX_SIZE) {
38 |     return false;
39 |   } else {
40 |     q->elements[q->tail_index] = newbie;
41 |     q->tail_index = (q->tail_index + 1) % MAX_SIZE;
42 |     ++q->elements_count;
43 |     return true;
44 |   }
45 | }
46 | 
47 | bool Dequeue(Queue* q, int* result) {
48 |   if (Empty(q)) {
49 |     return false;
50 |   } else {
51 |     *result = q->elements[q->head_index];
52 |     q->head_index = (q->head_index + 1) % MAX_SIZE;
53 |     --q->elements_count;
54 |     return true;
55 |   }
56 | }
57 | 
58 | 
59 | int main() {
60 |   Queue q;
61 |   Init(&q);
62 |   
63 |   for (int i = 0; i < MAX_SIZE; ++i) {
64 |     Enqueue(&q, i);
65 |   }
66 |   
67 |   cout << Size(&q) << endl;
68 |   
69 |   for (int i = 0; i < MAX_SIZE; ++i) {
70 |     int result;
71 |     Dequeue(&q, &result);
72 |     cout << result << ' ';
73 |   }
74 |   
75 |   cout << endl;
76 |   
77 |   cout << Size(&q) << endl;
78 |   
79 |   
80 |   for (int i = 0; i < 20; ++i) {
81 |     Enqueue(&q, i);
82 |     int result;
83 |     Dequeue(&q, &result);
84 |     cout << result << ' ';
85 |   }
86 |   cout << endl;
87 |   
88 |   for (int i = 0; i < 10; ++i) {
89 |     if (!Enqueue(&q, i)) {
90 |       cout << "no way" << endl;
91 |     }
92 |   }
93 |   
94 |   return 0;
95 | }
96 | 


--------------------------------------------------------------------------------
/7/slist.cc:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <cassert>
  3 | 
  4 | using std::cout;
  5 | using std::endl;
  6 | using std::cin;
  7 | 
  8 | struct Node {
  9 |   int value;
 10 |   Node* next;
 11 |   
 12 |   Node(int _value) :
 13 |       value(_value),
 14 |       next(NULL)
 15 |   { }
 16 | };
 17 | 
 18 | struct Slist {
 19 |   Slist() :
 20 |       head(NULL),
 21 |       size(0)
 22 |   { }
 23 | 
 24 |   ~Slist();
 25 |   
 26 |   void push_front(int value);
 27 |   Node* find(int value);
 28 |   void reverse();
 29 |   int get_size() {
 30 |     return size;
 31 |   }
 32 | 
 33 |   void output();
 34 |   
 35 |   Node* head;
 36 |   int size;
 37 | };
 38 | 
 39 | void Slist::push_front(int value) {
 40 |   Node* newbie = new Node(value);
 41 |   newbie->next = head;
 42 |   head = newbie;
 43 |   ++size;
 44 | }
 45 | 
 46 | Node* Slist::find(int value) {
 47 |   Node* p = head;
 48 |   while (p != NULL && p->value != value) {
 49 |     if (p->value == value) {
 50 |       break;
 51 |     }
 52 |     p = p->next;
 53 |   }
 54 |   return p;
 55 | }
 56 | 
 57 | void Slist::output() {
 58 |   for (Node* p = head; p != NULL; p = p->next) {
 59 |     cout << p->value << ' ';
 60 |   }
 61 |   cout << endl;
 62 | }
 63 | 
 64 | void Slist::reverse() {
 65 |   if (head == NULL) {
 66 |     return;
 67 |   }
 68 |   
 69 |   Node* p = head;
 70 |   Node* q = head->next;
 71 |   p->next = NULL;
 72 |   while (q != NULL) {
 73 |     Node* r = q->next;
 74 |     q->next = p;
 75 |     p = q;
 76 |     q = r;
 77 |   }
 78 |   head = p;
 79 | }
 80 | 
 81 | Slist::~Slist() {
 82 |   Node* p = head;
 83 |   while (p != NULL) {
 84 |     Node* q = p->next;
 85 |     delete p;
 86 |     p = q;
 87 |   }
 88 | }
 89 | 
 90 | int main() {
 91 |   const int N = 10;
 92 |   Slist l;
 93 | 
 94 |   for (int i = 0; i < N; ++i) {
 95 |     l.push_front(i);
 96 |   }
 97 |   assert(l.get_size() == N);
 98 | 
 99 |   cout << "original:" << endl;
100 |   l.output();
101 | 
102 |   l.reverse();
103 |   cout << "reversed:" << endl;
104 |   l.output();
105 |   assert(l.get_size() == N);
106 |   
107 |   for (int i = 0; i < N; ++i) {
108 |     assert(l.find(i) != NULL);
109 |   }
110 |   assert(l.find(N) == NULL);
111 | 
112 |   return 0;
113 | }
114 | 
115 | 
116 | 
117 | 


--------------------------------------------------------------------------------
/java/Main.java:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | 
 4 | public class Main {
 5 |     public static void main(String args[]) {
 6 |         try {
 7 |             InputReader reader = new InputReader(System.in);
 8 |             PrintWriter writer = new PrintWriter(System.out);
 9 |             Thread thread = new Thread(null, new Solver(reader, writer), "", 128 * 1024 * 1024);
10 |             thread.start();
11 |             thread.join();
12 |             writer.close();
13 |         } catch (Exception e) {
14 |             throw new RuntimeException(e);
15 |         }
16 |     }
17 | }
18 | 
19 | class Solver implements Runnable {
20 |     private InputReader in;
21 |     private PrintWriter out;
22 | 
23 |     public Solver(InputReader reader, PrintWriter writer) {
24 |         in = reader;
25 |         out = writer;
26 |     }
27 | 
28 |     @Override
29 |     public void run() {
30 | 
31 |     }
32 | }
33 | 
34 | class InputReader {
35 |     private BufferedReader reader;
36 |     private StringTokenizer tokenizer;
37 | 
38 |     public InputReader(InputStream stream) {
39 |         reader = new BufferedReader(new InputStreamReader(stream));
40 |         tokenizer = null;
41 |     }
42 | 
43 |     public InputReader(FileReader fileReader) {
44 |         reader = new BufferedReader(fileReader);
45 |         tokenizer = null;
46 |     }
47 | 
48 |     public String next() {
49 |         while (tokenizer == null || !tokenizer.hasMoreTokens()) {
50 |             try {
51 |                 tokenizer = new StringTokenizer(reader.readLine());
52 |             } catch (Exception e) {
53 |                 throw new RuntimeException(e);
54 |             }
55 |         }
56 |         return tokenizer.nextToken();
57 |     }
58 | 
59 |     public int nextInt() {
60 |         return Integer.parseInt(next());
61 |     }
62 | 
63 |     public long nextLong() {
64 |         return Long.parseLong(next());
65 |     }
66 | 
67 |     public double nextDouble() {
68 |         return Double.parseDouble(next());
69 |     }
70 | 
71 |     public String readLine() {
72 |         try {
73 |             return reader.readLine();
74 |         } catch (Exception e) {
75 |             throw new RuntimeException(e);
76 |         }
77 |     }
78 | 
79 |     public char readChar() {
80 |         try {
81 |             return (char) reader.read();
82 |         } catch (Exception e) {
83 |             throw new RuntimeException(e);
84 |         }
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/10/heap.cc:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <vector>
  3 | #include <cassert>
  4 | #include <cstdlib>
  5 | #include <queue>
  6 | 
  7 | using namespace std;
  8 | 
  9 | class Heap {
 10 |  public:
 11 |   Heap();
 12 |   void push(int v);
 13 |   void pop();
 14 |   int top();
 15 |   
 16 |   bool empty() {
 17 |     return a.size() == 1;
 18 |   }
 19 |   
 20 |  private:
 21 |   vector<int> a;
 22 | 
 23 |   void sift_up(int n);
 24 |   void sift_down(int n);
 25 | };
 26 | 
 27 | Heap::Heap() {
 28 |   a.push_back(0);
 29 | }
 30 | 
 31 | void Heap::sift_up(int n) {
 32 |   while (n > 1 && a[n] > a[n / 2]) {
 33 |     swap(a[n], a[n / 2]);
 34 |     n /= 2;
 35 |   }
 36 | }
 37 | 
 38 | void Heap::push(int v) {
 39 |   a.push_back(v);
 40 |   int n = a.size() - 1;
 41 |   sift_up(n);
 42 | }
 43 | 
 44 | void Heap::sift_down(int n) {
 45 |   while (2 * n < a.size()) {
 46 |     if (2 * n + 1 < a.size()) {
 47 |       int mx = n;
 48 |       if (a[2 * n] > a[mx]) {
 49 |         mx = 2 * n;
 50 |       }
 51 |       if (a[2 * n + 1] > a[mx]) {
 52 |         mx = 2 * n + 1;
 53 |       }
 54 |       if (mx != n) {
 55 |         swap(a[n], a[mx]);
 56 |         n = mx;
 57 |       } else {
 58 |         break;
 59 |       }
 60 |     } else {
 61 |       if (a[2 * n] > a[n]) {
 62 |         swap(a[2 * n], a[n]);
 63 |         n = 2 * n;
 64 |       } else {
 65 |         break;
 66 |       }
 67 |     }
 68 |   }
 69 | }
 70 | 
 71 | void Heap::pop() {
 72 |   assert(!empty());
 73 |   swap(a[1], a[a.size() - 1]);
 74 |   a.pop_back();
 75 |   sift_down(1);
 76 | }
 77 | 
 78 | int Heap::top() {
 79 |   assert(!empty());
 80 |   return a[1];
 81 | }
 82 | 
 83 | int main() {
 84 |   const int N = 10;
 85 |   const int M = 10;
 86 |   vector<int> r(N);
 87 |   for (int i = 0; i < N; ++i) {
 88 |     r[i] = rand() % M;
 89 |     cout << r[i] << ' ';
 90 |   }
 91 |   cout << endl;
 92 | 
 93 |   Heap h;
 94 |   
 95 |   for (int i = 0; i < N; ++i) {
 96 |     h.push(r[i]);
 97 |   }
 98 | 
 99 |   for (int i = 0; i < N; ++i) {
100 |     cout << h.top() << ' ';
101 |     h.pop();
102 |   }
103 |   cout << endl;
104 | 
105 |   assert(h.empty());
106 | 
107 |   priority_queue<int> q;
108 |   for (int i = 0; i < N; ++i) {
109 |     h.push(r[i]);
110 |     q.push(r[i]);
111 |     assert(h.top() == q.top());
112 |   }
113 | 
114 |   for (int i = 0; i < N; ++i) {
115 |     assert(h.top() == q.top());
116 |     h.pop();
117 |     q.pop();
118 |   }
119 |   
120 |   
121 |   return 0;
122 | }
123 | 


--------------------------------------------------------------------------------
/5/stack_class.cc:
--------------------------------------------------------------------------------
  1 | // rewrite to class
  2 | #include <iostream>
  3 | #include <string>
  4 | 
  5 | using std::cin;
  6 | using std::cout;
  7 | using std::endl;
  8 | using std::string;
  9 | 
 10 | const int MAX_SIZE = 10000;
 11 | 
 12 | struct Stack {
 13 |   int elements[MAX_SIZE];
 14 |   int top_index;
 15 |   
 16 |   Stack() {
 17 |     top_index = 0;
 18 |   }
 19 |   
 20 |   void Clear();
 21 |   int Size();
 22 |   bool Empty();
 23 |   bool Push(int noob);
 24 |   bool Pop(int* r);
 25 |   bool Top(int* result);
 26 | };
 27 | 
 28 | int Stack::Size() {
 29 |   return top_index;
 30 | }
 31 | 
 32 | bool Stack::Empty() {
 33 |   return Size() == 0;
 34 | } 
 35 | 
 36 | // returns true if ok
 37 | // returns false if stack is full 
 38 | bool Stack::Push(int newbie) {
 39 |   if (Size() == MAX_SIZE) {
 40 |     return false;
 41 |   } else {
 42 |     elements[top_index] = newbie;
 43 |     ++top_index;
 44 |     return true;
 45 |   }
 46 | }
 47 | 
 48 | // returns true if ok
 49 | // return false if stack is empty
 50 | bool Stack::Pop(int* result) {
 51 |   if (Empty()) {
 52 |     return false;
 53 |   } else {
 54 |     *result = elements[top_index - 1];
 55 |     --(top_index);
 56 |     return true;
 57 |   }
 58 | }
 59 | 
 60 | // returns true if ok
 61 | // return false if stack is empty
 62 | bool Stack::Top(int* result) {
 63 |   if (Empty()) {
 64 |     return false;
 65 |   } else {
 66 |     *result = elements[top_index - 1];
 67 |     return true;
 68 |   }
 69 | }
 70 | 
 71 | int f() {
 72 |   Stack s1;
 73 |   s1.push(123);
 74 | }
 75 | 
 76 | int main() {
 77 |   for (;;) {
 78 |     string query;
 79 |     cin >> query;
 80 |     if (query == "push") {
 81 |       int t;
 82 |       cin >> t;
 83 |       s.Push(t);
 84 |       cout << "ok" << endl;
 85 |     } else if (query == "pop") {
 86 |       int result;
 87 |       if (!s.Pop(&result)) {
 88 |         cout << "error" << endl;
 89 |       } else {
 90 |         cout << result << endl;
 91 |       }
 92 |     } else if (query == "back") {
 93 |       int result;
 94 |       if (!s.Top(&result)) {
 95 |         cout << "error" << endl;
 96 |       } else {
 97 |         cout << result << endl;
 98 |       }
 99 |     } else if (query == "size") {
100 |       cout << s.Size() << endl;
101 |     } else if (query == "clear") {
102 |       s.Clear();
103 |       cout << "ok" << endl;
104 |     } else if (query == "exit") {
105 |       cout << "bye" << endl;
106 |       return 0;
107 |     }
108 |   }
109 |     
110 |   return 0;
111 | }
112 | 


--------------------------------------------------------------------------------
/java/IO/IO.java:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | 
 4 | public class IO {
 5 |     public static void main(String args[]) {
 6 |         InputReader inputReader = new InputReader(System.in);
 7 |         PrintWriter printWriter = new PrintWriter(System.out);
 8 |         TaskSolver solver = new TaskSolver(inputReader, printWriter);
 9 |         solver.solve();
10 |         printWriter.close();
11 |     }
12 | }
13 | 
14 | class TaskSolver {
15 |     private InputReader in;
16 |     private PrintWriter out;
17 | 
18 |     public TaskSolver(InputReader inputReader, PrintWriter printWriter) {
19 |         in = inputReader;
20 |         out = printWriter;
21 |     }
22 | 
23 |     public void solve() {
24 |         
25 |     }
26 | }
27 | 
28 | class InputReader {
29 |     protected BufferedReader reader;
30 |     protected StringTokenizer tokenizer;
31 | 
32 |     public InputReader(InputStream stream) {
33 |         reader = new BufferedReader(new InputStreamReader(stream));
34 |         tokenizer = null;
35 |     }
36 | 
37 |     public InputReader(FileReader fileReader) {
38 |         reader = new BufferedReader(fileReader);
39 |     }
40 | 
41 |     public String next() {
42 |         while (tokenizer == null || !tokenizer.hasMoreTokens()) {
43 |             try {
44 |                 tokenizer = new StringTokenizer(reader.readLine());
45 |             } catch (Exception e) {
46 |                 throw new RuntimeException(e);
47 |             }
48 |         }
49 |         return tokenizer.nextToken();
50 |     }
51 | 
52 |     public int nextInt() {
53 |         return Integer.parseInt(next());
54 |     }
55 | 
56 |     public long nextLong() {
57 |         return Long.parseLong(next());
58 |     }
59 | 
60 |     public double nextDouble() {
61 |         return Double.parseDouble(next());
62 |     }
63 | 
64 |     public char readChar() {
65 |         try {
66 |             return (char) reader.read();
67 |         } catch (Exception e) {
68 |             throw new RuntimeException(e);
69 |         }
70 |     }
71 | 
72 |     public String readLine() {
73 |         try {
74 |             return reader.readLine();
75 |         } catch (Exception e) {
76 |             throw new RuntimeException(e);
77 |         }
78 |     }
79 | 
80 |     public boolean ready() {
81 |         try {
82 |             return reader.ready() || 
83 |                     tokenizer != null && tokenizer.hasMoreTokens();
84 |         } catch (Exception e) {
85 |             throw new RuntimeException(e);
86 |         }
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/7/list.cc:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <cassert>
  3 | #include <algorithm>
  4 | 
  5 | using std::cout;
  6 | using std::endl;
  7 | using std::cin;
  8 | using std::swap;
  9 | 
 10 | struct Node {
 11 |   int value;
 12 |   Node* next;
 13 |   Node* prev;
 14 |   
 15 |   Node(int _value) :
 16 |       value(_value),
 17 |       next(NULL),
 18 |       prev(NULL)
 19 |   { }
 20 | };
 21 | 
 22 | struct List {
 23 |   List() :
 24 |       head(NULL),
 25 |       size(0)
 26 |   { }
 27 | 
 28 |   ~List();
 29 |   
 30 |   void push_front(int value);
 31 |   Node* find(int value);
 32 |   void erase(Node* p);
 33 |   void reverse();
 34 |   int get_size() {
 35 |     return size;
 36 |   }
 37 | 
 38 |   void output();
 39 |   
 40 |   Node* head;
 41 |   int size;
 42 | };
 43 | 
 44 | void List::push_front(int value) {
 45 |   Node* newbie = new Node(value);
 46 |   if (head != NULL) {
 47 |     head->prev = newbie;
 48 |   }
 49 |   newbie->next = head;
 50 |   head = newbie;
 51 |   ++size;
 52 | }
 53 | 
 54 | Node* List::find(int value) {
 55 |   Node* p = head;
 56 |   while (p != NULL && p->value != value) {
 57 |     if (p->value == value) {
 58 |       break;
 59 |     }
 60 |     p = p->next;
 61 |   }
 62 |   return p;
 63 | }
 64 | 
 65 | void List::erase(Node* p) {
 66 |   assert(p != NULL);
 67 |   if (p->prev != NULL) {
 68 |     p->prev->next = p->next;
 69 |   } else {
 70 |     head = p->next;
 71 |   }
 72 |   if (p->next != NULL) {
 73 |     p->next->prev = p->prev;
 74 |   }
 75 |   --size;
 76 | }
 77 | 
 78 | void List::output() {
 79 |   for (Node* p = head; p != NULL; p = p->next) {
 80 |     cout << p->value << ' ';
 81 |   }
 82 |   cout << endl;
 83 | }
 84 | 
 85 | void List::reverse() {
 86 |   if (head == 0) {
 87 |     return;
 88 |   }
 89 |   
 90 |   Node* p = head;
 91 |   while (p->next != NULL) {
 92 |     Node* q = p->next;
 93 |     swap(p->next, p->prev);
 94 |     p = q;
 95 |   }
 96 |   
 97 |   head = p;
 98 |   swap(p->next, p->prev);
 99 | }
100 | 
101 | 
102 | List::~List() {
103 |   Node* p = head;
104 |   while (p != NULL) {
105 |     Node* q = p->next;
106 |     delete p;
107 |     p = q;
108 |   }
109 | }
110 | 
111 | int main() {
112 |   const int N = 10;
113 |   List l;
114 | 
115 |   for (int i = 0; i < N; ++i) {
116 |     l.push_front(i);
117 |   }
118 | 
119 |   assert(l.get_size() == N);
120 | 
121 |   cout << "original:" << endl;
122 |   l.output();
123 | 
124 |   l.reverse();
125 |   cout << "reversed:" << endl;
126 |   l.output();
127 |   
128 |   for (int i = 0; i < N; ++i) {
129 |     Node* p = l.find(i);
130 |     l.erase(p);
131 |     assert(l.get_size() == N - i - 1);
132 |   }
133 |   assert(l.get_size() == 0);
134 | 
135 |   return 0;
136 | }
137 | 
138 | 
139 | 
140 | 


--------------------------------------------------------------------------------
/java/IO/FileIO.java:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | 
 4 | public class FileIO {
 5 |     public static void main(String args[]) {
 6 |         InputReader inputReader;
 7 |         PrintWriter printWriter;
 8 |         try {
 9 |             inputReader = new InputReader(new FileReader("input.txt"));
10 |             printWriter = new PrintWriter(new FileWriter("output.txt"));
11 |         } catch (Exception e) {
12 |             throw new RuntimeException(e);
13 |         }
14 |         TaskSolver solver = new TaskSolver(inputReader, printWriter);
15 |         solver.solve();
16 |         printWriter.close();
17 |     }
18 | }
19 | 
20 | class TaskSolver {
21 |     private InputReader in;
22 |     private PrintWriter out;
23 | 
24 |     public TaskSolver(InputReader inputReader, PrintWriter printWriter) {
25 |         in = inputReader;
26 |         out = printWriter;
27 |     }
28 | 
29 |     public void solve() {
30 |         
31 |     }
32 | }
33 | 
34 | class InputReader {
35 |     protected BufferedReader reader;
36 |     protected StringTokenizer tokenizer;
37 | 
38 |     public InputReader(InputStream stream) {
39 |         reader = new BufferedReader(new InputStreamReader(stream));
40 |         tokenizer = null;
41 |     }
42 | 
43 |     public InputReader(FileReader fileReader) {
44 |         reader = new BufferedReader(fileReader);
45 |     }
46 | 
47 |     public String next() {
48 |         while (tokenizer == null || !tokenizer.hasMoreTokens()) {
49 |             try {
50 |                 tokenizer = new StringTokenizer(reader.readLine());
51 |             } catch (Exception e) {
52 |                 throw new RuntimeException(e);
53 |             }
54 |         }
55 |         return tokenizer.nextToken();
56 |     }
57 | 
58 |     public int nextInt() {
59 |         return Integer.parseInt(next());
60 |     }
61 | 
62 |     public long nextLong() {
63 |         return Long.parseLong(next());
64 |     }
65 | 
66 |     public double nextDouble() {
67 |         return Double.parseDouble(next());
68 |     }
69 | 
70 |     public char readChar() {
71 |         try {
72 |             return (char) reader.read();
73 |         } catch (Exception e) {
74 |             throw new RuntimeException(e);
75 |         }
76 |     }
77 | 
78 |     public String readLine() {
79 |         try {
80 |             return reader.readLine();
81 |         } catch (Exception e) {
82 |             throw new RuntimeException(e);
83 |         }
84 |     }
85 | 
86 |     public boolean ready() {
87 |         try {
88 |             return reader.ready() || 
89 |                     tokenizer != null && tokenizer.hasMoreTokens();
90 |         } catch (Exception e) {
91 |             throw new RuntimeException(e);
92 |         }
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/java/data_structures/QueueTask.java:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | 
 4 | public class QueueTask {
 5 |     public static void main(String args[]) {
 6 |         InputReader inputReader = new InputReader(System.in);
 7 |         PrintWriter printWriter = new PrintWriter(System.out);
 8 |         TaskSolver solver = new TaskSolver(inputReader, printWriter);
 9 |         solver.solve();
10 |         printWriter.close();
11 |     }
12 | }
13 | 
14 | class TaskSolver {
15 |     private InputReader in;
16 |     private PrintWriter out;
17 | 
18 |     public TaskSolver(InputReader inputReader, PrintWriter printWriter) {
19 |         in = inputReader;
20 |         out = printWriter;
21 |     }
22 | 
23 |     public void solve() {
24 |         Queue<Integer> q = new ArrayDeque<Integer>(); // Аналог std::queue<int>
25 |         int x = in.nextInt(), y = in.nextInt();
26 |         q.add(x); // Вставка в конец очереди
27 |         q.add(y);
28 |         out.println("Queue size = " + q.size());
29 |         int z = q.poll(); // Удаление элемента из начала очереди с его возвратом
30 |         out.println("Front of Queue  = " + z);
31 |         out.println("Queue size = " + q.size());
32 |         z = q.peek(); // Возврат элемента из начала очереди
33 |         out.println("Front of Queue  = " + z);
34 |         out.println("Queue size = " + q.size());
35 |     }
36 | }
37 | 
38 | class InputReader {
39 |     protected BufferedReader reader;
40 |     protected StringTokenizer tokenizer;
41 | 
42 |     public InputReader(InputStream stream) {
43 |         reader = new BufferedReader(new InputStreamReader(stream));
44 |         tokenizer = null;
45 |     }
46 | 
47 |     public InputReader(FileReader fileReader) {
48 |         reader = new BufferedReader(fileReader);
49 |     }
50 | 
51 |     public String next() {
52 |         while (tokenizer == null || !tokenizer.hasMoreTokens()) {
53 |             try {
54 |                 tokenizer = new StringTokenizer(reader.readLine());
55 |             } catch (Exception e) {
56 |                 throw new RuntimeException(e);
57 |             }
58 |         }
59 |         return tokenizer.nextToken();
60 |     }
61 | 
62 |     public int nextInt() {
63 |         return Integer.parseInt(next());
64 |     }
65 | 
66 |     public long nextLong() {
67 |         return Long.parseLong(next());
68 |     }
69 | 
70 |     public double nextDouble() {
71 |         return Double.parseDouble(next());
72 |     }
73 | 
74 |     public char readChar() {
75 |         try {
76 |             return (char) reader.read();
77 |         } catch (Exception e) {
78 |             throw new RuntimeException(e);
79 |         }
80 |     }
81 | 
82 |     public String readLine() {
83 |         try {
84 |             return reader.readLine();
85 |         } catch (Exception e) {
86 |             throw new RuntimeException(e);
87 |         }
88 |     }
89 | 
90 |     public boolean ready() {
91 |         try {
92 |             return reader.ready() ||
93 |                     tokenizer != null && tokenizer.hasMoreTokens();
94 |         } catch (Exception e) {
95 |             throw new RuntimeException(e);
96 |         }
97 |     }
98 | }
99 | 


--------------------------------------------------------------------------------
/java/data_structures/DequeTask.java:
--------------------------------------------------------------------------------
  1 | import java.io.*;
  2 | import java.util.*;
  3 | 
  4 | public class DequeTask {
  5 |     public static void main(String args[]) {
  6 |         InputReader inputReader = new InputReader(System.in);
  7 |         PrintWriter printWriter = new PrintWriter(System.out);
  8 |         TaskSolver solver = new TaskSolver(inputReader, printWriter);
  9 |         solver.solve();
 10 |         printWriter.close();
 11 |     }
 12 | }
 13 | 
 14 | class TaskSolver {
 15 |     private InputReader in;
 16 |     private PrintWriter out;
 17 | 
 18 |     public TaskSolver(InputReader inputReader, PrintWriter printWriter) {
 19 |         in = inputReader;
 20 |         out = printWriter;
 21 |     }
 22 | 
 23 |     public void solve() {
 24 |         Deque<Integer> q = new ArrayDeque<Integer>(); // Аналог std::deque<int>
 25 |         int x = in.nextInt(), y = in.nextInt();
 26 |         q.addFirst(x); // Вставка в начало дека
 27 |         q.addLast(y); // Вставка в конец дека
 28 |         int z = q.pollFirst(); // Удаление элемента из начала дека с его возвратом
 29 |         out.println(z);
 30 |         z = q.pollLast(); // Удаление элемента из конца дека с его возвратом
 31 |         out.println(z);
 32 |         q.addFirst(x);
 33 |         q.addLast(y);
 34 |         z = q.peekFirst(); // Возврат элемента из начала дека
 35 |         out.println(z);
 36 |         z = q.peekLast(); // Возврат элемента из конца дека
 37 |         out.println(z);
 38 |     }
 39 | }
 40 | 
 41 | class InputReader {
 42 |     protected BufferedReader reader;
 43 |     protected StringTokenizer tokenizer;
 44 | 
 45 |     public InputReader(InputStream stream) {
 46 |         reader = new BufferedReader(new InputStreamReader(stream));
 47 |         tokenizer = null;
 48 |     }
 49 | 
 50 |     public InputReader(FileReader fileReader) {
 51 |         reader = new BufferedReader(fileReader);
 52 |     }
 53 | 
 54 |     public String next() {
 55 |         while (tokenizer == null || !tokenizer.hasMoreTokens()) {
 56 |             try {
 57 |                 tokenizer = new StringTokenizer(reader.readLine());
 58 |             } catch (Exception e) {
 59 |                 throw new RuntimeException(e);
 60 |             }
 61 |         }
 62 |         return tokenizer.nextToken();
 63 |     }
 64 | 
 65 |     public int nextInt() {
 66 |         return Integer.parseInt(next());
 67 |     }
 68 | 
 69 |     public long nextLong() {
 70 |         return Long.parseLong(next());
 71 |     }
 72 | 
 73 |     public double nextDouble() {
 74 |         return Double.parseDouble(next());
 75 |     }
 76 | 
 77 |     public char readChar() {
 78 |         try {
 79 |             return (char) reader.read();
 80 |         } catch (Exception e) {
 81 |             throw new RuntimeException(e);
 82 |         }
 83 |     }
 84 | 
 85 |     public String readLine() {
 86 |         try {
 87 |             return reader.readLine();
 88 |         } catch (Exception e) {
 89 |             throw new RuntimeException(e);
 90 |         }
 91 |     }
 92 | 
 93 |     public boolean ready() {
 94 |         try {
 95 |             return reader.ready() ||
 96 |                     tokenizer != null && tokenizer.hasMoreTokens();
 97 |         } catch (Exception e) {
 98 |             throw new RuntimeException(e);
 99 |         }
100 |     }
101 | }
102 | 


--------------------------------------------------------------------------------
/java/data_structures/ArrayListTask.java:
--------------------------------------------------------------------------------
  1 | import java.io.*;
  2 | import java.util.*;
  3 | 
  4 | public class ArrayListTask {
  5 |     public static void main(String args[]) {
  6 |         InputReader inputReader = new InputReader(System.in);
  7 |         PrintWriter printWriter = new PrintWriter(System.out);
  8 |         TaskSolver solver = new TaskSolver(inputReader, printWriter);
  9 |         solver.solve();
 10 |         printWriter.close();
 11 |     }
 12 | }
 13 | 
 14 | class TaskSolver {
 15 |     private InputReader in;
 16 |     private PrintWriter out;
 17 | 
 18 |     public TaskSolver(InputReader inputReader, PrintWriter printWriter) {
 19 |         in = inputReader;
 20 |         out = printWriter;
 21 |     }
 22 | 
 23 |     public void solve() {
 24 |         /* Документация http://docs.oracle.com/javase/7/docs/api/ */
 25 |         ArrayList<Integer> a = new ArrayList<Integer>(); // Аналог std::vector<int>
 26 |         for (int i = 0; i < 10; i++) {
 27 |             a.add(i); // Добавление в конец, аналог push_back
 28 |         }
 29 |         out.println(a.get(5)); // Вывод элемента по индексу
 30 |         a.set(5, 100); // Изменение элемента по индексу
 31 |         out.println(a.get(5));
 32 |         out.println(a.size()); // Взятие размера ArrayList
 33 |         a.add(5, 178); // Добавление на нужное место, при этом все элементы с этого места сдвигаются
 34 |         out.println(a.get(5) + " " + a.size());
 35 |         // Полный перечень методов динамического массива в документации
 36 |     }
 37 | }
 38 | 
 39 | class InputReader {
 40 |     protected BufferedReader reader;
 41 |     protected StringTokenizer tokenizer;
 42 | 
 43 |     public InputReader(InputStream stream) {
 44 |         reader = new BufferedReader(new InputStreamReader(stream));
 45 |         tokenizer = null;
 46 |     }
 47 | 
 48 |     public InputReader(FileReader fileReader) {
 49 |         reader = new BufferedReader(fileReader);
 50 |     }
 51 | 
 52 |     public String next() {
 53 |         while (tokenizer == null || !tokenizer.hasMoreTokens()) {
 54 |             try {
 55 |                 tokenizer = new StringTokenizer(reader.readLine());
 56 |             } catch (Exception e) {
 57 |                 throw new RuntimeException(e);
 58 |             }
 59 |         }
 60 |         return tokenizer.nextToken();
 61 |     }
 62 | 
 63 |     public int nextInt() {
 64 |         return Integer.parseInt(next());
 65 |     }
 66 | 
 67 |     public long nextLong() {
 68 |         return Long.parseLong(next());
 69 |     }
 70 | 
 71 |     public double nextDouble() {
 72 |         return Double.parseDouble(next());
 73 |     }
 74 | 
 75 |     public char readChar() {
 76 |         try {
 77 |             return (char) reader.read();
 78 |         } catch (Exception e) {
 79 |             throw new RuntimeException(e);
 80 |         }
 81 |     }
 82 | 
 83 |     public String readLine() {
 84 |         try {
 85 |             return reader.readLine();
 86 |         } catch (Exception e) {
 87 |             throw new RuntimeException(e);
 88 |         }
 89 |     }
 90 | 
 91 |     public boolean ready() {
 92 |         try {
 93 |             return reader.ready() ||
 94 |                     tokenizer != null && tokenizer.hasMoreTokens();
 95 |         } catch (Exception e) {
 96 |             throw new RuntimeException(e);
 97 |         }
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/cpp_rbtree/RBtree.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <algorithm>
  3 | 
  4 | using namespace std;
  5 | 
  6 | const int BLACK = 0;
  7 | const int RED = 1;
  8 | 
  9 | struct node {
 10 |   int data, color;
 11 |   node *parent, *left, *right;
 12 |   
 13 |   node() :
 14 |     color(RED),
 15 |     parent(0),
 16 |     left(0),
 17 |     right(0)
 18 |   { }
 19 |   
 20 |   node(int data) :
 21 |     data(data),
 22 |     color(RED),
 23 |     parent(0),
 24 |     left(0),
 25 |     right(0)
 26 |   { }
 27 | };
 28 | 
 29 | typedef node* ref;
 30 | 
 31 | ref root = 0;
 32 | 
 33 | ref get_grandparent(ref self) {
 34 |   if (self->parent)
 35 |     return self->parent->parent;
 36 |   else
 37 |     return 0;
 38 | }
 39 | 
 40 | ref get_uncle(ref self) {
 41 |   ref gp = get_grandparent(self);
 42 |   if (gp)
 43 |     if (gp->left == self->parent)
 44 |       return gp->right;
 45 |     else
 46 |       return gp->left;
 47 |   else
 48 |     return 0;
 49 | }
 50 | 
 51 | int get_color(ref self) {
 52 |   if (!self)
 53 |     return BLACK;
 54 |   else
 55 |     return self->color;
 56 | }
 57 | 
 58 | void set_color(ref &self, int color) {
 59 |   if (self)
 60 |     self->color = color;
 61 | }
 62 | 
 63 | void set_parent(ref &self, ref parent) {
 64 |   if (self)
 65 |     self->parent = parent;
 66 | }
 67 | 
 68 | void set_left(ref self, ref left) {
 69 |   if (self)
 70 |     self->left = left;
 71 | }
 72 | 
 73 | void set_right(ref self, ref right) {
 74 |   if (self)
 75 |     self->right = right;
 76 | }
 77 | 
 78 | void left_rotate(ref self) {
 79 |   ref newself = self->right;
 80 |   ref buffer = newself->left;
 81 |   ref parent = self->parent;
 82 |   
 83 |   set_parent(self, newself);
 84 |   set_parent(newself, parent);
 85 |   set_parent(buffer, self);
 86 |   
 87 |   set_right(self, buffer);
 88 |   set_left(newself, self);
 89 |   
 90 |   if (parent) {
 91 |     if (parent->left == self)
 92 |       set_left(parent, newself);
 93 |     else
 94 |       set_right(parent, newself);
 95 |   } else {
 96 |     root = newself;
 97 |   }
 98 | }
 99 | 
100 | void right_rotate(ref self) {
101 |   ref newself = self->left;
102 |   ref buffer = newself->right;
103 |   ref parent = self->parent;
104 |   
105 |   set_parent(self, newself);
106 |   set_parent(newself, parent);
107 |   set_parent(buffer, self);
108 |   
109 |   set_left(self, buffer);
110 |   set_right(newself, self);
111 |   
112 |   if (parent) {
113 |     if (parent->left == self)
114 |       set_left(parent, newself);
115 |     else
116 |       set_right(parent, newself);
117 |   } else {
118 |     root = newself;
119 |   }
120 | }
121 | 
122 | void fix_up(ref self) {
123 |   while (get_color(self->parent) == RED) {
124 |     ref gp = get_grandparent(self);
125 |     if (!gp)
126 |       return (void) set_color(self->parent, BLACK);
127 |     ref uncle = get_uncle(self);
128 |     ref parent = self->parent;
129 |     if (get_color(uncle) == RED) {
130 |       set_color(uncle, BLACK);
131 |       set_color(parent, BLACK);
132 |       set_color(gp, RED);
133 |     } else {
134 |       set_color(gp, RED);
135 |       set_color(parent, BLACK);
136 |       if (self->parent == gp->right) {
137 |         if (self == self->parent->left)
138 |           right_rotate(self->parent);
139 |         left_rotate(gp);
140 |       } else {
141 |         if (self == self->parent->right)
142 |           left_rotate(self->parent);
143 |         right_rotate(gp);
144 |       }
145 |     }
146 |     self = gp;
147 |   }
148 | }
149 | 
150 | void insert(ref &self, int x) {
151 |   ref it = self;
152 |   ref prev = 0;
153 |   while (it) {
154 |     prev = it;
155 |     if (it->data < x)
156 |       it = it->right;
157 |     else
158 |       it = it->left;
159 |   }
160 |   ref newbie = new node(x);
161 |   if (!prev) {
162 |     self = newbie;
163 |   } else {
164 |     if (prev->data < x)
165 |       prev->right = newbie;
166 |     else
167 |       prev->left = newbie;
168 |   }
169 |   set_parent(newbie, prev);
170 |   fix_up(newbie);
171 |   set_color(root, BLACK);
172 | }
173 | 
174 | void print(ref self, int n = 0) {
175 |   if (self) {
176 |     print(self->right, n + 1);
177 |     for (int i = 0; i < n; i++)
178 |       cout << "    ";
179 |     cout << self->data << ',' << (get_color(self) == RED ? "RED" : "BLACK") << endl;
180 |     print(self->left, n + 1);
181 |   }
182 | }
183 | 
184 | int main() {
185 |   for (int i = 1; i <= 200; i += 2) {
186 |     insert(root, i);
187 |   }
188 |   for (int i = 200; i >= 1; i -= 2) {
189 |     insert(root, i);
190 |   }
191 |   print(root);
192 |   return 0;
193 | }
194 | 


--------------------------------------------------------------------------------
/4/pointers.cc:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <limits>
  3 | #include <string>
  4 | 
  5 | using std::cout;
  6 | using std::endl;
  7 | 
  8 | void sep(int n, char c) {
  9 |   for (int i = 0; i < n; ++i) {
 10 |     cout << c;
 11 |   }
 12 |   cout << endl;
 13 | }
 14 | 
 15 | string getBitRepresentation(int x) {
 16 | 	int length = 8 * sizeof(x);
 17 | 	string result;
 18 | 
 19 | 	for (int i = 0; i < length; ++i) {
 20 | 		if (x & (1 << i)) {
 21 | 			result += '1';
 22 | 		} else {
 23 | 			result += '0';
 24 | 		}
 25 | 	}
 26 | 	
 27 | 	return result;
 28 | }
 29 | 
 30 | void inc(int* p) {
 31 |   (*p)++;
 32 | }
 33 | 
 34 | void swap(int* x, int* y) {
 35 |   int z = *x;
 36 |   *x = *y;
 37 |   *y = z;
 38 | }
 39 | 
 40 | int foo(int *x) {
 41 |   cout << x << endl;
 42 |   ++x;
 43 |   cout << x << endl;
 44 | }
 45 | 
 46 | void dec(int& x) {
 47 |   x--;
 48 | }
 49 | 
 50 | int main() {
 51 |   
 52 |   // ++, --
 53 |   {
 54 |     int a = 10;
 55 |     int x = ++a; // a = a + 1; return a;
 56 |     cout << "x = " << x << ", a = " << a << endl;
 57 |     int y = a++; // t = a; a = a + 1; return t;
 58 |     cout << "y = " << y << ", a = " << a << endl;
 59 |   }
 60 |   
 61 |   sep(40, '-');
 62 |   
 63 |   // +=, -=, *=, %=
 64 |   {
 65 |     int a = 2;
 66 |     a += 2; // a = a + 2;
 67 |     cout << "a = " << a << endl;
 68 |     a /= 4;
 69 |     cout << "a = " << a << endl; 
 70 |   }
 71 |   
 72 |   sep(40, '-');
 73 |   
 74 |   // basic types
 75 |   cout << "bool size = " << sizeof(bool) << endl
 76 |        << "char size = " << sizeof(char) << endl
 77 |        << "short int size = " << sizeof(short) << endl
 78 |        << "int size = " << sizeof(int) << endl
 79 |        << "long long size = " << sizeof(long long) << endl
 80 |        << "float size = " << sizeof(float) << endl
 81 |        << "double size = " << sizeof(double) << endl;
 82 |   
 83 |   
 84 |   // signed/unsigned
 85 |   // sizeof(signed T) == sizeof(unsigned T) == sizeof(T)
 86 |   {
 87 |     signed char x = -1; // = char, [-128; 127]
 88 |     unsigned char y = 192; // [0; 255]
 89 |   }
 90 |   
 91 |   // short/long
 92 |   // sizeof(short T) <= sizeof(T) <= sizeof(long T)
 93 |   // short int == short
 94 |   // long int == long
 95 |   
 96 |   sep(40, '-');
 97 |   
 98 |   // bit representation
 99 |   cout << getBitRepresentation(97) << endl;
100 |   // cout << getBitRepresentation(-97) << endl;
101 |   // cout << getBitRepresentation(-1) << endl;
102 | 
103 |   sep(40, '-');
104 |   
105 |   // pointers
106 |   {
107 |     int a = 97;
108 |     int* p = &a;
109 |     
110 |     cout << "p = " << p << endl;
111 |     cout << "sizeof(p) = " << sizeof(p) << endl;
112 |     
113 |     cout << "*p = " << *p << endl;
114 |     
115 |     char* q = (char*)&a;
116 |     
117 |     cout << "*q = " << *q << endl;
118 |     *q = 'b'; 
119 |     
120 |     cout << "*q = " << *q << endl;
121 |     q += 2;
122 |     *q = 'c';
123 |     
124 |     cout << "*p = " << *p << endl;
125 |   
126 |     ++p;
127 |     cout << "after increment p = " << p << endl;
128 |     cout << "garbage at *p = " << *p << endl;
129 |     
130 |     char* pc = (char*)(&a);
131 |     cout << "*pc = " << *pc << endl;
132 |   
133 |     int* x, y; // never do this!!!
134 |   }
135 |   
136 |   sep(40, '-');
137 |   
138 |   // why pointers are useful?
139 |   {
140 |     int x = 0;
141 |     cout << "before inc x = " << x << endl;
142 |     inc(&x);
143 |     cout << "after inc x = " << x << endl;
144 |     
145 |     int first = 1;
146 |     int second = 2;
147 |     cout << "before swap, first = " << first
148 |          << ", second = " << second << endl;
149 |     swap(&first, &second);
150 |     cout << "after swap, first = " << first
151 |          << ", second = " << second << endl;    
152 |   }
153 |   
154 |   
155 |   sep(40, '-');
156 |   
157 |   // references
158 |   {
159 |     int a = 5;
160 |     int& r = a;
161 |     ++r;
162 |     cout << "r = " << r << endl;
163 |     cout << "a = " << a << endl;
164 |   }
165 |   
166 |   sep(40, '-');
167 |   
168 |   // pass parameters by reference
169 |   {
170 |     int t = 10;
171 |     dec(t);
172 |     cout << "t = " << t << endl;
173 |   }
174 |   
175 |   sep(40, '-');
176 |   
177 |   // arrays
178 |   {
179 |     int m[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
180 |     cout << "m = " << m << endl;
181 |     int* p = m;
182 |     cout << "p = " << p << endl;
183 |     cout << "*p = " << *p << endl;
184 |     
185 |     // m[i] <=> *(m + i)
186 |     for (int i = 0; i < 12; ++i) {
187 |       cout << *(m + i) << ' ';
188 |     }
189 |     cout << endl;
190 |     
191 |     for (int* p = m; p != m + 12; ++p) {
192 |       cout << *p << ' ';
193 |     }
194 |     cout << endl;
195 |   }
196 |    
197 |   return 0;
198 | }
199 | 


--------------------------------------------------------------------------------
/3/table.wiki:
--------------------------------------------------------------------------------
  1 | {| class="wikitable"
  2 | |-
  3 | ! 
  4 | ! Pascal(1970, 1991)
  5 | ! C++(1983, 1998, 2011)
  6 | 
  7 | |- valign="top"
  8 | | 
  9 | hello world <br />
 10 | (pashello.pas, chello.cpp)
 11 | |
 12 | <syntaxhighlight lang="pascal">
 13 | program hello;
 14 | begin
 15 |   writeln('Hello, Pascal World!');
 16 | end.
 17 | </syntaxhighlight>
 18 | |
 19 | <syntaxhighlight lang="cpp">
 20 | #include <iostream>
 21 |   
 22 | int main() {
 23 |   std::cout << "Hello, C++ World!" << std::endl;
 24 |   return 0;
 25 | }
 26 | </syntaxhighlight>
 27 | 
 28 | |- valign="top"
 29 | | компиляция и запуск
 30 | |
 31 | <syntaxhighlight lang="bash">
 32 | $ fpc hello.pas
 33 | $ ./hello
 34 | </syntaxhighlight>
 35 | |
 36 | <syntaxhighlight lang="bash">
 37 | $ g++ -o hello hello.cpp
 38 | $ ./hello
 39 | </syntaxhighlight>
 40 | 
 41 | |- valign="top"
 42 | | "начало и конец", составной оператор
 43 | |
 44 | <syntaxhighlight lang="pascal">
 45 | begin
 46 | ...
 47 | end
 48 | </syntaxhighlight>
 49 | |
 50 | <syntaxhighlight lang="cpp">
 51 | {
 52 | ...
 53 | }
 54 | </syntaxhighlight>
 55 | 
 56 | |- valign="top"
 57 | | коментарии
 58 | |
 59 | <syntaxhighlight lang="pascal">
 60 | // ваш любимый однострочный коментарий
 61 | {*
 62 | ваш любимый
 63 | многострочный коментарий
 64 | *}
 65 | </syntaxhighlight>
 66 | |
 67 | <syntaxhighlight lang="cpp">
 68 | // ваш любимый однострочный коментарий
 69 | /*
 70 | ваш любимый
 71 | многострочный коментарий
 72 | */
 73 | </syntaxhighlight>
 74 | |- valign="top"
 75 | | подключение библиотек
 76 | |
 77 | <syntaxhighlight lang="pascal">
 78 | uses crt, graph;
 79 | </syntaxhighlight>
 80 | |
 81 | <syntaxhighlight lang="cpp">
 82 | #include <iostream>
 83 | #include <magic.h>
 84 | </syntaxhighlight>
 85 | 
 86 | |- valign="top"
 87 | |
 88 | встроенные типы данных
 89 | <br />(pastypes.pas, ctypes.cpp)
 90 | |
 91 | <syntaxhighlight lang="pascal">
 92 | var
 93 | b : boolean; 
 94 | c : char;
 95 | n : integer;
 96 | m : longint;
 97 | x : real;
 98 | s : string;
 99 | a : array[1..10] of integer;
100 | </syntaxhighlight>
101 | |
102 | <syntaxhighlight lang="cpp">
103 | #include <string>
104 | using std::string;
105 | ...
106 | 
107 | bool b;
108 | char c;
109 | int n;
110 | long long m;
111 | double x;
112 | string s;
113 | int a[10]; // a[0], ..., a[9]
114 | </syntaxhighlight>
115 | 
116 | |- valign="top"
117 | |
118 | оператор присваивания
119 | <br />(pastypes.pas, ctypes.cpp)
120 | |
121 | <syntaxhighlight lang="pascal">
122 |   b := true;
123 |   c := 'a';
124 |   n := 1000;
125 |   m := 1000000000;
126 |   x := 3.14;
127 |   s := 'mnogo bykv';
128 |   a[1] := 5;
129 | </syntaxhighlight>
130 | |
131 | <syntaxhighlight lang="cpp">
132 |   b = true;
133 |   c = 'a';
134 |   n = 1000;
135 |   m = 1000000000;
136 |   x = 3.14;
137 |   s = "mnogo bykv";
138 |   a[0] = 5;
139 | </syntaxhighlight>
140 | 
141 | |- valign="top"
142 | |
143 | вывод данных
144 | <br />(pastypes.pas, ctypes.cpp)
145 | |
146 | <syntaxhighlight lang="pascal">
147 |   writeln('b = ', b, #13, #10,
148 |           'c = ', c, #13, #10,
149 |           'n = ', n, #13, #10,
150 |           'm = ', m,  #13, #10,
151 |           'x = ', x,  #13, #10,
152 |           's = ', s,  #13, #10,
153 |           'a[1] = ', a[1]);
154 | </syntaxhighlight>
155 | |
156 | <syntaxhighlight lang="cpp">
157 |   cout << "b = " << b << endl
158 |        << "c = " << c << endl
159 |        << "n = " << n << endl
160 |        << "m = " << m << endl
161 |        << "x = " << x << endl
162 |        << "s = " << s << endl
163 |        << "a[0] = " << a[0] << endl;
164 | </syntaxhighlight>
165 | 
166 | |- valign="top"
167 | |
168 | ввод данных
169 | <br />(pasio.pas, cio.cpp)
170 | |
171 | <syntaxhighlight lang="pascal">
172 |   ...
173 |   readln(a, b);
174 | </syntaxhighlight>
175 | |
176 | <syntaxhighlight lang="cpp">
177 |   ...
178 |   int a, b;
179 |   cin >> a >> b;
180 | </syntaxhighlight>
181 | 
182 | |- valign="top"
183 | | операторы отношения
184 | | '''=''' <> < > <= >=
185 | | '''==''' != < > <= >=
186 | 
187 | |- valign="top"
188 | | логические операции
189 | | and or xor not
190 | | && || !
191 | 
192 | |- valign="top"
193 | | битовые операции
194 | | shl shr and or xor not
195 | | << >> & | ^ ~ 
196 | 
197 | |- valign="top"
198 | | арифметические операции
199 | | + - * / div mod
200 | | + - * / %
201 | 
202 | |- valign="top"
203 | | if
204 | |
205 | <syntaxhighlight lang="pascal">
206 | if i > 0 then begin
207 |   signum := 1;
208 | end else if i = 0 then begin
209 |   signum := 0;
210 | end else begin
211 |   signum := -1;
212 | end;
213 | </syntaxhighlight>
214 | |
215 | <syntaxhighlight lang="cpp">
216 | if (i > 0) {
217 |   signum = 1;
218 | } else if (i == 0) {
219 |   signum = 0;
220 | } else {
221 |   signum = -1;
222 | }
223 | </syntaxhighlight>
224 | 
225 | |- valign="top"
226 | | while
227 | |
228 | <syntaxhighlight lang="pascal">
229 | i := 0;
230 | while i < 10 do
231 | begin
232 |   writeln(i);
233 |   Inc(i); // i := i + 1
234 | end
235 | </syntaxhighlight>
236 | |
237 | <syntaxhighlight lang="cpp">
238 | int i = 0;
239 | while (i < 10) {
240 |   cout << i << endl;
241 |   i++; // i = i + 1 
242 | }
243 | </syntaxhighlight>
244 | 
245 | |- valign="top"
246 | | for
247 | |
248 | <syntaxhighlight lang="pascal">
249 | for i := 0 to 9 do
250 | begin
251 |   writeln(i);
252 | end;
253 | </syntaxhighlight>
254 | |
255 | <syntaxhighlight lang="cpp">
256 | for (i = 0; i < 10; i++) {
257 |   cout << i << endl;
258 | }
259 | </syntaxhighlight>
260 | 
261 | |- valign="top"
262 | | константы
263 | | 
264 | <syntaxhighlight lang="pascal">
265 | const // специальный раздел
266 |   PI = 3.14159;
267 | </syntaxhighlight>
268 | |
269 | <syntaxhighlight lang="cpp">
270 | const double PI = 3.14159;
271 | #define ANSWER 42
272 | </syntaxhighlight>
273 | 
274 | |- valign="top"
275 | | пользовательские типы
276 | | 
277 | <syntaxhighlight lang="pascal">
278 | type
279 |   customer = record
280 |     id : integer;
281 |     name : string;
282 |   end;
283 | var
284 |  c : customer;
285 | begin
286 |   c.id = 1;
287 |   c.name = 'Dima';
288 | end.
289 | </syntaxhighlight>
290 | |
291 | <syntaxhighlight lang="cpp">
292 | struct Customer {
293 |   int id;
294 |   string name;
295 | };
296 | int main() {
297 |   Customer c;
298 |   c.id = 1;
299 |   c.name = "Dima";
300 | }
301 | </syntaxhighlight>
302 | 
303 | |- valign="top"
304 | |
305 | Функции
306 | <br />(pasfunc.pas, cfunc.cpp)
307 | | 
308 | <syntaxhighlight lang="pascal">
309 | function Max(a : integer; b : integer): integer;
310 | begin
311 |   if (a > b) then 
312 |     Max := a
313 |   else
314 |     Max := b;
315 | end;
316 | ...
317 | // место вызова
318 | z := Max(x, y);
319 | </syntaxhighlight>
320 | |
321 | <syntaxhighlight lang="cpp">
322 | int Max(int a, int b) {
323 |   if (a > b) {
324 |     return a;
325 |   } else {
326 |     return b;
327 |   }
328 | }
329 | ...
330 | // место вызова
331 | z := Max(x, y);
332 | </syntaxhighlight>
333 | 
334 | 
335 | |- valign="top"
336 | | 
337 | процедуры
338 | <br />(pasproc.pas, cproc.cpp)
339 | | 
340 | <syntaxhighlight lang="pascal">
341 | procedure PrintSeparator(c : char; n : integer);
342 | var
343 |   i : integer;
344 | begin
345 |   for i := 1 to n do begin
346 |     write(c);
347 |   end;
348 |   writeln;
349 | end;
350 | ...
351 | // место вызова
352 | PrintSeparator('#', 20);
353 | </syntaxhighlight>
354 | |
355 | <syntaxhighlight lang="cpp">
356 | void PrintSeparator(char c, int n) {
357 |   for (int i = 0; i < n; i++) {
358 |     cout << c;
359 |   }
360 |   cout << endl;
361 | }
362 | // место вызова
363 | PrintSeparator('#', 20);
364 | </syntaxhighlight>
365 | 
366 | |- valign="top"
367 | | 
368 | передача параметров по ссылке
369 | <br />(pasref.pas, cref.cpp)
370 | | 
371 | <syntaxhighlight lang="pascal">
372 | procedure Swap(var a : integer; var b : integer);
373 | var
374 |   c : integer;
375 | begin
376 |   c := a;
377 |   a := b;
378 |   b := c;
379 | end;
380 | </syntaxhighlight>
381 | |
382 | <syntaxhighlight lang="cpp">
383 | void Swap(int& a, int& b) {
384 |   int c;
385 |   c = a;
386 |   a = b;
387 |   b = c;
388 | }
389 | </syntaxhighlight>
390 | 
391 | |- valign="top"
392 | |
393 | передача своих типов
394 | <br />(pasreftypes.pas, creftypes.cpp)
395 | | 
396 | <syntaxhighlight lang="pascal">
397 | function Accept(var s : Student) : boolean;
398 | begin
399 |   if ((s.faculty = 'B') or (s.faculty = 'K'))
400 |      and (s.grade >= MIN_GRADE) then
401 |     Accept := true
402 |   else
403 |     Accept := false;
404 | end;
405 | </syntaxhighlight>
406 | |
407 | <syntaxhighlight lang="cpp">
408 | bool Accept(Student& s) {
409 |   if ((s.faculty == "B" || s.faculty == "K") 
410 |       && s.grade >= MIN_GRADE) {
411 |     return true;
412 |   } else {
413 |     return false;
414 |   }
415 | }
416 | </syntaxhighlight>
417 | 
418 | |- valign="top"
419 | |
420 | Массивы в качестве параметров
421 | <br />(pasreverse.pas, creverse.pas)
422 | | 
423 | <syntaxhighlight lang="pascal">
424 | type 
425 |   FixedArray = array[1..100] of integer;
426 | procedure Reverse(var a : FixedArray; n : integer);
427 | var
428 |   i : integer;
429 | begin
430 |   for i := 1 to n div 2 do
431 |     Swap(a[i], a[n - i + 1]);
432 | end;
433 | </syntaxhighlight>
434 | |
435 | <syntaxhighlight lang="cpp">
436 | void Reverse(int* a, int n) {
437 |   for (int i = 0; i < n / 2; i++) {
438 |     Swap(a[i], a[n - i - 1]);
439 |   }
440 | }
441 | </syntaxhighlight>
442 | 
443 | 
444 | |- valign="top"
445 | |
446 | рекурсия
447 | <br />(pasrec.pas, crec.cpp)
448 | | 
449 | <syntaxhighlight lang="pascal">
450 | function f(n : integer) : integer;
451 | begin
452 |   if n = 0 then
453 |     f := 1
454 |   else
455 |     f := n * f(n - 1);
456 | end;
457 | </syntaxhighlight>
458 | |
459 | <syntaxhighlight lang="cpp">
460 | int f(int n) {
461 |   if (n == 0) {
462 |     return 1;
463 |   } else {
464 |     return n * f(n - 1);
465 |   }
466 | }
467 | </syntaxhighlight>
468 | 
469 | |- valign="top"
470 | |
471 | многомерные массивы
472 | <br />(pasmatrix.pas, cmatrix.cpp)
473 | | 
474 | <syntaxhighlight lang="pascal">
475 | const
476 |   N = 3;
477 |   M = 5;
478 | 
479 | var
480 |  a : array[1..N, 1..M] of integer;
481 |  i, j : integer;
482 | 
483 | begin
484 |   for i := 1 to N do
485 |     for j := 1 to M do
486 |       a[i,j] := i + j;
487 | end.
488 | </syntaxhighlight>
489 | |
490 | <syntaxhighlight lang="cpp">
491 | const int N = 3;
492 | const int M = 5;
493 | 
494 | int main() {
495 |   int a[N][M];
496 |   for (int i = 0; i < N; i++) 
497 |     for (int j = 0; j < M; j++)
498 |       a[i][j] = i + j;
499 |   return 0;
500 | }
501 | </syntaxhighlight>
502 | 
503 | 
504 | |- valign="top"
505 | | Считывание строки целиком
506 | | 
507 | <syntaxhighlight lang="pascal">
508 | readln(s);
509 | </syntaxhighlight>
510 | |
511 | <syntaxhighlight lang="cpp">
512 | getline(cin, s);
513 | </syntaxhighlight>
514 | 
515 | |- valign="top"
516 | | Считывание строки до пробела
517 | | 
518 | ?
519 | |
520 | <syntaxhighlight lang="cpp">
521 | cin >> s;
522 | </syntaxhighlight>
523 | 
524 | |- valign="top"
525 | | сравнение строк
526 | | лексикографическое(как в словаре)
527 | | лексикографическое(как в словаре)
528 | 
529 | |- valign="top"
530 | | 
531 | Длина строки
532 | <br />(passtring.pas, cstring.cpp)
533 | | 
534 | <syntaxhighlight lang="pascal">
535 | length(s);
536 | </syntaxhighlight>
537 | |
538 | <syntaxhighlight lang="cpp">
539 | s.length();
540 | </syntaxhighlight>
541 | 
542 | |- valign="top"
543 | |
544 | Выделение подстроки
545 | <br />(passtring.pas, cstring.cpp)
546 | | 
547 | <syntaxhighlight lang="pascal">
548 | r := copy(s, from, count); 
549 | </syntaxhighlight>
550 | |
551 | <syntaxhighlight lang="cpp">
552 | r = s.substr(from, count);
553 | </syntaxhighlight>
554 | 
555 | |- valign="top"
556 | |
557 | Удаление подстроки
558 | <br />(passtring.pas, cstring.cpp)
559 | | 
560 | <syntaxhighlight lang="pascal">
561 | delete(s, from, count);
562 | </syntaxhighlight>
563 | |
564 | <syntaxhighlight lang="cpp">
565 | s.erase(from, count);
566 | </syntaxhighlight>
567 | 
568 | |- valign="top"
569 | |
570 | Поиск подстроки
571 | <br />(passtring.pas, cstring.cpp)
572 | | 
573 | <syntaxhighlight lang="pascal">
574 | r := pos(substring, s);
575 | </syntaxhighlight>
576 | |
577 | <syntaxhighlight lang="cpp">
578 | r = s.find(substring);
579 | </syntaxhighlight>
580 | 
581 | |- valign="top"
582 | |
583 | Вставка подстроки
584 | <br />(passtring.pas, cstring.cpp)
585 | | 
586 | <syntaxhighlight lang="pascal">
587 | insert(substring, s, where);
588 | </syntaxhighlight>
589 | |
590 | <syntaxhighlight lang="cpp">
591 | s.insert(where, substring);
592 | </syntaxhighlight>
593 | 
594 | |}
595 | 


--------------------------------------------------------------------------------