Calculate the digital root of a number

digitalRoot n
    | n < 10 = n
    | otherwise = digitalRoot . sum . map (c -> read [c]) . show $ n

digital-root: func [n [integer!] /local added expanded] [
    either n < 10 [
        n
    ][
        expanded: copy []
        foreach c to-string n [
            append expanded to-integer to-string c
        ]
        added: 0
        foreach e expanded [
            added: added + e
        ]
        digital-root added
    ]
]

public class DigitalRoot
{
   public static int GetDigitalRoot(long inputNumber)
   {
      if (inputNumber%9==0)
           return 9;
      else
           return inputNumber%9;
   }
}

public class DigitalRoot
{
   public static int GetDigitalRoot(long inputNumber)
   {
      if (inputNumber%9==0)
           return 9;
      else
           return inputNumber%9;
   }
}

dr = 1 + ((n - 1) % 9);

while($n>9){my$t;for(split//,$n){$t+=$_}$n=$t}

while ($number > 9) {
   my $total;
   for $digit (split(//,$number)) {
       $total += $digit
   }
   $number=$total;
}

$n=($n%9?$n%9:9);

digitalRoot n
    | m9 == 0 = 9
    | otherwise = m9
    where
        m9 = n `mod` 9

def dr(n:Int) = (n % 9) match {case 0 => 9; case x => x}

def dr(x):
  if x < 10: return x
  return dr(sum(int(c) for c in str(x)))

def dr2(x):
  if x == 0: return 0
  if x % 9 == 0: return 9
  else: return x % 9

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

unsigned int digital_root(const char *string)
{
        int i;
        unsigned int v = 0;

        /* Add all digits. */
        for(i = 0; isdigit(string[i]); i++)
                v += string[i] - '0';

        /* Recursion necessary? */
        if(v >= 10)
        {
                char buf[32];
                snprintf(buf, sizeof buf, "%u", v);
                return digital_root(buf);
        }
        return v;
}

int main(int argc, char *argv[])
{
        int i;

        for(i = 1; argv[i] != NULL; i++)
                printf("%s: %un", argv[i], digital_root(argv[i]));
        return EXIT_SUCCESS;
}

(defun digital-root (x)
  (setf x (1+ (mod (- x 1) 9))))

@echo off
setlocal enabledelayedexpansion

set /a number  = %1
set /a droot = 0

:loop
rem Sum up digits
if %number% leq 0 goto check
set /a droot += !number! %% 10
set /a number ^/= 10
goto loop

:check
rem Got a single-digit number?
if %droot% leq 9 goto end

rem Do one more pass
set /a number = droot
set /a droot = 0
goto loop

:end
echo %droot%

@echo off
setlocal enabledelayedexpansion

set /a number = %1
set /a droot = 0

:loop
if %number% leq 0 goto end
set /a droot += !number! %% 10
if !droot! gtr 9 set /a droot -= 9
set /a number ^/= 10
goto loop

:end
echo %droot%

@set /a dr = (%1 - 1) %% 9 + 1
@echo %dr%

>digitalroot.bat 42
6
>digitalroot.bat 256
4

public static int DigitalRoot(this int source)
{
    int result =
        source.ToString().ToCharArray().Sum(x => int.Parse(x.ToString()));
    return (result > 9) ? result.DigitalRoot() : result;
}

def digitalRoot(n)
   s = n.to_i.to_s
   while (s.length > 1) do
      result = 0
      s.each do |d|
        result += d.to_i
      end
      s = result.to_i.to_s
   end
   return s.to_i
end

def digitalRoot(n)
  return 1 + ((n.to_i - 1) % 9)
end

int DigitalRoot(int number)
{
    if ( number < 10) return number;
    else
    {
        int counter = 0; int h = 0;
        for (int f = 10; number / (f / 10) > 0; f *= 10)
        {
            counter += ((number % f) - h) / (f / 10);
            h = number % f;
        }
        return DigitalRoot(counter);
    }
}

int DigitalRoot(int number)
{
    return number % 9 == 0 ? 9 : number % 9;
}

<?php
function digitalRoot($num)
 {
    while($num > 9)
     {
        $num = array_sum(str_split($num));
     }
    return $num;
 }
echo digitalRoot('65536');
?>

function getDigitalRoot($n)
{
    // Don't forget to allow for 0
    return (($n%9) == 0 && ($n != 0) )? 9: $n%9;
}

function getDigitalRoot($n)
{
    while($n>9)
    {
        // Create array from the digits
        $vals = str_split($n);
        // Sum up the array. If it's not a single digit, we'll loop again
        $n = array_sum($vals);
    }
    return n;
}

Input: 99
Output: 9

Input: 102
Output: 3

def digitalSum(n)
  return 1+((n-1)%9)
end

def digitalRoot(n):
    sum = 0
    for d in str(n):
        sum += int(d)
        if sum > 9: sum -= 9
    return sum

def digitalRoot(n):
    return 0 if n==0 else 1+((n-1)%9)

sub digitalroot ( $number is copy ){
  while ($number > 9) {
    $number = [+] split( "", $number );
  }
  return $number;
}

multi digitalroot ( $number where{ .perl >= 10 } ){
  return digitalroot( [+] split( "", $number ) );
}
multi digitalroot ( $number where{ .perl <= 9  } ){
  return $number;
}

$n=($n%9??$n%9!!9);