├── 2006
    ├── J062.pas
    ├── J062.cpp
    ├── J064.cpp
    ├── J064.pas
    ├── J061.cpp
    └── J061.pas
├── 2007
    ├── J074.cpp
    └── J074.pas
├── 2008
    ├── J083.pas
    ├── J083.cpp
    ├── J082.cpp
    ├── J082.pas
    ├── J084.cpp
    ├── J084.pas
    ├── J081.cpp
    ├── J081.pas
    ├── S081.cpp
    └── S081.pas
├── 2009
    ├── S091.pas
    ├── S091.cpp
    ├── S093.cpp
    ├── S093.pas
    ├── S094.cpp
    ├── S094.pas
    ├── J093.cpp
    ├── S092.cpp
    ├── S092.pas
    ├── J094.pas
    ├── J094.cpp
    ├── J093.pas
    ├── J092.cpp
    ├── J092.pas
    ├── J091.cpp
    └── J091.pas
├── 2010
    ├── S101.cpp
    ├── J101.pas
    ├── J101.cpp
    └── S101.pas
├── 2011
    ├── J113.pas
    ├── J113.cpp
    ├── S111.cpp
    ├── S111.pas
    ├── J112.pas
    ├── S112.cpp
    ├── J112.cpp
    ├── J114.cpp
    ├── J114.pas
    ├── S114.cpp
    ├── S112.pas
    ├── S114.pas
    ├── J111.pas
    ├── J111.cpp
    ├── S113.cpp
    └── S113.pas
├── 2012
    ├── S122.cpp
    ├── J124.cpp
    ├── S122.pas
    ├── J122.cpp
    ├── J122.pas
    ├── J124.pas
    ├── J121.cpp
    └── J121.pas
├── 2013
    ├── S133.cpp
    ├── S133.pas
    ├── J131.cpp
    ├── J132.cpp
    ├── J131.pas
    ├── J132.pas
    ├── J134.pas
    ├── J134.cpp
    ├── J133.cpp
    └── J133.pas
├── 2014
    ├── J140.cpp
    ├── S140.cpp
    ├── J140.pas
    ├── S140.pas
    ├── J142.cpp
    ├── J141.cpp
    ├── J142.pas
    ├── J141.pas
    ├── J144.cpp
    ├── J144.pas
    ├── J143.cpp
    ├── J143.pas
    ├── S143.cpp
    └── S143.pas
├── 201415
    ├── S150.pas
    ├── S150.cpp
    ├── J150.pas
    ├── J150.cpp
    ├── J151.pas
    ├── J153.pas
    ├── J151.cpp
    ├── J153.cpp
    ├── S152.pas
    ├── S152.cpp
    ├── S153.cpp
    ├── S153.pas
    ├── S151.cpp
    ├── S151.pas
    ├── J154.cpp
    ├── J154.pas
    ├── J152.cpp
    ├── J152.pas
    ├── S154.cpp
    └── S154.pas
├── .gitattributes
├── .gitignore
├── json2md.js
├── README.md
└── solutions.json


/201415/S150.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, i, j: longint;
 3 | begin
 4 |   read(n);
 5 |   for i := 0 to n - 1 do
 6 |   begin
 7 |     for j := i downto 1 do
 8 |       write(i * j + 1, ' ');
 9 |     writeln(1)
10 |   end;
11 | end.
12 | 


--------------------------------------------------------------------------------
/2014/J140.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int main() {
 3 |   int n;
 4 |   scanf("%d", &n);
 5 |   for (int i = 1; i <= n; i++) {
 6 |     for (int j = 0; j < n; j++) {
 7 |       printf("%d%c", i * i + j * i, j == n - 1 ? '\n' : ' ');
 8 |     }
 9 |   }
10 |   return 0;
11 | }
12 | 


--------------------------------------------------------------------------------
/201415/S150.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int main() {
 3 |   int n;
 4 |   scanf("%d", &n);
 5 |   for (int i = 0; i < n; i++) {
 6 |     for (int j = i * i; j > 0; j -= i) {
 7 |       printf("%d ", j + 1);
 8 |     }
 9 |     printf("1\n");
10 |   }
11 |   return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/2014/S140.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int main() {
 3 |   int n;
 4 |   scanf("%d", &n);
 5 |   for (int i = n; i >= 1; i--) {
 6 |     for (int j = 0; j < n; j++) {
 7 |       printf("%d%c", i * (i + 1) / 2 * n - i * j, j == n - 1 ? '\n' : ' ');
 8 |     }
 9 |   }
10 |   return 0;
11 | }
12 | 


--------------------------------------------------------------------------------
/2009/S091.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   r1, g1, b1, r2, g2, b2: int64;
 3 | begin
 4 |   read(r1, g1, b1, r2, g2, b2);
 5 |   if ((g1 + b2 + 2 * (b1 + g2)) mod 3 = 0) then
 6 |     writeln('R')
 7 |   else if ((g1 + b2 + 2 * (b1 + g2)) mod 3 = 1) then
 8 |     writeln('G')
 9 |   else
10 |     writeln('B');
11 | end.
12 | 


--------------------------------------------------------------------------------
/2014/J140.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, i, j: longint;
 3 | begin
 4 |   read(n);
 5 |   for i := 1 to n do
 6 |   begin
 7 |     for j := 0 to n - 1 do
 8 |     begin
 9 |       write(i * i + j * i);
10 |       if (j = n - 1) then
11 |         writeln
12 |       else
13 |         write(' ')
14 |     end
15 |   end
16 | end.
17 | 


--------------------------------------------------------------------------------
/2014/S140.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, i, j: longint;
 3 | begin
 4 |   read(n);
 5 |   for i := n downto 1 do
 6 |   begin
 7 |     for j := 0 to n - 1 do
 8 |     begin
 9 |       write(i * (i + 1) div 2 * n - i * j);
10 |       if (j = n - 1) then
11 |         writeln
12 |       else
13 |         write(' ')
14 |     end
15 |   end
16 | end.
17 | 


--------------------------------------------------------------------------------
/2008/J083.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, sum, k: int64;
 3 |   i: longint;
 4 | begin
 5 |   read(n);
 6 |   sum := 0;
 7 |   k := 1;
 8 |   for i := 0 to 58 do
 9 |   begin
10 |     sum := sum + n div (k * 2) * k;
11 |     if (n mod (k * 2) >= k) then
12 |       sum := sum + n mod k + 1;
13 |     k := k * 2
14 |   end;
15 |   writeln(sum)
16 | end.
17 | 


--------------------------------------------------------------------------------
/2011/J113.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, twos, i: longint;
 3 | begin
 4 |   read(n);
 5 |   twos := 0;
 6 |   while (n >= 4) do
 7 |   begin
 8 |     inc(twos);
 9 |     n := n div 2
10 |   end;
11 |   if (n = 3) then
12 |     write(3);
13 |   if (n = 2) then
14 |     inc(twos);
15 |   for i := 1 to twos do
16 |     write(2);
17 |   writeln
18 | end.
19 | 


--------------------------------------------------------------------------------
/201415/J150.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, k, i, j: longint;
 3 | begin
 4 |   read(n);
 5 |   k := 1;
 6 |   for i := 1 to n do
 7 |     for j := 1 to n do
 8 |     begin
 9 |       write(k);
10 |       if (j = n) then
11 |         writeln
12 |       else
13 |       begin
14 |         write(' ');
15 |         k := k + 4
16 |       end
17 |     end
18 | end.
19 | 


--------------------------------------------------------------------------------
/2008/J083.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int main() {
 3 |   long long n;
 4 |   long long sum = 0, k = 1;
 5 |   scanf("%lld", &n);
 6 |   for (int i = 0; i <= 58; i++) {
 7 |     sum += n / (k * 2) * k;
 8 |     if (n % (k * 2) >= k) {
 9 |       sum += n % k + 1;
10 |     }
11 |     k *= 2;
12 |   }
13 |   printf("%lld\n", sum);
14 |   return 0;
15 | }
16 | 


--------------------------------------------------------------------------------
/2009/S091.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int main() {
 3 |   long long r1, g1, b1, r2, g2, b2;
 4 |   scanf("%lld %lld %lld %lld %lld %lld", &r1, &g1, &b1, &r2, &g2, &b2);
 5 |   if ((g1 + b2 + 2 * (b1 + g2)) % 3 == 0)
 6 |     printf("R\n");
 7 |   else if ((g1 + b2 + 2 * (b1 + g2)) % 3 == 1)
 8 |     printf("G\n");
 9 |   else
10 |     printf("B\n");
11 |   return 0;
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/201415/J150.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int main() {
 3 |   int n, k = 1;
 4 |   scanf("%d", &n);
 5 |   for (int i = 0; i < n; i++) {
 6 |     for (int j = 0; j < n; j++) {
 7 |       printf("%d", k);
 8 |       if (j == n - 1) {
 9 |         printf("\n");
10 |       } else {
11 |         printf(" ");
12 |         k += 4;
13 |       }
14 |     }
15 |   }
16 |   return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/2011/J113.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int main() {
 3 |   int n;
 4 |   int twos = 0;
 5 |   scanf("%d", &n);
 6 |   while (n >= 4) {
 7 |     twos++;
 8 |     n /= 2;
 9 |   }
10 |   if (n == 3) {
11 |     printf("3");
12 |   }
13 |   if (n == 2) {
14 |     twos++;
15 |   }
16 |   for (int i = 0; i < twos; i++) {
17 |     printf("2");
18 |   }
19 |   printf("\n");
20 |   return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/2008/J082.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int main() {
 3 |   int n, k, sum = 0;
 4 |   scanf("%d", &n);
 5 |   for (int i = 1; i <= n; i++) {
 6 |     scanf("%d", &k);
 7 |     sum += k;
 8 |     if (sum == n - i - 1) {
 9 |       printf("%d\n", n - i - 1);
10 |       break;
11 |     } else if (sum >= n - i) {
12 |       printf("%d\n", n - i);
13 |       break;
14 |     }
15 |   }
16 |   return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/2008/J082.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, k, sum, i:longint;
 3 | begin
 4 |   read(n);
 5 |   sum := 0;
 6 |   for i := 1 to n do
 7 |   begin
 8 |     read(k);
 9 |     sum := sum + k;
10 |     if (k = n - i - 1) then
11 |     begin
12 |       writeln(n - i - 1);
13 |       break
14 |     end
15 |     else if (k >= n - i) then
16 |     begin
17 |       writeln(n - i);
18 |       break
19 |     end
20 |   end
21 | end.
22 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | 
 7 | # Standard to msysgit
 8 | *.doc	 diff=astextplain
 9 | *.DOC	 diff=astextplain
10 | *.docx diff=astextplain
11 | *.DOCX diff=astextplain
12 | *.dot  diff=astextplain
13 | *.DOT  diff=astextplain
14 | *.pdf  diff=astextplain
15 | *.PDF	 diff=astextplain
16 | *.rtf	 diff=astextplain
17 | *.RTF	 diff=astextplain
18 | 


--------------------------------------------------------------------------------
/201415/J151.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, m, i: longint;
 3 | begin
 4 |   read(n, m);
 5 |   if ((m > 1000000) or (m < -1000000)) then
 6 |     for i := 1 to (n - 1) div 2 do
 7 |       write(i, ' ', -i, ' ')
 8 |   else
 9 |     for i := 1 to (n - 1) div 2 do
10 |       write(i + 2000000, ' ', -i - 2000000, ' ');
11 |   if (n mod 2 = 0) then
12 |     if (m = 0) then
13 |       writeln('-99999999 99999999')
14 |     else
15 |       writeln(0, ' ', m)
16 |   else
17 |     writeln(m)
18 | end.
19 | 


--------------------------------------------------------------------------------
/201415/J153.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a, b: ansistring;
 3 |   i, y, overtype, deleted: longint;
 4 | begin
 5 |   readln(a);
 6 |   readln(b);
 7 |   y := length(b);
 8 |   overtype := 0;
 9 |   deleted := 0;
10 |   for i := 1 to y do
11 |   begin
12 |     if (b[i] = 'D') then
13 |       inc(deleted)
14 |     else if (b[i] = 'I') then
15 |       overtype := 1 - overtype
16 |     else
17 |     begin
18 |       write(b[i]);
19 |       deleted := deleted + overtype
20 |     end
21 |   end;
22 |   delete(a, 1, deleted);
23 |   writeln(a)
24 | end.
25 | 


--------------------------------------------------------------------------------
/201415/J151.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int main() {
 3 |   int n, m;
 4 |   scanf("%d %d", &n, &m);
 5 |   if (m > 1000000 || m < -1000000) {
 6 |     for (int i = 1; i < (n + 1) / 2; i++) {
 7 |       printf("%d %d ", i, -i);
 8 |     }
 9 |   } else {
10 |     for (int i = 1; i < (n + 1) / 2; i++) {
11 |       printf("%d %d ", i + 2000000, -i - 2000000);
12 |     }
13 |   }
14 |   if (n % 2 == 0) {
15 |     if (m == 0) {
16 |       printf("-99999999 99999999\n");
17 |     } else {
18 |       printf("0 %d\n", m);
19 |     }
20 |   } else {
21 |     printf("%d\n", m);
22 |   }
23 |   return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/201415/J153.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | char a[100001], b[100001];
 4 | int main() {
 5 |   int x, y;
 6 |   scanf("%s %s", a, b);
 7 |   x = strlen(a);
 8 |   y = strlen(b);
 9 |   int overtype = 0;
10 |   int deleted = 0;
11 |   for (int i = 0; i < y; i++) {
12 |     if (b[i] == 'D') {
13 |       deleted++;
14 |     } else if (b[i] == 'I') {
15 |       overtype = 1 - overtype;
16 |     } else {
17 |       printf("%c", b[i]);
18 |       deleted += overtype;
19 |     }
20 |   }
21 |   if (deleted < x) {
22 |     printf("%s", a + deleted);
23 |   }
24 |   printf("\n");
25 |   return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/2009/S093.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | long long right[3000];
 3 | int main() {
 4 |   int n, m, a, b;
 5 |   for (int i = 0; i < 3000; i++) {
 6 |     right[i] = 0;
 7 |   }
 8 |   scanf("%d %d", &n, &m);
 9 |   for (int i = 0; i < n; i++) {
10 |     scanf("%d %d", &a, &b);
11 |     long long max = 0;
12 |     int j;
13 |     for (j = m - 1; j >= 0; j--) {
14 |       if (right[j] > max) {
15 |         if (m - j - 1 >= b)  {
16 |           break;
17 |         }
18 |         max = right[j];
19 |       }
20 |     }
21 |     right[j + b] = max + a;
22 |     printf("%lld %d\n", max, j + 1);
23 |   }
24 |   return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/2011/S111.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int sum[202];
 3 | int main() {
 4 |   int n, m, dir, x, y, z, ss = 0;
 5 |   scanf("%d %d %d", &n, &m, &dir);
 6 |   for (int i = 0; i < m; i++) {
 7 |     scanf("%d %d %d", &x, &y, &z);
 8 |     if (dir == 0) {
 9 |       sum[x + 101] += z;
10 |     } else {
11 |       sum[x - y + 101] += z;
12 |     }
13 |     ss += z;
14 |   }
15 |   int s = 0;
16 |   for (int i = -100; i <= 100; i++) {
17 |     s += sum[i - 1 + 101];
18 |     if (s * 2 == ss - sum[i + 101]) {
19 |       printf("%d\n", i);
20 |       return 0;
21 |     }
22 |   }
23 |   printf("OH NO\n");
24 |   return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/2009/S093.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   right: array[0..2999] of int64;
 3 |   n, m, a, b, i, j: longint;
 4 |   max: int64;
 5 | begin
 6 |   for i := 0 to 2999 do
 7 |     right[i] := 0;
 8 |   read(n, m);
 9 |   for i := 1 to n do
10 |   begin
11 |     read(a, b);
12 |     max := 0;
13 |     for j := m - 1 downto -1 do
14 |     begin
15 |       if (j = -1) then
16 |         break;
17 |       if (right[j] > max) then
18 |       begin
19 |         if (m - j - 1 >= b) then
20 |           break;
21 |         max := right[j];
22 |       end
23 |     end;
24 |     right[j + b] := max + a;
25 |     writeln(max, ' ', j + 1)
26 |   end
27 | end.
28 | 


--------------------------------------------------------------------------------
/2006/J062.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   valid: array[1..100, 1..100] of boolean;
 3 |   n, m, k, i, j, from, too, pieces, a: longint;
 4 |   ok:boolean;
 5 | begin
 6 |   read(n, m, k);
 7 |   for i := 1 to m do
 8 |     for j := 1 to n do
 9 |       valid[i][j] := i = 1;
10 |   for i := 1 to k do
11 |   begin
12 |     read(from, too, pieces);
13 |     for j := 1 to pieces do
14 |     begin
15 |       read(a);
16 |       valid[too][a] := valid[too][a] or valid[from][a]
17 |     end
18 |   end;
19 |   for i := 1 to m do
20 |   begin
21 |     ok := true;
22 |     for j := 1 to n do
23 |       ok := ok and valid[i][j];
24 |     if (ok) then
25 |       writeln(i)
26 |   end
27 | end.
28 | 


--------------------------------------------------------------------------------
/2009/S094.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int s[5000001];
 3 | int main() {
 4 |   int n, m;
 5 |   scanf("%d %d", &n, &m);
 6 |   for (int i = 1; i <= m; i++){
 7 |     scanf("%d", &s[i]);
 8 |   }
 9 |   int j = 1;
10 |   int sum = 0, start = -1, len = m + 1;
11 |   for (int i = 1; i <= m; i++){
12 |     while (j <= m && sum < n){
13 |       sum += s[j];
14 |       j++;
15 |     }
16 |     if (sum == n) {
17 |       if (j-i < len) {
18 |         len = j - i;
19 |         start = i;
20 |       }
21 |     }
22 |     sum -= s[i];
23 |   }
24 |   if (start != -1) {
25 |     printf("%d %d\n", start, len);
26 |   } else {
27 |     printf("Impossible\n");
28 |   }
29 |   return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/2011/S111.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   sum: array[0..201] of longint;
 3 |   n, m, dir, x, y, z, s, ss, i: longint;
 4 | begin
 5 |   read(n, m, dir);
 6 |   for i := 0 to 201 do
 7 |     sum[i] := 0;
 8 |   ss := 0;
 9 |   for i := 1 to m do
10 |   begin
11 |     read(x, y, z);
12 |     if (dir = 0) then
13 |       sum[x + 101] := sum[x + 101] + z
14 |     else
15 |       sum[x - y + 101] := sum[x - y + 101] + z;
16 |     ss := ss + z;
17 |   end;
18 |   s := 0;
19 |   for i := -100 to 100 do
20 |   begin
21 |     s := s + sum [i - 1 + 101];
22 |     if (s * 2 = ss - sum[i + 101]) then
23 |     begin
24 |       writeln(i);
25 |       halt
26 |     end;
27 |   end;
28 |   writeln('OH NO')
29 | end.  
30 | 


--------------------------------------------------------------------------------
/201415/S152.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   x, y, l: array[1..2000] of longint;
 3 |   n, m, k, ans, i, j, lc, left: longint;
 4 | begin
 5 |   read(n, m, k);
 6 |   for i := 1 to k do
 7 |     read(x[i], y[i]);
 8 |   ans := 1;
 9 |   for i := 1 to k do
10 |   begin
11 |     lc := 0;
12 |     for j := 1 to k do
13 |       if ((y[j] >= y[i]) and (y[j] < y[i] + m)) then
14 |       begin
15 |         inc(lc);
16 |         l[lc] := x[j]
17 |       end;
18 |     left := 1;
19 |     for j := 2 to lc do
20 |     begin
21 |       while (l[left] <= l[j] - m) do
22 |         inc(left);
23 |       if (j - left + 1 > ans) then
24 |         ans := j - left + 1
25 |     end
26 |   end;
27 |   writeln(ans)
28 | end.
29 | 


--------------------------------------------------------------------------------
/2006/J062.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | bool valid[101][101];
 3 | int main() {
 4 |   int n, m, k;
 5 |   scanf("%d %d %d", &n, &m, &k);
 6 |   for (int i = 1; i <= m; i++)
 7 |     for (int j = 1; j <= n; j++)
 8 |       valid[i][j] = (i == 1);
 9 |   for (int i = 0; i < k; i++) {
10 |     int from, to, pieces, a;
11 |     scanf("%d %d %d", &from, &to, &pieces);
12 |     for (int j = 0; j < pieces; j++) {
13 |       scanf("%d", &a);
14 |       valid[to][a] |= valid[from][a];
15 |     }
16 |   }
17 |   for (int i = 1; i <= m; i++) {
18 |     bool ok = true;
19 |     for (int j = 1; j <= n; j++)
20 |       ok &= valid[i][j];
21 |     if (ok)
22 |       printf("%d\n", i);
23 |   }
24 |   return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/2009/S094.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   s: array[1..5000000] of longint;
 3 |   n, m, i, j, sum, start, len: longint;
 4 | begin
 5 |   read(n, m);
 6 |   for i := 1 to m do
 7 |     read(s[i]);
 8 |   j := 1;
 9 |   sum := 0;
10 |   start := -1;
11 |   len := m + 1;
12 |   for i := 1 to m do
13 |   begin
14 |     while ((j <= m) and (sum < n)) do
15 |     begin
16 |       sum := sum + s[j];
17 |       inc(j)
18 |     end;
19 |     if (sum = n) then
20 |       if (j - i < len) then
21 |       begin
22 |         len := j - i;
23 |         start := i
24 |       end;
25 |     sum := sum - s[i]
26 |   end;
27 |   if (start > 0) then
28 |     writeln(start, ' ', len)
29 |   else
30 |     writeln('Impossible')
31 | end.
32 | 


--------------------------------------------------------------------------------
/201415/S152.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int x[2000], y[2000], l[2000];
 3 | int main() {
 4 |   int n, m, k;
 5 |   scanf("%d %d %d", &n, &m, &k);
 6 |   for (int i = 0; i < k; i++) {
 7 |     scanf("%d %d", &x[i], &y[i]);
 8 |   }
 9 |   int ans = 1;
10 |   for (int i = 0; i < k; i++) {
11 |     int lc = 0;
12 |     for (int j = 0; j < k; j++) {
13 |       if (y[j] >= y[i] && y[j] < y[i] + m) {
14 |         l[lc++] = x[j];
15 |       }
16 |     }
17 |     int left = 0;
18 |     for (int j = 1; j < lc; j++) {
19 |       while (l[left] <= l[j] - m) {
20 |         left++;
21 |       }
22 |       if (j - left + 1 > ans) {
23 |         ans = j - left + 1;
24 |       }
25 |     }
26 |   }
27 |   printf("%d\n", ans);
28 |   return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/2006/J064.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int a[501][501];
 3 | bool covered[501], b[501];
 4 | int main() {
 5 |   int n;
 6 |   scanf("%d", &n);
 7 |   for (int i = 1; i <= n; i++) {
 8 |     scanf("%d", &a[i][0]);
 9 |     for (int j = 1; j <= a[i][0]; j++) {
10 |       scanf("%d", &a[i][j]);
11 |     }
12 |   }
13 |   for (int i = n; i >= 1; i--) {
14 |     if (!covered[i]) {
15 |       b[i] = true;
16 |       for (int j = 1; j <= a[i][0]; j++) {
17 |         if (covered[a[i][j]]) {
18 |           printf("-1\n");
19 |           return 0;
20 |         }
21 |         covered[a[i][j]] = true;
22 |       }
23 |     }
24 |   }
25 |   for (int i = 1; i <= n; i++) {
26 |     if (b[i])
27 |       printf("%d\n", i);
28 |   }
29 |   return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/2011/J112.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, m, x, y, i: longint;
 3 |   count, twos, threes, ans: longint;
 4 | begin
 5 |   read(n, m, x);
 6 |   count := 1;
 7 |   twos := 0;
 8 |   threes := 0;
 9 |   for i := 1 to n - 1 do
10 |   begin
11 |     read(x, y);
12 |     if (x = y) then
13 |       inc(count)
14 |     else
15 |       count := 1;
16 |     if (count mod 3 = 0) then
17 |     begin
18 |       dec(twos);
19 |       inc(threes)
20 |     end;
21 |     if (count mod 3 = 2) then
22 |       inc(twos)
23 |   end;
24 |   if (m >= threes + twos) then
25 |     ans := threes * 2 + twos
26 |   else if (m <= threes) then
27 |     ans := m * 2
28 |   else
29 |     ans := threes + m;
30 |   if (ans + m > n) then
31 |     ans := n - m;
32 |   writeln(ans)
33 | end.
34 | 


--------------------------------------------------------------------------------
/2011/S112.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int sum[2000][4], u[2005][4];
 3 | char s[200005], t[2005];
 4 | int main() {
 5 |   int n, m;
 6 |   scanf("%d %s %d %s", &n, s, &m, t);
 7 |   for (int i = 0; i < n; i++) {
 8 |     sum[i % m][0] += s[i] == 'B';
 9 |     sum[i % m][1] += s[i] == 'G';
10 |     sum[i % m][2] += s[i] == 'W';
11 |   }
12 |   int ans = 2147483647;
13 |   for (int i = 0; i < m; i++) {
14 |     int dist = 0;
15 |     for (int j = 0; j < m; j++) {
16 |       dist += sum[(i + j) % m][0] * (t[j] != 'B');
17 |       dist += sum[(i + j) % m][1] * (t[j] != 'G');
18 |       dist += sum[(i + j) % m][2] * (t[j] != 'W');
19 |     }
20 |     if (dist < ans) {
21 |       ans = dist;
22 |     }
23 |   }
24 |   printf("%d\n", ans);
25 |   return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/2011/J112.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int main() {
 3 |   int n, m, x, y, count = 1;
 4 |   int twos = 0, threes = 0;
 5 |   scanf("%d %d %d", &n, &m, &x);
 6 |   for (int i = 0; i < n - 1; i++) {
 7 |     scanf("%d %d", &x, &y);
 8 |     if (x == y) {
 9 |       count++;
10 |     } else {
11 |       count = 1;
12 |     }
13 |     if (count % 3 == 0) {
14 |       twos--;
15 |       threes++;
16 |     }
17 |     if (count % 3 == 2) {
18 |       twos++;
19 |     }
20 |   }
21 |   int ans;
22 |   if (m >= threes + twos) {
23 |     ans = threes * 2 + twos;
24 |   } else if (m <= threes) {
25 |     ans = m * 2;
26 |   } else {
27 |     ans = threes + m;
28 |   }
29 |   if (ans + m > n) {
30 |     ans = n - m;
31 |   }
32 |   printf("%d\n", ans);
33 |   return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/2014/J142.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int main() {
 3 |   int n, a = 0, b = 0, c = 0, d = 0, x, y;
 4 |   scanf("%d", &n);
 5 |   for (int i = 0; i < n; i++) {
 6 |     scanf("%d", &x);
 7 |     if (x <= 3) {
 8 |       scanf("%d", &y);
 9 |     }
10 |     if (x == 1) {
11 |       a += y;
12 |       b += y;
13 |     }
14 |     if (x == 2) {
15 |       c += y;
16 |       d += y;
17 |     }
18 |     if (x == 3) {
19 |       if (b < y) {
20 |         c -= y - b;
21 |         b = 0;
22 |       } else {
23 |         b -= y;
24 |       }
25 |       if (d < y) {
26 |         a -= y - d;
27 |         d = 0;
28 |       } else {
29 |         d -= y;
30 |       }
31 |     }
32 |     if (x == 4) {
33 |       printf("%d %d\n", a, b);
34 |     }
35 |   }
36 |   return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/2011/J114.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int a[200000];
 3 | int main() {
 4 |   int n, k, m = 0, mi;
 5 |   scanf("%d", &n);
 6 |   for (int i = n - 1; i >= 0; i--) {
 7 |     scanf("%d", &k);
 8 |     a[k + i]++;
 9 |     if (a[k + i] > m) {
10 |       m = a[k + i];
11 |       mi = k + i;
12 |     } else if (a[k + i] == m) {
13 |       if (k + i > mi) {
14 |         mi = k + i;
15 |       }
16 |     }
17 |   }
18 |   for (int i = 1; i < n; i++) {
19 |     scanf("%d", &k);
20 |     a[k + i]++;
21 |     if (a[k + i] > m) {
22 |       m = a[k + i];
23 |       mi = k + i;
24 |     } else if (a[k + i] == m) {
25 |       if (k + i > mi) {
26 |         mi = k + i;
27 |       }
28 |     }
29 |   }
30 |   printf("%d\n", 2 * n - m - 1);
31 |   printf("%d\n", mi);
32 |   return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Windows image file caches
 2 | Thumbs.db
 3 | ehthumbs.db
 4 | 
 5 | # Folder config file
 6 | Desktop.ini
 7 | 
 8 | # Recycle Bin used on file shares
 9 | $RECYCLE.BIN/
10 | 
11 | # Windows Installer files
12 | *.cab
13 | *.msi
14 | *.msm
15 | *.msp
16 | 
17 | # Windows shortcuts
18 | *.lnk
19 | 
20 | # =========================
21 | # Operating System Files
22 | # =========================
23 | 
24 | # OSX
25 | # =========================
26 | 
27 | .DS_Store
28 | .AppleDouble
29 | .LSOverride
30 | 
31 | # Thumbnails
32 | ._*
33 | 
34 | # Files that might appear on external disk
35 | .Spotlight-V100
36 | .Trashes
37 | 
38 | # Directories potentially created on remote AFP share
39 | .AppleDB
40 | .AppleDesktop
41 | Network Trash Folder
42 | Temporary Items
43 | .apdisk
44 | 
45 | *.o
46 | 


--------------------------------------------------------------------------------
/201415/S153.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | #include <vector>
 4 | using namespace std;
 5 | char s[300001], t[300001];
 6 | int u[300001];
 7 | vector<int> l[100];
 8 | int freq[100];
 9 | int main() {
10 |   scanf("%s", s);
11 |   int n = strlen(s);
12 |   int cur;
13 |   for (int i = 0; i < n; i++) {
14 |     if (s[i] == '.') {
15 |       cur = i;
16 |     } else {
17 |       freq[s[i]]++;
18 |       l[s[i]].push_back(i);
19 |     }
20 |   }
21 |   int m = 1;
22 |   for (int i = 'A'; i <= 'Z'; i++) {
23 |     for (int j = 0; j < freq[i]; j++) {
24 |       t[m] = i;
25 |       u[m] = j;
26 |       m++;
27 |     }
28 |   }
29 |   for (int i = 0; i < n - 1; i++) {
30 |     printf("%c", t[cur]);
31 |     cur = l[t[cur]][u[cur]];
32 |   }
33 |   printf(".\n");
34 |   return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/2009/J093.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int a[100000];
 3 | int freq[501];
 4 | int main() {
 5 |   int n, m;
 6 |   scanf("%d %d", &n, &m);
 7 |   for (int i = 0; i < n; i++) {
 8 |     scanf("%d", &a[i]);
 9 |   }
10 |   int ans = n;
11 |   for (int i = 1; i < n; i++) {
12 |     if (n % i != 0) {
13 |         continue;
14 |     }
15 |     int sum = 0;
16 |     for (int j = 0; j < i; j++) {
17 |       int max = 0;
18 |       for (int k = j; k < n; k += i) {
19 |         freq[a[k]]++;
20 |         if (freq[a[k]] > max) {
21 |           max = freq[a[k]];
22 |         }
23 |       }
24 |       for (int k = j; k < n; k += i) {
25 |         freq[a[k]]--;
26 |       }
27 |       sum += max;
28 |     }
29 |     if (n - sum < ans) {
30 |       ans = n - sum;
31 |     }
32 |   }
33 |   printf("%d\n", ans);
34 |   return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/2012/S122.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | int a[1000], b[1000], c[1000], d[1000];
 5 | int main() {
 6 |   int n;
 7 |   scanf("%d", &n);
 8 |   long long sum = 0;
 9 |   for (int i = 0; i < n; i++) {
10 |     scanf("%d %d %d %d", &a[i], &b[i], &c[i], &d[i]);
11 |     sum += 1LL * (c[i] - a[i]) * (d[i] - b[i] + 1)
12 |     sum += 1LL * (c[i] - a[i] + 1) * (d[i] - b[i]);
13 |     for (int j = 0; j < i; j++) {
14 |       if (a[i] == c[j] || c[i] == a[j]) {
15 |         sum -= max(0, d[i] - b[i] + d[j] - b[j] - max(d[i], d[j]) + min(b[i], b[j]));
16 |       } 
17 |       if (b[i] == d[j] || d[i] == b[j]) {
18 |         sum -= max(0, c[i] - a[i] + c[j] - a[j] - max(c[i], c[j]) + min(a[i], a[j]));
19 |       }
20 |     }
21 |   }
22 |   printf("%lld\n", sum);
23 |   return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/2011/J114.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a: array[0..200000] of longint;
 3 |   n, k, m, mi, i: longint;
 4 | begin
 5 |   for i := 0 to 200000 do
 6 |     a[i] := 0;
 7 |   read(n);
 8 |   m := 0;
 9 |   for i := n - 1 downto 0 do
10 |   begin
11 |     read(k);
12 |     inc(a[k + i]);
13 |     if (a[k + i] > m) then
14 |     begin
15 |       m := a[k + i];
16 |       mi := k + i
17 |     end
18 |     else if (a[k + i] = m) then
19 |       if (k + i > mi) then
20 |         mi := k + i
21 |   end;
22 |   for i := 1 to n - 1 do
23 |   begin
24 |     read(k);
25 |     inc(a[k + i]);
26 |     if (a[k + i] > m) then
27 |     begin
28 |       m := a[k + i];
29 |       mi := k + i
30 |     end
31 |     else if (a[k + i] = m) then
32 |       if (k + i > mi) then
33 |         mi := k + i
34 |   end;
35 |   writeln(2 * n - m - 1);
36 |   writeln(mi)
37 | end.
38 | 


--------------------------------------------------------------------------------
/2014/J141.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <algorithm>
 3 |  
 4 | using namespace std;
 5 |  
 6 | int main() {
 7 |   int n, m, k;
 8 |   long long tm, ts;
 9 |   scanf("%d %d %d %lld %lld", &n, &m, &k, &tm, &ts);
10 |   int batch = (k - 1) / m + 1;
11 |   int last_batch = (n - 1) / m + 1;
12 |   int page_of_batch = k - (batch - 1) * m;
13 |   long long method0 = ts * (k - 1);
14 |   long long pred_batch = tm * (batch - 2) + max(tm, ts);
15 |   long long method1 = pred_batch + ts * page_of_batch;
16 |   long long batch_end = tm * (batch - 1) + ts;
17 |   long long method2 = batch_end + ts * (last_batch == batch ? n - k : m - page_of_batch);
18 |   if (tm > ts * m)
19 |     method0 = 2147483647;
20 |   if (batch == 1)
21 |     method1 = 2147483647;
22 |   printf("%lld\n", min(method0, min(method1, method2)));
23 |   return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/201415/S153.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   s: ansistring;
 3 |   t: array[1..300000] of char;
 4 |   u: array[1..300000] of longint;
 5 |   l: array['A'..'Z', 1..300000] of longint;
 6 |   freq: array['A'..'Z'] of longint;
 7 |   n, m, cur, i: longint;
 8 |   c: char;
 9 | begin
10 |   read(s);
11 |   n := length(s);
12 |   for c := 'A' to 'Z' do
13 |     freq[c] := 0;
14 |   for i := 1 to n do
15 |     if (s[i] = '.') then
16 |       cur := i
17 |     else
18 |     begin
19 |       inc(freq[s[i]]);
20 |       l[s[i]][freq[s[i]]] := i
21 |     end;
22 |   m := 2;
23 |   for c := 'A' to 'Z' do
24 |     for i := 1 to freq[c] do
25 |     begin
26 |       t[m] := c;
27 |       u[m] := i;
28 |       inc(m)
29 |     end;
30 |   for i := 1 to n - 1 do
31 |   begin
32 |     write(t[cur]);
33 |     cur := l[t[cur]][u[cur]]
34 |   end;
35 |   writeln('.')
36 | end.
37 | 


--------------------------------------------------------------------------------
/2006/J064.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a: array[1..500, 0..500] of longint;
 3 |   b, covered: array[1..500] of boolean;
 4 |   i, j, n: longint;
 5 | begin
 6 |   for i := 1 to 500 do
 7 |   begin
 8 |     covered[i] := false;
 9 |     b[i] := false
10 |   end;
11 |   read(n);
12 |   for i := 1 to n do
13 |   begin
14 |     read(a[i][0]);
15 |     for j := 1 to a[i][0] do
16 |       read(a[i][j])
17 |   end;
18 |   for i := n downto 1 do
19 |   begin
20 |     if (not covered[i]) then
21 |     begin
22 |       b[i] := true;
23 |       for j := 1 to a[i][0] do
24 |       begin
25 |         if (covered[a[i][j]]) then
26 |         begin
27 |           writeln(-1);
28 |           halt
29 |         end;
30 |         covered[a[i][j]] := true
31 |       end
32 |     end
33 |   end;
34 |   for i := 1 to n do
35 |     if (b[i]) then
36 |       writeln(i)
37 | end.
38 | 


--------------------------------------------------------------------------------
/2009/S092.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int gifts[500000];
 3 | int last[1001];
 4 | int w[50000], v[50000];
 5 | int main() {
 6 |   int n, m;
 7 |   scanf("%d %d", &n, &m);
 8 |   for (int i = 0; i < n; i++) {
 9 |     scanf("%d", &gifts[i]);
10 |   }
11 |   for (int i = 0; i < m; i++) {
12 |     scanf("%d %d", &w[i], &v[i]);
13 |   }
14 |   for (int i = 0; i < n; i++) {
15 |     while (last[gifts[i]] < m && (w[last[gifts[i]]] < gifts[i] || v[last[gifts[i]]] < gifts[i])) {
16 |       last[gifts[i]]++;
17 |     }
18 |     if (last[gifts[i]] == m) {
19 |       printf("Impossible\n");
20 |       return 0;
21 |     }
22 |     v[last[gifts[i]]] -= gifts[i];
23 |     gifts[i] = last[gifts[i]] + 1;
24 |   }
25 |   for (int i = 0; i < n - 1; i++) {
26 |     printf("%d ", gifts[i]);
27 |   }
28 |   printf("%d\n", gifts[n - 1]);
29 |   return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/2009/S092.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   gifts: array[1..500000] of longint;
 3 |   last: array[1..1000] of longint;
 4 |   w, v: array[1..50000] of longint;
 5 |   n, m, i: longint;
 6 | begin
 7 |   for i := 1 to 1000 do
 8 |     last[i] := 1;
 9 |   read(n, m);
10 |   for i := 1 to n do
11 |     read(gifts[i]);
12 |   for i := 1 to m do
13 |     read(w[i], v[i]);
14 |   for i := 1 to n do
15 |   begin
16 |     while ((last[gifts[i]] <= m) and ((w[last[gifts[i]]] < gifts[i]) or (v[last[gifts[i]]] < gifts[i]))) do
17 |       inc(last[gifts[i]]);
18 |     if (last[gifts[i]] = m + 1) then
19 |     begin
20 |       writeln('Impossible');
21 |       halt
22 |     end;
23 |     v[last[gifts[i]]] := v[last[gifts[i]]] - gifts[i];
24 |     gifts[i] := last[gifts[i]]
25 |   end;
26 |   for i := 1 to n - 1 do
27 |     write(gifts[i], ' ');
28 |   writeln(gifts[n])
29 | end.
30 | 


--------------------------------------------------------------------------------
/2006/J061.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | char months[12][4] = {"Jan", "Feb", "Mar", "Apr", "May",
 4 |     "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 5 | int main() {
 6 |   int d, m, y, n;
 7 |   char mm[4];
 8 |   scanf("%d %s %d", &d, &mm, &y);
 9 |   scanf("%d", &n);
10 |   for (int i = 0; i < 12; i++)
11 |     if (strcmp(months[i], mm)==0)
12 |       m = i + 1;
13 |   for (int i = 0; i < n; i++) {
14 |     d++;
15 |     if (d == 32 || d == 31 && (m == 4 || m == 6 || m == 9 || m == 11)) {
16 |       m++;
17 |       d = 1;
18 |     }
19 |     if (d == 30 && m == 2 || d == 29 && m == 2 && (y % 4 != 0 || y % 100 == 0 && y%400 != 0)) {
20 |       m++;
21 |       d = 1;
22 |     }
23 |     if (m == 13) {
24 |       y++;
25 |       m = 1;
26 |     }
27 |   }
28 |   printf("%d %s %d\n", d, months[m - 1], y);
29 |   return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/2014/J142.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, a, b, c, d, x, y, i: longint;
 3 | begin
 4 |   a := 0;
 5 |   b := 0;
 6 |   c := 0;
 7 |   d := 0;
 8 |   read(n);
 9 |   for i := 1 to n do
10 |   begin
11 |     read(x);
12 |     if (x <= 3) then
13 |       read(y);
14 |     if (x = 1) then
15 |     begin
16 |       a := a + y;
17 |       b := b + y
18 |     end;
19 |     if (x = 2) then
20 |     begin
21 |       c := c + y;
22 |       d := d + y
23 |     end;
24 |     if (x = 3) then
25 |     begin
26 |       if (b < y) then
27 |       begin
28 |         c := c - y + b;
29 |         b := 0
30 |       end
31 |       else
32 |         b := b - y;
33 |       if (d < y) then
34 |       begin
35 |         a := a - y + d;
36 |         d := 0
37 |       end
38 |       else
39 |         d := d - y
40 |     end;
41 |     if (x = 4) then
42 |       writeln(a, ' ', b)
43 |   end
44 | end.
45 | 


--------------------------------------------------------------------------------
/201415/S151.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | inline int divide(int a, int b) {
 5 |   if (a < 0) return 0;
 6 |   return b == 0 ? 9999999 : a / b;
 7 | }
 8 | int main() {
 9 |   int r, g, w, x, y, z, p, q;
10 |   scanf("%d %d %d %d %d %d %d %d", &r, &g, &w, &x, &y, &z, &p, &q);
11 |   int ans = 0;
12 |   for (int red = 0; red <= r; red++) {
13 |     int green = min((r - red * (w - 1)) / y,  divide(g - red * x - 1, z - 1));
14 |     if (green < 1) {
15 |       break;
16 |     }
17 |     ans = max(ans, red * p + green * q);
18 |   }
19 |   for (int green = 0; green <= g; green++) {
20 |     int red = min(divide(r - green * y - 1, w - 1),  (g - green * (z - 1)) / x);
21 |     if (red < 1) {
22 |       break;
23 |     }
24 |     ans = max(ans, red * p + green * q);
25 |   }
26 |   printf("%d\n", ans + r * p + g * q);
27 |   return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/2013/S133.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | int a[2000][10001];
 4 | int b[2000];
 5 | int main() {
 6 |   memset(a, 0, 2000 * 10001 * 4);
 7 |   memset(b, 0, 2000 * 4);
 8 |   int n,m;
 9 |   double ans = 999999.0;
10 |   scanf("%d %d", &n, &m);
11 |   for (int i = 0; i < n; i++) {
12 |     for (int j = 0; j < m; j++) {
13 |       int x, y;
14 |       scanf("%d %d", &x, &y);
15 |       if (x > a[i][y])
16 |         a[i][y] = x;
17 |     }
18 |   }
19 |   for (int i = 1; i <= 10000; i++) {
20 |     double sum = 0.0;
21 |     bool ok = true;
22 |     for (int j = 0; j < n; j++) {
23 |       if (a[j][i] > b[j])
24 |         b[j] = a[j][i];
25 |       if (a[j][i] + b[j] == 0)
26 |         ok = false;
27 |       else
28 |         sum += b[j];
29 |     }
30 |     if (ok && i / sum < ans) 
31 |       ans = i / sum;
32 |   }
33 |   printf("%lf\n", ans);
34 |   return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/2006/J061.pas:
--------------------------------------------------------------------------------
 1 | const
 2 |   months: array[1..12] of string[3] = ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec');
 3 | var
 4 |   d, m, y, n, i: longint;
 5 |   mm: string[3];
 6 |   dummy: char;
 7 | begin
 8 |   read(d, dummy, mm, y);
 9 |   read(n);
10 |   for i := 1 to 12 do
11 |     if (months[i] = mm) then
12 |       m := i;
13 |   for i := 1 to n do
14 |   begin
15 |     inc(d);
16 |     if ((d = 32) or (d = 31) and ((m = 4) or (m = 6) or (m = 9) or (m = 11))) then
17 |     begin
18 |       inc(m);
19 |       d := 1;
20 |     end;
21 |     if ((d = 30) and (m = 2) or (d = 29) and (m = 2) and ((y mod 4 > 0) or (y mod 100 = 0) and (y mod 400 > 0))) then
22 |     begin
23 |       inc(m);
24 |       d := 1
25 |     end;
26 |     if (m = 13) then
27 |     begin
28 |       inc(y);
29 |       m := 1
30 |     end;
31 |   end;
32 |   writeln(d, ' ', months[m], ' ', y)
33 | end.
34 | 


--------------------------------------------------------------------------------
/2009/J094.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a, b, c, d: array[1..10000] of longint;
 3 |   n, m, k, x, ans, last, i: longint;
 4 | begin
 5 |   read(n, m, a[1]);
 6 |   for i := 2 to n - 1 do
 7 |     read(a[i]);
 8 |   for i := 2 to n - 1 do
 9 |     read(b[i]);
10 |   b[1] := 0;
11 |   a[n] := 0;
12 |   b[n] := 0;
13 |   c[n] := m;
14 |   for i := n - 1 downto 1 do
15 |   begin
16 |     c[i] := c[i + 1] + b[i + 1];
17 |     if (a[i + 1] > 0) then
18 |       dec(c[i]);
19 |     if (m < c[i]) then
20 |       c[i] := m
21 |   end;
22 |   ans := 0;
23 |   last := 0;
24 |   for i := 1 to n - 1 do
25 |   begin
26 |     last := last - b[i];
27 |     if (a[i] < c[i] - last) then
28 |       d[i] := a[i]
29 |     else
30 |       d[i] := c[i] - last;
31 |     ans := ans + d[i] * (n - i);
32 |     last := last + d[i]
33 |   end;
34 |   writeln(ans);
35 |   for i := 1 to n - 2 do
36 |     write(d[i], ' ');
37 |   writeln(d[n - 1])
38 | end.
39 | 


--------------------------------------------------------------------------------
/2009/J094.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int a[10001], b[10001], c[10001], d[10001];
 3 | int main() {
 4 |   int n, m, k, x;
 5 |   scanf("%d %d %d", &n, &m, &a[1]);
 6 |   for (int i = 2; i <= n - 1; i++) {
 7 |     scanf("%d", &a[i]);
 8 |   }
 9 |   for (int i = 2; i <= n - 1; i++) {
10 |     scanf("%d", &b[i]);
11 |   }
12 |   c[n] = m;
13 |   for (int i = n - 1; i >= 1; i--) {
14 |     c[i] = c[i + 1] - (a[i + 1] > 0) + b[i + 1];
15 |     if (m < c[i]) {
16 |       c[i] = m;
17 |     }
18 |   }
19 |   int ans = 0, last = 0;
20 |   for (int i = 1; i <= n - 1; i++) {
21 |     last -= b[i];
22 |     if (a[i] < c[i] - last) {
23 |       d[i] = a[i];
24 |     } else {
25 |       d[i] = c[i] - last;
26 |     }
27 |     ans += d[i] * (n - i);
28 |     last += d[i];
29 |   }
30 |   printf("%d\n", ans);
31 |   for (int i = 1; i <= n - 1; i++) {
32 |     printf("%d%c", d[i], i == n - 1 ? '\n' : ' ');
33 |   }
34 |   return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/2009/J093.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a: array[1..100000] of longint;
 3 |   freq: array[1..500] of longint;
 4 |   n, m, sum, max, ans, i, j, k: longint;
 5 | begin
 6 |   read(n, m);
 7 |   for i := 1 to m do
 8 |     freq[i] := 0;
 9 |   for i := 1 to n do
10 |     read(a[i]);
11 |   ans := n;
12 |   for i := 1 to n - 1 do
13 |   begin
14 |     if (n mod i <> 0) then
15 |       continue;
16 |     sum := 0;
17 |     for j := 1 to i do
18 |     begin
19 |       max := 0;
20 |       k := j;
21 |       while (k <= n) do
22 |       begin
23 |         inc(freq[a[k]]);
24 |         if (freq[a[k]] > max) then
25 |           max := freq[a[k]];
26 |         k := k + i;
27 |       end;
28 |       k := j;
29 |       while (k <= n) do
30 |       begin
31 |         dec(freq[a[k]]);
32 |         k := k + i
33 |       end;
34 |       sum := sum + max
35 |     end;
36 |     if (n - sum < ans) then
37 |       ans := n - sum
38 |   end;
39 |   writeln(ans)
40 | end.
41 | 


--------------------------------------------------------------------------------
/2009/J092.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | char s[20][21];
 4 | int v[20];
 5 | int main() {
 6 |   int n;
 7 |   scanf("%d", &n);
 8 |   for (int i = 0; i < n; i++) {
 9 |     scanf("%s", s[i]);
10 |     v[i] = 0;
11 |     for (int j = 0; j < strlen(s[i]); j++) {
12 |       v[i] |= 1 << (s[i][j] - 'A');
13 |     }
14 |   }
15 |   int mini, min = 21;
16 |   for (int i = 0; i < 1 << n; i++) {
17 |     int a = 0, count = 0;
18 |     for (int j = 0; j < n; j++) {
19 |       if (i & 1 << j) {
20 |         a |= v[j];
21 |         count++;
22 |       }
23 |     }
24 |     if (a == (1 << 26) - 1 && count < min) {
25 |       min = count;
26 |       mini = i;
27 |     }
28 |   }
29 |   if (min == 21) {
30 |     printf("Impossible\n");
31 |     return 0;
32 |   }
33 |   printf("%d\n", min);
34 |   for (int j = 0; j < n; j++) {
35 |     if (mini & 1 << j) {
36 |       printf("%s\n", s[j]);
37 |     }
38 |   }
39 |   return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/2011/S114.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | int a[1000], b[1000];
 5 | int main() {
 6 |   int n, c;
 7 |   scanf("%d %d", &n, &c);
 8 |   for (int i = 0; i < n; i++) {
 9 |     scanf("%d", &a[i]);
10 |   }
11 |   sort(a, a + n);
12 |   if (n % 2) {
13 |     for (int i = 0; i < n; i += 2) {
14 |       b[i] = a[i];
15 |     }
16 |     for (int i = 1; i < n; i += 2) {
17 |       b[i] = a[n - i - 1];
18 |     }
19 |   } else {
20 |     for (int i = 0; i < n / 2; i++) {
21 |       if (i % 2 == 0) {
22 |         b[i] = a[i];
23 |       } else {
24 |         b[n - i - 1] = a[i];
25 |       }
26 |     }
27 |     for (int i = n / 2; i < n; i++) {
28 |       if (i % 2 == 0) {
29 |         b[i + 1] = a[i];
30 |       } else {
31 |         b[n - i] = a[i];
32 |       }
33 |     }
34 |   }
35 |   for (int i = 0; i < n; i++) {
36 |     printf("%d%c", b[i], i == n - 1 ? '\n' : ' ');
37 |   }
38 |   return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/2013/S133.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a: array[1..2000, 1..10000] of longint;
 3 |   b: array[1..2000] of longint;
 4 |   n, m, i, j, x, y: longint;
 5 |   ok: boolean;
 6 |   sum, ans: double;
 7 | begin
 8 |   for i := 1 to 2000 do
 9 |   begin
10 |     for j := 1 to 10000 do
11 |       a[i][j] := 0;
12 |     b[i] := 0
13 |   end;
14 |   ans := 99999.0;
15 |   read(n, m);
16 |   for i := 1 to n do
17 |     for j := 1 to m do
18 |     begin
19 |       read(x, y);
20 |       if (x > a[i][y]) then
21 |         a[i][y] := x
22 |     end;
23 |   for i := 1 to 10000 do
24 |   begin
25 |     sum := 0.0;
26 |     ok := true;
27 |     for j := 1 to n do
28 |     begin
29 |       if (a[j][i] > b[j]) then
30 |         b[j] := a[j][i];
31 |       if (a[j][i] + b[j] = 0) then
32 |         ok := false
33 |       else
34 |         sum := sum + b[j];
35 |     end;
36 |     if (ok and (i / sum < ans)) then
37 |       ans := i / sum
38 |   end;
39 |   writeln(ans:0:6)
40 | end.
41 | 


--------------------------------------------------------------------------------
/2007/J074.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cmath>
 3 | #include <algorithm>
 4 | using namespace std;
 5 | pair<double, double> plans[6001];
 6 | double cost[6000001];
 7 | int main() {
 8 |   int n;
 9 |   scanf("%d", &n);
10 |   for (int i = 0; i < n; i++) {
11 |     scanf("%lf %lf", &plans[i].first, &plans[i].second);
12 |   }
13 |   sort(plans, plans + n);
14 |   plans[n].first = 99999.0;
15 |   plans[n].second = 99999.0;
16 |   int plan = 0;
17 |   for (int i = 0; i <= 6000000; i++) {
18 |     while (plans[plan].first + plans[plan].second * i / 1000.0 >
19 |       plans[plan + 1].first + plans[plan+1].second * i / 1000.0) {
20 |       plan++;
21 |     }
22 |     cost[i] = plans[plan].first + plans[plan].second * i / 1000.0;
23 |   }
24 |   int m;
25 |   double d;
26 |   scanf("%d", &m);
27 |   for (int i = 0; i < m; i++) {
28 |     scanf("%lf", &d);
29 |     printf("%.3lf\n", cost[(int)round(d * 1000.0)] + 0.0000001);
30 |   }
31 |   return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/2012/J124.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | int x[10000], y[10000];
 5 | int main() {
 6 |   int n, w, h, s, xx, yy, t;
 7 |   scanf("%d %d %d %d", &n, &w, &h, &s);
 8 |   for (int i = 0; i < n; i++) {
 9 |     scanf("%d %d", &x[i], &y[i]);
10 |   }
11 |   scanf("%d %d %d", &xx, &yy, &t);
12 |   long long sum = 0;
13 |   for (int i = 0; i < n; i++) {
14 |     int x1 = max(0, x[i] - t);
15 |     int x2 = min(w, x[i] + t);
16 |     int y1 = max(0, y[i] - t);
17 |     int y2 = min(h, y[i] + t);
18 |     sum += 1LL * (x2 - x1) * (y2 - y1);
19 |     int d = min(1000000LL, 1LL * s * t);
20 |     int x3 = max(0, xx - d);
21 |     int x4 = min(w, xx + d);
22 |     int y3 = max(0, yy - d);
23 |     int y4 = min(h, yy + d);
24 |     sum -= 1LL * max(0, x2 - x1 + x4 - x3 - max(x2, x4) + min(x1, x3))
25 |                * max(0, y2 - y1 + y4 - y3 - max(y2, y4) + min(y1, y3));
26 |   }
27 |   printf("%lld\n", sum);
28 |   return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/2009/J092.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, i, j, a, count, mini, min: longint;
 3 |   s: array[0..20] of string;
 4 |   v: array[0..20] of longint;
 5 | begin
 6 |   readln(n);
 7 |   for i := 0 to n - 1 do
 8 |   begin
 9 |     readln(s[i]);
10 |     v[i] := 0;
11 |     for j := 1 to length(s[i]) do
12 |       v[i] := v[i] or (1 shl (ord(s[i][j]) - ord('A')));
13 |   end;
14 |   min := 21;
15 |   for i := 0 to 1 shl n do
16 |   begin
17 |     a := 0;
18 |     count := 0;
19 |     for j := 0 to n - 1 do
20 |       if ((i and (1 shl j)) > 0) then
21 |       begin
22 |         a := a or v[j];
23 |         inc(count);
24 |       end;
25 |     if ((a = (1 shl 26) - 1) and (count < min)) then
26 |     begin
27 |       min := count;
28 |       mini := i;
29 |     end;
30 |   end;
31 |   if (min = 21) then
32 |     writeln('Impossible')
33 |   else
34 |   begin
35 |     writeln(min);
36 |     for j := 0 to n - 1 do
37 |       if ((mini and (1 shl j)) > 0) then
38 |         writeln(s[j]);
39 |   end;
40 | end.


--------------------------------------------------------------------------------
/2012/S122.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a, b, c, d: array[1..1000] of longint;
 3 |   n, i, j: longint;
 4 |   sum: int64;
 5 | function min(a, b: longint): longint;
 6 | begin
 7 |   if (a < b) then
 8 |     min := a
 9 |   else
10 |     min := b
11 | end;
12 | function max(a, b: longint): longint;
13 | begin
14 |   if (a > b) then
15 |     max := a
16 |   else
17 |     max := b
18 | end;
19 | begin
20 |   read(n);
21 |   sum := 0;
22 |   for i := 1 to n do
23 |   begin
24 |     read(a[i], b[i], c[i], d[i]);
25 |     sum := sum + int64(c[i] - a[i]) * (d[i] - b[i] + 1);
26 |     sum := sum + int64(c[i] - a[i] + 1) * (d[i] - b[i]);
27 |     for j := 1 to i - 1 do
28 |     begin
29 |       if ((a[i] = c[j]) or (c[i] = a[j])) then
30 |         sum := sum - max(0, d[i] - b[i] + d[j] - b[j] - max(d[i], d[j]) + min(b[i], b[j]));
31 |       if ((b[i] = d[j]) or (d[i] = b[j])) then
32 |         sum := sum - max(0, c[i] - a[i] + c[j] - a[j] - max(c[i], c[j]) + min(a[i], a[j]))
33 |     end
34 |   end;
35 |   writeln(sum)
36 | end.
37 | 


--------------------------------------------------------------------------------
/2007/J074.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   pa, pb: array[0..6000] of double;
 3 |   cost: array[0..6000000] of double;
 4 |   n, m, i, j, plan: longint;
 5 |   d: double;
 6 | begin
 7 |   read(n);
 8 |   for i := 0 to n - 1 do
 9 |     read(pa[i], pb[i]);
10 |   for i := n - 2 downto 0 do
11 |     for j := 0 to i do
12 |     begin
13 |       if (pa[j] > pa[j + 1]) then
14 |       begin
15 |         d := pa[j];
16 |         pa[j] := pa[j + 1];
17 |         pa[j + 1] := d;
18 |         d := pb[j];
19 |         pb[j] := pb[j + 1];
20 |         pb[j + 1] := d
21 |       end
22 |     end;
23 |   pa[n] := 99999.0;
24 |   pb[n] := 99999.0;
25 |   plan := 0;
26 |   for i := 0 to 6000000 do
27 |   begin
28 |     while (pa[plan] + pb[plan] * i / 1000.0 >
29 |       pa[plan + 1] + pb[plan + 1] * i / 1000.0) do
30 |       inc(plan);
31 |     cost[i] := pa[plan] + pb[plan] * i / 1000.0
32 |   end;
33 |   read(m);
34 |   for i := 1 to m do
35 |   begin
36 |     read(d);
37 |     writeln(cost[round(d * 1000.0)] + 0.0000001 : 0 : 3)
38 |   end
39 | end.
40 | 


--------------------------------------------------------------------------------
/2014/J141.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, m, k, batch, last_batch, page_of_batch: longint;
 3 |   tm, ts, method0, method1, method2, pred_batch, batch_end: int64;
 4 | begin
 5 |   read(n, m, k, tm, ts);
 6 |   batch := (k - 1) div m + 1;
 7 |   last_batch := (n - 1) div m + 1;
 8 |   page_of_batch := k - (batch - 1) * m;
 9 |   method0 := ts * (k - 1);
10 |   if (tm > ts) then
11 |     pred_batch := tm * (batch - 2) + tm
12 |   else
13 |     pred_batch := tm * (batch - 2) + ts;
14 |   method1 := pred_batch + ts * page_of_batch;
15 |   batch_end := tm * (batch - 1) + ts;
16 |   if (last_batch = batch) then
17 |     method2 := batch_end + ts * (n - k)
18 |   else
19 |     method2 := batch_end + ts * (m - page_of_batch);
20 |   if (tm > ts * m) then
21 |     method0 := 2147483647;
22 |   if (batch = 1) then
23 |     method1 := 2147483647;
24 |   if ((method0 < method1) and (method0 < method2)) then
25 |     writeln(method0)
26 |   else if (method1 < method2) then
27 |     writeln(method1)
28 |   else
29 |     writeln(method2)
30 | end.
31 | 


--------------------------------------------------------------------------------
/2013/J131.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | 
 3 | int main() {
 4 |   int n, m;
 5 |   int a[10001];
 6 |   int count[6];
 7 |   int last[6];
 8 |   scanf("%d %d", &n, &m);
 9 |   for (int i = 1; i <= m; i++) {
10 |     a[i] = 0;
11 |   }
12 |   for (int i = 1; i <= 100; i++) {
13 |     count[1] = count[3] = count[5] = 0;
14 |     for (int j = 1; j <= m; j++) {
15 |       int k;
16 |       scanf("%d", &k);
17 |       count[k]++;
18 |       last[k] = j;
19 |     }
20 |     if (count[1] == 1) {
21 |       a[last[1]] += 1;
22 |       gameover = a[last[1]] >= n;
23 |     }
24 |     if (count[3] == 1) {
25 |       a[last[3]] += 3;
26 |       gameover |= a[last[3]] >= n;
27 |     }
28 |     if (count[5] == 1) {
29 |       a[last[5]] += 5;
30 |       gameover |= a[last[5]] >= n;
31 |     }
32 |     if (gameover) {
33 |       printf("%d\n", i);
34 |       for (int j = 1; j < m; j++) {
35 |         printf("%d ", a[j] > n ? n : a[j]);
36 |       }   
37 |       printf("%d\n", a[m] > n ? n : a[m]);
38 |       return 0;
39 |     }
40 |   }
41 |   return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/2013/J132.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | char a[50001][13];
 4 | char b[50001][13];
 5 | int main() {
 6 |   int n, m;
 7 |   scanf("%d",&n);
 8 |   for (int i = 1; i <= n; i++) {
 9 |     scanf("%s", a[i]);
10 |   }
11 |   // simulate
12 |   int stalled = 0;
13 |   for (int front = 1; front < n; front++) {
14 |     if (strlen(a[front]) == 12 && strlen(a[front + 1]) == 8 && stalled < 2) {
15 |       strcpy(b[front], a[front + 1]);
16 |       strcpy(a[front + 1], a[front]);
17 |       stalled++;
18 |     } else if (strlen(a[front]) == 8 && strlen(a[front + 1]) == 8 && a[front][0] == '0' && a[front + 1][0] == '1' && stalled == 0) {
19 |       strcpy(b[front], a[front + 1]);
20 |       strcpy(a[front + 1], a[front]);
21 |       stalled++;
22 |     } else {
23 |       strcpy(b[front], a[front]);
24 |       stalled = 0;
25 |     }
26 |   }
27 |   strcpy(b[n], a[n]);
28 |   scanf("%d", &m);
29 |   int k;
30 |   for (int i = 1; i <= m; i++) {
31 |     scanf("%d", &k);
32 |     printf("%s%c", b[k], i == m ? '\n' : ' ');
33 |   }
34 |   return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/2010/S101.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int d[3001], p[3001];
 3 | int a[60001], b[60001];
 4 | int main() {
 5 |   for (int i = 0; i <= 60000; i++) {
 6 |     a[i] = b[i] = -1;
 7 |   }
 8 |   int n, m, x, y;
 9 |   char c;
10 |   scanf("%d %d", &n, &m);
11 |   for (int i = 0; i < n; i++) {
12 |     scanf("%d %d %c", &x, &y, &c);
13 |     d[i] = x;
14 |     p[i] = y;
15 |     if (c == 'A') {
16 |       a[x] = i;
17 |     } else {
18 |       b[x] = i;
19 |     }
20 |   }
21 |   d[3000] = 99999;
22 |   p[3000] = 0;
23 |   a[60000] = 3000;
24 |   b[60000] = 3000;
25 |   for (int i = 60000; i >= 0; i--) {
26 |     if (a[i] == -1)
27 |       a[i] = a[i + 1];
28 |     if (b[i] == -1)
29 |       b[i] = b[i + 1];
30 |   }
31 |   int sum = 0;
32 |   for (int i = 0; i < m; i++) {
33 |     scanf("%d %d", &x, &y);
34 |     if (x < 0) x = -x;
35 |     if (y < 0) y = -y;
36 |     n = x > y ? x : y;
37 |     if (d[a[n]] != n && d[b[x + y]] != x + y) {
38 |       sum += d[a[n]] < d[b[x + y]] ? p[a[n]] : p[b[x + y]];
39 |     }
40 |   }
41 |   printf("%d\n", sum);
42 |   return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/2011/S112.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   sum: array[1..2000, 1..3] of longint;
 3 |   s, t: ansistring;
 4 |   n, m, i, j, ans, dist: longint;
 5 | begin
 6 |   readln(n);
 7 |   readln(s);
 8 |   readln(m);
 9 |   readln(t);
10 |   for i := 0 to m - 1 do
11 |   begin
12 |     sum[i][0] := 0;
13 |     sum[i][1] := 0;
14 |     sum[i][2] := 0
15 |   end;
16 |   for i := 1 to n do
17 |   begin
18 |     if (s[i] = 'B') then
19 |       inc(sum[(i - 1) mod m][1]);
20 |     if (s[i] = 'G') then
21 |       inc(sum[(i - 1) mod m][2]);
22 |     if (s[i] = 'W') then
23 |       inc(sum[(i - 1) mod m][3])
24 |   end;
25 |   ans := 2147483647;
26 |   for i := 0 to m - 1 do
27 |   begin
28 |     dist := 0;
29 |     for j := 0 to m - 1 do
30 |     begin
31 |       if (t[j + 1] <> 'B') then
32 |         dist := dist + sum[(i + j) mod m][1];
33 |       if (t[j + 1] <> 'G') then
34 |         dist := dist + sum[(i + j) mod m][2];
35 |       if (t[j + 1] <> 'W') then
36 |         dist := dist + sum[(i + j) mod m][3];
37 |     end;
38 |     if (dist < ans) then
39 |       ans := dist
40 |   end;
41 |   writeln(ans)
42 | end.
43 | 


--------------------------------------------------------------------------------
/2014/J144.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int x[200001];
 3 | int main() {
 4 |   long long n, a, b;
 5 |   scanf("%lld %lld %lld", &n, &a, &b);
 6 |   for (int i = 1; i <= a; i++) {
 7 |     x[i] = 1;
 8 |   }
 9 |   long long s = n * (n + 1) / 2;
10 |   long long sa = a * (a + 1) / 2;
11 |   long long t = s / 2;
12 |   for (int i = a, j = n; i > 0 && sa < t; i--, j--) {
13 |     if (t - sa >= b) {
14 |       sa += b;
15 |       x[i] = 0;
16 |       x[j] = 1;
17 |     } else {
18 |       x[i] = 0;
19 |       x[i + t - sa] = 1;
20 |       break;
21 |     }
22 |   }
23 |   bool space = false;
24 |   for (int i = 1; i <= n; i++) {
25 |     if (x[i] == 0) {
26 |       continue;
27 |     }
28 |     if (space) {
29 |       printf(" ");
30 |     }
31 |     printf("%d", i);
32 |     space = true;
33 |   }
34 |   printf("\n");
35 |   space = false;
36 |   for (int i = 1; i <= n; i++) {
37 |     if (x[i] == 1) {
38 |       continue;
39 |     }
40 |     if (space) {
41 |       printf(" ");
42 |     }
43 |     printf("%d", i);
44 |     space = true;
45 |   }
46 |   printf("\n");
47 |   return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/2012/J122.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | 
 3 | int main() {
 4 |   int R,C,r,c;
 5 |   scanf("%d %d %d %d", &R, &C, &r, &c);
 6 |   if ((R * C % 2 == 0) || ((r - c) % 2 != 0)) {
 7 |     printf("Impossible\n");
 8 |     return 0;
 9 |   }
10 |   for (int i=1; i<r; i++) {
11 |     for (int j=0; j<C-1; j++)
12 |       printf("%c", 'a' + (i % 2) + (j & 2));
13 |     printf("%c\n", 'm' + ((i-1) & 2));
14 |   }
15 |   if (r % 2 == 1) {
16 |     for (int j=0; j<c-1; j++)
17 |       printf("%c", 'e' + (j & 2));
18 |     printf("*");
19 |     for (int j=c; j<C; j++)
20 |       printf("%c", 'e' + ((j+1) & 2));
21 |     printf("\n");
22 |   } else {
23 |     printf("%c", 'p' + (r & 2));
24 |     for (int j=0; j<c-2; j++)
25 |       printf("%c", 'e' + (j & 2));
26 |     printf("*");
27 |     for (int j=c; j<C-1; j++)
28 |       printf("%c", 'e' + (j & 2));
29 |     printf("%c\n", 'm' + ((r-1) & 2));
30 |   }
31 |   for (int i=r+1; i<=R; i++) {
32 |     printf("%c", 'p' + (i & 2));
33 |     for (int j=0; j<C-1; j++)
34 |       printf("%c", 'a' + (i % 2) + (j & 2));
35 |     printf("\n");
36 |   }
37 |   return 0;
38 | }


--------------------------------------------------------------------------------
/2014/J144.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   x: array[1..200000] of longint;
 3 |   i, j: longint;
 4 |   n, a, b, s, sa, t: int64;
 5 |   space: boolean;
 6 | begin
 7 |   read(n, a, b);
 8 |   for i := 1 to a do
 9 |     x[i] := 1;
10 |   s := n * (n + 1) div 2;
11 |   sa := a * (a + 1) div 2;
12 |   t := s div 2;
13 |   i := a;
14 |   j := n;
15 |   while ((i > 0) and (sa < t)) do
16 |   begin
17 |     if (t - sa >= b) then
18 |     begin
19 |       sa := sa + b;
20 |       x[i] := 0;
21 |       x[j] := 1
22 |     end
23 |     else
24 |     begin
25 |       x[i] := 0;
26 |       x[i + t - sa] := 1;
27 |       break
28 |     end;
29 |     dec(i);
30 |     dec(j);
31 |   end;
32 |   space := false;
33 |   for i := 1 to n do
34 |   begin
35 |     if (x[i] = 0) then 
36 |       continue;
37 |     if (space) then
38 |       write(' ');
39 |     write(i);
40 |     space := true
41 |   end;
42 |   writeln;
43 |   space := false;
44 |   for i := 1 to n do
45 |   begin
46 |     if (x[i] = 1) then
47 |       continue;
48 |     if (space) then
49 |       write(' ');
50 |     write(i);
51 |     space := true
52 |   end;
53 |   writeln
54 | end.
55 | 


--------------------------------------------------------------------------------
/201415/S151.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   r, g, w, x, y, z, p, q: longint;
 3 |   red, green, ans: longint;
 4 | function min(a, b: longint): longint;
 5 | begin
 6 |   if (a < b) then
 7 |     min := a
 8 |   else
 9 |     min := b
10 | end;
11 | function max(a, b: longint): longint;
12 | begin
13 |   if (a > b) then
14 |     max := a
15 |   else
16 |     max := b
17 | end;
18 | function divide(a, b: longint): longint;
19 | begin
20 |   if (a < 0) then
21 |     divide := 0
22 |   else if (b = 0) then
23 |     divide := 9999999
24 |   else
25 |     divide := a div b
26 | end;
27 | begin
28 |   read(r, g, w, x, y, z, p, q);
29 |   ans := 0;
30 |   for red := 0 to r do
31 |   begin
32 |     green := min((r - red * (w - 1)) div y, divide(g - red * x - 1, z - 1));
33 |     if (green < 1) then
34 |       break;
35 |     ans := max(ans, red * p + green * q)
36 |   end;
37 |   for green := 0 to g do
38 |   begin
39 |     red := min(divide(r - green * y - 1, w - 1), (g - green * (z - 1)) div x);
40 |     if (red < 1) then
41 |       break;
42 |     ans := max(ans, red * p + green * q)
43 |   end;
44 |   writeln(ans + r * p + g * q)
45 | end.
46 | 


--------------------------------------------------------------------------------
/2011/S114.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a, b: array[0..1000] of longint;
 3 |   n, c, i, j, t: longint;
 4 | begin
 5 |   read(n, c);
 6 |   for i := 1 to n do
 7 |     read(a[i]);
 8 |   for i := n - 1 downto 1 do
 9 |     for j := 1 to i do
10 |       if (a[j] > a[j + 1]) then
11 |       begin
12 |         t := a[j];
13 |         a[j] := a[j + 1];
14 |         a[j + 1] := t
15 |       end;
16 |   if (n mod 2 = 1) then
17 |   begin
18 |     i := 1;
19 |     while (i <= n) do
20 |     begin
21 |       b[i] := a[i];
22 |       i := i + 2
23 |     end;
24 |     i := 2;
25 |     while (i <= n) do
26 |     begin
27 |       b[i] := a[n - i + 1];
28 |       i := i + 2
29 |     end
30 |   end
31 |   else
32 |   begin
33 |     for i := 1 to n div 2 do
34 |     begin
35 |       if (i mod 2 = 1) then
36 |         b[i] := a[i]
37 |       else
38 |         b[n - i + 1] := a[i]
39 |     end;
40 |     for i := n div 2 + 1 to n do
41 |     begin
42 |       if (i mod 2 = 1) then
43 |         b[i + 1] := a[i]
44 |       else
45 |         b[n - i + 2] := a[i]
46 |     end;
47 |   end;
48 |   for i := 1 to n - 1 do
49 |     write(b[i], ' ');
50 |   writeln(b[n])
51 | end.
52 | 


--------------------------------------------------------------------------------
/2010/J101.pas:
--------------------------------------------------------------------------------
 1 | const
 2 |   // 10 = 0 left, 11 = 0 right
 3 |   dist:array[1..11] of string[12] = (
 4 |     '01212323412',
 5 |     '10121232321',
 6 |     '21032143232',
 7 |     '12301212323',
 8 |     '21210121232',
 9 |     '32121032143',
10 |     '23412301234',
11 |     '32321210143',
12 |     '43232121054',
13 |     '12323434501',
14 |     '21232343410');
15 | var
16 |   s: ansistring;
17 |   location, moves, i, len: longint;
18 | begin
19 |   read(s);
20 |   moves := 0;
21 |   location := 5;
22 |   len := length(s);
23 |   for i := 1 to len do
24 |   begin
25 |     if ((s[i] = '0') and (location <> 10) and (location <> 1) and (location <> 4) and (location <> 7)) then
26 |     begin
27 |       moves := moves + ord(dist[location][11]) - ord('0');
28 |       location := 11
29 |     end
30 |     else if (s[i] = '0') then
31 |     begin
32 |       moves := moves + ord(dist[location][10]) - ord('0');
33 |       location := 10
34 |     end
35 |     else
36 |     begin
37 |       moves := moves + ord(dist[location][ord(s[i]) - ord('0')]) - ord('0');
38 |       location := ord(s[i]) - ord('0')
39 |     end
40 |   end;
41 |   writeln(moves)
42 | end.
43 | 


--------------------------------------------------------------------------------
/2011/J111.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   freq, sorter: array[1..26] of longint;
 3 |   s: ansistring;
 4 |   k, len, i, j, t, d: longint;
 5 |   c: char;
 6 | begin
 7 |   read(k, c);
 8 |   readln(c);
 9 |   read(s);
10 |   len := length(s);
11 |   for i := 1 to 26 do
12 |     freq[i] := 0;
13 |   for i := 1 to len do
14 |   begin
15 |     if ((s[i] >= 'A') and (s[i] <= 'Z') or
16 |         (s[i] >= 'a') and (s[i] <= 'z')) then
17 |       inc(freq[ord(s[i]) mod 32]);
18 |   end;
19 |   for i := 1 to 26 do
20 |     sorter[i] := i;
21 |   for i := 25 downto 1 do
22 |     for j := 1 to i do
23 |       if (freq[sorter[j]] < freq[sorter[j + 1]]) then
24 |       begin
25 |         t := sorter[j];
26 |         sorter[j] := sorter[j + 1];
27 |         sorter[j + 1] := t
28 |       end;
29 |   d := sorter[k] - ord(c) mod 32;
30 |   if (d < 0) then
31 |     d := d + 26;
32 |   for i := 1 to len do
33 |     if ((s[i] >= 'A') and (s[i] <= 'Z')) then
34 |       write(chr(65 + (ord(s[i]) - 65 + 26 - d) mod 26))
35 |     else if ((s[i] >= 'a') and (s[i] <= 'z')) then
36 |       write(chr(97 + (ord(s[i]) - 97 + 26 - d) mod 26))
37 |     else
38 |       write(s[i]);
39 |   writeln
40 | end.
41 | 


--------------------------------------------------------------------------------
/2010/J101.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | int main() {
 4 |   // 0 = 0 left, 10 = 0 right
 5 |   char dist[11][12] = {"01232343451",
 6 |                        "10121232342",
 7 |                        "21012123231",
 8 |                        "32103214322",
 9 |                        "21230121233",
10 |                        "32121012122",
11 |                        "43212103213",
12 |                        "32341230124",
13 |                        "43232121013",
14 |                        "54323212104",
15 |                        "12123234340"};
16 |   char s[32];
17 |   scanf("%s", s);
18 |   int location = 5, moves = 0;
19 |   int len = strlen(s);
20 |   for (int i = 0; i < len; i++) {
21 |     if (s[i] == '0' && location != 0 && location != 1 && location != 4 && location != 7) {
22 |       moves += dist[location][10] - '0';
23 |       location = 10;
24 |     } else if (s[i] == '0') {
25 |       moves += dist[location][0] - '0';
26 |       location = 0;
27 |     } else {
28 |       moves += dist[location][s[i] - '0'] - '0';
29 |       location = s[i] - '0';
30 |     }
31 |   }
32 |   printf("%d\n", moves);
33 |   return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/2011/J111.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | int freq[32], sorter[32];
 4 | char s[256];
 5 | int main() {
 6 |   int k;
 7 |   char c;
 8 |   scanf("%d %c ", &k, &c);
 9 |   gets(s);
10 |   int len = strlen(s);
11 |   for (int i = 0; i < len; i++) {
12 |     if (s[i] >= 'A' && s[i] <= 'Z' ||
13 |         s[i] >= 'a' && s[i] <= 'z')
14 |         freq[s[i] % 32]++;
15 |   }
16 |   for (int i = 1; i <= 26; i++) {
17 |     sorter[i] = i;
18 |   }
19 |   for (int i = 25; i >= 1; i--) {
20 |     for (int j = 1; j <= i; j++) {
21 |       if (freq[sorter[j]] < freq[sorter[j + 1]]) {
22 |         int t = sorter[j];
23 |         sorter[j] = sorter[j + 1];
24 |         sorter[j + 1] = t;
25 |       }
26 |     }
27 |   }
28 |   int d = sorter[k] - c % 32;
29 |   if (d < 0) {
30 |     d += 26;
31 |   }
32 |   for (int i = 0; i < len; i++) {
33 |     if (s[i] >= 'A' && s[i] <= 'Z') {
34 |       printf("%c", 'A' + (s[i] - 'A' + 26 - d) % 26);
35 |     } else if (s[i] >= 'a' && s[i] <= 'z') {
36 |       printf("%c", 'a' + (s[i] - 'a' + 26 - d) % 26);
37 |     } else {
38 |       printf("%c", s[i]);
39 |     }
40 |   }
41 |   printf("\n");
42 |   return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/2012/J122.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   r, c, rr, cc, i, j: longint;
 3 | begin
 4 |   read(r, c, rr, cc);
 5 |   if ((r * c mod 2 = 0) or ((rr - cc) mod 2 <> 0)) then
 6 |   begin
 7 |     writeln('Impossible');
 8 |     exit
 9 |   end;
10 |   for i := 1 to rr - 1 do
11 |   begin
12 |     for j := 0 to c - 2 do
13 |       write(chr(ord('a') + (i mod 2) + (j and 2)));
14 |     writeln(chr(ord('m') + ((i - 1) and 2)))
15 |   end;
16 |   if (rr mod 2 = 1) then
17 |   begin
18 |     for j := 0 to cc - 2 do
19 |       write(chr(ord('e') + (j and 2)));
20 |     write('*');
21 |     for j := cc to c - 1 do
22 |       write(chr(ord('e') + ((j + 1) and 2)));
23 |     writeln
24 |   end
25 |   else
26 |   begin
27 |     write(chr(ord('p') + (rr and 2)));
28 |     for j := 0 to cc - 3 do
29 |       write(chr(ord('e') + (j and 2)));
30 |     write('*');
31 |     for j := cc to c - 2 do
32 |       write(chr(ord('e') + (j and 2)));
33 |     writeln(chr(ord('m') + ((rr - 1) and 2)))
34 |   end;
35 |   for i := rr + 1 to r do
36 |   begin
37 |     write(chr(ord('p') + (i and 2)));
38 |     for j := 0 to c - 2 do
39 |       write(chr(ord('a') + (i mod 2) + (j and 2)));
40 |     writeln
41 |   end;
42 | end.
43 | 


--------------------------------------------------------------------------------
/201415/J154.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | long long h[100002];
 3 | int main() {
 4 |   int n;
 5 |   long long money;
 6 |   scanf("%d %lld", &n, &money);
 7 |   for (int i = 1; i <= n; i++) {
 8 |     scanf("%lld", &h[i]);
 9 |     if (i >= 2 && h[i - 1] == h[1] && money + h[1] < h[i]) {
10 |       printf("Impossible\n");
11 |       return 0;
12 |     }
13 |   }
14 |   if (n <= 2) {
15 |     printf("0\n");
16 |     return 0;
17 |   }
18 |   money += h[1];
19 |   h[n + 1] = 9999999999999999LL;
20 |   int target = 2;
21 |   long long years = 0;
22 |   while (true) {
23 |     // find best home
24 |     while (h[target] <= money) {
25 |       target++;
26 |     }
27 |     if (target == n + 1) {
28 |       // check if can buy 1 year earlier....
29 |       if (money + h[1] >= h[n] * 2 && years > 0) {
30 |         years--;
31 |       }
32 |       printf("%lld\n", years);
33 |       return 0;
34 |     }
35 |     long long missing = h[target] - money;
36 |     // fast foward
37 |     long long ffcycles = (missing - 1) / (h[target - 1] - h[1]) / 2 + 1;
38 |     if (ffcycles < 0) {
39 |       ffcycles = 0;
40 |     }
41 |     years += 4 * ffcycles;
42 |     money += ffcycles * (h[target - 1]-h[1]) * 2;
43 |   }
44 | }
45 | 


--------------------------------------------------------------------------------
/2012/J124.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   x, y: array[1..10000] of longint;
 3 |   n, w, h, s, xx, yy, t, i: longint;
 4 |   x1, x2, y1, y2, x3, x4, y3, y4: longint;
 5 |   d, sum: int64;
 6 | function min(a, b: longint): longint;
 7 | begin
 8 |   if (a < b) then
 9 |     min := a
10 |   else
11 |     min := b
12 | end;
13 | function max(a, b: longint): longint;
14 | begin
15 |   if (a > b) then
16 |     max := a
17 |   else
18 |     max := b
19 | end;
20 | begin
21 |   read(n, w, h, s);
22 |   for i := 1 to n do
23 |     read(x[i], y[i]);
24 |   read(xx, yy, t);
25 |   sum := 0;
26 |   for i := 1 to n do
27 |   begin
28 |     x1 := max(0, x[i] - t);
29 |     x2 := min(w, x[i] + t);
30 |     y1 := max(0, y[i] - t);
31 |     y2 := min(h, y[i] + t);
32 |     sum := sum + int64(x2 - x1) * (y2 - y1);
33 |     if (int64(s) * t > 1000000) then
34 |       d := 1000000
35 |     else
36 |       d := longint(int64(s) * t);
37 |     x3 := max(0, xx - d);
38 |     x4 := min(w, xx + d);
39 |     y3 := max(0, yy - d);
40 |     y4 := min(h, yy + d);
41 |     sum := sum - max(0, x2 - x1 + x4 - x3 - max(x2, x4) + min(x1, x3)) *
42 |            int64(max(0, y2 - y1 + y4 - y3 - max(y2, y4) + min(y1, y3)))
43 |   end;
44 |   writeln(sum)
45 | end.
46 | 


--------------------------------------------------------------------------------
/2008/J084.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int a[1000][1000];
 3 | int r[1000], c[1000];
 4 | char o1[2000000];
 5 | int o2[2000000];
 6 | int main() {
 7 |   int n;
 8 |   scanf("%d", &n);
 9 |   for (int i = 0; i < n; i++) {
10 |     for (int j = 0; j < n; j++) {
11 |       scanf("%d", &a[i][j]);
12 |     }
13 |     r[i] = c[i] = i;
14 |   }
15 |   int t, o = 0;
16 |   for (int i = n - 1; i >= 0; i--) {
17 |     for (int j = 0; j < i; j++) {
18 |       if (a[r[j]][0] > a[r[j+1]][0]) {
19 |         o1[o] = 'R';
20 |         o2[o++] = j + 1;
21 |         t = r[j];
22 |         r[j] = r[j + 1];
23 |         r[j + 1] = t;
24 |       }
25 |       if (a[0][c[j]] > a[0][c[j + 1]]) {
26 |         o1[o] = 'C';
27 |         o2[o++] = j + 1;
28 |         t = c[j];
29 |         c[j] = c[j + 1];
30 |         c[j + 1] = t;
31 |       }
32 |     }
33 |   }
34 |   t = 0;
35 |   for (int i = 0; i < n; i++) {
36 |     for (int j = 0; j < n; j++) {
37 |       if (a[r[i]][c[j]] < t) {
38 |         printf("No solution\n");
39 |         return 0;
40 |       }
41 |       t = a[r[i]][c[j]];
42 |     }
43 |   }
44 |   for (int i = 0; i < o; i++) {
45 |     printf("%c %d\n", o1[i], o2[i]);
46 |   }
47 |   printf("Z\n");
48 |   return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/2010/S101.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   d, p: array[1..3001] of longint;
 3 |   a, b: array[0..60000] of longint;
 4 |   i, n, m, x, y, sum: longint;
 5 |   dummy, c: char;
 6 | begin
 7 |   for i := 0 to 60000 do
 8 |   begin
 9 |     a[i] := -1;
10 |     b[i] := -1
11 |   end;
12 |   read(n, m);
13 |   for i := 1 to n do
14 |   begin
15 |     read(x, y, dummy, c);
16 |     d[i] := x;
17 |     p[i] := y;
18 |     if (c = 'A') then
19 |       a[x] := i
20 |     else
21 |       b[x] := i
22 |   end;
23 |   d[3001] := 99999;
24 |   p[3001] := 0;
25 |   a[60000] := 3001;
26 |   b[60000] := 3001;
27 |   for i := 59999 downto 0 do
28 |   begin
29 |     if (a[i] = -1) then
30 |       a[i] := a[i + 1];
31 |     if (b[i] = -1) then
32 |       b[i] := b[i + 1]
33 |   end;
34 |   sum := 0;
35 |   for i := 1 to m do
36 |   begin
37 |     read(x, y);
38 |     if (x < 0) then
39 |       x := -x;
40 |     if (y < 0) then
41 |       y := -y;
42 |     if (x > y) then
43 |       n := x
44 |     else
45 |       n := y;
46 |     if ((d[a[n]] <> n) and (d[b[x + y]] <> x + y)) then
47 |       if (d[a[n]] < d[b[x + y]]) then
48 |         sum := sum + p[a[n]]
49 |       else
50 |         sum := sum + p[b[x + y]]
51 |   end;
52 |   writeln(sum)
53 | end.
54 | 


--------------------------------------------------------------------------------
/201415/J154.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   h: array[1..100001] of int64;
 3 |   n, target, i: longint;
 4 |   money, missing, ffcycles, years: int64;
 5 | begin
 6 |   read(n, money);
 7 |   for i := 1 to n do
 8 |   begin
 9 |     read(h[i]);
10 |     if (i >= 2) then
11 |       if ((h[i - 1] = h[1]) and (money + h[1] < h[i])) then
12 |       begin
13 |         writeln('Impossible');
14 |         halt
15 |       end
16 |   end;
17 |   if (n <= 2) then
18 |   begin
19 |     writeln(0);
20 |     halt
21 |   end;
22 |   money := money + h[1];
23 |   h[n + 1] := 9999999999999999;
24 |   target := 2;
25 |   years := 0;
26 |   while (true) do
27 |   begin
28 |     while (h[target] <= money) do
29 |       inc(target);
30 |     if (target = n + 1) then
31 |     begin
32 |       { check if can buy 1 year earlier}
33 |       if ((money + h[1] >= h[n] * 2) and (years > 0)) then
34 |         dec(years);
35 |       writeln(years);
36 |       halt
37 |     end;
38 |     missing := h[target] - money;
39 |     { fast forward }
40 |     ffcycles := (missing - 1) div (h[target - 1] - h[1]) div 2 + 1;
41 |     if (ffcycles < 0) then
42 |       ffcycles := 0;
43 |     years := years + 4 * ffcycles;
44 |     money := money + ffcycles * (h[target - 1] - h[1]) * 2
45 |   end
46 | end.
47 | 


--------------------------------------------------------------------------------
/2012/J121.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | 
 4 | char s[90][100];
 5 | 
 6 | int main() {
 7 |   for (int i = 10; i <= 99; i++) {
 8 |     s[i - 10][0] = i / 10 + '0';
 9 |     s[i - 10][1] = i % 10 + '0';
10 |     for (int k = 2; k < 100; k++) {
11 |       s[i - 10][k] = (s[i - 10][k - 2] - '0') * (s[i - 10][k - 1] - '0');
12 |       s[i - 10][k] = (s[i - 10][k] % 10) + '0';
13 |     }
14 |   }
15 |   char a[101];
16 |   char b[101];
17 |   scanf("%s", a);
18 |   scanf("%s", b);
19 |   int counta, countb;
20 |   int len = strlen(a);
21 |   if (len == 1) {
22 |     counta = (a[0] - '0') - 1;
23 |   } else if (len == 2) {
24 |     counta = (a[0] - '0') * 10 + (a[1] - '0') - 1;
25 |   } else {
26 |     int i;
27 |     for (i = 0; i < 90; i++) {
28 |       if (strncmp(s[i], a, len) >= 0) break;
29 |     }
30 |     counta = 90 * (len - 2) + i + 9;
31 |   }
32 |   len = strlen(b);
33 |   if (len == 1) {
34 |     countb = b[0] - '0';
35 |   } else if (len == 2) {
36 |     countb = (b[0] - '0') * 10 + (b[1] - '0');
37 |   } else {
38 |     int i;
39 |     for (i = 0; i < 90; i++) {
40 |       if (strncmp(s[i], b, len) > 0) break;
41 |     }
42 |     countb = 90 * (len - 2) + i + 9;
43 |   }
44 |   printf("%d\n", countb - counta);
45 |   return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/2013/J131.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, m, i, j, k: longint;
 3 |   a: array[1..10000] of longint;
 4 |   count, last: array[1..5] of longint;
 5 |   gameover: boolean;
 6 | begin
 7 |   readln(n, m);
 8 |   for i := 1 to m do
 9 |     a[i] := 0;
10 |   for i := 1 to 100 do
11 |   begin
12 |     count[1] := 0;
13 |     count[3] := 0;
14 |     count[5] := 0;
15 |     for j:= 1 to m do
16 |     begin
17 |       read(k);
18 |       inc(count[k]);
19 |       last[k] := j
20 |     end;
21 |     if (count[1] = 1) then
22 |     begin
23 |       a[last[1]] := a[last[1]] + 1;
24 |       gameover := a[last[1]] >= n
25 |     end;
26 |     if (count[3] = 1) then
27 |     begin
28 |       a[last[3]] := a[last[3]] + 3;
29 |       gameover := gameover or (a[last[3]] >= n)
30 |     end;
31 |     if (count[5] = 1) then
32 |     begin
33 |       a[last[5]] := a[last[5]] + 5;
34 |       gameover := gameover or (a[last[5]] >= n)
35 |     end;
36 |     if (gameover) then
37 |     begin
38 |       writeln(i);
39 |       for j := 1 to m-1 do
40 |         if (a[j] > n) then
41 |           write(n, ' ')
42 |         else
43 |           write(a[j], ' ');
44 |       if (a[m] > n) then
45 |         writeln(n)
46 |       else
47 |         writeln(a[m]);
48 |       break
49 |     end
50 |   end
51 | end.
52 | 


--------------------------------------------------------------------------------
/2008/J084.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a: array[1..1000, 1..1000] of longint;
 3 |   r, c: array[1..1000] of longint;
 4 |   o1: array[1..2000000] of char;
 5 |   o2: array[1..2000000] of longint;
 6 |   n, t, o, i, j: longint;
 7 | begin
 8 |   read(n);
 9 |   for i := 1 to n do
10 |   begin
11 |     for j := 1 to n do
12 |       read(a[i][j]);
13 |     r[i] := i;
14 |     c[i] := i
15 |   end;
16 |   o := 1;
17 |   for i := n - 1 downto 1 do
18 |     for j := 1 to i do
19 |     begin
20 |       if (a[r[j]][1] > a[r[j + 1]][1]) then
21 |       begin
22 |         o1[o] := 'R';
23 |         o2[o] := j;
24 |         inc(o);
25 |         t := r[j];
26 |         r[j] := r[j + 1];
27 |         r[j + 1] := t
28 |       end;
29 |       if (a[1][c[j]] > a[1][c[j + 1]]) then
30 |       begin
31 |         o1[o] := 'C';
32 |         o2[o] := j;
33 |         inc(o);
34 |         t := c[j];
35 |         c[j] := c[j + 1];
36 |         c[j + 1] := t
37 |       end
38 |     end;
39 |   t := 0;
40 |   for i := 1 to n do
41 |     for j := 1 to n do
42 |     begin
43 |       if (a[r[i]][c[j]] < t) then
44 |       begin
45 |         writeln('No solution');
46 |         halt
47 |       end;
48 |       t := a[r[i]][c[j]]
49 |     end;
50 |   for i := 1 to o - 1 do
51 |     writeln(o1[i], ' ', o2[i]);
52 |   writeln('Z')
53 | end.
54 | 


--------------------------------------------------------------------------------
/2008/J081.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | char s[50];
 3 | int vars[26];
 4 | int main() {
 5 |   for (int i = 0; i < 26; i++)
 6 |     vars[i] = -1000001;
 7 |   int n;
 8 |   scanf("%d", &n);
 9 |   for (int i = 0; i < n; i++) {
10 |     int first, second, pos;
11 |     bool add;
12 |     scanf("%s", s);
13 |     if (s[2] >= 'A') {
14 |       first = vars[s[2] - 'A'];
15 |       pos = 3;
16 |     } else {
17 |       first = 0;
18 |       pos = 2;
19 |       if (s[2] == '-')
20 |         pos++;
21 |       while (s[pos] >= '0' && s[pos] <= '9')
22 |         first = first * 10 + (s[pos++] - '0');
23 |       if (s[2] == '-')
24 |         first *= -1;
25 |     }
26 |     if (s[pos] == 0) {
27 |       vars[s[0] - 'A'] = first;
28 |       continue;
29 |     }
30 |     add = s[pos++] == '+';
31 |     if (s[pos] >= 'A') {
32 |       second = vars[s[pos] - 'A'];
33 |     } else {
34 |       second = 0;
35 |       if (s[pos] == '-') {
36 |         add = !add;
37 |         pos++;
38 |       }
39 |       while (s[pos] >= '0' && s[pos] <= '9')
40 |         second = second * 10 + (s[pos++] - '0');
41 |     }
42 |     vars[s[0] - 'A'] = first + (add ? second : -second);
43 |   }
44 |   for (int i = 0; i < 26; i++)
45 |     if (vars[i] != -1000001)
46 |       printf("%c=%d\n", 'A' + i, vars[i]);
47 |   return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/2013/J132.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a, b: array[1..50000] of string;
 3 |   n, m, front, i, stalled, k: longint;
 4 |   c: char;
 5 | begin
 6 |   readln(n);
 7 |   i := 1;
 8 |   a[1] := '';
 9 |   while (true) do
10 |   begin
11 |     read(c);
12 |     if ((c >= '0') and (c <= '9')) then
13 |       a[i] := a[i] + c
14 |     else
15 |     begin
16 |       inc(i);
17 |       a[i] := ''
18 |     end;
19 |     if (eoln) then
20 |       break
21 |   end;
22 |   stalled := 0;
23 |   for front := 1 to n - 1 do
24 |   begin
25 |     if ((length(a[front]) = 12) and (length(a[front + 1]) = 8) and (stalled < 2)) then
26 |     begin
27 |       b[front] := a[front + 1];
28 |       a[front + 1] := a[front];
29 |       inc(stalled)
30 |     end
31 |     else if ((length(a[front]) = 8) and (length(a[front + 1]) = 8) and (a[front][1] = '0') and (a[front + 1][1] = '1') and (stalled = 0)) then
32 |     begin
33 |       b[front] := a[front + 1];
34 |       a[front + 1] := a[front];
35 |       inc(stalled)
36 |     end
37 |     else
38 |     begin
39 |       b[front] := a[front];
40 |       stalled := 0
41 |     end
42 |   end;
43 |   b[n] := a[n];
44 |   read(m);
45 |   for i := 1 to m do
46 |   begin
47 |     read(k);
48 |     write(b[k]);
49 |     if (i = m) then
50 |       writeln
51 |     else
52 |       write(' ')
53 |   end
54 | end.
55 | 


--------------------------------------------------------------------------------
/2014/J143.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int a[50000];
 3 | int i;
 4 | int serial(int x, int y) {
 5 |   return x * 50000 + y;
 6 | }
 7 | bool search(int x, int y) {
 8 |   int z = serial(x, y);
 9 |   int l = 0, r = i;
10 |   while (r >= l) {
11 |     int mid = (l + r) / 2;
12 |     if (a[mid] == z) {
13 |       return true;
14 |     } else if (a[mid] > z) {
15 |       r = mid - 1;
16 |     } else {
17 |       l = mid + 1;
18 |     }
19 |   }
20 |   return false;
21 | }
22 | int main() {
23 |   int w, h, n, x, y;
24 |   int count = 0;
25 |   scanf("%d %d %d", &w, &h, &n);
26 |   for (i = 0; i < n; i++) {
27 |     scanf("%d %d", &x, &y);
28 |     a[i] = serial(x, y);
29 |     // upright
30 |     if (search(x - 4, y) && search(x - 3, y) && search(x - 2, y + 3) && search(x - 2, y + 2) && search(x - 1, y))
31 |       count++;
32 |     // T
33 |     if (search(x - 4, y) && search(x - 3, y) && search(x - 2, y - 3) && search(x - 2, y - 2) && search(x - 1, y))
34 |       count++;
35 |     // -|
36 |     if (search(x - 3, y - 2) && search(x - 2, y - 2) && search(x, y - 4) && search(x, y - 3) && search(x, y - 1))
37 |       count++;
38 |     // |-
39 |     if (search(x - 3, y - 2) && search(x - 3, y - 1) && search(x - 3, y + 1) && search(x - 3, y + 2) && search(x - 1, y))
40 |       count++;
41 |   }
42 |   printf("%d\n", count);
43 |   return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/2013/J134.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a: array[0..1000, 0..1000] of char;
 3 |   c: array[0..1000, 0..1000] of longint;
 4 |   t: array['A'..'Z'] of longint;
 5 |   w, h, p, r, l, i, j, x, y, ww, hh, ans: longint;
 6 |   ch: char;
 7 |   tx, ty: double;
 8 |   ok: boolean;
 9 | begin
10 |   read(w, h, p, r, l);
11 |   for i := 0 to p - 1 do
12 |     read(t[chr(65 + i)]);
13 |   readln;
14 |   for i := h - 1 downto 0 do
15 |   begin
16 |     for j := 0 to w - 1 do
17 |       read(a[i][j]);
18 |     readln
19 |   end;
20 |   for i := 0 to h - 1 do
21 |   begin
22 |     c[i][w - 1] := 1;
23 |     for j := w - 2 downto 0 do
24 |       if (a[i][j] = a[i][j + 1]) then
25 |         c[i][j] := c[i][j + 1] + 1
26 |       else
27 |         c[i][j] := 1
28 |   end;
29 |   ans := 0;
30 |   for i := 1 to r do
31 |   begin
32 |     read(tx, ty);
33 |     x := trunc(tx);
34 |     y := trunc(ty);
35 |     if (x = tx) then
36 |       ww := l
37 |     else
38 |       ww := l + 1;
39 |     if (y = ty) then
40 |       hh := l
41 |     else
42 |       hh := l + 1;
43 |     if ((tx < 0) or (ty < 0) or (x + ww > w) or (y + hh > h)) then
44 |       continue;
45 |     ok := true;
46 |     for j := 0 to hh - 1 do
47 |       if ((a[y + j][x] <> a[y][x]) or (c[y + j][x] < ww)) then
48 |       begin
49 |         ok := false;
50 |         break
51 |       end;
52 |     if (ok) then
53 |       ans := ans + t[a[y][x]]
54 |   end;
55 |   writeln(ans)
56 | end.
57 | 


--------------------------------------------------------------------------------
/2014/J143.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a: array[1..50000] of longint;
 3 |   i, w, h, n, x, y, count: longint;
 4 | function serial(x, y: longint): longint;
 5 | begin
 6 |   serial := x * 50000 + y;
 7 | end;
 8 | function search(x, y: longint): boolean;
 9 | var
10 |   l, r, mid, z: longint;
11 | begin
12 |   search := false;
13 |   z := serial(x, y);
14 |   l := 1;
15 |   r := i;
16 |   while (r >= l) do
17 |   begin
18 |     mid := (l + r) div 2;
19 |     if (a[mid] = z) then
20 |     begin
21 |       search := true;
22 |       exit
23 |     end
24 |     else if (a[mid] > z) then
25 |       r := mid - 1
26 |     else
27 |       l := mid + 1
28 |   end
29 | end;
30 | begin
31 |   count := 0;
32 |   read(w, h, n);
33 |   for i := 1 to n do
34 |   begin
35 |     read(x, y);
36 |     a[i] := serial(x, y);
37 |     if (search(x - 4, y) and search(x - 3, y) and search(x - 2, y + 3) and search(x - 2, y + 2) and search(x - 1, y)) then
38 |       inc(count);
39 |     if (search(x - 4, y) and search(x - 3, y) and search(x - 2, y - 3) and search(x - 2, y - 2) and search(x - 1, y)) then
40 |       inc(count);
41 |     if (search(x - 3, y - 2) and search(x - 2, y - 2) and search(x, y - 4) and search(x, y - 3) and search(x, y - 1)) then
42 |       inc(count);
43 |     if (search(x - 3, y - 2) and search(x - 3, y - 1) and search(x - 3, y + 1) and search(x - 3, y + 2) and search(x - 1, y)) then
44 |       inc(count);
45 |   end;
46 |   writeln(count)
47 | end.
48 | 


--------------------------------------------------------------------------------
/2009/J091.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int a[200001], b[200001], c[400001];
 3 | int ds[200001], de[200001];
 4 | int main() {
 5 |   int n, m;
 6 |   scanf("%d", &n);
 7 |   for (int i = 0; i < n; i++) {
 8 |     scanf("%d %d", &a[i * 2], &a[i * 2 + 1]);
 9 |     a[i * 2 + 1]++;
10 |   }
11 |   a[2 * n] = 999999999;
12 |   scanf("%d", &m);
13 |   for (int i = 0; i < m; i++) {
14 |     scanf("%d %d", &b[i * 2], &b[i * 2 + 1]);
15 |     b[i * 2 + 1]++;
16 |   }
17 |   b[2 * m] = 999999999;
18 |   int aa = 0, bb = 0;
19 |   for (int i = 0; i < 2 * (m + n); i++) {
20 |     if (a[aa] < b[bb]) {
21 |       if (aa % 2 == 0)
22 |         c[i] = a[aa];
23 |       else
24 |         c[i] = -a[aa];
25 |       aa++;
26 |     } else {
27 |       if (bb % 2 == 0)
28 |         c[i] = b[bb];
29 |       else
30 |         c[i] = -b[bb];
31 |       bb++;
32 |     }
33 |   }
34 |   c[2 * (m + n)] = 999999999;
35 |   int sum = 0;
36 |   int count = 0;
37 |   for (int i = 0; i < 2 * (m + n); i++) {
38 |     if (c[i] == -c[i + 1]) {
39 |       i++;
40 |       continue;
41 |     }
42 |     if (c[i] > 0) {
43 |       if (sum == 0) {
44 |         ds[count] = c[i];
45 |       }
46 |       sum++;
47 |     } else {
48 |       sum--;
49 |       if (sum == 0) {
50 |         de[count] = -c[i]-1;
51 |         count++;
52 |       }
53 |     }
54 |   }
55 |   printf("%d\n", count);
56 |   for (int i = 0; i < count; i++) {
57 |     printf("%d %d\n", ds[i], de[i]);
58 |   }
59 |   return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/2013/J134.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | #include <cmath>
 4 | char a[1001][1001];
 5 | int c[1001][1001];
 6 | int t[100];
 7 | int main() {
 8 |   int w, h, p, r, l;
 9 |   scanf("%d %d %d %d %d", &w, &h, &p, &r, &l);  
10 |   for (int i = 0; i < p; i++) {
11 |     scanf("%d", &t['A' + i]);
12 |   }
13 |   for (int i = h - 1; i >= 0; i--) {
14 |     scanf("%s", a[i]);
15 |   }
16 |   // compute
17 |   for (int i = 0; i < h; i++) {
18 |     c[i][w - 1] = 1;
19 |     for (int j = w - 2; j >= 0; j--) {
20 |       if (a[i][j] == a[i][j + 1]) {
21 |         c[i][j] = c[i][j + 1] + 1;
22 |       } else {
23 |         c[i][j] = 1;
24 |       }
25 |     }
26 |   }
27 |   int ans = 0;
28 |   for (int i = 0; i < r; i++) {
29 |     int x, y, ww, hh;
30 |     double tx, ty;
31 |     scanf("%lf %lf", &tx, &ty);
32 |     x = floor(tx);
33 |     y = floor(ty);
34 |     if (x == tx) {
35 |       ww = l;
36 |     } else {
37 |       ww = l + 1;
38 |     }
39 |     if (y == ty) {
40 |       hh = l;
41 |     } else {
42 |       hh = l + 1;
43 |     }            
44 |     if (tx < 0 || ty < 0 || x + ww > w || y + hh > h) {
45 |       continue;
46 |     }
47 |     bool ok = true;
48 |     for (int j = 0; j < hh; j++) {
49 |       if (a[y + j][x] != a[y][x] || c[y + j][x] < ww) {
50 |         ok = false;
51 |         break;
52 |       }
53 |     }
54 |     if (ok) {
55 |       ans += t[a[y][x]];
56 |     }
57 |   }
58 |   printf("%d\n", ans);
59 |   return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/2012/J121.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   s: array[0..89] of ansistring;
 3 |   a, b: ansistring;
 4 |   i, j, k, counta, countb, len: longint;
 5 | begin
 6 |   for i := 10 to 99 do
 7 |   begin
 8 |     setlength(s[i - 10], 100);
 9 |     s[i - 10][1] := chr(i div 10 + ord('0'));
10 |     s[i - 10][2] := chr(i mod 10 + ord('0'));
11 |     for k := 3 to 100 do
12 |     begin
13 |       j := (ord(s[i - 10][k - 2]) - ord('0')) * (ord(s[i - 10][k - 1]) - ord('0'));
14 |       s[i - 10][k] := chr(j mod 10 + ord('0'))
15 |     end
16 |   end;
17 |   readln(a);
18 |   readln(b);
19 |   len := length(a);
20 |   if (len = 1) then
21 |     counta := ord(a[1]) - ord('0') - 1
22 |   else if (len = 2) then
23 |     counta := (ord(a[1]) - ord('0')) * 10 + (ord(a[2]) - ord('0')) - 1
24 |   else
25 |   begin
26 |     i := 0;
27 |     while (i < 90) do
28 |     begin
29 |       setlength(s[i], len);
30 |       if (s[i] >= a) then
31 |         break;
32 |       inc(i)
33 |     end;
34 |     counta := 90 * (len - 2) + i + 9;
35 |   end;
36 |   len := length(b);
37 |   if (len = 1) then
38 |     countb := ord(b[1]) - ord('0')
39 |   else if (len = 2) then
40 |     countb := (ord(b[1]) - ord('0')) * 10 + (ord(b[2]) - ord('0'))
41 |   else
42 |   begin
43 |     i := 0;
44 |     while (i < 90) do
45 |     begin
46 |       setlength(s[i], len);
47 |       if (s[i] > b) then
48 |         break;
49 |       inc(i)
50 |     end;
51 |     countb := 90 * (len - 2) + i + 9
52 |   end;
53 |   writeln(countb - counta)
54 | end.
55 | 


--------------------------------------------------------------------------------
/2013/J133.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | char s[100001];
 3 | int main() {
 4 |   int n;
 5 |   scanf("%d", &n);
 6 |   scanf("%s", s);
 7 |   s[n] = 'G';
 8 |   char mode = 0;
 9 |   int start_y, start_w;
10 |   for (int i = 0; i <= n; i++) {
11 |     if (mode == 0 && s[i] == 'Y') {
12 |       mode = 11;
13 |       start_y = i + 1;
14 |     } else if (mode == 0 && s[i] == 'W') {
15 |       mode = 22;
16 |       start_w = i + 1;
17 |     } else if (mode == 11 && s[i] == 'G') {
18 |       mode = 0;
19 |       printf("Grow %d %d\n", start_y, i);
20 |     } else if (mode == 12 && s[i] == 'G') {
21 |       mode = 0;
22 |       printf("Grow %d %d\n", start_w, i);
23 |       printf("Grow %d %d\n", start_y, i);
24 |     } else if (mode == 21 && s[i] == 'G') {
25 |       mode = 0;
26 |       printf("Blow %d %d\n", start_y, i);
27 |       printf("SuperGrow %d %d\n", start_w, i);
28 |     } else if (mode == 22 && s[i] == 'G') {
29 |       mode = 0;
30 |       printf("SuperGrow %d %d\n", start_w, i);
31 |     } else if (mode == 11 && s[i] == 'W') {
32 |       mode = 12;
33 |       start_w = i + 1;
34 |     } else if (mode == 12 && s[i] == 'Y') {
35 |       mode = 11;
36 |       printf("Grow %d %d\n", start_w, i);
37 |     } else if (mode == 22 && s[i] == 'Y') {
38 |       mode = 21;
39 |       start_y = i + 1;
40 |     } else if (mode == 21 && s[i] == 'W') {
41 |       mode = 22;
42 |       printf("Blow %d %d\n", start_y, i);
43 |     }
44 |   }
45 |   printf("Finish\n");
46 |   return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/2011/S113.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | char a[1002][1002];
 4 | int up[1002][1002], down[1002][1002], left[1002][1002], right[1002][1002];
 5 | char s[4000001];
 6 | int main() {
 7 |   int n, m, c;
 8 |   scanf("%d %d %d", &n, &m, &c);
 9 |   for (int i = 1; i <= n; i++) {
10 |     scanf("%s", a[i] + 1);
11 |     a[i][0] = a[i][m + 1] = '#';
12 |   }
13 |   for (int j = 1; j <= m; j++) {
14 |     a[0][j] = a[n + 1][j] = '#';
15 |   }
16 |   for (int i = 1; i <= n; i++) {
17 |     for (int j = 1; j <= m; j++) {
18 |       left[i][j] = a[i][j - 1] == '#' ? 0 : left[i][j - 1] + 1;
19 |     }
20 |     for (int j = m; j >= 1; j--) {
21 |       right[i][j] = a[i][j + 1] == '#' ? 0 : right[i][j + 1] + 1;
22 |     }
23 |   }
24 |   for (int j = 1; j <= m; j++) {
25 |     for (int i = 1; i <= n; i++) {
26 |       up[i][j] = a[i - 1][j] == '#' ? 0 : up[i - 1][j] + 1;
27 |     }
28 |     for (int i = n; i >= 1; i--) {
29 |       down[i][j] = a[i + 1][j] == '#' ? 0 : down[i + 1][j] + 1;
30 |     }
31 |   }
32 |   long long sum = 0;
33 |   int x, y;
34 |   scanf("%d %d %s", &x, &y, s);
35 |   for (int i = 0; i < c; i++) {
36 |     if (s[i] == 'N') {
37 |       sum += up[x][y];
38 |       x -= up[x][y];
39 |     } else if (s[i] == 'E') {
40 |       sum += right[x][y];
41 |       y += right[x][y];
42 |     } else if (s[i] == 'S') {
43 |       sum += down[x][y];
44 |       x += down[x][y];
45 |     } else {
46 |       sum += left[x][y];
47 |       y -= left[x][y];
48 |     }
49 |   }
50 |   printf("%lld\n", sum);
51 |   return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/2009/J091.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a, b, ds, de: array[0..200000] of longint;
 3 |   c: array[0..400000] of longint;
 4 |   n, m, i, aa, bb, sum, count: longint;
 5 | begin
 6 |   read(n);
 7 |   for i := 0 to n - 1 do
 8 |   begin
 9 |     read(a[i * 2], a[i * 2 + 1]);
10 |     inc(a[i * 2 + 1])
11 |   end;
12 |   a[2 * n] := 999999999;
13 |   read(m);
14 |   for i := 0 to m - 1 do
15 |   begin
16 |     read(b[i * 2], b[i * 2 + 1]);
17 |     inc(b[i * 2 + 1])
18 |   end;
19 |   b[2 * m] := 999999999;
20 |   aa := 0;
21 |   bb := 0;
22 |   for i := 0 to 2 * (m + n) - 1 do
23 |   begin
24 |     if (a[aa] < b[bb]) then
25 |     begin
26 |       if (aa mod 2 = 0) then
27 |         c[i] := a[aa]
28 |       else
29 |         c[i] := -a[aa];
30 |       inc(aa)
31 |     end
32 |     else
33 |     begin
34 |       if (bb mod 2 = 0) then
35 |         c[i] := b[bb]
36 |       else
37 |         c[i] := -b[bb];
38 |       inc(bb)
39 |     end;
40 |   end;
41 |   c[2 * (m + n)] := 999999999;
42 |   sum := 0;
43 |   count := 0;
44 |   i := 0;
45 |   while (i < 2 * (m + n)) do
46 |   begin
47 |     if (c[i] = -c[i + 1]) then
48 |     begin
49 |       i := i + 2;
50 |       continue
51 |     end;
52 |     if (c[i] > 0) then
53 |     begin
54 |       if (sum = 0) then
55 |         ds[count] := c[i];
56 |       inc(sum)
57 |     end
58 |     else
59 |     begin
60 |       dec(sum);
61 |       if (sum = 0) then
62 |       begin
63 |         de[count] := -c[i] - 1;
64 |         inc(count)
65 |       end;
66 |     end;
67 |     inc(i)
68 |   end;
69 |   writeln(count);
70 |   for i := 0 to count - 1 do
71 |     writeln(ds[i], ' ', de[i]);
72 | end.
73 | 


--------------------------------------------------------------------------------
/2008/J081.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   vars: array['A'..'Z'] of longint;
 3 |   i, n, first, second, pos: longint;
 4 |   s: string;
 5 |   j: char;
 6 |   add: boolean;
 7 | begin
 8 |   for j := 'A' to 'Z' do
 9 |     vars[j] := -1000001;
10 |   readln(n);
11 |   for i := 1 to n do
12 |   begin
13 |     readln(s);
14 |     s[length(s) + 1] := ' ';
15 |     if (s[3] >= 'A') then
16 |     begin
17 |       first := vars[s[3]];
18 |       pos := 4
19 |     end
20 |     else
21 |     begin
22 |       first := 0;
23 |       pos := 3;
24 |       if (s[3] = '-') then
25 |         pos := 4;
26 |       while ((s[pos] >= '0') and (s[pos] <= '9')) do
27 |       begin
28 |         first := first * 10 + ord(s[pos]) - ord('0');
29 |         inc(pos)
30 |       end;
31 |       if (s[3] = '-') then
32 |         first := -first
33 |     end;
34 |     if (s[pos] = ' ') then
35 |     begin
36 |       vars[s[1]] := first;
37 |       continue
38 |     end;
39 |     add := s[pos] = '+';
40 |     inc(pos);
41 |     if (s[pos] >= 'A') then
42 |       second := vars[s[pos]]
43 |     else
44 |     begin
45 |       second := 0;
46 |       if (s[pos] = '-') then
47 |       begin
48 |         add := not add;
49 |         inc(pos)
50 |       end;
51 |       while ((s[pos] >= '0') and (s[pos] <= '9')) do
52 |       begin
53 |         second := second * 10 + ord(s[pos]) - ord('0');
54 |         inc(pos)
55 |       end;
56 |     end;
57 |     if (add) then
58 |       vars[s[1]] := first + second
59 |     else
60 |       vars[s[1]] := first - second
61 |   end;
62 |   for j := 'A' to 'Z' do
63 |     if (vars[j] <> -1000001) then
64 |       writeln(j, '=', vars[j])
65 | end.


--------------------------------------------------------------------------------
/json2md.js:
--------------------------------------------------------------------------------
 1 | fs = require("fs");
 2 | 
 3 | process.stdout.write('# HKOI Final Event Solutions\n\n## License for source codes in this repository\n\n');
 4 | process.stdout.write('Creative Commons Attribution-ShareAlike 4.0 International. ');
 5 | process.stdout.write('The full text of the license is available at ');
 6 | process.stdout.write('https://creativecommons.org/licenses/by-sa/4.0/legalcode.');
 7 | process.stdout.write('\n\n## Solutions\n\n');
 8 | 
 9 | var json = fs.readFileSync("solutions.json");
10 | var solutions = JSON.parse(json);
11 | var years = Object.keys(solutions);
12 | years.sort();
13 | var groups = ['senior', 'junior'];
14 | for (var i = years.length - 1; i >= 0; i--) {
15 |     var year = years[i];
16 |     process.stdout.write('### ' + year + '\n\n| ID | Name | Code | Slides |\n| ------ | ------ | ------ | ------ |\n');
17 |     for (var group in groups) {
18 |         for (var taskseq in solutions[year][groups[group]]) {
19 |             var task = solutions[year][groups[group]][taskseq];
20 |             process.stdout.write('| ' + task['id'] + ' | ');
21 |             process.stdout.write(task['name_en'] + ' | ');
22 |             if (task['code']) {
23 |                 process.stdout.write('[Pascal](' + year.replace('/', '') + '/' + task['id'] + '.pas) ');
24 |                 process.stdout.write('[C++](' + year.replace('/', '') + '/' + task['id'] + '.cpp) | ');
25 |             } else {
26 |                 process.stdout.write(' | ');
27 |             }
28 |             if (task['slides']) {
29 |                 process.stdout.write('[Slides](' + task['slides'] + ') |\n');
30 |             } else {
31 |                 process.stdout.write(' |\n');
32 |             }
33 |         }
34 |     }
35 |     process.stdout.write('\n');
36 | }
37 | 


--------------------------------------------------------------------------------
/2013/J133.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, i, mode, start_y, start_w: longint;
 3 |   s: ansistring;
 4 | begin
 5 |   readln(n);
 6 |   read(s);
 7 |   setlength(s, n + 1);
 8 |   s[n + 1] := 'G';
 9 |   mode := 0;
10 |   for i := 1 to n + 1 do
11 |   begin
12 |     if ((mode = 0) and (s[i] = 'Y')) then
13 |     begin
14 |       mode := 11;
15 |       start_y := i
16 |     end
17 |     else if ((mode = 0) and (s[i] = 'W')) then
18 |     begin
19 |       mode := 22;
20 |       start_w := i
21 |     end
22 |     else if ((mode = 11) and (s[i] = 'G')) then
23 |     begin
24 |       mode := 0;
25 |       writeln('Grow ', start_y, ' ', i - 1)
26 |     end
27 |     else if ((mode = 12) and (s[i] = 'G')) then
28 |     begin
29 |       mode := 0;
30 |       writeln('Grow ', start_w, ' ', i - 1);
31 |       writeln('Grow ', start_y, ' ', i - 1)
32 |     end
33 |     else if ((mode = 21) and (s[i] = 'G')) then
34 |     begin
35 |       mode := 0;
36 |       writeln('Blow ', start_y, ' ', i - 1);
37 |       writeln('SuperGrow ', start_w, ' ', i - 1)
38 |     end
39 |     else if ((mode = 22) and (s[i] = 'G')) then
40 |     begin
41 |       mode := 0;
42 |       writeln('SuperGrow ', start_w, ' ', i - 1)
43 |     end
44 |     else if ((mode = 11) and (s[i] = 'W')) then
45 |     begin
46 |       mode := 12;
47 |       start_w := i
48 |     end
49 |     else if ((mode = 12) and (s[i] = 'Y')) then
50 |     begin
51 |       mode := 11;
52 |       writeln('Grow ', start_w, ' ', i - 1)
53 |     end
54 |     else if ((mode = 22) and (s[i] = 'Y')) then
55 |     begin
56 |       mode := 21;
57 |       start_y := i
58 |     end
59 |     else if ((mode = 21) and (s[i] = 'W')) then
60 |     begin
61 |       mode := 22;
62 |       writeln('Blow ', start_y, ' ', i - 1)
63 |     end
64 |   end;
65 |   writeln('Finish')
66 | end.
67 | 


--------------------------------------------------------------------------------
/2014/S143.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | char s[50001][51];
 3 | int ahead[20001], atail[20001];
 4 | int bhead[20001], btail[20001];
 5 | int aa[50001], bb[50001];
 6 | int main() {
 7 |   int l, n, m;
 8 |   scanf("%d %d", &n, &l);
 9 |   for (int i = 0; i < 20001; i++) {
10 |     ahead[i] = -1;
11 |     bhead[i] = -1;
12 |   }
13 |   for (int i = 0; i < n; i++) {
14 |     scanf("%s", s[i]);
15 |     int akey = s[i][0] * 26 * 26 + s[i][1] * 26 + s[i][2] - 67488;
16 |     int bkey = s[i][l - 3] * 26 * 26 + s[i][l - 2] * 26 + s[i][l - 1] - 67488;
17 |     if (ahead[akey] == -1)
18 |       ahead[akey] = i;
19 |     else
20 |       aa[atail[akey]] = i;
21 |     atail[akey] = i;
22 |     if (bhead[bkey] == -1)
23 |       bhead[bkey] = i;
24 |     else 
25 |       bb[btail[bkey]] = i;
26 |     btail[bkey] = i;
27 |     aa[i] = bb[i] = -1;
28 |   }
29 |   char q[51];
30 |   scanf("%d", &m);  
31 |   for (int i = 0; i < m; i++) {
32 |     scanf(" %s", q);
33 |     int akey = q[0] * 26 * 26 + q[1] * 26 + q[2] - 67488;
34 |     int bkey = q[l - 3] * 26 * 26 + q[l - 2] * 26 + q[l - 1] - 67488;
35 |     int search = ahead[akey];
36 |     int diff = 0;
37 |     while (search != -1) {
38 |       diff = 0;
39 |       for (int k = 0; k < l; k++) {
40 |         if (q[k] != s[search][k])
41 |           diff++;
42 |         if (diff == 2)
43 |           break;
44 |       }
45 |       if (diff == 1) {
46 |         printf("%s\n", s[search]);
47 |         break;
48 |       }
49 |       search = aa[search];
50 |     }
51 |     if (diff == 1)
52 |       continue;
53 |     search = bhead[bkey];
54 |     while (search != -1) {
55 |       diff = 0;
56 |       for (int k = 0; k < l; k++) {
57 |         if (q[k] != s[search][k])
58 |           diff++;
59 |         if (diff == 2)
60 |           break;
61 |       }
62 |       if (diff == 1) {
63 |         printf("%s\n", s[search]);
64 |         break;
65 |       }
66 |       search = bb[search];
67 |     }
68 |   }
69 |   return 0;
70 | }
71 | 


--------------------------------------------------------------------------------
/2011/S113.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   a: array[0..1001, 0..1001] of char;
 3 |   up, down, left, right: array[0..1001, 0..1001] of longint;
 4 |   s: ansistring;
 5 |   n, m, c, i, j, x, y: longint;
 6 |   sum: int64;
 7 | begin
 8 |   readln(n, m, c);
 9 |   for i := 1 to n do
10 |   begin
11 |     for j := 1 to m do
12 |       read(a[i][j]);
13 |     a[i][0] := '#';
14 |     a[i][m + 1] := '#';
15 |     readln
16 |   end;
17 |   for j := 1 to m do
18 |   begin
19 |     a[0][j] := '#';
20 |     a[n + 1][j] := '#';
21 |   end;
22 |   for i := 1 to n do
23 |   begin
24 |     left[i][0] := 0;
25 |     for j := 1 to m do
26 |       if (a[i][j - 1] = '#') then
27 |         left[i][j] := 0
28 |       else
29 |         left[i][j] := left[i][j - 1] + 1;
30 |     right[i][m + 1] := 0;
31 |     for j := m downto 1 do
32 |       if (a[i][j + 1] = '#') then
33 |         right[i][j] := 0
34 |       else
35 |         right[i][j] := right[i][j + 1] + 1
36 |   end;
37 |   for j := 1 to m do
38 |   begin
39 |     up[0][j] := 0;
40 |     for i := 1 to n do
41 |       if (a[i - 1][j] = '#') then
42 |         up[i][j] := 0
43 |       else
44 |         up[i][j] := up[i - 1][j] + 1;
45 |     down[n + 1][j] := 0;
46 |     for i := n downto 1 do
47 |       if (a[i + 1][j] = '#') then
48 |         down[i][j] := 0
49 |       else
50 |         down[i][j] := down[i + 1][j] + 1;
51 |   end;
52 |   sum := 0;
53 |   readln(x, y);
54 |   read(s);
55 |   for i := 1 to c do
56 |   begin
57 |     if (s[i] = 'N') then
58 |     begin
59 |       sum := sum + up[x][y];
60 |       x := x - up[x][y]
61 |     end
62 |     else if (s[i] = 'E') then
63 |     begin
64 |       sum := sum + right[x][y];
65 |       y := y + right[x][y]
66 |     end
67 |     else if (s[i] = 'S') then
68 |     begin
69 |       sum := sum + down[x][y];
70 |       x := x + down[x][y]
71 |     end
72 |     else
73 |     begin
74 |       sum := sum + left[x][y];
75 |       y := y - left[x][y]
76 |     end
77 |   end;
78 |   writeln(sum)
79 | end.
80 | 


--------------------------------------------------------------------------------
/201415/J152.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int ones[20][2], zeros[20][2];
 3 | bool done[20];
 4 | int r[1048576];
 5 | char s[1048576][21];
 6 | int o1[20], o2[20], o3[20];
 7 | int main() {
 8 |   int n;
 9 |   scanf("%d", &n);
10 |   int m = 1 << n;
11 |   for (int i = 0; i < m; i++) {
12 |     scanf("%s %d", s[i], &r[i]);
13 |     for (int j = 0; j < n; j++) {
14 |       if (r[i] == 1) {
15 |         ones[j][s[i][j] - '0']++;
16 |       } else {
17 |         zeros[j][s[i][j] - '0']++;
18 |       }
19 |     }
20 |   }
21 |   int req = m / 2;
22 |   for (int i = 0; i < n - 1; i++) {
23 |     bool found = false;
24 |     for (int j = 0; j < n; j++) {
25 |       if (done[j]) {
26 |         continue;
27 |       }
28 |       for (int k = 0; k <= 1; k++) {
29 |         if (ones[j][k] == req || zeros[j][k] == req) {
30 |           o1[i] = j + 1;
31 |           o2[i] = k;
32 |           o3[i] = ones[j][k] == req ? 1 : 0;
33 |           for (int p = 0; p < m; p++) {
34 |             if (r[p] != -1 && s[p][j] - '0' == k) {
35 |               for (int q = 0; q < n; q++) {
36 |                 if (r[p] == 1) {
37 |                   ones[q][s[p][q] - '0']--;
38 |                 } else {
39 |                   zeros[q][s[p][q] - '0']--;
40 |                 }
41 |               }
42 |               r[p] = -1;
43 |             }
44 |           }
45 |           done[j] = true;
46 |           found = true;
47 |           break;
48 |         }
49 |       }
50 |     }
51 |     if (!found) {
52 |       printf("Impossible\n");
53 |       return 0;
54 |     }
55 |     req /= 2;
56 |   }
57 |   for (int j = 0; j < n; j++) {
58 |     if (!done[j]) {
59 |       if (ones[j][0] + ones[j][1] != 1) {
60 |         printf("Impossible\n");
61 |         return 0;
62 |       }
63 |       for (int i = 0; i < n - 1; i++) {
64 |         printf("%d %d %d\n", o1[i], o2[i], o3[i]);
65 |       }
66 |       printf("%d %d\n", j + 1, ones[j][0] > ones[j][1] ? 0 : 1);
67 |       return 0;
68 |     }
69 |   }
70 | }
71 | 


--------------------------------------------------------------------------------
/2014/S143.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   s: array[0..20000] of string;
 3 |   ahead, atail, bhead, btail: array[0..20000] of longint;
 4 |   aa, bb: array[0..20000] of longint;
 5 |   l, n, m, i, j: longint;
 6 |   q: string;
 7 |   akey, bkey, search, diff: longint;
 8 | begin
 9 |   readln(n, l);
10 |   for i := 0 to 20000 do
11 |   begin
12 |     ahead[i] := -1;
13 |     bhead[i] := -1;
14 |     atail[i] := -1;
15 |     btail[i] := -1
16 |   end;
17 |   for i := 1 to n do
18 |   begin
19 |     readln(q);
20 |     s[i] := q;
21 |     akey := ord(s[i][1]) * 26 * 26 + ord(s[i][2]) * 26 + ord(s[i][3]) - 67488;
22 |     bkey := ord(s[i][l - 2]) * 26 * 26 + ord(s[i][l - 1]) * 26 + ord(s[i][l]) - 67488;
23 |     if (ahead[akey] = -1) then
24 |       ahead[akey] := i
25 |     else
26 |       aa[atail[akey]] := i;
27 |     atail[akey] := i;
28 |     if (bhead[bkey] = -1) then
29 |       bhead[bkey] := i
30 |     else
31 |       bb[btail[bkey]] := i;
32 |     btail[bkey] := i;
33 |     aa[i] := -1;
34 |     bb[i] := -1
35 |   end;
36 |   readln(m);
37 |   for i := 1 to m do
38 |   begin
39 |     readln(q);
40 |     akey := ord(q[1]) * 26 * 26 + ord(q[2]) * 26 + ord(q[3]) - 67488;
41 |     bkey := ord(q[l - 2]) * 26 * 26 + ord(q[l - 1]) * 26 + ord(q[l]) - 67488;
42 |     search := ahead[akey];
43 |     diff := 0;
44 |     while (search <> -1) do
45 |     begin
46 |       diff := 0;
47 |       for j := 1 to l do
48 |       begin
49 |         if (q[j] <> s[search][j]) then
50 |           inc(diff);
51 |         if (diff = 2) then
52 |           break
53 |       end;
54 |       if (diff = 1) then
55 |       begin
56 |         writeln(s[search]);
57 |         break
58 |       end;
59 |       search := aa[search]
60 |     end;
61 |     if (diff = 1) then
62 |       continue;
63 |     search := bhead[bkey];
64 |     diff := 0;
65 |     while (search <> -1) do
66 |     begin
67 |       diff := 0;
68 |       for j := 1 to l do
69 |       begin
70 |         if (q[j] <> s[search][j]) then
71 |           inc(diff);
72 |         if (diff = 2) then 
73 |           break
74 |       end;
75 |       if (diff = 1) then
76 |       begin
77 |         writeln(s[search]);
78 |         break
79 |       end;
80 |       search := bb[search]
81 |     end
82 |   end
83 | end.
84 | 


--------------------------------------------------------------------------------
/201415/J152.pas:
--------------------------------------------------------------------------------
 1 | var
 2 |   n, m, i, j, l, p, q, req: longint;
 3 |   k: char;
 4 |   ones: array[1..20, '0'..'1'] of longint;
 5 |   zeros: array[1..20, '0'..'1'] of longint;
 6 |   done: array[1..20] of boolean;
 7 |   r: array[0..1048575] of longint;
 8 |   s: array[0..1048575] of string[20];
 9 |   o1, o3: array[1..20] of longint;
10 |   o2: array[1..20] of char;
11 |   found: boolean;
12 | begin
13 |   readln(n);
14 |   m := 1 shl n;
15 |   for i := 0 to m - 1 do
16 |   begin
17 |     readln(s[i]);
18 |     readln(r[i]);
19 |     for j := 1 to n do
20 |       if (r[i] = 1) then
21 |         inc(ones[j][s[i][j]])
22 |       else
23 |         inc(zeros[j][s[i][j]])
24 |   end;
25 |   req := m div 2;
26 |   for i := 1 to n - 1 do
27 |   begin
28 |     found := false;
29 |     for j := 1 to n do
30 |     begin
31 |       if (done[j]) then
32 |         continue;
33 |       for k := '0' to '1' do
34 |       begin
35 |         if ((ones[j][k] = req) or (zeros[j][k] = req)) then
36 |         begin
37 |           o1[i] := j;
38 |           o2[i] := k;
39 |           if (ones[j][k] = req) then
40 |             o3[i] := 1
41 |           else
42 |             o3[i] := 0;
43 |           for p := 0 to m - 1 do
44 |             if ((r[p] <> - 1) and (s[p][j] = k)) then
45 |             begin
46 |               for q := 1 to n do
47 |                 if (r[p] = 1) then
48 |                   dec(ones[q][s[p][q]])
49 |                 else
50 |                   dec(zeros[q][s[p][q]]);
51 |               r[p] := -1
52 |             end;
53 |           done[j] := true;
54 |           found := true;
55 |           break
56 |         end;
57 |       end
58 |     end;
59 |     if (not found) then
60 |     begin
61 |       writeln('Impossible');
62 |       halt
63 |     end;
64 |     req := req div 2
65 |   end;
66 |   for j := 1 to n do
67 |     if (not done[j]) then
68 |     begin
69 |       if (ones[j]['0'] + ones[j]['1'] <> 1) then
70 |       begin
71 |         writeln('Impossible');
72 |         halt
73 |       end;
74 |       for i := 1 to n - 1 do
75 |         writeln(o1[i], ' ', o2[i], ' ', o3[i]);
76 |       write(j, ' ');
77 |       if (ones[j]['0'] > ones[j]['1']) then
78 |         writeln('0')
79 |       else
80 |         writeln('1')
81 |     end
82 | end.
83 | 


--------------------------------------------------------------------------------
/2008/S081.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | int maxyears[1000001];
 3 | int dows[1000001];
 4 | int main() {
 5 |   int months[101];
 6 |   int m, w, l, mleap, dleap;
 7 |   int yul, mul, dul, a, b, n, sum = 0;
 8 |   scanf("%d %d %d %d %d", &m, &w, &l, &mleap, &dleap);
 9 |   for (int i = 1; i <= m; i++) {
10 |     scanf("%d", &months[i]);
11 |     sum += months[i];
12 |   }
13 |   scanf("%d %d %d %d %d", &yul, &mul, &dul, &a, &b);
14 |   
15 |   // first we assume the day before 1st Jan, 1 is day 0
16 |   int dow = 0;
17 |   for (int i = 1; i <= 1000000; i++) {
18 |     dows[i] = dow;
19 |     dow += sum + (i % l == 0 ? dleap : 0);
20 |     dow %= w;
21 |   }
22 | 
23 |   // find dow of given date
24 |   n = dows[yul];
25 |   for (int i = 1; i < mul; i++) {
26 |     n += months[i] + (yul % l == 0 && i == mleap ? dleap : 0);
27 |   }
28 |   n = (n + dul) % w;
29 | 
30 |   // then we simulate with all different day of week on day before 1st Jan
31 |   int noleap[100], leap[100];
32 |   for (int i = 0; i < w; i++) {
33 |     noleap[i] = 0;
34 |     dow = i;
35 |     for (int j = 1; j <= m; j++) {
36 |       if (months[j] >= 13 && (dow + 13) % w == n) {
37 |         noleap[i]++;
38 |       }
39 |       dow += months[j];
40 |     }
41 |   }
42 |   for (int i = 0; i < w; i++) {
43 |     leap[i] = 0;
44 |     dow = i;
45 |     for (int j = 1; j <= m; j++) {
46 |       if (months[j] + (j == mleap ? dleap : 0) >= 13 && (dow + 13) % w == n) {
47 |         leap[i]++;
48 |       }
49 |       dow += months[j] + (j == mleap ? dleap : 0);
50 |     }
51 |   }
52 |   
53 |   // lastly scan through year a to b to find max
54 |   int max = 0;
55 |   int maxcount = 0;
56 |   for (int i = a; i <= b; i++) {
57 |     if (i % l == 0) {
58 |       if (leap[dows[i]] > max) {
59 |         max = leap[dows[i]];
60 |         maxyears[0] = i;
61 |         maxcount = 1;
62 |       } else if (leap[dows[i]] == max) {
63 |         maxyears[maxcount] = i;
64 |         maxcount++;
65 |       }
66 |     } else if (noleap[dows[i]] > max) {
67 |       max = noleap[dows[i]];
68 |       maxyears[0] = i;
69 |       maxcount = 1;
70 |     } else if (noleap[dows[i]] == max) {
71 |       maxyears[maxcount] = i;
72 |       maxcount++;
73 |     }
74 |   }
75 |   
76 |   // output
77 |   printf("%d\n", max);
78 |   for (int i = 0; i < maxcount - 1; i++) {
79 |     printf("%d ", maxyears[i]);
80 |   }
81 |   printf("%d\n", maxyears[maxcount - 1]);
82 |   return 0;
83 | }
84 | 


--------------------------------------------------------------------------------
/2008/S081.pas:
--------------------------------------------------------------------------------
  1 | var
  2 |   maxyears, dows: array[1..1000000] of longint;
  3 |   months, noleap, leap: array[0..100] of longint;
  4 |   m, w, l, mleap, dleap, yul, mul, dul: longint;
  5 |   a, b, n, sum, i, j, dow, max, maxcount: longint;
  6 | begin
  7 |   read(m, w, l, mleap, dleap);
  8 |   sum := 0;
  9 |   for i := 1 to m do
 10 |   begin
 11 |     read(months[i]);
 12 |     sum := sum + months[i];
 13 |   end;
 14 |   read(yul, mul, dul, a, b);
 15 | 
 16 |   // first we assume the day before 1st Jan, 1 is day 0
 17 |   dow := 0;
 18 |   for i := 1 to 1000000 do
 19 |   begin
 20 |     dows[i] := dow;
 21 |     dow := dow + sum;
 22 |     if (i mod l = 0) then
 23 |       dow := dow + dleap;
 24 |     dow := dow mod w;
 25 |   end;
 26 | 
 27 |   // dow of given date
 28 |   n := dows[yul];
 29 |   for i := 1 to mul - 1 do
 30 |   begin
 31 |     n := n + months[i];
 32 |     if ((yul mod l = 0) and (i = mleap)) then
 33 |       n := n + dleap;
 34 |   end;
 35 |   n := (n + dul) mod w;
 36 | 
 37 |   // simulate all different day of week on day before 1st Jan
 38 |   for i := 0 to w - 1 do
 39 |   begin
 40 |     noleap[i] := 0;
 41 |     dow := i;
 42 |     for j := 1 to m do
 43 |     begin
 44 |       if ((months[j] >= 13) and ((dow + 13) mod w = n)) then
 45 |         inc(noleap[i]);
 46 |       dow := dow + months[j];
 47 |     end;
 48 |   end;
 49 |   for i := 0 to w - 1 do
 50 |   begin
 51 |     leap[i] := 0;
 52 |     dow := i;
 53 |     for j := 1 to m do
 54 |     begin
 55 |       if ((months[j] >= 13) or ((j = mleap) and (months[j] + dleap >= 13))) then
 56 |         if ((dow + 13) mod w = n) then
 57 |           inc(leap[i]);
 58 |       dow := dow + months[j];
 59 |       if (j = mleap) then
 60 |         dow := dow + dleap;
 61 |     end;
 62 |   end;
 63 | 
 64 |   // lastly scan through year a to b to find max
 65 |   max := 0;
 66 |   maxcount := 0;
 67 |   for i := a to b do
 68 |   begin
 69 |     if (i mod l = 0) then
 70 |     begin
 71 |       if (leap[dows[i]] > max) then
 72 |       begin
 73 |         max := leap[dows[i]];
 74 |         maxyears[1] := i;
 75 |         maxcount := 1;
 76 |       end
 77 |       else if (leap[dows[i]] = max) then
 78 |       begin
 79 |         maxyears[maxcount + 1] := i;
 80 |         inc(maxcount);
 81 |       end
 82 |     end
 83 |     else if (noleap[dows[i]] > max) then
 84 |     begin
 85 |       max := noleap[dows[i]];
 86 |       maxyears[1] := i;
 87 |       maxcount := 1;
 88 |     end
 89 |     else if (noleap[dows[i]] = max) then
 90 |     begin
 91 |       maxyears[maxcount + 1] := i;
 92 |       inc(maxcount);
 93 |     end;
 94 |   end;
 95 | 
 96 |   //output
 97 |   writeln(max);
 98 |   for i := 1 to maxcount - 1 do
 99 |     write(maxyears[i], ' ');
100 |   writeln(maxyears[maxcount])
101 | end.


--------------------------------------------------------------------------------
/201415/S154.cpp:
--------------------------------------------------------------------------------
  1 | #include <cstdio>
  2 | #include <cstdlib>
  3 | int a[1002][1002];
  4 | char b[1002][1002];
  5 | int n, m, xprev, yprev, minimum = 999999;
  6 | int minx1, miny1, minx2, miny2, mindir, minstartdir;
  7 | void check(int x1, int y1, int x2, int y2, int dir, int startdir, bool print) {
  8 |   a[xprev][yprev] = 0;
  9 |   a[x2][y2] = 1;
 10 |   xprev = x2;
 11 |   yprev = y2;
 12 |   if (x2 - x1 + abs(y1 - y2) - 1 != m) {
 13 |     return ;
 14 |   }
 15 |   int x = x1, y = y1, d = startdir;
 16 |   int count = 0;
 17 |   while (x != x2 || y != y2) {
 18 |     if (d == 2) {
 19 |       if (a[x + 1][y] == 1) {
 20 |         x++;
 21 |       } else {
 22 |         if (print) {
 23 |           b[x][y] = dir ? '\\' : '/';
 24 |         }
 25 |         count++;
 26 |         d = dir;
 27 |         if (d == 0) {
 28 |           y--;
 29 |           if (a[x][y] == 0) {
 30 |             return ;
 31 |           }
 32 |         }
 33 |         if (d == 1) {
 34 |           y++;
 35 |           if (a[x][y] == 0) {
 36 |             return ;
 37 |           }
 38 |         }
 39 |       }
 40 |     } else if (d == 0) {
 41 |       if (a[x][y - 1] == 1) {
 42 |         y--;
 43 |       } else {
 44 |         if (print) {
 45 |           b[x][y] = dir ? '\\' : '/';
 46 |         }
 47 |         count++;
 48 |         d = 2;
 49 |         x++;
 50 |         if (a[x][y] == 0) {
 51 |           return ;
 52 |         }
 53 |       }
 54 |     } else {
 55 |       if (a[x][y + 1] == 1) {
 56 |         y++;
 57 |       } else {
 58 |         if (print) {
 59 |           b[x][y] = dir ? '\\' : '/';
 60 |         }
 61 |         count++;
 62 |         d = 2;
 63 |         x++;
 64 |         if (a[x][y] == 0) {
 65 |           return ;
 66 |         }
 67 |       }
 68 |     }
 69 |   }
 70 |   if (!print) {
 71 |     if (count < minimum) {
 72 |       minimum = count;
 73 |       minx1 = x1;
 74 |       miny1 = y1;
 75 |       minx2 = x2;
 76 |       miny2 = y2;
 77 |       mindir = dir;
 78 |       minstartdir = startdir;
 79 |     }
 80 |   } else {
 81 |     for (int i = 1; i <= n; i++) {
 82 |       printf("%s\n", b[i] + 1);
 83 |     }
 84 |   }
 85 | }
 86 | int main() {
 87 |   scanf("%d", &n);
 88 |   char s[1001];
 89 |   for (int i = 1; i <= n; i++) {
 90 |     scanf("%s", s);
 91 |     for (int j = 0; j < n; j++) {
 92 |       if (s[j] == '#') {
 93 |         a[i][j + 1] = 1;
 94 |         m++;
 95 |       }
 96 |       b[i][j + 1] = '.';
 97 |     }
 98 |     b[i][n + 1] = 0;
 99 |   }
100 |   for (int i = 1; i <= n; i++) {
101 |     for (int j = 1; j <= n; j++) {
102 |       // 0 = left, 1 = right
103 |       check(0, i, j, 0, 0, 2, false); // J
104 |       check(0, i, j, n + 1, 1, 2, false); // L
105 |       if (i <= j) {
106 |         check(0, i, n + 1, j, 1, 2, false); // |
107 |         check(i, 0, j, n + 1, 1, 1, false); // Z
108 |       } else {
109 |         check(0, i, n + 1, j, 0, 2, false); // |
110 |         check(j, n + 1, i, 0, 0, 0, false); 
111 |       }
112 |       check(i, 0, n + 1, j, 1, 1, false); // 7
113 |       check(i, n + 1, n + 1, j, 0, 0, false); // r
114 |     }
115 |   }
116 |   if (minimum != 999999) {
117 |     check(minx1, miny1, minx2, miny2, mindir, minstartdir, true);
118 |   } else {
119 |     printf("Impossible\n");
120 |   }
121 |   return 0;
122 | }
123 | 


--------------------------------------------------------------------------------
/201415/S154.pas:
--------------------------------------------------------------------------------
  1 | var
  2 |   a: array[0..1001, 0..1001] of longint;
  3 |   b: array[0..1001] of ansistring;
  4 |   n, m, i, j, xprev, yprev, minn: longint;
  5 |   minx1, miny1, minx2, miny2, mindir, minstartdir: longint;
  6 |   s: ansistring;
  7 | procedure check(x1, y1, x2, y2, dir, startdir: longint; print: boolean);
  8 | var
  9 |   x, y, d, count: longint;
 10 | begin
 11 |   a[xprev][yprev] := 0;
 12 |   a[x2][y2] := 1;
 13 |   xprev := x2;
 14 |   yprev := y2;
 15 |   if (x2 - x1 + abs(y1 - y2) - 1 <> m) then
 16 |     exit;
 17 |   x := x1;
 18 |   y := y1;
 19 |   d := startdir;
 20 |   count := 0;
 21 |   while ((x <> x2) or (y <> y2)) do
 22 |   begin
 23 |     if (d = 2) then
 24 |     begin
 25 |       if (a[x + 1][y] = 1) then
 26 |         inc(x)
 27 |       else
 28 |       begin
 29 |         if (print) then
 30 |           if (dir = 1) then
 31 |             b[x][y] := '\'
 32 |           else
 33 |             b[x][y] := '/';
 34 |         inc(count);
 35 |         d := dir;
 36 |         if (d = 0) then
 37 |         begin
 38 |           dec(y);
 39 |           if (a[x][y] = 0) then
 40 |             exit
 41 |         end;
 42 |         if (d = 1) then
 43 |         begin
 44 |           inc(y);
 45 |           if (a[x][y] = 0) then
 46 |             exit
 47 |         end
 48 |       end
 49 |     end
 50 |     else if (d = 0) then
 51 |     begin
 52 |       if (a[x][y - 1] = 1) then
 53 |         dec(y)
 54 |       else
 55 |       begin
 56 |         if (print) then
 57 |           if (dir = 1) then
 58 |             b[x][y] := '\'
 59 |           else
 60 |             b[x][y] := '/';
 61 |         inc(count);
 62 |         d := 2;
 63 |         inc(x);
 64 |         if (a[x][y] = 0) then
 65 |           exit
 66 |       end
 67 |     end
 68 |     else
 69 |     begin
 70 |       if (a[x][y + 1] = 1) then
 71 |         inc(y)
 72 |       else
 73 |       begin
 74 |         if (print) then
 75 |           if (dir = 1) then
 76 |             b[x][y] := '\'
 77 |           else
 78 |             b[x][y] := '/';
 79 |         inc(count);
 80 |         d := 2;
 81 |         inc(x);
 82 |         if (a[x][y] = 0) then
 83 |           exit
 84 |       end
 85 |     end
 86 |   end;
 87 |   if (not print) then
 88 |   begin
 89 |     if (count < minn) then
 90 |     begin
 91 |       minn := count;
 92 |       minx1 := x1;
 93 |       miny1 := y1;
 94 |       minx2 := x2;
 95 |       miny2 := y2;
 96 |       mindir := dir;
 97 |       minstartdir := startdir
 98 |     end
 99 |   end
100 |   else
101 |     for i := 1 to n do
102 |     begin
103 |       for j := 1 to n do
104 |         write(b[i][j]);
105 |       writeln
106 |     end
107 | end;
108 | begin
109 |   readln(n);
110 |   for i := 0 to n + 1 do
111 |     for j := 0 to n + 1 do
112 |       a[i][j] := 0;
113 |   m := 0;
114 |   for i := 1 to n do
115 |   begin
116 |     readln(s);
117 |     setlength(b[i], n);
118 |     for j := 1 to n do
119 |     begin
120 |       if (s[j] = '#') then
121 |       begin
122 |         a[i][j] := 1;
123 |         inc(m)
124 |       end;
125 |       b[i][j] := '.'
126 |     end
127 |   end;
128 |   minn := 999999;
129 |   for i := 1 to n do
130 |     for j := 1 to n do
131 |     begin
132 |       { 0 = left, 1 = right }
133 |       check(0, i, j, 0, 0, 2, false); { J }
134 |       check(0, i, j, n + 1, 1, 2, false); { L }
135 |       if (i <= j) then
136 |       begin
137 |         check(0, i, n + 1, j, 1, 2, false); { | }
138 |         check(i, 0, j, n + 1, 1, 1, false) { Z }
139 |       end
140 |       else
141 |       begin
142 |         check(0, i, n + 1, j, 0, 2, false);
143 |         check(j, n + 1, i, 0, 0, 0, false)
144 |       end;
145 |       check(i, 0, n + 1, j, 1, 1, false); { 7 }
146 |       check(i, n + 1, n + 1, j, 0, 0, false) { r }
147 |     end;
148 |   if (minn <> 999999) then
149 |     check(minx1, miny1, minx2, miny2, mindir, minstartdir, true)
150 |   else
151 |     writeln('Impossible')
152 | end.
153 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # HKOI Final Event Solutions
  2 | 
  3 | ## License for source codes in this repository
  4 | 
  5 | Creative Commons Attribution-ShareAlike 4.0 International. The full text of the license is available at https://creativecommons.org/licenses/by-sa/4.0/legalcode.
  6 | 
  7 | ## Solutions
  8 | 
  9 | ### 2023/24
 10 | 
 11 | | ID | Name | Code | Slides |
 12 | | ------ | ------ | ------ | ------ |
 13 | | S241 | Mirror Horror |  | [Slides](https://assets.hkoi.org/training2024/S241.pdf) |
 14 | | S242 | Path of Infinity |  | [Slides](https://assets.hkoi.org/training2024/S242.pdf) |
 15 | | S243 | Stop the Avalanche! |  | [Slides](https://assets.hkoi.org/training2024/S243.pdf) |
 16 | | S244 | Group Photo |  | [Slides](https://assets.hkoi.org/training2024/S244.pdf) |
 17 | | J241 | Watermelon Game |  | [Slides](https://assets.hkoi.org/training2024/J241.pdf) |
 18 | | J242 | Digit Cipher |  | [Slides](https://assets.hkoi.org/training2024/J242.pdf) |
 19 | | J243 | Neat Corridor |  | [Slides](https://assets.hkoi.org/training2024/J243.pdf) |
 20 | | J244 | Passing Rate |  | [Slides](https://assets.hkoi.org/training2024/J244.pdf) |
 21 | 
 22 | ### 2022/23
 23 | 
 24 | | ID | Name | Code | Slides |
 25 | | ------ | ------ | ------ | ------ |
 26 | | S231 | Ambiguous Undecimal System |  | [Slides](https://assets.hkoi.org/training2023/S231.pdf) |
 27 | | S232 | Team Formation |  | [Slides](https://assets.hkoi.org/training2023/S232.pdf) |
 28 | | S233 | Doctor String in the Coordinates of Madness |  | [Slides](https://assets.hkoi.org/training2023/S233.pdf) |
 29 | | S234 | Triangle Tour |  | [Slides](https://assets.hkoi.org/training2023/S234.pdf) |
 30 | | J231 | Bubble Tea Shop |  | [Slides](https://assets.hkoi.org/training2023/J231.pdf) |
 31 | | J232 | Move Pads |  | [Slides](https://assets.hkoi.org/training2023/J232.pdf) |
 32 | | J233 | Mechanical Grid |  | [Slides](https://assets.hkoi.org/training2023/J233.pdf) |
 33 | | J234 | Rotating Needle |  | [Slides](https://assets.hkoi.org/training2023/J234.pdf) |
 34 | 
 35 | ### 2021/22
 36 | 
 37 | | ID | Name | Code | Slides |
 38 | | ------ | ------ | ------ | ------ |
 39 | | S221 | Hotel Rankings |  | [Slides](https://assets.hkoi.org/training2022/S221.pdf) |
 40 | | S222 | Gathering |  | [Slides](https://assets.hkoi.org/training2022/S222.pdf) |
 41 | | S223 | Pixel Math Puzzle |  | [Slides](https://assets.hkoi.org/training2022/S223.pdf) |
 42 | | S224 | Connectors |  | [Slides](https://assets.hkoi.org/training2022/S224.pdf) |
 43 | | J221 | Bus Route Category |  | [Slides](https://assets.hkoi.org/training2022/J221.pdf) |
 44 | | J222 | Spicy Ramen |  | [Slides](https://assets.hkoi.org/training2022/J222.pdf) |
 45 | | J223 | Ice Cream |  | [Slides](https://assets.hkoi.org/training2022/J223.pdf) |
 46 | | J224 | Digit Implant Strategy |  | [Slides](https://assets.hkoi.org/training2022/J224.pdf) |
 47 | 
 48 | ### 2020/21
 49 | 
 50 | | ID | Name | Code | Slides |
 51 | | ------ | ------ | ------ | ------ |
 52 | | S211 | Skyscraperhenge |  | [Slides](https://assets.hkoi.org/training2021/S211.pdf) |
 53 | | S212 | Super Chat |  | [Slides](https://assets.hkoi.org/training2021/S212.pdf) |
 54 | | S213 | Chinese Checkers |  | [Slides](https://assets.hkoi.org/training2021/S213.pdf) |
 55 | | J211 | Paint Shop |  | [Slides](https://assets.hkoi.org/training2021/J211.pdf) |
 56 | | J212 | Paint the Floor |  | [Slides](https://assets.hkoi.org/training2021/J212.pdf) |
 57 | | J213 | Paint the Wall |  | [Slides](https://assets.hkoi.org/training2021/J213.pdf) |
 58 | 
 59 | ### 2018/19
 60 | 
 61 | | ID | Name | Code | Slides |
 62 | | ------ | ------ | ------ | ------ |
 63 | | S191 | Unstoppable Onslaught |  | [Slides](https://assets.hkoi.org/training2019/S191.pdf) |
 64 | | S192 | Two Towers |  | [Slides](https://assets.hkoi.org/training2019/S192.pdf) |
 65 | | S193 | Alice's Housekeeper |  | [Slides](https://assets.hkoi.org/training2019/S193.pdf) |
 66 | | S194 | Snakes and Snakes |  | [Slides](https://assets.hkoi.org/training2019/S194.pdf) |
 67 | | J191 | Alice and Wings |  | [Slides](https://assets.hkoi.org/training2019/J191.pdf) |
 68 | | J192 | Bigger, Better |  | [Slides](https://assets.hkoi.org/training2019/J192.pdf) |
 69 | | J193 | Hyper Knight II |  | [Slides](https://assets.hkoi.org/training2019/J193.pdf) |
 70 | | J194 | Graffiti |  | [Slides](https://assets.hkoi.org/training2019/J194.pdf) |
 71 | 
 72 | ### 2017/18
 73 | 
 74 | | ID | Name | Code | Slides |
 75 | | ------ | ------ | ------ | ------ |
 76 | | S181 | Odd is Odd |  | [Slides](https://assets.hkoi.org/training2018/S181.pdf) |
 77 | | S182 | Tournament |  | [Slides](https://assets.hkoi.org/training2018/S182.pdf) |
 78 | | S183 | Desktop Icons |  | [Slides](https://assets.hkoi.org/training2018/S183.pdf) |
 79 | | S184 | Bogo Translate |  | [Slides](https://assets.hkoi.org/training2018/S184.pdf) |
 80 | | J181 | Wings and Nuggets |  | [Slides](https://assets.hkoi.org/training2018/J181.pdf) |
 81 | | J182 | Rope |  | [Slides](https://assets.hkoi.org/training2018/J182.pdf) |
 82 | | J183 | Shortest Path |  | [Slides](https://assets.hkoi.org/training2018/J183.pdf) |
 83 | | J184 | Mysterious Area |  | [Slides](https://assets.hkoi.org/training2018/J184.pdf) |
 84 | 
 85 | ### 2016/17
 86 | 
 87 | | ID | Name | Code | Slides |
 88 | | ------ | ------ | ------ | ------ |
 89 | | S171 | TV Ratings |  | [Slides](https://assets.hkoi.org/training2017/S171.pdf) |
 90 | | S172 | Degradion |  | [Slides](https://assets.hkoi.org/training2017/S172.pdf) |
 91 | | S173 | Monster GO |  | [Slides](https://assets.hkoi.org/training2017/S173.pdf) |
 92 | | S174 | Magic Triangle II |  | [Slides](https://assets.hkoi.org/training2017/S174.pdf) |
 93 | | J171 | Acronym |  | [Slides](https://assets.hkoi.org/training2017/J171.pdf) |
 94 | | J172 | Card Game |  | [Slides](https://assets.hkoi.org/training2017/J172.pdf) |
 95 | | J173 | Fibonacci Word |  | [Slides](https://assets.hkoi.org/training2017/J173.pdf) |
 96 | | J174 | Crosses |  | [Slides](https://assets.hkoi.org/training2017/J174.pdf) |
 97 | 
 98 | ### 2015/16
 99 | 
100 | | ID | Name | Code | Slides |
101 | | ------ | ------ | ------ | ------ |
102 | | S161 | Military Training |  | [Slides](https://assets.hkoi.org/training2016/2016-sen1.pdf) |
103 | | S162 | Robos' Feast |  | [Slides](https://assets.hkoi.org/training2016/2016-sen2.pdf) |
104 | | S163 | Arithmetic Sequence |  | [Slides](https://assets.hkoi.org/training2016/2016-sen3.pdf) |
105 | | S164 | Alice's Meal |  | [Slides](https://assets.hkoi.org/training2016/2016-sen4.pdf) |
106 | | J161 | Model Answer |  | [Slides](https://assets.hkoi.org/training2016/2016-jun1.pdf) |
107 | | J162 | Time Zones |  | [Slides](https://assets.hkoi.org/training2016/2016-jun2.pdf) |
108 | | J163 | Stone Game |  | [Slides](https://assets.hkoi.org/training2016/2016-jun3.pdf) |
109 | | J164 | Candy Factory |  | [Slides](https://assets.hkoi.org/training2016/2016-jun4.pdf) |
110 | 
111 | ### 2014/15
112 | 
113 | | ID | Name | Code | Slides |
114 | | ------ | ------ | ------ | ------ |
115 | | S150 | Enumeration | [Pascal](201415/S150.pas) [C++](201415/S150.cpp) |  |
116 | | S151 | Promotion Period | [Pascal](201415/S151.pas) [C++](201415/S151.cpp) | [Slides](https://assets.hkoi.org/training2015/sen1.pdf) |
117 | | S152 | Apple Garden | [Pascal](201415/S152.pas) [C++](201415/S152.cpp) | [Slides](https://assets.hkoi.org/training2015/sen2.pdf) |
118 | | S153 | Secret Message | [Pascal](201415/S153.pas) [C++](201415/S153.cpp) | [Slides](https://assets.hkoi.org/training2015/sen3.pdf) |
119 | | S154 | Monster Arena | [Pascal](201415/S154.pas) [C++](201415/S154.cpp) | [Slides](https://assets.hkoi.org/training2015/sen4.pdf) |
120 | | J150 | Enumeration | [Pascal](201415/J150.pas) [C++](201415/J150.cpp) |  |
121 | | J151 | Inverse Problem | [Pascal](201415/J151.pas) [C++](201415/J151.cpp) | [Slides](https://assets.hkoi.org/training2015/jun1.pdf) |
122 | | J152 | Royal Bodyguard | [Pascal](201415/J152.pas) [C++](201415/J152.cpp) | [Slides](https://assets.hkoi.org/training2015/jun2.pdf) |
123 | | J153 | Insert Delete | [Pascal](201415/J153.pas) [C++](201415/J153.cpp) | [Slides](https://assets.hkoi.org/training2015/jun3.pdf) |
124 | | J154 | Father's Will | [Pascal](201415/J154.pas) [C++](201415/J154.cpp) | [Slides](https://assets.hkoi.org/training2015/jun4.pdf) |
125 | 
126 | ### 2014
127 | 
128 | | ID | Name | Code | Slides |
129 | | ------ | ------ | ------ | ------ |
130 | | S140 | Enumeration | [Pascal](2014/S140.pas) [C++](2014/S140.cpp) |  |
131 | | S141 | Dividing the Cities |  |  |
132 | | S142 | Gene Mutation 2 |  | [Slides](https://assets.hkoi.org/training2014/sq2.pptx) |
133 | | S143 | Input Method | [Pascal](2014/S143.pas) [C++](2014/S143.cpp) | [Slides](https://assets.hkoi.org/training2014/sq3.pdf) |
134 | | S144 | Pharmaceutical Company |  | [Slides](https://assets.hkoi.org/training2014/sq4.pptx) |
135 | | J140 | Enumeration | [Pascal](2014/J140.pas) [C++](2014/J140.cpp) |  |
136 | | J141 | Phone Menu | [Pascal](2014/J141.pas) [C++](2014/J141.cpp) |  |
137 | | J142 | Magic Stones | [Pascal](2014/J142.pas) [C++](2014/J142.cpp) | [Slides](https://assets.hkoi.org/training2014/jq2.pptx) |
138 | | J143 | Power Socket | [Pascal](2014/J143.pas) [C++](2014/J143.cpp) | [Slides](https://assets.hkoi.org/training2014/jq3.pdf) |
139 | | J144 | Fair Santa Claus | [Pascal](2014/J144.pas) [C++](2014/J144.cpp) | [Slides](https://assets.hkoi.org/training2014/jq4.pdf) |
140 | 
141 | ### 2013
142 | 
143 | | ID | Name | Code | Slides |
144 | | ------ | ------ | ------ | ------ |
145 | | S131 | Bacteria Research |  | [Slides](https://assets.hkoi.org/training2013/sen1.pdf) |
146 | | S132 | Safe Storage |  | [Slides](https://assets.hkoi.org/training2013/sen2.pdf) |
147 | | S133 | TB | [Pascal](2013/S133.pas) [C++](2013/S133.cpp) |  |
148 | | S134 | Unfair Santa Claus |  | [Slides](https://assets.hkoi.org/training2013/sen4.pdf) |
149 | | J131 | Strategy Steps | [Pascal](2013/J131.pas) [C++](2013/J131.cpp) | [Slides](https://assets.hkoi.org/solutions/2130.pptx) |
150 | | J132 | Queueing | [Pascal](2013/J132.pas) [C++](2013/J132.cpp) | [Slides](https://assets.hkoi.org/training2013/jun2.pptx) |
151 | | J133 | Dryads | [Pascal](2013/J133.pas) [C++](2013/J133.cpp) | [Slides](https://assets.hkoi.org/training2013/jun3.pdf) |
152 | | J134 | Lucky Rainbow | [Pascal](2013/J134.pas) [C++](2013/J134.cpp) | [Slides](https://assets.hkoi.org/solutions/2133.pptx) |
153 | 
154 | ### 2012
155 | 
156 | | ID | Name | Code | Slides |
157 | | ------ | ------ | ------ | ------ |
158 | | S121 | Infinite Coding |  | [Slides](https://assets.hkoi.org/training2012/Infinite%20Coding.pdf) |
159 | | S122 | Toothpicks | [Pascal](2012/S122.pas) [C++](2012/S122.cpp) | [Slides](https://assets.hkoi.org/training2012/Toothpick.pdf) |
160 | | S123 | Songs |  | [Slides](https://assets.hkoi.org/training2012/Songs.pptx) |
161 | | S124 | Gene Mutation |  | [Slides](https://assets.hkoi.org/training2012/GeneMutation.ppt) |
162 | | J121 | Outstanding Integer | [Pascal](2012/J121.pas) [C++](2012/J121.cpp) |  |
163 | | J122 | Hotel | [Pascal](2012/J122.pas) [C++](2012/J122.cpp) |  |
164 | | J123 | Cheating Dice |  | [Slides](https://assets.hkoi.org/training2012/Dice.pptx) |
165 | | J124 | Penicillin | [Pascal](2012/J124.pas) [C++](2012/J124.cpp) | [Slides](https://assets.hkoi.org/training2012/Penicillin.ppt) |
166 | 
167 | ### 2011
168 | 
169 | | ID | Name | Code | Slides |
170 | | ------ | ------ | ------ | ------ |
171 | | S111 | Nuclear Reactor | [Pascal](2011/S111.pas) [C++](2011/S111.cpp) | [Slides](https://assets.hkoi.org/training2011/hkoi2011sol.pdf) |
172 | | S112 | Spectrum Identification | [Pascal](2011/S112.pas) [C++](2011/S112.cpp) | [Slides](https://assets.hkoi.org/training2011/hkoi2011sol.pdf) |
173 | | S113 | Gravity Game | [Pascal](2011/S113.pas) [C++](2011/S113.cpp) | [Slides](https://assets.hkoi.org/training2011/hkoi2011sol.pdf) |
174 | | S114 | Circular Circuit | [Pascal](2011/S114.pas) [C++](2011/S114.cpp) | [Slides](https://assets.hkoi.org/training2011/hkoi2011sol.pdf) |
175 | | J111 | WippiLeaks | [Pascal](2011/J111.pas) [C++](2011/J111.cpp) | [Slides](https://assets.hkoi.org/training2011/hkoi2011sol.pdf) |
176 | | J112 | Housekeeper | [Pascal](2011/J112.pas) [C++](2011/J112.cpp) | [Slides](https://assets.hkoi.org/training2011/hkoi2011sol.pdf) |
177 | | J113 | Factor Factory | [Pascal](2011/J113.pas) [C++](2011/J113.cpp) | [Slides](https://assets.hkoi.org/training2011/hkoi2011sol.pdf) |
178 | | J114 | Pyramid | [Pascal](2011/J114.pas) [C++](2011/J114.cpp) | [Slides](https://assets.hkoi.org/training2011/hkoi2011sol.pdf) |
179 | 
180 | ### 2010
181 | 
182 | | ID | Name | Code | Slides |
183 | | ------ | ------ | ------ | ------ |
184 | | S101 | Squares Dartboard | [Pascal](2010/S101.pas) [C++](2010/S101.cpp) |  |
185 | | S102 | Igloo |  | [Slides](https://assets.hkoi.org/training2010/igloo.pptx) |
186 | | S103 | Flexibility |  | [Slides](https://assets.hkoi.org/training2010/s3.pdf) |
187 | | S104 | OI Football Team |  | [Slides](https://assets.hkoi.org/training2010/s4.pdf) |
188 | | J101 | Numpad | [Pascal](2010/J101.pas) [C++](2010/J101.cpp) |  |
189 | | J102 | Quest for Polar Bear |  | [Slides](https://assets.hkoi.org/training2010/quest.pptx) |
190 | | J103 | Insect Galore |  | [Slides](https://assets.hkoi.org/training2010/insect.pptx) |
191 | | J104 | Reading Books |  | [Slides](https://assets.hkoi.org/training2010/score.pptx) |
192 | 
193 | ### 2009
194 | 
195 | | ID | Name | Code | Slides |
196 | | ------ | ------ | ------ | ------ |
197 | | S091 | Colored Balls | [Pascal](2009/S091.pas) [C++](2009/S091.cpp) |  |
198 | | S092 | Santa's Gifts | [Pascal](2009/S092.pas) [C++](2009/S092.cpp) |  |
199 | | S093 | Posters | [Pascal](2009/S093.pas) [C++](2009/S093.cpp) |  |
200 | | S094 | Reaching the Destination | [Pascal](2009/S094.pas) [C++](2009/S094.cpp) |  |
201 | | J091 | Set Union | [Pascal](2009/J091.pas) [C++](2009/J091.cpp) |  |
202 | | J092 | Dictionary | [Pascal](2009/J092.pas) [C++](2009/J092.cpp) |  |
203 | | J093 | Necklace | [Pascal](2009/J093.pas) [C++](2009/J093.cpp) |  |
204 | | J094 | Full | [Pascal](2009/J094.pas) [C++](2009/J094.cpp) | [Slides](https://assets.hkoi.org/solutions/2093.pptx) |
205 | 
206 | ### 2008
207 | 
208 | | ID | Name | Code | Slides |
209 | | ------ | ------ | ------ | ------ |
210 | | S081 | Black Day | [Pascal](2008/S081.pas) [C++](2008/S081.cpp) |  |
211 | | S082 | Shy Tortoise |  | [Slides](https://assets.hkoi.org/training2008/01_sol_sq2.ppt) |
212 | | S083 | Storage Box |  | [Slides](https://assets.hkoi.org/training2008/01_sol_sq3.ppt) |
213 | | S084 | Defense Line |  | [Slides](https://assets.hkoi.org/training2008/01_sol_sq4.ppt) |
214 | | J081 | Simple Calculator | [Pascal](2008/J081.pas) [C++](2008/J081.cpp) |  |
215 | | J082 | Joining Metal Chains | [Pascal](2008/J082.pas) [C++](2008/J082.cpp) |  |
216 | | J083 | Count 1s | [Pascal](2008/J083.pas) [C++](2008/J083.cpp) | [Slides](https://assets.hkoi.org/training2008/01_sol_jq3.ppt) |
217 | | J084 | Who Moved My Cheese | [Pascal](2008/J084.pas) [C++](2008/J084.cpp) | [Slides](https://assets.hkoi.org/training2008/01_sol_jq4.ppt) |
218 | 
219 | ### 2007
220 | 
221 | | ID | Name | Code | Slides |
222 | | ------ | ------ | ------ | ------ |
223 | | S071 | Storage Centre |  | [Slides](https://assets.hkoi.org/training2007/01_sol_sq1.ppt) |
224 | | S072 | Partners |  | [Slides](https://assets.hkoi.org/training2007/01_sol_sq2.ppt) |
225 | | S073 | SOS |  | [Slides](https://assets.hkoi.org/training2007/01_sol_sq3.pdf) |
226 | | S074 | Meet in the Middle |  |  |
227 | | J071 | Zoo Planning |  | [Slides](https://assets.hkoi.org/training2007/01_sol_jq1.pdf) |
228 | | J072 | Little Stage |  | [Slides](https://assets.hkoi.org/training2007/01_sol_jq2.ppt) |
229 | | J073 | Shuttle Bus |  |  |
230 | | J074 | Best Plan | [Pascal](2007/J074.pas) [C++](2007/J074.cpp) |  |
231 | 
232 | ### 2006
233 | 
234 | | ID | Name | Code | Slides |
235 | | ------ | ------ | ------ | ------ |
236 | | S061 | Three Little Pigs |  | [Slides](https://assets.hkoi.org/training2006/01_sol_s1.ppt) |
237 | | S062 | Toggle |  | [Slides](https://assets.hkoi.org/training2006/01_sol_s2.ppt) |
238 | | S063 | Squareland |  | [Slides](https://assets.hkoi.org/training2006/01_sol_s3.ppt) |
239 | | S064 | Tappy Game |  | [Slides](https://assets.hkoi.org/training2006/01_sol_s4.ppt) |
240 | | J061 | Expiry Date | [Pascal](2006/J061.pas) [C++](2006/J061.cpp) |  |
241 | | J062 | Bit Split | [Pascal](2006/J062.pas) [C++](2006/J062.cpp) |  |
242 | | J063 | Sudoku |  | [Slides](https://assets.hkoi.org/training2006/01_sol_j3.ppt) |
243 | | J064 | Cave Adventures | [Pascal](2006/J064.pas) [C++](2006/J064.cpp) | [Slides](https://assets.hkoi.org/training2006/01_sol_j4.ppt) |
244 | 
245 | ### 2005
246 | 
247 | | ID | Name | Code | Slides |
248 | | ------ | ------ | ------ | ------ |
249 | | S051 | Symbolic Links |  | [Slides](https://assets.hkoi.org/training2005/01_sol_s1.ppt) |
250 | | S052 | Land |  | [Slides](https://assets.hkoi.org/training2005/01_sol_s2.pdf) |
251 | | S053 | Atlantis |  | [Slides](https://assets.hkoi.org/training2005/01_sol_s3.ppt) |
252 | | S054 | Gift |  | [Slides](https://assets.hkoi.org/training2005/01_sol_s4.ppt) |
253 | | J051 | Pattern Matching |  | [Slides](https://assets.hkoi.org/training2005/01_sol_j1.ppt) |
254 | | J052 | Whirlpool |  | [Slides](https://assets.hkoi.org/training2005/01_sol_j2.ppt) |
255 | | J053 | Word Wrap |  | [Slides](https://assets.hkoi.org/training2005/01_sol_j3.ppt) |
256 | | J054 | Competition |  | [Slides](https://assets.hkoi.org/training2005/01_sol_j4.pdf) |
257 | 
258 | ### 2004
259 | 
260 | | ID | Name | Code | Slides |
261 | | ------ | ------ | ------ | ------ |
262 | | S041 | Credit Card |  |  |
263 | | S042 | Teacher's Problem |  | [Slides](https://assets.hkoi.org/training2004/01_sol_s2.pdf) |
264 | | S043 | Forecasting |  | [Slides](https://assets.hkoi.org/training2004/01_sol_s3.pdf) |
265 | | S044 | Set Intersection |  | [Slides](https://assets.hkoi.org/training2004/01_sol_s4.pdf) |
266 | | J041 | Traffic Lights |  | [Slides](https://assets.hkoi.org/training2004/01_sol_j1.pdf) |
267 | | J042 | Currency Exchange |  | [Slides](https://assets.hkoi.org/training2004/01_sol_j2.pdf) |
268 | | J043 | Reversi |  |  |
269 | | J044 | Amazing Robot |  | [Slides](https://assets.hkoi.org/training2004/01_sol_j4.pdf) |
270 | 
271 | 


--------------------------------------------------------------------------------
/solutions.json:
--------------------------------------------------------------------------------
   1 | {
   2 |     "2023/24": {
   3 |         "senior": [
   4 |             {
   5 |                 "id": "S241",
   6 |                 "name_en": "Mirror Horror",
   7 |                 "name_zh": "鏡像恐懼",
   8 |                 "code": false,
   9 |                 "slides": "https://assets.hkoi.org/training2024/S241.pdf"
  10 |             },
  11 |             {
  12 |                 "id": "S242",
  13 |                 "name_en": "Path of Infinity",
  14 |                 "name_zh": "無限之路",
  15 |                 "code": false,
  16 |                 "slides": "https://assets.hkoi.org/training2024/S242.pdf"
  17 |             },
  18 |             {
  19 |                 "id": "S243",
  20 |                 "name_en": "Stop the Avalanche!",
  21 |                 "name_zh": "阻止雪崩！",
  22 |                 "code": false,
  23 |                 "slides": "https://assets.hkoi.org/training2024/S243.pdf"
  24 |             },
  25 |             {
  26 |                 "id": "S244",
  27 |                 "name_en": "Group Photo",
  28 |                 "name_zh": "大合照",
  29 |                 "code": false,
  30 |                 "slides": "https://assets.hkoi.org/training2024/S244.pdf"
  31 |             }
  32 |         ],
  33 |         "junior": [
  34 |             {
  35 |                 "id": "J241",
  36 |                 "name_en": "Watermelon Game",
  37 |                 "name_zh": "西瓜遊戲",
  38 |                 "code": false,
  39 |                 "slides": "https://assets.hkoi.org/training2024/J241.pdf"
  40 |             },
  41 |             {
  42 |                 "id": "J242",
  43 |                 "name_en": "Digit Cipher",
  44 |                 "name_zh": "數位密碼",
  45 |                 "code": false,
  46 |                 "slides": "https://assets.hkoi.org/training2024/J242.pdf"
  47 |             },
  48 |             {
  49 |                 "id": "J243",
  50 |                 "name_en": "Neat Corridor",
  51 |                 "name_zh": "整潔的走廊",
  52 |                 "code": false,
  53 |                 "slides": "https://assets.hkoi.org/training2024/J243.pdf"
  54 |             },
  55 |             {
  56 |                 "id": "J244",
  57 |                 "name_en": "Passing Rate",
  58 |                 "name_zh": "合格率",
  59 |                 "code": false,
  60 |                 "slides": "https://assets.hkoi.org/training2024/J244.pdf"
  61 |             }
  62 |         ]
  63 |     },
  64 |     "2022/23": {
  65 |         "senior": [
  66 |             {
  67 |                 "id": "S231",
  68 |                 "name_en": "Ambiguous Undecimal System",
  69 |                 "name_zh": "含糊的十一進制系統",
  70 |                 "code": false,
  71 |                 "slides": "https://assets.hkoi.org/training2023/S231.pdf"
  72 |             },
  73 |             {
  74 |                 "id": "S232",
  75 |                 "name_en": "Team Formation",
  76 |                 "name_zh": "組隊",
  77 |                 "code": false,
  78 |                 "slides": "https://assets.hkoi.org/training2023/S232.pdf"
  79 |             },
  80 |             {
  81 |                 "id": "S233",
  82 |                 "name_en": "Doctor String in the Coordinates of Madness",
  83 |                 "name_zh": "字串博士：失控座標系統",
  84 |                 "code": false,
  85 |                 "slides": "https://assets.hkoi.org/training2023/S233.pdf"
  86 |             },
  87 |             {
  88 |                 "id": "S234",
  89 |                 "name_en": "Triangle Tour",
  90 |                 "name_zh": "三角形周遊",
  91 |                 "code": false,
  92 |                 "slides": "https://assets.hkoi.org/training2023/S234.pdf"
  93 |             }
  94 |         ],
  95 |         "junior": [
  96 |             {
  97 |                 "id": "J231",
  98 |                 "name_en": "Bubble Tea Shop",
  99 |                 "name_zh": "手搖飲品店",
 100 |                 "code": false,
 101 |                 "slides": "https://assets.hkoi.org/training2023/J231.pdf"
 102 |             },
 103 |             {
 104 |                 "id": "J232",
 105 |                 "name_en": "Move Pads",
 106 |                 "name_zh": "輸送板",
 107 |                 "code": false,
 108 |                 "slides": "https://assets.hkoi.org/training2023/J232.pdf"
 109 |             },
 110 |             {
 111 |                 "id": "J233",
 112 |                 "name_en": "Mechanical Grid",
 113 |                 "name_zh": "機械網格",
 114 |                 "code": false,
 115 |                 "slides": "https://assets.hkoi.org/training2023/J233.pdf"
 116 |             },
 117 |             {
 118 |                 "id": "J234",
 119 |                 "name_en": "Rotating Needle",
 120 |                 "name_zh": "旋轉的指針",
 121 |                 "code": false,
 122 |                 "slides": "https://assets.hkoi.org/training2023/J234.pdf"
 123 |             }
 124 |         ]
 125 |     },
 126 |     "2021/22": {
 127 |         "senior": [
 128 |             {
 129 |                 "id": "S221",
 130 |                 "name_en": "Hotel Rankings",
 131 |                 "name_zh": "酒店排名",
 132 |                 "code": false,
 133 |                 "slides": "https://assets.hkoi.org/training2022/S221.pdf"
 134 |             },
 135 |             {
 136 |                 "id": "S222",
 137 |                 "name_en": "Gathering",
 138 |                 "name_zh": "集合啦",
 139 |                 "code": false,
 140 |                 "slides": "https://assets.hkoi.org/training2022/S222.pdf"
 141 |             },
 142 |             {
 143 |                 "id": "S223",
 144 |                 "name_en": "Pixel Math Puzzle",
 145 |                 "name_zh": "像素數學謎題",
 146 |                 "code": false,
 147 |                 "slides": "https://assets.hkoi.org/training2022/S223.pdf"
 148 |             },
 149 |             {
 150 |                 "id": "S224",
 151 |                 "name_en": "Connectors",
 152 |                 "name_zh": "連接器",
 153 |                 "code": false,
 154 |                 "slides": "https://assets.hkoi.org/training2022/S224.pdf"
 155 |             }
 156 |         ],
 157 |         "junior": [
 158 |             {
 159 |                 "id": "J221",
 160 |                 "name_en": "Bus Route Category",
 161 |                 "name_zh": "巴士路線分類",
 162 |                 "code": false,
 163 |                 "slides": "https://assets.hkoi.org/training2022/J221.pdf"
 164 |             },
 165 |             {
 166 |                 "id": "J222",
 167 |                 "name_en": "Spicy Ramen",
 168 |                 "name_zh": "辣辣拉麵",
 169 |                 "code": false,
 170 |                 "slides": "https://assets.hkoi.org/training2022/J222.pdf"
 171 |             },
 172 |             {
 173 |                 "id": "J223",
 174 |                 "name_en": "Ice Cream",
 175 |                 "name_zh": "食軟雪糕",
 176 |                 "code": false,
 177 |                 "slides": "https://assets.hkoi.org/training2022/J223.pdf"
 178 |             },
 179 |             {
 180 |                 "id": "J224",
 181 |                 "name_en": "Digit Implant Strategy",
 182 |                 "name_zh": "數位植入策略",
 183 |                 "code": false,
 184 |                 "slides": "https://assets.hkoi.org/training2022/J224.pdf"
 185 |             }
 186 |         ]
 187 |     },
 188 |     "2020/21": {
 189 |         "senior": [
 190 |             {
 191 |                 "id": "S211",
 192 |                 "name_en": "Skyscraperhenge",
 193 |                 "name_zh": "巨廈陣",
 194 |                 "code": false,
 195 |                 "slides": "https://assets.hkoi.org/training2021/S211.pdf"
 196 |             },
 197 |             {
 198 |                 "id": "S212",
 199 |                 "name_en": "Super Chat",
 200 |                 "name_zh": "超級留言",
 201 |                 "code": false,
 202 |                 "slides": "https://assets.hkoi.org/training2021/S212.pdf"
 203 |             },
 204 |             {
 205 |                 "id": "S213",
 206 |                 "name_en": "Chinese Checkers",
 207 |                 "name_zh": "波子棋",
 208 |                 "code": false,
 209 |                 "slides": "https://assets.hkoi.org/training2021/S213.pdf"
 210 |             }
 211 |         ],
 212 |         "junior": [
 213 |             {
 214 |                 "id": "J211",
 215 |                 "name_en": "Paint Shop",
 216 |                 "name_zh": "油漆商店",
 217 |                 "code": false,
 218 |                 "slides": "https://assets.hkoi.org/training2021/J211.pdf"
 219 |             },
 220 |             {
 221 |                 "id": "J212",
 222 |                 "name_en": "Paint the Floor",
 223 |                 "name_zh": "地板塗漆",
 224 |                 "code": false,
 225 |                 "slides": "https://assets.hkoi.org/training2021/J212.pdf"
 226 |             },
 227 |             {
 228 |                 "id": "J213",
 229 |                 "name_en": "Paint the Wall",
 230 |                 "name_zh": "牆壁塗漆",
 231 |                 "code": false,
 232 |                 "slides": "https://assets.hkoi.org/training2021/J213.pdf"
 233 |             }
 234 |         ]
 235 |     },
 236 |     "2018/19": {
 237 |         "senior": [
 238 |             {
 239 |                 "id": "S191",
 240 |                 "name_en": "Unstoppable Onslaught",
 241 |                 "name_zh": "猛烈狂擊",
 242 |                 "code": false,
 243 |                 "slides": "https://assets.hkoi.org/training2019/S191.pdf"
 244 |             },
 245 |             {
 246 |                 "id": "S192",
 247 |                 "name_en": "Two Towers",
 248 |                 "name_zh": "雙城奇謀",
 249 |                 "code": false,
 250 |                 "slides": "https://assets.hkoi.org/training2019/S192.pdf"
 251 |             },
 252 |             {
 253 |                 "id": "S193",
 254 |                 "name_en": "Alice's Housekeeper",
 255 |                 "name_zh": "愛麗絲的管家",
 256 |                 "code": false,
 257 |                 "slides": "https://assets.hkoi.org/training2019/S193.pdf"
 258 |             },
 259 |             {
 260 |                 "id": "S194",
 261 |                 "name_en": "Snakes and Snakes",
 262 |                 "name_zh": "蛇蛇棋",
 263 |                 "code": false,
 264 |                 "slides": "https://assets.hkoi.org/training2019/S194.pdf"
 265 |             }
 266 |         ],
 267 |         "junior": [
 268 |             {
 269 |                 "id": "J191",
 270 |                 "name_en": "Alice and Wings",
 271 |                 "name_zh": "愛麗絲與雞翼",
 272 |                 "code": false,
 273 |                 "slides": "https://assets.hkoi.org/training2019/J191.pdf"
 274 |             },
 275 |             {
 276 |                 "id": "J192",
 277 |                 "name_en": "Bigger, Better",
 278 |                 "name_zh": "越大越好",
 279 |                 "code": false,
 280 |                 "slides": "https://assets.hkoi.org/training2019/J192.pdf"
 281 |             },
 282 |             {
 283 |                 "id": "J193",
 284 |                 "name_en": "Hyper Knight II",
 285 |                 "name_zh": "超級騎士 II",
 286 |                 "code": false,
 287 |                 "slides": "https://assets.hkoi.org/training2019/J193.pdf"
 288 |             },
 289 |             {
 290 |                 "id": "J194",
 291 |                 "name_en": "Graffiti",
 292 |                 "name_zh": "塗鴉",
 293 |                 "code": false,
 294 |                 "slides": "https://assets.hkoi.org/training2019/J194.pdf"
 295 |             }
 296 |         ]
 297 |     },
 298 |     "2017/18": {
 299 |         "senior": [
 300 |             {
 301 |                 "id": "S181",
 302 |                 "name_en": "Odd is Odd",
 303 |                 "name_zh": "奇怪的奇數",
 304 |                 "code": false,
 305 |                 "slides": "https://assets.hkoi.org/training2018/S181.pdf"
 306 |             },
 307 |             {
 308 |                 "id": "S182",
 309 |                 "name_en": "Tournament",
 310 |                 "name_zh": "聯賽",
 311 |                 "code": false,
 312 |                 "slides": "https://assets.hkoi.org/training2018/S182.pdf"
 313 |             },
 314 |             {
 315 |                 "id": "S183",
 316 |                 "name_en": "Desktop Icons",
 317 |                 "name_zh": "桌面圖案",
 318 |                 "code": false,
 319 |                 "slides": "https://assets.hkoi.org/training2018/S183.pdf"
 320 |             },
 321 |             {
 322 |                 "id": "S184",
 323 |                 "name_en": "Bogo Translate",
 324 |                 "name_zh": "Bogo 翻譯",
 325 |                 "code": false,
 326 |                 "slides": "https://assets.hkoi.org/training2018/S184.pdf"
 327 |             }
 328 |         ],
 329 |         "junior": [
 330 |             {
 331 |                 "id": "J181",
 332 |                 "name_en": "Wings and Nuggets",
 333 |                 "name_zh": "雞翼與雞塊",
 334 |                 "code": false,
 335 |                 "slides": "https://assets.hkoi.org/training2018/J181.pdf"
 336 |             },
 337 |             {
 338 |                 "id": "J182",
 339 |                 "name_en": "Rope",
 340 |                 "name_zh": "繩",
 341 |                 "code": false,
 342 |                 "slides": "https://assets.hkoi.org/training2018/J182.pdf"
 343 |             },
 344 |             {
 345 |                 "id": "J183",
 346 |                 "name_en": "Shortest Path",
 347 |                 "name_zh": "最短路徑",
 348 |                 "code": false,
 349 |                 "slides": "https://assets.hkoi.org/training2018/J183.pdf"
 350 |             },
 351 |             {
 352 |                 "id": "J184",
 353 |                 "name_en": "Mysterious Area",
 354 |                 "name_zh": "神秘的海域",
 355 |                 "code": false,
 356 |                 "slides": "https://assets.hkoi.org/training2018/J184.pdf"
 357 |             }
 358 |         ]
 359 |     },
 360 |     "2016/17": {
 361 |         "senior": [
 362 |             {
 363 |                 "id": "S171",
 364 |                 "name_en": "TV Ratings",
 365 |                 "name_zh": "電視收視",
 366 |                 "code": false,
 367 |                 "slides": "https://assets.hkoi.org/training2017/S171.pdf"
 368 |             },
 369 |             {
 370 |                 "id": "S172",
 371 |                 "name_en": "Degradion",
 372 |                 "name_zh": "弱化術",
 373 |                 "code": false,
 374 |                 "slides": "https://assets.hkoi.org/training2017/S172.pdf"
 375 |             },
 376 |             {
 377 |                 "id": "S173",
 378 |                 "name_en": "Monster GO",
 379 |                 "name_zh": "捕捉怪獸",
 380 |                 "code": false,
 381 |                 "slides": "https://assets.hkoi.org/training2017/S173.pdf"
 382 |             },
 383 |             {
 384 |                 "id": "S174",
 385 |                 "name_en": "Magic Triangle II",
 386 |                 "name_zh": "魔幻三角 II",
 387 |                 "code": false,
 388 |                 "slides": "https://assets.hkoi.org/training2017/S174.pdf"
 389 |             }
 390 |         ],
 391 |         "junior": [
 392 |             {
 393 |                 "id": "J171",
 394 |                 "name_en": "Acronym",
 395 |                 "name_zh": "縮寫",
 396 |                 "code": false,
 397 |                 "slides": "https://assets.hkoi.org/training2017/J171.pdf"
 398 |             },
 399 |             {
 400 |                 "id": "J172",
 401 |                 "name_en": "Card Game",
 402 |                 "name_zh": "紙牌遊戲",
 403 |                 "code": false,
 404 |                 "slides": "https://assets.hkoi.org/training2017/J172.pdf"
 405 |             },
 406 |             {
 407 |                 "id": "J173",
 408 |                 "name_en": "Fibonacci Word",
 409 |                 "name_zh": "斐波納契字串",
 410 |                 "code": false,
 411 |                 "slides": "https://assets.hkoi.org/training2017/J173.pdf"
 412 |             },
 413 |             {
 414 |                 "id": "J174",
 415 |                 "name_en": "Crosses",
 416 |                 "name_zh": "交叉",
 417 |                 "code": false,
 418 |                 "slides": "https://assets.hkoi.org/training2017/J174.pdf"
 419 |             }
 420 |         ]
 421 |     },
 422 |     "2015/16": {
 423 |         "senior": [
 424 |             {
 425 |                 "id": "S161",
 426 |                 "name_en": "Military Training",
 427 |                 "name_zh": "軍事訓練",
 428 |                 "code": false,
 429 |                 "slides": "https://assets.hkoi.org/training2016/2016-sen1.pdf"
 430 |             },
 431 |             {
 432 |                 "id": "S162",
 433 |                 "name_en": "Robos' Feast",
 434 |                 "name_zh": "露寶的盛宴",
 435 |                 "code": false,
 436 |                 "slides": "https://assets.hkoi.org/training2016/2016-sen2.pdf"
 437 |             },
 438 |             {
 439 |                 "id": "S163",
 440 |                 "name_en": "Arithmetic Sequence",
 441 |                 "name_zh": "等差數列",
 442 |                 "code": false,
 443 |                 "slides": "https://assets.hkoi.org/training2016/2016-sen3.pdf"
 444 |             },
 445 |             {
 446 |                 "id": "S164",
 447 |                 "name_en": "Alice's Meal",
 448 |                 "name_zh": "愛麗斯的餐點",
 449 |                 "code": false,
 450 |                 "slides": "https://assets.hkoi.org/training2016/2016-sen4.pdf"
 451 |             }
 452 |         ],
 453 |         "junior": [
 454 |             {
 455 |                 "id": "J161",
 456 |                 "name_en": "Model Answer",
 457 |                 "name_zh": "標準答案",
 458 |                 "code": false,
 459 |                 "slides": "https://assets.hkoi.org/training2016/2016-jun1.pdf"
 460 |             },
 461 |             {
 462 |                 "id": "J162",
 463 |                 "name_en": "Time Zones",
 464 |                 "name_zh": "時區轉換",
 465 |                 "code": false,
 466 |                 "slides": "https://assets.hkoi.org/training2016/2016-jun2.pdf"
 467 |             },
 468 |             {
 469 |                 "id": "J163",
 470 |                 "name_en": "Stone Game",
 471 |                 "name_zh": "石頭遊戲",
 472 |                 "code": false,
 473 |                 "slides": "https://assets.hkoi.org/training2016/2016-jun3.pdf"
 474 |             },
 475 |             {
 476 |                 "id": "J164",
 477 |                 "name_en": "Candy Factory",
 478 |                 "name_zh": "糖果工廠",
 479 |                 "code": false,
 480 |                 "slides": "https://assets.hkoi.org/training2016/2016-jun4.pdf"
 481 |             }
 482 |         ]
 483 |     },
 484 |     "2014/15": {
 485 |         "senior": [
 486 |             {
 487 |                 "id": "S150",
 488 |                 "name_en": "Enumeration",
 489 |                 "name_zh": "枚舉",
 490 |                 "code": true,
 491 |                 "slides": false
 492 |             },
 493 |             {
 494 |                 "id": "S151",
 495 |                 "name_en": "Promotion Period",
 496 |                 "name_zh": "大宣傳",
 497 |                 "code": true,
 498 |                 "slides": "https://assets.hkoi.org/training2015/sen1.pdf"
 499 |             },
 500 |             {
 501 |                 "id": "S152",
 502 |                 "name_en": "Apple Garden",
 503 |                 "name_zh": "蘋果莊園",
 504 |                 "code": true,
 505 |                 "slides": "https://assets.hkoi.org/training2015/sen2.pdf"
 506 |             },
 507 |             {
 508 |                 "id": "S153",
 509 |                 "name_en": "Secret Message",
 510 |                 "name_zh": "秘密訊息",
 511 |                 "code": true,
 512 |                 "slides": "https://assets.hkoi.org/training2015/sen3.pdf"
 513 |             },
 514 |             {
 515 |                 "id": "S154",
 516 |                 "name_en": "Monster Arena",
 517 |                 "name_zh": "妖魔擂台",
 518 |                 "code": true,
 519 |                 "slides": "https://assets.hkoi.org/training2015/sen4.pdf"
 520 |             }
 521 |         ],
 522 |         "junior": [
 523 |             {
 524 |                 "id": "J150",
 525 |                 "name_en": "Enumeration",
 526 |                 "name_zh": "枚舉",
 527 |                 "code": true,
 528 |                 "slides": false
 529 |             },
 530 |             {
 531 |                 "id": "J151",
 532 |                 "name_en": "Inverse Problem",
 533 |                 "name_zh": "逆向問題",
 534 |                 "code": true,
 535 |                 "slides": "https://assets.hkoi.org/training2015/jun1.pdf"
 536 |             },
 537 |             {
 538 |                 "id": "J152",
 539 |                 "name_en": "Royal Bodyguard",
 540 |                 "name_zh": "皇家護衛",
 541 |                 "code": true,
 542 |                 "slides": "https://assets.hkoi.org/training2015/jun2.pdf"
 543 |             },
 544 |             {
 545 |                 "id": "J153",
 546 |                 "name_en": "Insert Delete",
 547 |                 "name_zh": "插入刪除",
 548 |                 "code": true,
 549 |                 "slides": "https://assets.hkoi.org/training2015/jun3.pdf"
 550 |             },
 551 |             {
 552 |                 "id": "J154",
 553 |                 "name_en": "Father's Will",
 554 |                 "name_zh": "父親的遺願",
 555 |                 "code": true,
 556 |                 "slides": "https://assets.hkoi.org/training2015/jun4.pdf"
 557 |             }
 558 |         ]
 559 |     },
 560 |     "2014": {
 561 |         "senior": [
 562 |             {
 563 |                 "id": "S140",
 564 |                 "name_en": "Enumeration",
 565 |                 "name_zh": "枚舉",
 566 |                 "code": true,
 567 |                 "slides": false
 568 |             },
 569 |             {
 570 |                 "id": "S141",
 571 |                 "name_en": "Dividing the Cities",
 572 |                 "name_zh": "城市分配",
 573 |                 "code": false,
 574 |                 "slides": false
 575 |             },
 576 |             {
 577 |                 "id": "S142",
 578 |                 "name_en": "Gene Mutation 2",
 579 |                 "name_zh": "基因突變二",
 580 |                 "code": false,
 581 |                 "slides": "https://assets.hkoi.org/training2014/sq2.pptx"
 582 |             },
 583 |             {
 584 |                 "id": "S143",
 585 |                 "name_en": "Input Method",
 586 |                 "name_zh": "輸入法",
 587 |                 "code": true,
 588 |                 "slides": "https://assets.hkoi.org/training2014/sq3.pdf"
 589 |             },
 590 |             {
 591 |                 "id": "S144",
 592 |                 "name_en": "Pharmaceutical Company",
 593 |                 "name_zh": "製藥公司",
 594 |                 "code": false,
 595 |                 "slides": "https://assets.hkoi.org/training2014/sq4.pptx"
 596 |             }
 597 |         ],
 598 |         "junior": [
 599 |             {
 600 |                 "id": "J140",
 601 |                 "name_en": "Enumeration",
 602 |                 "name_zh": "枚舉",
 603 |                 "code": true,
 604 |                 "slides": false
 605 |             },
 606 |             {
 607 |                 "id": "J141",
 608 |                 "name_en": "Phone Menu",
 609 |                 "name_zh": "電話目錄",
 610 |                 "code": true,
 611 |                 "slides": false
 612 |             },
 613 |             {
 614 |                 "id": "J142",
 615 |                 "name_en": "Magic Stones",
 616 |                 "name_zh": "魔法石",
 617 |                 "code": true,
 618 |                 "slides": "https://assets.hkoi.org/training2014/jq2.pptx"
 619 |             },
 620 |             {
 621 |                 "id": "J143",
 622 |                 "name_en": "Power Socket",
 623 |                 "name_zh": "電源插頭",
 624 |                 "code": true,
 625 |                 "slides": "https://assets.hkoi.org/training2014/jq3.pdf"
 626 |             },
 627 |             {
 628 |                 "id": "J144",
 629 |                 "name_en": "Fair Santa Claus",
 630 |                 "name_zh": "公平的聖誕老人",
 631 |                 "code": true,
 632 |                 "slides": "https://assets.hkoi.org/training2014/jq4.pdf"
 633 |             }
 634 |         ]
 635 |     },
 636 |     "2013": {
 637 |         "senior": [
 638 |             {
 639 |                 "id": "S131",
 640 |                 "name_en": "Bacteria Research",
 641 |                 "name_zh": "細菌研究",
 642 |                 "code": false,
 643 |                 "slides": "https://assets.hkoi.org/training2013/sen1.pdf"
 644 |             },
 645 |             {
 646 |                 "id": "S132",
 647 |                 "name_en": "Safe Storage",
 648 |                 "name_zh": "保險箱儲藏",
 649 |                 "code": false,
 650 |                 "slides": "https://assets.hkoi.org/training2013/sen2.pdf"
 651 |             },
 652 |             {
 653 |                 "id": "S133",
 654 |                 "name_en": "TB",
 655 |                 "name_zh": "結核病",
 656 |                 "code": true,
 657 |                 "slides": false
 658 |             },
 659 |             {
 660 |                 "id": "S134",
 661 |                 "name_en": "Unfair Santa Claus",
 662 |                 "name_zh": "不公平的聖誕老人",
 663 |                 "code": false,
 664 |                 "slides": "https://assets.hkoi.org/training2013/sen4.pdf"
 665 |             }
 666 |         ],
 667 |         "junior": [
 668 |             {
 669 |                 "id": "J131",
 670 |                 "name_en": "Strategy Steps",
 671 |                 "name_zh": "策略階梯",
 672 |                 "code": true,
 673 |                 "slides": "https://assets.hkoi.org/solutions/2130.pptx"
 674 |             },
 675 |             {
 676 |                 "id": "J132",
 677 |                 "name_en": "Queueing",
 678 |                 "name_zh": "排隊輪候",
 679 |                 "code": true,
 680 |                 "slides": "https://assets.hkoi.org/training2013/jun2.pptx"
 681 |             },
 682 |             {
 683 |                 "id": "J133",
 684 |                 "name_en": "Dryads",
 685 |                 "name_zh": "森林精靈",
 686 |                 "code": true,
 687 |                 "slides": "https://assets.hkoi.org/training2013/jun3.pdf"
 688 |             },
 689 |             {
 690 |                 "id": "J134",
 691 |                 "name_en": "Lucky Rainbow",
 692 |                 "name_zh": "幸運彩虹",
 693 |                 "code": true,
 694 |                 "slides": "https://assets.hkoi.org/solutions/2133.pptx"
 695 |             }
 696 |         ]
 697 |     },
 698 |     "2012": {
 699 |         "senior": [
 700 |             {
 701 |                 "id": "S121",
 702 |                 "name_en": "Infinite Coding",
 703 |                 "name_zh": "無限編程",
 704 |                 "code": false,
 705 |                 "slides": "https://assets.hkoi.org/training2012/Infinite%20Coding.pdf"
 706 |             },
 707 |             {
 708 |                 "id": "S122",
 709 |                 "name_en": "Toothpicks",
 710 |                 "name_zh": "牙籤",
 711 |                 "code": true,
 712 |                 "slides": "https://assets.hkoi.org/training2012/Toothpick.pdf"
 713 |             },
 714 |             {
 715 |                 "id": "S123",
 716 |                 "name_en": "Songs",
 717 |                 "name_zh": "歌曲",
 718 |                 "code": false,
 719 |                 "slides": "https://assets.hkoi.org/training2012/Songs.pptx"
 720 |             },
 721 |             {
 722 |                 "id": "S124",
 723 |                 "name_en": "Gene Mutation",
 724 |                 "name_zh": "基因突變",
 725 |                 "code": false,
 726 |                 "slides": "https://assets.hkoi.org/training2012/GeneMutation.ppt"
 727 |             }
 728 |         ],
 729 |         "junior": [
 730 |             {
 731 |                 "id": "J121",
 732 |                 "name_en": "Outstanding Integer",
 733 |                 "name_zh": "優秀的整數",
 734 |                 "code": true,
 735 |                 "slides": false
 736 |             },
 737 |             {
 738 |                 "id": "J122",
 739 |                 "name_en": "Hotel",
 740 |                 "name_zh": "酒店",
 741 |                 "code": true,
 742 |                 "slides": false
 743 |             },
 744 |             {
 745 |                 "id": "J123",
 746 |                 "name_en": "Cheating Dice",
 747 |                 "name_zh": "大話骰",
 748 |                 "code": false,
 749 |                 "slides": "https://assets.hkoi.org/training2012/Dice.pptx"
 750 |             },
 751 |             {
 752 |                 "id": "J124",
 753 |                 "name_en": "Penicillin",
 754 |                 "name_zh": "青黴素",
 755 |                 "code": true,
 756 |                 "slides": "https://assets.hkoi.org/training2012/Penicillin.ppt"
 757 |             }
 758 |         ]
 759 |     },
 760 |     "2011": {
 761 |         "senior": [
 762 |             {
 763 |                 "id": "S111",
 764 |                 "name_en": "Nuclear Reactor",
 765 |                 "name_zh": "核能反應器",
 766 |                 "code": true,
 767 |                 "slides": "https://assets.hkoi.org/training2011/hkoi2011sol.pdf"
 768 |             },
 769 |             {
 770 |                 "id": "S112",
 771 |                 "name_en": "Spectrum Identification",
 772 |                 "name_zh": "光譜辨認",
 773 |                 "code": true,
 774 |                 "slides": "https://assets.hkoi.org/training2011/hkoi2011sol.pdf"
 775 |             },
 776 |             {
 777 |                 "id": "S113",
 778 |                 "name_en": "Gravity Game",
 779 |                 "name_zh": "重力遊戲",
 780 |                 "code": true,
 781 |                 "slides": "https://assets.hkoi.org/training2011/hkoi2011sol.pdf"
 782 |             },
 783 |             {
 784 |                 "id": "S114",
 785 |                 "name_en": "Circular Circuit",
 786 |                 "name_zh": "環廻電路",
 787 |                 "code": true,
 788 |                 "slides": "https://assets.hkoi.org/training2011/hkoi2011sol.pdf"
 789 |             }
 790 |         ],
 791 |         "junior": [
 792 |             {
 793 |                 "id": "J111",
 794 |                 "name_en": "WippiLeaks",
 795 |                 "name_zh": "維特解密",
 796 |                 "code": true,
 797 |                 "slides": "https://assets.hkoi.org/training2011/hkoi2011sol.pdf"
 798 |             },
 799 |             {
 800 |                 "id": "J112",
 801 |                 "name_en": "Housekeeper",
 802 |                 "name_zh": "侍從的煩惱",
 803 |                 "code": true,
 804 |                 "slides": "https://assets.hkoi.org/training2011/hkoi2011sol.pdf"
 805 |             },
 806 |             {
 807 |                 "id": "J113",
 808 |                 "name_en": "Factor Factory",
 809 |                 "name_zh": "因數工廠",
 810 |                 "code": true,
 811 |                 "slides": "https://assets.hkoi.org/training2011/hkoi2011sol.pdf"
 812 |             },
 813 |             {
 814 |                 "id": "J114",
 815 |                 "name_en": "Pyramid",
 816 |                 "name_zh": "金字塔",
 817 |                 "code": true,
 818 |                 "slides": "https://assets.hkoi.org/training2011/hkoi2011sol.pdf"
 819 |             }
 820 |         ]
 821 |     },
 822 |     "2010": {
 823 |         "senior": [
 824 |             {
 825 |                 "id": "S101",
 826 |                 "name_en": "Squares Dartboard",
 827 |                 "name_zh": "方形標靶",
 828 |                 "code": true,
 829 |                 "slides": false
 830 |             },
 831 |             {
 832 |                 "id": "S102",
 833 |                 "name_en": "Igloo",
 834 |                 "name_zh": "冰上遠足",
 835 |                 "code": false,
 836 |                 "slides": "https://assets.hkoi.org/training2010/igloo.pptx"
 837 |             },
 838 |             {
 839 |                 "id": "S103",
 840 |                 "name_en": "Flexibility",
 841 |                 "name_zh": "靈敏度",
 842 |                 "code": false,
 843 |                 "slides": "https://assets.hkoi.org/training2010/s3.pdf"
 844 |             },
 845 |             {
 846 |                 "id": "S104",
 847 |                 "name_en": "OI Football Team",
 848 |                 "name_zh": "電腦奧林匹克足球隊",
 849 |                 "code": false,
 850 |                 "slides": "https://assets.hkoi.org/training2010/s4.pdf"
 851 |             }
 852 |         ],
 853 |         "junior": [
 854 |             {
 855 |                 "id": "J101",
 856 |                 "name_en": "Numpad",
 857 |                 "name_zh": "數字鍵盤",
 858 |                 "code": true,
 859 |                 "slides": false
 860 |             },
 861 |             {
 862 |                 "id": "J102",
 863 |                 "name_en": "Quest for Polar Bear",
 864 |                 "name_zh": "尋熊冒險記",
 865 |                 "code": false,
 866 |                 "slides": "https://assets.hkoi.org/training2010/quest.pptx"
 867 |             },
 868 |             {
 869 |                 "id": "J103",
 870 |                 "name_en": "Insect Galore",
 871 |                 "name_zh": "豐富的昆蟲",
 872 |                 "code": false,
 873 |                 "slides": "https://assets.hkoi.org/training2010/insect.pptx"
 874 |             },
 875 |             {
 876 |                 "id": "J104",
 877 |                 "name_en": "Reading Books",
 878 |                 "name_zh": "看書",
 879 |                 "code": false,
 880 |                 "slides": "https://assets.hkoi.org/training2010/score.pptx"
 881 |             }
 882 |         ]
 883 |     },
 884 |     "2009": {
 885 |         "senior": [
 886 |             {
 887 |                 "id": "S091",
 888 |                 "name_en": "Colored Balls",
 889 |                 "name_zh": "顏色球",
 890 |                 "code": true,
 891 |                 "slides": false
 892 |             },
 893 |             {
 894 |                 "id": "S092",
 895 |                 "name_en": "Santa's Gifts",
 896 |                 "name_zh": "聖誕禮物",
 897 |                 "code": true,
 898 |                 "slides": false
 899 |             },
 900 |             {
 901 |                 "id": "S093",
 902 |                 "name_en": "Posters",
 903 |                 "name_zh": "海報",
 904 |                 "code": true,
 905 |                 "slides": false
 906 |             },
 907 |             {
 908 |                 "id": "S094",
 909 |                 "name_en": "Reaching the Destination",
 910 |                 "name_zh": "向終點邁進",
 911 |                 "code": true,
 912 |                 "slides": false
 913 |             }
 914 |         ],
 915 |         "junior": [
 916 |             {
 917 |                 "id": "J091",
 918 |                 "name_en": "Set Union",
 919 |                 "name_zh": "集合並集",
 920 |                 "code": true,
 921 |                 "slides": false
 922 |             },
 923 |             {
 924 |                 "id": "J092",
 925 |                 "name_en": "Dictionary",
 926 |                 "name_zh": "字典",
 927 |                 "code": true,
 928 |                 "slides": false
 929 |             },
 930 |             {
 931 |                 "id": "J093",
 932 |                 "name_en": "Necklace",
 933 |                 "name_zh": "五彩繽紛的項鍊",
 934 |                 "code": true,
 935 |                 "slides": false
 936 |             },
 937 |             {
 938 |                 "id": "J094",
 939 |                 "name_en": "Full",
 940 |                 "name_zh": "滿",
 941 |                 "code": true,
 942 |                 "slides": "https://assets.hkoi.org/solutions/2093.pptx"
 943 |             }
 944 |         ]
 945 |     },
 946 |     "2008": {
 947 |         "senior": [
 948 |             {
 949 |                 "id": "S081",
 950 |                 "name_en": "Black Day",
 951 |                 "name_zh": "黑色日子",
 952 |                 "code": true,
 953 |                 "slides": false
 954 |             },
 955 |             {
 956 |                 "id": "S082",
 957 |                 "name_en": "Shy Tortoise",
 958 |                 "name_zh": "害羞的小烏龜",
 959 |                 "code": false,
 960 |                 "slides": "https://assets.hkoi.org/training2008/01_sol_sq2.ppt"
 961 |             },
 962 |             {
 963 |                 "id": "S083",
 964 |                 "name_en": "Storage Box",
 965 |                 "name_zh": "貯物箱",
 966 |                 "code": false,
 967 |                 "slides": "https://assets.hkoi.org/training2008/01_sol_sq3.ppt"
 968 |             },
 969 |             {
 970 |                 "id": "S084",
 971 |                 "name_en": "Defense Line",
 972 |                 "name_zh": "防衛線",
 973 |                 "code": false,
 974 |                 "slides": "https://assets.hkoi.org/training2008/01_sol_sq4.ppt"
 975 |             }
 976 |         ],
 977 |         "junior": [
 978 |             {
 979 |                 "id": "J081",
 980 |                 "name_en": "Simple Calculator",
 981 |                 "name_zh": "簡單運算",
 982 |                 "code": true,
 983 |                 "slides": false
 984 |             },
 985 |             {
 986 |                 "id": "J082",
 987 |                 "name_en": "Joining Metal Chains",
 988 |                 "name_zh": "鐵鍊接合",
 989 |                 "code": true,
 990 |                 "slides": false
 991 |             },
 992 |             {
 993 |                 "id": "J083",
 994 |                 "name_en": "Count 1s",
 995 |                 "name_zh": "「1」的數量",
 996 |                 "code": true,
 997 |                 "slides": "https://assets.hkoi.org/training2008/01_sol_jq3.ppt"
 998 |             },
 999 |             {
1000 |                 "id": "J084",
1001 |                 "name_en": "Who Moved My Cheese",
1002 |                 "name_zh": "誰動了我的乳酪",
1003 |                 "code": true,
1004 |                 "slides": "https://assets.hkoi.org/training2008/01_sol_jq4.ppt"
1005 |             }
1006 |         ]
1007 |     },
1008 |     "2007": {
1009 |         "senior": [
1010 |             {
1011 |                 "id": "S071",
1012 |                 "name_en": "Storage Centre",
1013 |                 "name_zh": "貯存中心",
1014 |                 "code": false,
1015 |                 "slides": "https://assets.hkoi.org/training2007/01_sol_sq1.ppt"
1016 |             },
1017 |             {
1018 |                 "id": "S072",
1019 |                 "name_en": "Partners",
1020 |                 "name_zh": "伙伴",
1021 |                 "code": false,
1022 |                 "slides": "https://assets.hkoi.org/training2007/01_sol_sq2.ppt"
1023 |             },
1024 |             {
1025 |                 "id": "S073",
1026 |                 "name_en": "SOS",
1027 |                 "name_zh": "求救訊號",
1028 |                 "code": false,
1029 |                 "slides": "https://assets.hkoi.org/training2007/01_sol_sq3.pdf"
1030 |             },
1031 |             {
1032 |                 "id": "S074",
1033 |                 "name_en": "Meet in the Middle",
1034 |                 "name_zh": "中途相遇",
1035 |                 "code": false,
1036 |                 "slides": false
1037 |             }
1038 |         ],
1039 |         "junior": [
1040 |             {
1041 |                 "id": "J071",
1042 |                 "name_en": "Zoo Planning",
1043 |                 "name_zh": "動物園規劃",
1044 |                 "code": false,
1045 |                 "slides": "https://assets.hkoi.org/training2007/01_sol_jq1.pdf"
1046 |             },
1047 |             {
1048 |                 "id": "J072",
1049 |                 "name_en": "Little Stage",
1050 |                 "name_zh": "小舞台",
1051 |                 "code": false,
1052 |                 "slides": "https://assets.hkoi.org/training2007/01_sol_jq2.ppt"
1053 |             },
1054 |             {
1055 |                 "id": "J073",
1056 |                 "name_en": "Shuttle Bus",
1057 |                 "name_zh": "穿梭巴士",
1058 |                 "code": false,
1059 |                 "slides": false
1060 |             },
1061 |             {
1062 |                 "id": "J074",
1063 |                 "name_en": "Best Plan",
1064 |                 "name_zh": "最佳收費計劃",
1065 |                 "code": true,
1066 |                 "slides": false
1067 |             }
1068 |         ]
1069 |     },
1070 |     "2006": {
1071 |         "senior": [
1072 |             {
1073 |                 "id": "S061",
1074 |                 "name_en": "Three Little Pigs",
1075 |                 "name_zh": "三隻小豬",
1076 |                 "code": false,
1077 |                 "slides": "https://assets.hkoi.org/training2006/01_sol_s1.ppt"
1078 |             },
1079 |             {
1080 |                 "id": "S062",
1081 |                 "name_en": "Toggle",
1082 |                 "name_zh": "開關",
1083 |                 "code": false,
1084 |                 "slides": "https://assets.hkoi.org/training2006/01_sol_s2.ppt"
1085 |             },
1086 |             {
1087 |                 "id": "S063",
1088 |                 "name_en": "Squareland",
1089 |                 "name_zh": "方形大陸",
1090 |                 "code": false,
1091 |                 "slides": "https://assets.hkoi.org/training2006/01_sol_s3.ppt"
1092 |             },
1093 |             {
1094 |                 "id": "S064",
1095 |                 "name_en": "Tappy Game",
1096 |                 "name_zh": "塌片遊戲",
1097 |                 "code": false,
1098 |                 "slides": "https://assets.hkoi.org/training2006/01_sol_s4.ppt"
1099 |             }
1100 |         ],
1101 |         "junior": [
1102 |             {
1103 |                 "id": "J061",
1104 |                 "name_en": "Expiry Date",
1105 |                 "name_zh": "有效日期",
1106 |                 "code": true,
1107 |                 "slides": false
1108 |             },
1109 |             {
1110 |                 "id": "J062",
1111 |                 "name_en": "Bit Split",
1112 |                 "name_zh": "Bit Split",
1113 |                 "code": true,
1114 |                 "slides": false
1115 |             },
1116 |             {
1117 |                 "id": "J063",
1118 |                 "name_en": "Sudoku",
1119 |                 "name_zh": "數獨",
1120 |                 "code": false,
1121 |                 "slides": "https://assets.hkoi.org/training2006/01_sol_j3.ppt"
1122 |             },
1123 |             {
1124 |                 "id": "J064",
1125 |                 "name_en": "Cave Adventures",
1126 |                 "name_zh": "山洞歷險",
1127 |                 "code": true,
1128 |                 "slides": "https://assets.hkoi.org/training2006/01_sol_j4.ppt"
1129 |             }
1130 |         ]
1131 |     },
1132 |     "2005": {
1133 |         "senior": [
1134 |             {
1135 |                 "id": "S051",
1136 |                 "name_en": "Symbolic Links",
1137 |                 "name_zh": "符號鏈結",
1138 |                 "code": false,
1139 |                 "slides": "https://assets.hkoi.org/training2005/01_sol_s1.ppt"
1140 |             },
1141 |             {
1142 |                 "id": "S052",
1143 |                 "name_en": "Land",
1144 |                 "name_zh": "土地",
1145 |                 "code": false,
1146 |                 "slides": "https://assets.hkoi.org/training2005/01_sol_s2.pdf"
1147 |             },
1148 |             {
1149 |                 "id": "S053",
1150 |                 "name_en": "Atlantis",
1151 |                 "name_zh": "阿特蘭提斯",
1152 |                 "code": false,
1153 |                 "slides": "https://assets.hkoi.org/training2005/01_sol_s3.ppt"
1154 |             },
1155 |             {
1156 |                 "id": "S054",
1157 |                 "name_en": "Gift",
1158 |                 "name_zh": "禮物",
1159 |                 "code": false,
1160 |                 "slides": "https://assets.hkoi.org/training2005/01_sol_s4.ppt"
1161 |             }
1162 |         ],
1163 |         "junior": [
1164 |             {
1165 |                 "id": "J051",
1166 |                 "name_en": "Pattern Matching",
1167 |                 "name_zh": "模式匹配",
1168 |                 "code": false,
1169 |                 "slides": "https://assets.hkoi.org/training2005/01_sol_j1.ppt"
1170 |             },
1171 |             {
1172 |                 "id": "J052",
1173 |                 "name_en": "Whirlpool",
1174 |                 "name_zh": "漩渦",
1175 |                 "code": false,
1176 |                 "slides": "https://assets.hkoi.org/training2005/01_sol_j2.ppt"
1177 |             },
1178 |             {
1179 |                 "id": "J053",
1180 |                 "name_en": "Word Wrap",
1181 |                 "name_zh": "自動換行",
1182 |                 "code": false,
1183 |                 "slides": "https://assets.hkoi.org/training2005/01_sol_j3.ppt"
1184 |             },
1185 |             {
1186 |                 "id": "J054",
1187 |                 "name_en": "Competition",
1188 |                 "name_zh": "競賽",
1189 |                 "code": false,
1190 |                 "slides": "https://assets.hkoi.org/training2005/01_sol_j4.pdf"
1191 |             }
1192 |         ]
1193 |     },
1194 |     "2004": {
1195 |         "senior": [
1196 |             {
1197 |                 "id": "S041",
1198 |                 "name_en": "Credit Card",
1199 |                 "name_zh": "信用卡",
1200 |                 "code": false,
1201 |                 "slides": false
1202 |             },
1203 |             {
1204 |                 "id": "S042",
1205 |                 "name_en": "Teacher's Problem",
1206 |                 "name_zh": "老師的難題",
1207 |                 "code": false,
1208 |                 "slides": "https://assets.hkoi.org/training2004/01_sol_s2.pdf"
1209 |             },
1210 |             {
1211 |                 "id": "S043",
1212 |                 "name_en": "Forecasting",
1213 |                 "name_zh": "預測",
1214 |                 "code": false,
1215 |                 "slides": "https://assets.hkoi.org/training2004/01_sol_s3.pdf"
1216 |             },
1217 |             {
1218 |                 "id": "S044",
1219 |                 "name_en": "Set Intersection",
1220 |                 "name_zh": "集的相交",
1221 |                 "code": false,
1222 |                 "slides": "https://assets.hkoi.org/training2004/01_sol_s4.pdf"
1223 |             }
1224 |         ],
1225 |         "junior": [
1226 |             {
1227 |                 "id": "J041",
1228 |                 "name_en": "Traffic Lights",
1229 |                 "name_zh": "交通燈",
1230 |                 "code": false,
1231 |                 "slides": "https://assets.hkoi.org/training2004/01_sol_j1.pdf"
1232 |             },
1233 |             {
1234 |                 "id": "J042",
1235 |                 "name_en": "Currency Exchange",
1236 |                 "name_zh": "貨幣兌換",
1237 |                 "code": false,
1238 |                 "slides": "https://assets.hkoi.org/training2004/01_sol_j2.pdf"
1239 |             },
1240 |             {
1241 |                 "id": "J043",
1242 |                 "name_en": "Reversi",
1243 |                 "name_zh": "黑白棋",
1244 |                 "code": false,
1245 |                 "slides": false
1246 |             },
1247 |             {
1248 |                 "id": "J044",
1249 |                 "name_en": "Amazing Robot",
1250 |                 "name_zh": "神奇的機械人",
1251 |                 "code": false,
1252 |                 "slides": "https://assets.hkoi.org/training2004/01_sol_j4.pdf"
1253 |             }
1254 |         ]
1255 |     }
1256 | }


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