Calculate difference of indices The challenge is to reconstruct an n-digit number using the following information:


  On each step, you choose an index x from 1 to n.  For all indices y (y
  &lt; x), you calculate the difference by = ax - ay.
  
  You then calculate B1 — sum of all by which are greater
  than 0 and B2 — sum of all by which are less than 0.
  
  The answer for this step is B1 - B2.
  
  Input
  
  The first line contains two integers n and m, denoting the number
  of digits and number of steps. The second line contains n digits
  (without spaces) a1, a2, ..., an.
  Each of the next m lines contains a single integer x denoting the index for
  the current step.
  
  Output
  
  For each of m steps print single number in a line - answer of the
  step.


Can someone please help me optimize this code or provide a better, less time-consuming solution?

import java.io.*;
import java.util.*;
public class Chefs
{
    //BufferedReader in;
    DataInputStream in;
    PrintWriter out;
    HashMap&lt;Integer,Integer&gt; mymap=new HashMap&lt;Integer,Integer&gt;();
    int a[],n,m,b1,b2;
    public Chefs()
    {
        //in=new BufferedReader(new InputStreamReader(System.in));
        in=new DataInputStream(System.in);
        out=new PrintWriter(System.out,true);
        readInput();
        calchef();
    }
    void readInput()
    {
        try
        {
            String digit=in.readLine();
            String split[]=digit.split("\\s+");
            n=Integer.parseInt(split[0]);
            m=Integer.parseInt(split[1]);
            a=new int[n];

            digit=in.readLine();

            for(int i=0;i&lt;digit.length();i++)
                a[i]=digit.charAt(i);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    void calchef()
    {
        for(int i=0;i&lt;m;i++)
        {  
            try
            {
                b1=0;
                b2=0;
                int index=Integer.parseInt(in.readLine());
                if(mymap.containsKey(index))
                {
                    int ans=mymap.get(index);
                    out.println(ans);
                }
                else
                {
                    for(int j=0;j&lt;index-1;j++)
                    {
                        if(a[index-1]-a[j]&gt;0)
                        {
                            b1+=(a[index-1]-a[j]);
                        }
                        else
                        {
                            b2+=(a[index-1]-a[j]);
                        }
                    }
                    int ans=b1-b2;
                    out.println(ans);
                    mymap.put(index,ans);
                }
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args)
    {
        //long startTime = System.currentTimeMillis();
        Chefs c=new Chefs();
        //long endTime   = System.currentTimeMillis();
        //long totalTime = endTime - startTime;
        //System.out.println(totalTime);
    }
}
1) I would change the inner for loop this way (very little optimization, unlikely it will bring better performance)

int ans=0;
int y=index-1;
for(int j=0; j&lt;y; j++)
{
    int diff = a[y] - a[j];

    if(diff &gt; 0)
        ans += diff;
    else
        ans -= diff;
}


2) You never store ans in the map.