CareerCup

This is number nine trick. Ans=(Number)%9
Proof I don't know.

May not accept numbers with size larger than 12 digits.. But that can be handled..

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Summation {
    public static void main(String[] args) throws IOException {
        System.out.println("Enter the Number:");
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String snum = in.readLine();
        long num = Integer.parseInt(snum);
        
        while (size(num) != 1) {           
            num = addDigits(num);
        }
        
        System.out.println("Ans:" + num);
    }

    public static long addDigits(long num) {
        long numOfDigits = size(num);
        int startMod = 10;
        long sum = 0;

        for(int i = 0; i < numOfDigits; i++){
            long digit = num%startMod;
            sum = sum + digit;
            num = (int) num/startMod;
        }
        return (sum);
    }

    public static long size(long num) {      
        int digits = 0;
        int step = 1;
        while (step <= num) {
            digits++;
            step = step * 10;
        }
        return (digits);
    }
}

int sum(int n)
{
int s;

while (1)
{
s = 0;
while (n > 9)
{
s += n % 10;
n = n /10;
}
n = s;
if (n < 10) break;
}
}

int main()
{
    long no = 312451223999999;
	int sum = 0;
	int flag = 0;

	do{
		if(flag==1){
			no = sum;
			sum = 0;
		}
		while(no/10){
			sum += (no-((no/10)*10));
			no = no/10;
		}
		sum+=no;
		flag = 1;

	}while(sum/10);

	cout << "sum : " << sum;

    return 0;
}

but seriously? Amazon is asking such simple Q's ?????
Was that a phone intv?

Recursive Solution !

public static int digitsSum(int n)
	{
		if(n<10) return n;
		int sum = 0, d;
		while(n>0) 
		{
			d = n%10;  n = n/10; sum += d;
		}
		return digitsSum(sum);
	}

The above code is correct, except it should simply return sum, instead of recursively calling the function .

such a easy question asked by amazon :)

int sumofnumber(int num)
{
int t,sum=0;
while(num/10)
{
t=num;
while(t)
{
sum=sum+t%10;
t=t/10;
}
num=sum;
sum=0;
}
return num;
}

int recursiveSum(int num)
{
    if(num % 10 == num)
        return num;

    int lastDigit = num % 10;
    int remainder = num / 10;

    return (lastDigit + recursiveSum(remainder);
}

Time Complexity: O(n).

PS: If there is anything wrong with the code, feel free to correct me ...

def sumDigits(n):  # assumption: n >= 0
  if n / 10 == 0: return n
  else:
    s = 0
    while n != 0:
      s += n % 10
      n = n / 10
    return sumDigits(s)

public void sumdigits(int num)
        {
            int temp = 0;
            while (num > 0)
            {
                temp = temp + num % 10;
                num = num / 10;
            }
            if (temp > 9)
            {
                sumdigits(temp);
            }
            else
            {
                Console.WriteLine(temp);
            }
        }

public static int SumOfDigit(int sum)
{
if(sum<9)
return sum;
string digit = sum + "";
sum = 0;
foreach (char c in digit)
{
sum += (c - 48);
}
return SumOfDigit(sum);

}

public class SumOfDigits {
public static void main(String[] args) {

int n=123456;
int remainder=n%10;
int sum=0;
while(n!=0){
remainder=n%10;
sum+=remainder;
n=n/10;
if(n==0)
{
n=sum;
if(n/10==0)
break;
sum=0;
}
}
System.out.println("The Sum is:"+sum);
}

}


output: 3

public class SumtoSingle {

public static void main(String[] args) {
int num=810;
int sum=0;
while(true)
{
sum=sum+num%10;
num=num/10;
if(num==0 && sum>9)
{
num=sum;
sum=0;
}
else if(num ==0 && sum<=9)
break;
}
System.out.println(sum);

}

}