Trần Quang Đạt

Var a,b: longint;
Function TDT(x,y: longint): longint;
Begin
        Exit(x*y);
End;
Begin
        Assign(Input,'RECCT.INP');
        Assign(Output,'RECT.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(a,b);
        Write(TDT(a,b));;
        Close(Input);
        Close(Output);
End.

Var a: longint;
Function Tong(x: longint): longint;
Var s: longint;
Begin
        S:=0;
        While x<>0 do
                Begin
                        s:=s+(x mod 10);
                        x:=x div 10;
                End;
        Exit(s);
End;
Begin
        Assign(Input,'PERM.INP');
        Assign(Output,'PERM.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(a);
        Write(Tong(a));
        Close(Input);
        Close(Output);
End.

Var n: longint;
Function Tong(x: longint): longint;
Var s: longint;
Begin
        s:=0;
        While x <> 0 do
                Begin
                        s:=s+(x mod 10);
                        x:=x div 10;
                End;
        Exit(s);
End;
Begin
        Assign(Input,'NCOUNT.INP');
        Assign(Output,'NCOUNT.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n);
        Write(Tong(n));
        Close(Input);
        Close(Output);
End.

Var n,i,s: longint;
Function demcs(u: longint): longint;
Var dem: longint;
Begin
        Dem:=0;
        While u>0 do
                Begin
                        Inc(dem);
                        U:=u div 10;
                End;
        Exit(dem);
End;
Begin
        Assign(Input,'DCOUNT.INP');
        Assign(Output,'DCOUNT.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n);
        S:=0;
        For i:=1 to n do s:=s+demcs(i);
        Write(s);
        Close(Input);
        Close(Output);
End.

Var loai50,loai20,loai10,n,i,j,k,dem,max50,max20,max10 : longint;
Begin
        Assign(Input,'XCHANGE.INP');
        Assign(Output,'XCHANGE.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n);
        loai50:=n div 50;
        n:=n mod 50;
        If (n<>0) then
                Begin
                        loai20:=n div 20;
                        n:=n mod 20;
                        If (n<>0) then
                                Begin
                                        loai10:=n div 10;
                                        n:=n mod 10;
                                End;
                End;
        If n<>0 then write('-1') else
        Writeln(loai50+loai20+loai10);
        Close(Input);
        Close(Output);
End.

program chuso_max;
var n,max,so: int64;
begin
    Assign(Input,'XMAX.INP');
    Assign(Output,'XMAX.OUT');
    reset(Input);
    rewrite(Output);
    readln(n);
    max:=0;
    while n>0 do
        begin
            so:=n mod 10;
            if so>max then max:=so;
            n:=n div 10;
        end;
    write(max);
    close(input);
    close(output);
end.

Var n,i,s: longint;
Function TongUoc(x: longint): longint;
Var s: longint;
Begin
        s:=0;
        For i:=1 to trunc(sqrt(x)) do
                If x mod i = 0 then
                        Begin
                                s:=s+i;
                                If i <> x div i then s:=s+ x div i;
                        End;
        Exit(s);
End;
Begin
        Assign(Input,'SDIV.INP');
        Assign(Output,'SDIV.OUT');
        Reset(Input);
        Rewrite(output);
        Readln(n);
        Write(TongUoc(n));
        Close(Input);
        Close(Output);
End.

Var n,a: longint;
Const l= trunc(1e9) + 7;
Function Amux(u,v: longint): int64;
Var t: int64;
Begin
        If v = 1 then exit(u);
        If v = 0 then exit(1);
        t:=amux(u,v div 2);
        Exit(t*t*amux(u, v mod 2) mod l);
End;
Begin
        Assign(Input,'AMUX.INP');
        Assign(Output,'AMUX.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(a,n);
        Write(Amux(a,n));
        Close(Input);
        Close(Output);
End.

Var a: longint;
Function Canbac3(u: longint): Real;
Var d,giua,c: real;
Begin
        d:=1; c:=sqrt(u);
        While c-d> 0.00001 do
                Begin
                        Giua:=(d+c)/2;
                        If giua*giua*giua - u > 0 then c:=giua
                        Else d:=giua
                End;
        Exit(giua);
End;
begin
        Assign(Input,'SQUA.INP');
        Assign(Output,'SQUA.OUT');
        Reset(Input);
        Rewrite(output);
        Readln(a);
        Write(Canbac3(a):0:2);
        Close(Input);
        Close(Output);
end.

Var n: longint;
Function Snt(x: longint): boolean;
Var i: longint;
Begin
        If x<2 then exit(false);
        For i:=2 to trunc(sqrt(x)) do
                If x mod i = 0 then exit(false);
        Exit(true);
End;
Begin
        Assign(Input,'CKPRIME.INP');
        Assign(Output,'CKPRIME.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n);
        If Snt(n) then write('TRUE') Else write('FALSE');
        Close(Input);
        Close(Output);
End.

Var n,i: longint;
Function SNT(x: longint): boolean;
Var i: longint;
Begin
        If x<2 then exit(false);
        For i:=2 to trunc(sqrt(x)) do
                If x mod i=0 then exit(false);
        Exit(true);
End;
Begin
        Assign(Input,'ERATOS.INP');
        Assign(Output,'ERATOS.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n);
        For i:=1 to n do
                If (snt(i)) and (i<n) then write(i,#32);
        Close(Input);
        Close(Output);
End.

Var f: array[-7..100007] of longint;
    dem,p,i: longint;
Function nguyento(x: longint): boolean;
Var u: longint;
Begin
        If x<2 then exit(false);
        For u:=2 to trunc(sqrt(x)) do
                If x mod u = 0 then exit(false);
        Exit(true);
End;
Begin
        Assign(Input,'FPRIME.INP');
        Assign(Output,'FPRIME.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(p);
        i:=2;
        dem:=0;
        F[1]:=1;
        F[2]:=1;
        While F[i-1] + F[i-2] <= P do
                Begin
                        F[i]:=F[i-1] + F[i-2];
                        If nguyento(F[i]) then inc(dem);
                        Inc(i);
                End;
        Write(dem);
        Close(Input);
        Close(Output);
End.

Var n: longint;
Function TachSo(i: longint): longint;
Begin
        I:=2;
        While n>1 do
        Begin
                If n mod i = 0 then
                        Begin
                                Write(i,#32);
                                N:= n div i
                        End
                Else i:=i+1;
        End;
End;
Begin
        Assign(Input,'TSNT.INP');
        Assign(Output,'TSNT.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n);
        Write(TachSo(n));
        Close(Input);
        Close(Output);
End.Var n: longint;
Function TachSo(i: longint): longint;
Begin
        I:=2;
        While n>1 do
        Begin
                If n mod i = 0 then
                        Begin
                                Write(i,#32);
                                N:= n div i
                        End
                Else i:=i+1;
        End;
End;
Begin
        Assign(Input,'TSNT.INP');
        Assign(Output,'TSNT.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n);
        Write(TachSo(n));
        Close(Input);
        Close(Output);
End.

Var m,k,n,p,i: longint;
    c: array[-7..100007] of longint;
Function tichcs(u: longint): longint;
Var s: longint;
Begin
        s:=1;
        While u>0 do
                Begin
                        S:=s*(u mod 10);
                        u:=u div 10;
                End;
        Exit(s);
End;
Begin
        Assign(Input,'NFIND.INP');
        Assign(Output,'NFIND.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(m);
        k:=1;
        While Tichcs(k) <> m do Inc(k);
        Write(k);
        Close(Input);
        Close(Output);
End.

Var n:longint;
    c:array[1..10000000]of longint;
Function ngto(x: longint): boolean;
Begin
        If x<2 then exit(false);
        For i:=2 to trunc(sqrt(x)) do
                If x mod i = 0 then exit(false);
        Exit(true);
End;
Begin
        Assign(Input,'NUMBERC.INP');
        Assign(Output,'NUMBERC.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n);
        While (ngto(n)=false)and(n>0) do
        Begin
                n:=n div 10;
                If n>0 then
                Begin
                        If n>0 then write(n)
                        Else write('-1');
                End;
        End;
End.

Var a: array[1..100000] of longint;
    i,j,k,n: longint;
Begin
        Assign(Input,'ARRDEL.INP');
        Assign(Output,'ARRDEL.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n);
        For i:=1 to n do Write('A[',i,']');
        Readln(A[i]);
        i:=2;
        While i <= n do
                Begin
                        j:=1;
                        While a[j] <> a[i] do
                                j:=j+1;
                                        If j<i then
                                                Begin
                                                        For k:=i to n-1 do
                                                                A[k]:=a[k+1];
                                                                n:=n-1;
                                                End
                        Else i:=i+1;
                End;
        Writeln;
        For i:=1 to n do write(A[i],#32);
        Close(Input);
        Close(Output);
End.

Var a: array[1..100000] of longint;
    n,i: longint;
Procedure Qsort(l,r: longint);
Var i,j,t,chot,giua: longint;
    a:array[1..100000] of longint;
Begin
        i:=l;
        j:=r;
        giua:=(i+j) div 2;
        chot:=a[giua];
        while i<j do
                Begin
                        while a[i]<chot do inc(j);
                                while a[j]>chot do dec(j);
                                        if i<=j then
                                                begin
                                                        t:=a[i];
                                                        a[i]:=a[j];
                                                        a[j]:=l;
                                                        inc(i);
                                                        dec(j);
                                                end;
                end;
        if i<r then qsort(i,r);
        if i>l then qsort(l,i);
end;
Begin
        Assign(Input,'QSORT.INP');
        Assign(Output,'QSORT.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n);
        For i:=1 to n do read(a[i]);
        Qsort(1,n);
        For i:=1 to n do write(a[i],#32);
        Close(Input);
        Close(Output);
End.

Var n,i,l,r,k:longint;
    a:array [0..1000] of longint;
Begin
        Assign(Input,'ILUCKY.INP');
        Assign(Output,'ILUCKY.OUT');
        Reset(input);
        Rewrite(Output);
        readln(n);
        for i:=1 to n do read(a[i]);
                for i:=1 to n do r:=r+a[i];
                        for i:=0 to n do
                                begin
                                        if l=r then
                                                begin
                                                        write(i,#32);
                                                        k:=1;
                                                end;
                                        l:=l+a[i+1];
                                        r:=r-a[i+1];
                                end;
        If k=0 then write(-1);
End.

Var a,b,c,res: 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,'GCD.INP');
        Assign(Output,'GCD.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(a,b,c);
        Res:=Ucln(a,b);
        Res:=Ucln(res,c);
        Write(res);
        Close(Input);
        Close(Output);
End.

Var a,b,c: array[-7..100007] of longint;
    n,i,m: longint;
Procedure Qsort(l,r: longint);
Var i,j,t,chot,giua: longint;
Begin
        i:=l;
        j:=r;
        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
                                                        t:=c[i];
                                                        c[i]:=c[j];
                                                        c[j]:=t;
                                                        inc(i);
                                                        dec(j);
                                                end;
                end;
        if i<r then qsort(i,r);
        if j>l then qsort(l,j);
end;
Begin
        Assign(Input,'ARRADD2.INP');
        Assign(Output,'ARRADD2.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n,m);
        For i:=1 to n do read(a[i]);
        For i:=1 to m do read(b[i]);
        For i:=1 to n do c[i]:=a[i];
        For i:=1 to m do c[i+n]:=b[i];
        Qsort(1,m+n);
        For i:=1 to m+n do write(c[i],#32);
        Close(Input);
        Close(Output);
End.

Var a,b,c,res: 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,'GCD.INP');
        Assign(Output,'GCD.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(a,b,c);
        Res:=Ucln(a,b);
        Res:=Ucln(res,c);
        Write(res);
        Close(Input);
        Close(Output);
End.

Var m,n,i:longint;
    a,b,c:array[1..100000]of longint;
Procedure qsort(l,r:longint);
Var i,j,t,chot,giua:longint;
Begin
        I:=l;
        J:=r;
        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
                                        T:=c[i];
                                        C[i]:=c[j];
                                        C[j]:=t;
                                        Inc(i);
                                        Dec(j);
                                End;
                End;
        If l<j then qsort(l,j);
        If i<r then qsort(i,r);
End;
Begin
        Assign(Input,'ARRADD2.INP');
        Assign(output,'ARRADD2.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n,m);
        For i:=1 to n do read(a[i]);
        For i:=1 to m do read(b[i]);
        For i:=1 to n do c[i]:=a[i];
        For i:=1 to m do c[i+n]:=b[i];
        Qsort(1,m+n);
        For i:=1 to m+n do write(c[i],#32);
        Close(Input);
        Close(Output);
End.

Var n,k,ii:longint;
    a:array [-7..100007] of longint;
Procedure qsort(l, r: longint);
Var i,j,chot,tam: longint;
Begin
        I:= l;
        J:= r;
        Chot:=a[(i+j) div 2];
        While i<= j do
        Begin
        While a[i] < chot do inc(i);
        While a[j] > chot do dec(j);
        If i <= j then
                Begin
                        Tam:=a[i];
                        A[i]:=a[j];
                        A[j]:=tam;
                        Inc(i);
                        Dec(j);
                End;
        End;
        If i < r then qsort(i,r);
        If l < j then qsort(l,j);
End;
Begin
        Assign(Input,'ARRCOUNT.INP');
        Assign(Output,'ARRCOUNT.OUT');
        Reset(Input);
        Rewrite(Output);
        Readln(n);
        For ii:=1 to n do read(a[ii]);
        Qsort(1,n);
        K:=1;
        For ii:=1 to n do
        If a[ii]=a[ii+1] then inc(k) else
                Begin
                        Write(a[ii],#32,k); k:=1;
                End;
        Close(Input);
        Close(Output);
End.

Var a:array[-7..100007] of longint;
    n,i,dau,cuoi,giua,vt,m: longint;
Begin
        Assign(Input,'BINS.INP');
        Assign(Output,'BINS.OUT');
        Reset(Input);
        Rewrite(Output);
        Read(n,m);
        Vt:=1;
        For i:=1 to n do read(a[i]);
        Dau:= 1;
        Cuoi:= n;
        While dau <= cuoi do
                Begin
                        Giua:= (dau+cuoi) div 2;
                        If m=a[giua] then
                                Begin
                                        Vt:=giua;
                                        Write(vt);
                                        Break;
                                End
                        Else if m < a[giua] then cuoi:=giua-1
                                Else dau:= giua+1;
                End;
        If dau > cuoi then write('-1');
        Close(Input);
        Close(Output);
End.