Jednocyfrowa suma

Na ferie dostałem zadanie do zrobienia i w nie wiem o co w nim chodzi , prosze o jakas pomoc.

Napisz program, który dla podanej na standardowym wejściu liczb całkowitej n wypisze jednocyfrową sumę jej cyfr. (liczba całkowite typu int).

Przykład
Dla danych wejściowych:

18,25,793

poprawnym rozwiązaniem jest:

9,7,1

Dziękujemy za tak wyczerpujące informacje :/ Zdradź przynajmniej w jakim języku, to może ktoś będzie w stanie coś pomóc!!!

liczba 18 czyli 1+8=9
liczba 25 czyli 2+5=7

i ostatnia prawdopodobnie:
liczba 793 czyli 7+9+3=19
.. 19= 1+9=10
.. 10= 1+0=1

Całość zrobisz za pomocą div mod i pętli np. while.

Jeżeli nie rozumiesz jeszcze to poszukaj w numerologi, pamiętam, że tam tak samo przeliczało się jakieś cyferki..

Wersja 1, mało efektywna i mało elegancka:

object Main extends Application {
  def contract(number: String): String = {
    if (number.length < 2)
      return number
    contract(number.map(_.asDigit).sum.toString)
  }
  print(contract(Console.readLine))
}

Wersja 2, elegancka i efektywna, funkcje w funkcjach - fajny bajer:

object Main extends Application {
  def contract(sNumber: String) = {
    def contractInt(iNumber: Int): Int = {
      if (iNumber < 10)
        iNumber
      else 
        contractInt(iNumber % 10 + iNumber / 10)
    }
    contractInt(sNumber.map(_.asDigit).sum)
  }
  print(contract(Console.readLine))
}

Wersja 3, najmniej elegancka i średnio efektywna, ale za to najkrótsza:

object Main extends Application {
  var bigInt = BigInt(readLine)
  while (bigInt > 9) {
    bigInt = bigInt % 10 + bigInt / 10;
  }
  print(bigInt)
}

Ogłaszam konkurs na najbardziej elegancki kod rozwiązujący zadanie podobne do zadania z pierwszego posta, tzn wczytywany numer nie musi się mieścić w 32-bitach. Autor nie dopisał też jednej rzeczy: cyfry sumujemy rekurencyjnie, aż wyjdzie nam suma jednocyfrowa.

s = readline
s = s.chars.to_a.map(&:to_i).inject(&:+) until s.length < 2
puts s

Nie mam na razie pomysłu jak to poprawić by było trochę ładniejsze

long long int Potega(long long int Licz, int Wykl)
{
    for(int a = 1; a != Wykl; a++)
        Licz *= Licz;
    return Licz;
}
long long int DlugoscBardzoEleganckiejLiczby(long long int Liczba)
{
    long long int Dlug;
    for(Dlug = 1;; Dlug++)
        if(Potega(10, Dlug) > Liczba)
            return Dlug;
}
long long int JestemBardzoElegancki(long long int Liczba)
{
    int Dlugosc = DlugoscBardzoEleganckiejLiczby(Liczba);
    long long int Wynik = 0;
    for(int a = 0; a != Dlugosc; a++)
    {
        Wynik += Liczba % 10;
        Liczba /= 10;
    }
    return Wynik;
}
long long int Dlugosc(long long int Liczba)
{
    for(int a = 0; Liczba > 9; a++)
    {
         Liczba = JestemBardzoElegancki(Liczba);
         } 
    return Liczba;
    } 

Panowie, źle. To ma sumować rekurencyjnie, aż do uzyskania sumy jednocyforwej - tak jak w numerologii. Bez rekurencji program wyjdzie zbyt krótki:

object Main extends Application {
  print(readLine.map(_.asDigit).sum)
}

Mój już działa (bez rekurencji :P, tylko ładna pętelka).

Ruby v2:

i = readline.to_i
i = i % 10 + i / 10 until i < 10
puts i

long long get(long long n)
{
    long long suma=0;
    while(n!=0)
    {
        suma+=n%10;
        n/=10;
    }
    return suma;
}
int main()
{
    long long n;
    cin>>n;
    while(n>9)
        n=get(n);
    cout<<n;
    return 0;
}

wieżę, ze proste rozwiązania to dobre rozwiązania:D