Bdtjtk

What you are looking for is digital root. So here's a better solution using the formula from wiki page I linked.

Without Recursion: -

public static int compute( int n ) {

    return n - 9 * ((n - 1) / 9);

}

And, just in case you want (Which I don't think you would), here's a one-liner (Using Recursion): -

public static int compute( int n ) {

    return n < 10 ? n : compute(n % 10 + compute(n / 10));

}

    public int FindSumDigit(int number)

    {

        if (number < 10) return number;

        int sum = 0;

        while (number > 0)

        {

            sum += number % 10;

            number = number / 10;

        }

        return FindSumDigit(sum);

    }

Find my code...
Poon you were not adding the whole digits.. In middle itself u was keep on adding the right most digit.

Many wrong answers here. Here's what OP wants:

Method return should be like if entered a number, suppose 345, then
output should be 3+4+5=12 --> 1+2 = 3.

This will do the job:

public static int compute(int param) {

    int sum = 0;

    do {

        sum = 0;

        while (param > 0) {

            sum += param % 10;

            param /= 10;

        }

        param = sum;

    } while (sum >= 10);

    return sum;

}

I changed your method to this, then it gives the requested result:

public int compute(int methParam) {

    int sum = 0;

    for (int i = 0; methParam > 10; i++) {

        int currentDigit = methParam % 10;

        methParam = methParam / 10;

        sum = sum + currentDigit;

    }

    if (sum + methParam > 10) {

        return compute(sum + methParam);

    } else {

        return sum + methParam;

    }

}

Please note that i moved the declaration of sum inside the method, instead of making it a field.

IN your code your are not properly returning values to get call for your recursion method.

        if ((MethParam >= 10)){

            return compute(MethParam);

        }else

            return Sum + MethParam;

public int compute( int param )

{

    int x = param % 10;

    int y = param / 10;



    if (y > 0)

        return x + compute(y);



    return x;

}



public int computeNonRec(int param) {

    int result = 0;

    while (param > 0) {

        result += param % 10;

        param /= 10;

    }

    return result;

}

Try

 public int sumDigit(int n) {

        int sum = 0;

        while (n > 0) {

            sum += n % 10;

            number = n / 10;

        }

        return sum;

    }

just a different approach, may not be as efficient due to involved conversions:

private static int getUltimateSum(int input) {

    String inputStr = String.valueOf(input);

    int sum = 0;

    for (int i = 0; i < inputStr.length(); i++) {

        int digit = Integer.valueOf(String.valueOf(inputStr.charAt(i)));

        sum += digit;

    }

    if(sum > 9)

        return getUltimateSum(sum);

    else

        return sum;

}

Here's a string solution:

public int compute( int MethParam )

{

    int sum = 0; 

    string meth = MethParam.ToString();        



    for (char x in meth) {

        sum += int.Parse(x);

    }

    if (sum >= 10) {

        return compute(sum);

    }

    else {

        return sum;

    }

}

This code is in C# not Java so consider it pseudocode.

try

public class DigitSum {

int  Sum=0;

public int compute( int MethParam )

{

    int rem = MethParam%10; 

    Sum+=rem;        



    MethParam = MethParam/10; 

    if(MethParam>10)

        compute(MethParam);

    else

        Sum+=MethParam;



        if(Sum>=10){

        int temp=Sum;

        Sum=0;

        compute(temp);

    }



         return Sum;  

}



public static void main(String args){

    DigitSum ds= new DigitSum();

        System.out.println(ds.compute(435));

    }

}

shortest code for this is -

int compute(int n){

    while(n > 9){

        n = n - 9;

    }

    return n;

}

where n is number for which you want to compute some of its digits.

EDIT: Efficient for only small numbers, say 3 digit number.

EDIT: Tested few answers:

public class Test {

    public static void main(String  args){

        int i = 0x0fefefef;



        long st1 = System.nanoTime();

        int n1 = sumDigit(i);

        long t1 = System.nanoTime() - st1;



        long st2 = System.nanoTime();

        int n2 = FindSumDigit(i);

        long t2 = System.nanoTime() - st2;



        long st3 = System.nanoTime();

        int n3 = compute(i);

        long t3 = System.nanoTime() - st3;



        long st4 = System.nanoTime();

        int n4 = compute1(i);

        long t4 = System.nanoTime() - st4;



        System.out.println("Tested for: "+i);

        System.out.println(n1+": "+t1);

        System.out.println(n2+": "+t2);

        System.out.println(n3+": "+t3);

        System.out.println(n4+": "+t4);

    }



    public static int sumDigit(int n){

      int sum = n % 9;

      if(sum == 0){

          if(n > 0)

               return 9;

      }

      return sum;

    }



    public static int FindSumDigit(int n)

    {

        if (n < 10) return n;

        int sum = 0;

        while (n > 0)

        {

            sum += n % 10;

            n = n / 10;

        }

        return FindSumDigit(sum);

    }



    public static int compute( int n ) {

        return n - 9 * ((n - 1) / 9);

    }



    public static int compute1(int n){

        while(n > 9){

            n = n - 9;

        }

        return n;

    }

}

Here is result for above test:

Tested for: 267382767

3: 2432

3: 1621

3: 810

3: 5354519

use this simple java code I created some tymz ago, this was for adding positive numbers as well as negative numbers:

class SumDigit

{

public static void main(String args)

{

int sum, i,a,d;

a = Integer.parseInt(args[0]);

sum = 0;

for(i=1;i< =10;i++)

{

d = a%10;

a = a/10;

sum=sum + d;

} 

System.out.println("Sum of Digit :"+sum);

}

}