Data update

Task/Digital-root/Amazing-Hopper/digital-root.hopper

@@ -0,0 +1,29 @@
+#!/usr/bin/hopper
+#include <batch-en.h>
+
+/* main program */
+begin
+    ld=0
+    set decimal '0'      // work with integers only
+    prepare data(DATA)   // my dear "old" BASIC!
+    get len data, move to 'ld'
+    iter group ( --ld, ld, get data, perform(digital root), echo )
+end
+
+/* procedures */
+.locals
+
+func(digital root, n)
+   c = 0, cnum=n
+   iter group (++c, #(n>=10), s=0, q=0, m=n, \
+       iter group ( m=q, #( m<>0 ),\
+           #( q=int(m/10) ), #( s+= m-(q*10) ) ), n=s )
+ /* put all into stack */
+   #( lpad(".", 20, string(cnum) ) )
+   " -> digital root = ", #(n+0),", (additive persistence = ",#(c+0),")"
+back
+
+DATA:
+   data( 9992, 39390, 588225, 627615, 393900588225, 9837703004232342 )
+   data( 126765060022822940, 199, 10 )
+back

Task/Digital-root/EasyLang/digital-root.easy

@@ -1,21 +1,18 @@
-proc digitalRoot n . x persistence .
-   numberString$ = n
-   currentPersist = 0
-   while len numberString$ > 1
-      for i = 1 to len numberString$
-         sum += number substr numberString$ i 1
-      .
-      numberString$ = sum
-      currentPersist += 1
-      sum = 0
+func digsum num .
+   while num > 0
+      s += num mod 10
+      num = num div 10
    .
-   x = number numberString$
-   persistence = currentPersist
+   return s
+.
+func[] digrootpers x .
+   while x > 9
+      x = digsum x
+      cnt += 1
+   .
+   return [ x cnt ]
 .
 numbers[] = [ 627615 39390 588225 393900588225 ]
 for i in numbers[]
-   digitalRoot i x persistence
-   print i
-   print "Additive persistence: " & persistence
-   print "Digital root: " & x
+   print i & " -> " & digrootpers i
 .

Task/Digital-root/PascalABC.NET/digital-root.pas

@@ -0,0 +1,18 @@
+##
+function DigitalRoot(num: int64): (integer, integer);
+begin
+  var additivepersistence := 0;
+  while num > 9 do
+  begin
+    num := num.ToString.ToCharArray.Sum(x -> x.ToDigit);
+    additivepersistence += 1;
+  end;
+  result := (additivepersistence, integer(num));
+end;
+
+var nums := |627615, 39390, 588225, 393900588225|;
+foreach var num in nums do
+begin
+  var t := DigitalRoot(num);
+  Writeln(num, ' has additive persistence ', t[0], ' and digital root ', t[1])
+end;

Task/Digital-root/REXX/digital-root-4.rexx

@@ -0,0 +1,57 @@
+include Settings
+
+say version; say 'Digital root'; say
+numeric digits 30
+say Show(0)
+say Show(9)
+say Show(10)
+say Show(19)
+say Show(199)
+say Show(679)
+say Show(6788)
+say Show(39390)
+say Show(588225)
+say Show(2677889)
+say Show(393900588225)
+say Show(19999999999999999999999)
+say Format(Time('e'),,3) 'seconds'
+exit
+
+Show:
+arg x
+return 'Number:' x 'Digital root:' Digitroot(x) 'Additive persistence:' Persistence(x)
+
+Digitroot:
+/* Digital root function */
+procedure expose glob.
+arg x
+/* Formula */
+return 1+(x-1)//9
+
+Persistence:
+/* Additive persistence function */
+procedure expose glob.
+arg x
+/* Fast value */
+if x < 10 then
+   return 0
+/* Cf definition */
+do y = 1 until x < 10
+   x = Digitsum(x)
+end
+return y
+
+Digitsum:
+/* Digitsum function = sum(digits) */
+procedure expose glob.
+arg x
+/* Sum digits */
+y = 0
+do n = 1 to Length(x)
+   y = y+Substr(x,n,1)
+end
+return y
+
+include Functions
+include Numbers
+include Abend