Book of tasks on programming. Old version

 

 by Aliaksandr N. Prykhodzka

 

nil, NTFS, html, on-line, memory, on-line, справка, breakpoint, семантика, xsl, винчестер, paste, FAT, var, inline, return, function, alphabet, algol, procedure
 

Java. Answers. J.22. Realization of algorithms. Operations over symbolic numbers



главная страница


J.22.1


import java.awt.*;
import java.applet.*;


public class LargeNumbers
{

public int LNErr=0;
public String Quotient="";
public String Rest="";

int CharVal(char xx)
{
      int tt=-1;
      if (xx=='0') tt=0;
      if (xx=='1') tt=1;
      if (xx=='2') tt=2;
      if (xx=='3') tt=3;
      if (xx=='4') tt=4;
      if (xx=='5') tt=5;
      if (xx=='6') tt=6;
      if (xx=='7') tt=7;
      if (xx=='8') tt=8;
      if (xx=='9') tt=9;
      return tt;
}

char DigitVal(int xx)
{
      char tt='!';
      if (xx==0) tt='0';
      if (xx==1) tt='1';
      if (xx==2) tt='2';
      if (xx==3) tt='3';
      if (xx==4) tt='4';
      if (xx==5) tt='5';
      if (xx==6) tt='6';
      if (xx==7) tt='7';
      if (xx==8) tt='8';
      if (xx==9) tt='9';
      return tt;
}

String LNXCopy (String x, int pos, int col)
{
      String Res="";

      for (int i = pos; i < pos+col-1+1; i++) Res=Res+x.charAt(i-1);
      return Res;
}

String LNXChangeChar (String x, int pos, char NewValue)
{
      String Res;

      Res=LNXCopy(x,1,pos-1);
      Res=Res+NewValue;
      Res=Res+LNXCopy(x,pos+1,x.length()-pos);
      return Res;
}

String LNAddPositive (String x, String y)
{
      String z="";
      int sum; int per; int ix; int iy;
      char ax; char ay;

      if (LNErr==0)
      {
            if (!((x.length()>253) & (y.length()>253)))
            {
                  z="";      ix=x.length();
                  iy=y.length();      per=0;
                  while ((ix>0) | (iy>0))
                  {
                        if (ix>0) ax=x.charAt(ix-1);
                        else ax='0';
                        if (iy>0) ay=y.charAt(iy-1);
                        else ay='0';
                        sum=CharVal(ax)+CharVal(ay)+per;
                        per=sum/10;
                        z=DigitVal(sum % 10)+z;
                        ix=ix-1; iy=iy-1;
                  }
                  if (per>0) z=DigitVal(per)+z;
            }
            else LNErr=1;
      }
      return z;
}



boolean LNComparePositive (String x, String y)
{
      int i;
      boolean ll;
      boolean pr=false;

      if (LNErr==0)
      {
            if (x.length()>y.length()) pr=true;
            else
                  if (x.length()<y.length()) pr=false;
                  else
                  {
                        ll=true;      i=1;
                        while (ll & (!(i>x.length()-1)))
                        {
                              if (!(x.charAt(i-1)==y.charAt(i-1))) ll=false;
                              else i=i+1;
                        }
                        if (CharVal(x.charAt(i-1))>CharVal(y.charAt(i-1))) pr=true;
                        else pr=false;
                  }
      }
      return pr;
}


public int LNAskSign (String x)
{
      int l=0;

      if (LNErr==0)
      {
            if (x.charAt(0)=='-') l=-1;
            else l=1;
            return l;
      }
      return l;
}


public boolean LNAskZero (String x)
{
      boolean d=false;

      if (LNErr==0)
      {
            if ((x.charAt(0)=='0') & (x.length()==1)) d=true;
            else d=false;
            return d;
      }
      return d;
}



public String LNInvert (String x)
{
      String y="";

      if (LNErr==0)
      {
            if (!(x.length()>253))
            {
                  y=x;
                  if (!LNAskZero(x))
                  {
                        if (LNAskSign(x)==1) y='-'+x;
                        else y=LNXCopy(x,2,x.length()-1);
                  }
                  return y;
            }
            else LNErr=1;
      }
      return y;
}



String LNSubPositive (String x, String y)
{
      String z="";
      String m;
      boolean pr;
      int i1; int i2; int i3; int per;
      int fi;

      if (LNErr==0)
      {
            if (!((x.length()>253) & (y.length()>253)))
            {
                  if (LNComparePositive(x,y))
                  {
                        pr=false;
                        z=x;
                        m=y;
                  }
                  else
                  {
                        pr=true;
                        z=y;
                        m=x;
                  }
                  i1=z.length();      i2=m.length();      per=0;
                  while ((i1>0) & (i2>0))
                  {
                        if (per>0)
                        {
                              if (CharVal(z.charAt(i1-1))>0)
                              {
                                    z=LNXChangeChar(z,i1,DigitVal(CharVal(z.charAt(i1-1))-1));
                                    per=0;
                              }
                              else
                               z=LNXChangeChar(z,i1,'9');
                        }
                        if (!(CharVal(z.charAt(i1-1))<CharVal(m.charAt(i2-1))))
                              z=LNXChangeChar(z,i1,DigitVal(CharVal(z.charAt(i1-1))-CharVal(m.charAt(i2-1))));
                        else
                        {
                              per=1;
                              z=LNXChangeChar(z,i1,DigitVal(CharVal(z.charAt(i1-1))+10-CharVal(m.charAt(i2-1))));
                        }
                        i1--; i2--;
                  }
                  if (per>0)
                  {
                        if (!(z.charAt(i1-1)=='0')) z=LNXChangeChar(z,i1,DigitVal(CharVal(z.charAt(i1-1))-1));
                        else
                        {
                              i3=i1-1;
                              while (z.charAt(i3-1)=='0') i3--;
                              z=LNXChangeChar(z,i3,DigitVal(CharVal(z.charAt(i3-1))-1));
                              for (int i = i3+1; i < i1+1; i++) z=LNXChangeChar(z,i,'9');
                        }
                  }
                  while ((z.charAt(1-1)=='0') & (z.length()>1)) z=LNXCopy(z,2,z.length()-1);
                  if (pr) z=LNInvert(z);
            }
            else LNErr=1;
      }
      return z;
}


public String LNAdd (String x, String y)
{
      String xx;
      String yy;
      String z="";
      int ix;
      int iy;

      if (LNErr==0)
      {
            if (!((x.length()>253) & (y.length()>253)))
            {
                  ix=LNAskSign(x);
                  iy=LNAskSign(y);
                  if ((ix<0) & (iy<0))
                  {
                        xx=LNInvert(x);
                        yy=LNInvert(y);
                        z=LNAddPositive(xx,yy);
                        z=LNInvert(z);
                  }
                  else
                        if ((ix>0) & (iy>0)) z=LNAddPositive(x,y);
                        else
                              if ((ix>0) & (iy<0))
                              {
                                    yy=LNInvert(y);
                                    z=LNSubPositive(x,yy);
                              }
                              else
                                    if ((ix<0) & (iy>0))
                                    {
                                          xx=LNInvert(x);
                                          z=LNSubPositive(xx,y);
                                          z=LNInvert(z);
                                    }
            }
            else LNErr=1;
      }
      return z;
}



public String LNAssign (int i)
{
      int k;
      int l;
      boolean pr;
      String s="";

      if (LNErr==0)
      {
            if (i==0) s="0";
            else
            {
                  k=i;
                  if (k>0) pr=true;
                  else
                  {
                        pr=false;
                        k=-k;
                  }
                  s="";
                  while (!(k==0))
                  {
                        l=k % 10;
                        s=DigitVal(l)+s;
                        k=(k-l) / 10;
                  }
                  if (!pr) s='-'+s;
            }
      }
      return s;
}


void LN11DivModPositive(String x, String y)
{
      int i;
      String m;

      if (LNErr==0)
      {
            i=0;
            m=x;
            while (!LNComparePositive(y,m))
            {
                  i++;
                  m=LNSubPositive(m,y);
            }
            Rest=m;
            Quotient=LNAssign(i);
      }
}


void LNDivModPositive(String x, String y)
{
      String s;
      String g1;
      String g2;
      String g3;
      String z1;
      String t1;
      String z="";
      String t="";
      int s1;
      int ii;
      int jj;

      if (LNErr==0)
      {
            if (!LNAskZero(y))
            {
                  s=LNSubPositive(x,y);
                  s1=LNAskSign(s);
                  if (LNAskZero(s))
                  {
                        z=LNAssign(1);
                        t=LNAssign(0);
                  }
                  else
                        if (s1==-1)
                        {
                              z=LNAssign(0);
                              t=x;
                        }
                        else
                        {
                              g1=LNXCopy(x,1,y.length());
                              g2=LNXCopy(x,y.length()+1,x.length()-y.length());
                              LN11DivModPositive(g1,y);
                              z1=Quotient;
                              t1=Rest;
                              z=z1;      ii=t1.length();
                              while (!(g2==""))
                              {
                                    ii++;
                                    g3=t1+g2;
                                    g1=LNXCopy(g3,1,ii);
                                    jj=ii;
                                    while ((g1.length()>1) & (g1.charAt(1-1)=='0'))
                                    {
                                          g1=LNXCopy(g1,2,g1.length()-1);
                                          ii--;
                                    }
                                    g2=LNXCopy(g3,jj+1,g3.length()-jj);
                                    LN11DivModPositive(g1,y);
                                    z1=Quotient;
                                    t1=Rest;
                                    z=z+z1;
                                    if (!(z1=="0")) ii=t1.length();
                              }
                              if (z.length()>1)
                                    while (z.charAt(1-1)=='0') z=LNXCopy(z,2,z.length()-1);
                              t=t1;
                        }
            }
            else LNErr=2;
      }
      Quotient=z;
      Rest=t;
}



public String LNSub(String x, String y)
{
      String z;
      String Ret="";

      if (LNErr==0)
      {
            if (!((x.length()>253) & (y.length()>253)))
            {
                  z=LNInvert(y);
                  Ret=LNAdd(x,z);
            }
            else LNErr=1;
      }
      return Ret;
}


public void LNDivMod(String x, String y)
{
      String xx;
      String yy;
      String ff;
      String z="";
      String t="";

      if (LNErr==0)
      {
            if (LNAskSign(x)==1)
            {
                  if (LNAskSign(y)==1)
                  {
                        LNDivModPositive(x,y);
                        z=Quotient;
                        t=Rest;
                  }
                  else
                  {
                        yy=LNInvert(y);
                        LNDivModPositive(x,yy);
                        z=Quotient;
                        t=Rest;
                        t=LNInvert(t);
                  }
            }
            else
            {
                  if (LNAskSign(y)==1)
                  {
                        xx=LNInvert(x);
                        LNDivModPositive(xx,y);
                        z=Quotient;
                        t=Rest;
                        z=LNInvert(z);
                        if (!LNAskZero(t))
                        {
                              ff=LNAssign(1);
                              z=LNSub(z,ff);
                              t=LNSub(y,t);
                        }
                  }
                  else
                  {
                        xx=LNInvert(x);
                        yy=LNInvert(y);
                        LNDivModPositive(xx,yy);
                        z=Quotient;
                        t=Rest;
                        t=LNInvert(t);
                  }
            }
      }
      Quotient=z;
      Rest=t;
}


String LNDivPositive(String x)
{
      String y="";

      if (LNErr==0)
      {
            if (x.length()<2) y=LNAssign(0);
            else
                  y=LNXCopy(x,1,x.length()-1);
      }
      return y;
}


int LNModPositive(String x)
{
      int aa=0;

      if (LNErr==0)
            aa=CharVal(x.charAt(x.length()-1));
      return aa;
}


public int LNInteger (String x)
{
      String aa;
      String y;
      String yy;
      String bb;
      int sign;
      int i;
      int j;
      int s=0;
      int l;

      if (LNErr==0)
      {
            aa=LNAssign(32767);
            if (LNAskSign(x)==1)
            {
                  y=x;
                  sign=1;
            }
            else
            {
                  y=LNInvert(x);
                  sign=-1;
            }
            bb=LNSub(aa,y);
            if (!(LNAskSign(bb)==-1))
            {
                  i=y.length();      j=1;      s=0;
                  for (int k=1; k < i+1; k++)
                  {
                        l=LNModPositive(y);
                        s=s+l*j;
                        j=j*10;
                        yy=LNDivPositive(y);
                        y=yy;
                  }
                  if (sign==-1) s=-s;
            }
            else LNErr=4;
      }
      return s;
}


String LNMulPositiveToDigit(String x, int y)
{
      String z="";
      int i;
      int k;
      int per;

      if (LNErr==0)
      {
            if (!(x.length()>253))
            {
                  z=x;      per=0;      i=z.length();
                  while (i>0)
                  {
                        k=CharVal(z.charAt(i-1))*y+per;
                        z=LNXChangeChar(z,i,DigitVal(k % 10));
                        per=k / 10;
                        i--;
                  }
                  if (per>0) z=DigitVal(per)+z;
                  while ((z.charAt(1-1)=='0') & (z.length()>1))
                        z=LNXCopy(z,2,z.length()-1);
            }
            else LNErr=1;
      }
      return z;
}


String LNMulPositiveTo10(String x)
{
      String y="";

      if (LNErr==0)
      {
            if (!(x.length()>253))
            {
                  if (!LNAskZero(x)) y=x+'0';
                  else y=LNAssign(0);
            }
            else LNErr=1;
      }
      return y;
}


String LNMulPositiveToPositive(String x, String y)
{
      int c;
      int ib;
      String a;
      String b;
      String d="";
      String e;

      if (LNErr==0)
      {
            if (!(x.length()+y.length()>253))
            {
                  if (LNComparePositive(x,y))
                  {
                        a=x;
                        b=y;
                  }
                  else
                  {
                        a=y;
                        b=x;
                  }
                  d=LNAssign(0);      ib=1;
                  while (!(ib>b.length()))
                  {
                        c=CharVal(b.charAt(ib-1));
                        b=LNXCopy(b,2,b.length()-1);
                        d=LNMulPositiveTo10(d);
                        e=LNMulPositiveToDigit(a,c);
                        d=LNAdd(d,e);
                  }
            }
            else LNErr=1;
      }
      return d;
}

public String LNMul(String x, String y)
{
      int i;
      String a;
      String b;
      String c="";

      if (LNErr==0)
      {
            if (!(x.length()+y.length()>253))
            {
                  i=LNAskSign(x)*LNAskSign(y);
                  if (LNAskSign(x)==-1) a=LNInvert(x);
                  else a=x;
                  if (LNAskSign(y)==-1) b=LNInvert(y);
                  else b=y;
                  c=LNMulPositiveToPositive(a,b);
                  if (i==-1) c=LNInvert(c);
            }
            else LNErr=1;
      }
      return c;
}

}

 

©   Aliaksandr Prykhodzka    1993 - 2007