Nguyễn Phúc Tâm

var
  s: real;
  n, i: longint;
begin
    assign(input,'tinhs.inp');reset(input);
    assign(output,'tinhs.out');rewrite(output);
    readln(n);
    s := 0;
    s := (n*(n+3))/(4*(n+1)*(n+2));
    writeln(s:0:2);
    close(input);close(output);
end.

var
  s1, s2, sa, sb, s: string;
  p : longint;
begin
    assign(input,'merges.inp');reset(input);
    assign(output,'merges.out');rewrite(output);
    readln(s);
    p := pos(' ', s);
    s1 := copy(s, 1, p-1);
    s2 := copy(s, p+1, length(s)-p);
    sa := s1 + s2;
    sb := s2 + s1;
    if sa > sb then writeln(sa)
    else writeln(sb);
    close(input);close(output);
end.

var
  x1, x2, x3, y1, y2, y3: real;
  d1, d2, d3, s: real;
function dd(u1, u2, v1, v2: real): real;
begin
    exit(sqrt(sqr(u1-u2) + sqr(v1-v2)));
end;
begin
    assign(input,'trias.inp');reset(input);
    assign(output,'trias.out');rewrite(output);
    readln(x1, y1);
    readln(x2, y2);
    readln(x3, y3);
    d1 := dd(x1, x2, y1, y2);
    d2 := dd(x1, x3, y1, y3);
    d3 := dd(x2, x3, y2, y3);
    if (d1 + d2 > d3) and (d1 + d3 > d2) and (d2 + d3 > d1) then
      begin
          s := 1/2 *abs((x2-x1)*(y3-y1)-(x3-x1)*(y2-y1));
          writeln(s:0:2);
      end
    else writeln('NONE');
    close(input);close(output);
end.

var
  n, k, res, i: longint;
  c: array[-7..10007] of longint;
procedure tcs(u: longint);
begin
    k := 0;
    while u > 0 do
      begin
          inc(k);
          c[k] := u mod 10;
          u := u div 10;
      end;
end;
procedure qs(l, h: longint);
var i, j, giua, chot, tam: longint;
begin
    i := l;
    j := h;
    giua := (i+j) div 2;
    chot := c[giua];
    while i <= j do
      begin
          while c[i] > chot do inc(i);
          while c[j] < chot do dec(j);
          if i <= j then
            begin
                tam := c[i];
                c[i] := c[j];
                c[j] := tam;
                inc(i);
                dec(j);
            end;
      end;
    if i < h then qs(i, h);
    if l < j then qs(l, j);
end;
begin
    assign(input,'permax.inp');reset(input);
    assign(output,'permax.out');rewrite(output);
    readln(n);
    tcs(n);
    qs(1, k);
    res := 0;
    for i := 1 to k do res := res*10 + c[i];
    writeln(res);
    close(input);close(output);
end.

// Cap so cong(day so cach deu)
var
  s: real;
  n, i: longint;
  a: array[-7..100007] of longint;
begin
    assign(input,'ct1.inp');reset(input);
    assign(output,'ct1.out');rewrite(output);
    readln(n);
    for i := 1 to n do read(a[i]);
    s := n*(a[1] + a[n])/2; // s := n*(2*a[1]+(n-1)*(a[n]-a[n-1]))/2;
    writeln(s);
    close(input);close(output);
end.

var
  n, s: longint;
begin
    assign(input,'ct2.inp');reset(input);
    assign(output,'ct2.out');rewrite(output);
    readln(n);
    s := (n * (n + 1)) div 2;
    writeln(s);
    close(input);close(output);
end.

var
  n: longint;
  s: int64;
begin
    assign(input,'ct3.inp');reset(input);
    assign(output,'ct3.out');rewrite(output);
    readln(n);
    s := sqr(n);
    writeln(s);
    close(input);close(output);
end.

var
  n: longint;
  s: int64;
begin
    assign(input,'ct4.inp');reset(input);
    assign(output,'ct4.out');rewrite(output);
    readln(n);
    s := (n * (n + 1) * (2*n + 1)) div 6;
    writeln(s);
    close(input);close(output);
end.

var
  n: longint;
  s: int64;
begin
    assign(input,'ct5.inp');reset(input);
    assign(output,'ct5.out');rewrite(output);
    readln(n);
    s := sqr((n * (n + 1)) div 2);
    writeln(s);
    close(input);close(output);
end.

var
  n: longint;
  s: int64;
begin
    assign(input,'ct6.inp');reset(input);
    assign(output,'ct6.out');rewrite(output);
    readln(n);
    s := (sqr(n) * sqr(n + 1) * (2*sqr(n) + 2*n - 1)) div 12;
    writeln(s);
    close(input);close(output);
end.

var
  a, n, b, c, i: longint;
  s, r, d: real;
begin
    assign(input,'ct7.inp');reset(input);
    assign(output,'ct7.out');rewrite(output);
    readln(a, n);
    b := 1;
    c := 1;
    for i := 1 to n do
      begin
          b := b * a;
          c := c * a;
      end;
    c := c div a;
    d := b/c;
    r := 1;
    for i := 1 to n+1 do r := r * d;
    s := (a*(1-r))/(1-d);
    writeln(s:0:2);
    close(input);close(output);
end.

var
  n: longint;
  s: int64;
begin
    assign(input,'ct8.inp');reset(input);
    assign(output,'ct8.out');rewrite(output);
    readln(n);
    s := (n*(n+1)*(n+2)) div 3;
    writeln(s);
    close(input);close(output);
end.

var
  n: longint;
  s: real;
begin
    assign(input,'ct9.inp');reset(input);
    assign(output,'ct9.out');rewrite(output);
    readln(n);
    if n <= 1 then writeln('NONE')
    else
      begin
          s := n / (n + 1);
          writeln(s:0:2);
      end;
    close(input);close(output);
end.

var
  n: longint;
  s: real;
begin
    assign(input,'ct10.inp');reset(input);
    assign(output,'ct10.out');rewrite(output);
    readln(n);
    s := (n*(n+3)) / (4*(n+1)*(n+2));
    writeln(s:0:2);
    close(input);close(output);
end.

uses math;
var
  n, stam: string;
  res, tam: int64;
  i: longint;
begin
    assign(input,'delnmax.inp');reset(input);
    assign(output,'delnmax.out');rewrite(output);
    readln(n);
    res := high(int64);
    for i := 1 to length(n) do
      begin
          stam := n;
          delete(stam, i, 1);
          val(stam, tam);
          res := min(res, tam);
      end;
    writeln(res);
    close(input);close(output);
end.

uses math;
var
  a, b: array[-7..100007] of longint;
  i, res, t, j, rmax: longint;
  f: array[-7..100007] of longint;
procedure erathos(u: longint);
var i, j: longint;
begin
    for i := 1 to u do f[i] := 1;
    f[1] := 0;
    i := 2;
    while i*i <= u do
      if f[i] = 1 then
        begin
            j := 2;
            if i*j <= u then
              begin
                  f[i*j] := 0;
                  inc(j);
              end;
            inc(i);
        end
      else inc(i);
end;
begin
    assign(input,'couprime.inp');reset(input);
    assign(output,'couprime.out');rewrite(output);
    readln(t);
    rmax := low(longint);;
    for j := 1 to t do
      begin
          readln(a[j], b[j]);
          rmax := max(rmax, b[j]);
      end;
    erathos(rmax);
    for i := 1 to rmax do f[i] := f[i-1] + f[i];
    for i := 1 to t do writeln(f[b[i]] - f[a[i]-1]);
    close(input);close(output);
end.

var
  n: int64;
  k, d, i: longint;
  c: array[-7..100007] of longint;
procedure tsnt(u: int64);
var i: longint;
begin
    i := 2;
    while i*i <= u do
      if u mod i = 0 then
        begin
            inc(k);
            c[k] := i;
            u := u div i;
        end
      else inc(i);
    if u > 1 then
      begin
          inc(k);
          c[k] := u;
      end;
end;
begin
    assign(input,'alaprime.inp');reset(input);
    assign(output,'alaprime.out');rewrite(output);
    readln(n);
    k := 0;
    tsnt(n);
    d := 1;
    for i := 1 to k+1 do
      if (c[i] = c[i-1]) and (c[i-1] <> 0) then inc(d)
      else
        begin
            if c[i-1] <> 0 then writeln(c[i-1],#32,d);
            d := 1;
        end;
    close(input);close(output);
end.

var
  n: longint;
  s: real;
begin
    assign(input,'ct11.inp');reset(input);
    assign(output,'ct11.out');rewrite(output);
    readln(n);
    s := (n*(n+2)) / sqr(n+1);
    writeln(s:0:2);
    close(input);close(output);
end.

var
  n, i, p, q: longint;
  s: real;
begin
    assign(input,'ct12.inp');reset(input);
    assign(output,'ct12.out');rewrite(output);
    readln(n, p);
    q := p;
    for i := 2 to n+1 do p := p * q;
    s := (p-1) / (q-1);
    writeln(s:0:2);
    close(input);close(output);
end.

var
  n, i, p, q: longint;
  s: real;
begin
    assign(input,'ct13.inp');reset(input);
    assign(output,'ct13.out');rewrite(output);
    readln(n, p);
    q := p;
    for i := 2 to n+1 do p := p * q;
    s := (((n+1)*p) / (q-1)) - ((p-1) / sqr(q-1));
    writeln(s:0:2);
    close(input);close(output);
end.

var
  n: int64;
  k, d, i, t, p: longint;
  c: array[-7..100007] of longint;
procedure tsnt(u: int64);
var i: longint;
begin
    k := 0;
    i := 2;
    while i*i <= u do
      if u mod i = 0 then
        begin
            inc(k);
            c[k] := i;
            u := u div i;
        end
      else inc(i);
    if u > 1 then
      begin
          inc(k);
          c[k] := u;
      end;
end;
begin
    assign(input,'modma.inp');reset(input);
    assign(output,'modma.out');rewrite(output);
    readln(t);
    for p := 1 to t do
      begin
          readln(n);
          tsnt(n);
          writeln(c[k]);
      end;
    close(input);close(output);
end.

uses math;
var
  i, m, rmax, d: longint;
  n, a: array[-7..100007] of longint;
function scs(u: longint): longint;
var tam: longint;
begin
    tam := 0;
    while u > 0 do
      begin
          inc(tam);
          u := u div 10;
      end;
    exit(tam);
end;
function tcs(u: longint): longint;
var tam: longint;
begin
    tam := 0;
    while u > 0 do
      begin
          tam := tam + u mod 10;
          u := u div 10;
      end;
    exit(tam);
end;
begin
    assign(input,'beauty.inp');reset(input);
    assign(output,'beauty.out');rewrite(output);
    m := 0;
    rmax := low(longint);
    while not(eof()) do
      begin
          inc(m);
          readln(n[m]);
          rmax := max(rmax, n[m]);
      end;
    for i := 1 to 10 do a[i] := i;
    i := 10;
    d := 10;
    while d < rmax do
      begin
          inc(i);
          if tcs(i) mod scs(i) = 0 then
            begin
                inc(d);
                a[d] := i;
            end;
      end;
    for i := 1 to m do writeln(a[n[i]]);
    close(input);close(output);
end.

uses math;
var
  n, i, j, d, res, rmax, p: longint;
  a: array[-7..100007] of longint;
function ucln(u, v: longint): longint;
var r: longint;
begin
    while v > 0 do
      begin
          r := u mod v;
          u := v;
          v := r;
      end;
    exit(u);
end;
begin
    assign(input,'subseq.inp');reset(input);
    assign(output,'subseq.out');rewrite(output);
    readln(n);
    for i := 1 to n do read(a[i]);
    rmax := 1;
    for i := 1 to n-1 do
      for j := i+1 to n do
        begin
            d := 0;
            res := a[i];
            for p := i to j do
              begin
                  res := ucln(res, a[p]);
                  if res <= 1 then break;
                  inc(d);
              end;
            rmax := max(rmax, d);
        end;
    writeln(rmax);
    close(input);close(output);
end.