Rosetta Code

Digital root/Multiplicative digital root: Difference between revisions

Page Discussion

Digital root/Multiplicative digital root (view source)

Revision as of 23:40, 26 August 2022

1,976 bytes added ,  1 year ago
m
syntax highlighting fixup automation
No edit summary
m (syntax highlighting fixup automation)
Line 42:
=={{header|11l}}==
{{trans|Python}}
<langsyntaxhighlight lang="11l">F mdroot(n)
V count = 0
V mdr = n
Line 73:
L(val) table
print(‘#2: ’.format(L.index), end' ‘’)
print(val[0.<5])</langsyntaxhighlight>
 
{{out}}
Line 102:
The solution uses the Package "Generic_Root" from the additive digital roots [[http://rosettacode.org/wiki/Digital_root#Ada]].
 
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO, Generic_Root; use Generic_Root;
 
procedure Multiplicative_Root is
Line 148:
TIO.New_Line;
end loop;
end Multiplicative_Root;</langsyntaxhighlight>
 
{{out}}
Line 172:
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68">BEGIN # Multiplicative Digital Roots #
# structure to hold the results of calculating the digital root & persistence #
MODE DR = STRUCT( INT root, INT persistence );
Line 241:
print md root( 899998 );
tabulate mdr( 5 )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 263:
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang="algolw">begin
% calculate the Multiplicative Digital Root (mdr) and Multiplicative Persistence (mp) of n %
procedure getMDR ( integer value n
Line 328:
end
 
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 351:
 
=={{header|AWK}}==
<langsyntaxhighlight AWKlang="awk"># Multiplicative Digital Roots
 
BEGIN {
Line 426:
} # for pos
 
} # tabulateMdr</langsyntaxhighlight>
{{out}}
<pre>
Line 448:
 
=={{header|Bracmat}}==
<langsyntaxhighlight lang="bracmat">(
& ( MP/MDR
= prod L n
Line 493:
& put$\n
)
);</langsyntaxhighlight>
{{out}}
<pre>123321 : (3.8)
Line 511:
 
=={{header|C}}==
<syntaxhighlight lang="c">
<lang C>
#include <stdio.h>
 
Line 570:
return 0;
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 593:
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
Line 631:
Console.WriteLine(" {0} : [{1}]", i, string.Join(", ", table[i]));
}
}</langsyntaxhighlight>
{{out}}
<pre>123321 has multiplicative persistence 3 and multiplicative digital root 8
Line 649:
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">
#include <iomanip>
#include <map>
Line 709:
return system( "pause" );
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 736:
 
=={{header|CLU}}==
<langsyntaxhighlight lang="clu">digits = iter (n: int) yields (int)
while n>0 do
yield(n//10)
Line 794:
stream$putl(po, "")
end
end start_up</langsyntaxhighlight>
{{out}}
<pre> N MDR MP
Line 817:
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="lisp">
(defun mdr/p (n)
"Return a list with MDR and MP of n"
Line 842:
do (format t "~6@a: ~{~3@a ~}~%" el (mdr/p el)))
(format t "~%MDR: [n0..n4]~%")
(first-n-number-for-each-root 5))</langsyntaxhighlight>
{{out}}
<pre>
Line 865:
=={{header|Component Pascal}}==
{{Works with| BlackBox Component Builder}}
<langsyntaxhighlight lang="oberon2">
MODULE MDR;
IMPORT StdLog, Strings, TextMappers, DevCommanders;
Line 935:
 
END MDR.
</syntaxhighlight>
</lang>
Execute:
^Q MDR.Do 123321 7739 893 899998 ~
Line 963:
=={{header|D}}==
{{trans|Python}}
<langsyntaxhighlight lang="d">import std.stdio, std.algorithm, std.typecons, std.range, std.conv;
 
/// Multiplicative digital root.
Line 989:
foreach (const mp; table.byKey.array.sort())
writefln("%2d: %s", mp, table[mp].take(5));
}</langsyntaxhighlight>
{{out}}
<pre>Number: (MP, MDR)
Line 1,012:
 
===Alternative Version===
<langsyntaxhighlight lang="d">import std.stdio, std.algorithm, std.typecons, std.range;
 
uint digitsProduct(uint n) pure nothrow @nogc {
Line 1,045:
foreach (const mp; table.byKey.array.sort())
writefln("%2d: %s", mp, table[mp].take(5));
}</langsyntaxhighlight>
 
===More Efficient Version===
<langsyntaxhighlight lang="d">import std.stdio, std.algorithm, std.range;
 
/// Multiplicative digital root.
Line 1,083:
foreach (const mp; table.byKey.array.sort())
writefln("%2d: %s", mp, table[mp].take(5));
}</langsyntaxhighlight>
The output is similar.
 
=={{header|Elixir}}==
<langsyntaxhighlight lang="elixir">defmodule Digital do
def mdroot(n), do: mdroot(n, 0)
Line 1,123:
 
Digital.task1([123321, 7739, 893, 899998])
Digital.task2</langsyntaxhighlight>
 
{{out}}
Line 1,149:
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
// mdr. Nigel Galloway: June 29th., 2021
let rec fG n g=if n=0 then g else fG(n/10)(g*(n%10))
Line 1,156:
let fN g=Seq.initInfinite id|>Seq.filter((mdr>>fst>>(=)g))|>Seq.take 5
seq{0..9}|>Seq.iter(fun n->printf "First 5 numbers with mdr %d -> " n; Seq.initInfinite id|>Seq.filter((mdr>>fst>>(=)n))|>Seq.take 5|>Seq.iter(printf "%d ");printfn "")
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,175:
</pre>
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">USING: arrays formatting fry io kernel lists lists.lazy math
math.text.utils prettyprint sequences ;
IN: rosetta-code.multiplicative-digital-root
Line 1,205:
{ 123321 7739 893 899998 } [ print-mdr ] each nl first5-table ;
 
MAIN: main</langsyntaxhighlight>
{{out}}
<pre>
Line 1,228:
 
=={{header|Fortran}}==
<syntaxhighlight lang="fortran">
<lang Fortran>
!Implemented by Anant Dixit (Oct, 2014)
program mdr
Line 1,320:
end subroutine
 
</syntaxhighlight>
</lang>
 
<pre>
Line 1,347:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
Function multDigitalRoot(n As UInteger, ByRef mp As Integer, base_ As Integer = 10) As Integer
Line 1,398:
Print
Print "Press any key to quit"
Sleep</langsyntaxhighlight>
 
{{out}}
Line 1,427:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 1,481:
fmt.Printf(tableFmt, i, l)
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,508:
=={{header|Haskell}}==
Note that in the function <code>mdrNums</code> we don't know in advance how many numbers we'll need to examine to find the first 5 associated with all the MDRs. Using a lazy array to accumulate these numbers allows us to keep the function simple.
<langsyntaxhighlight lang="haskell">import Control.Arrow
import Data.Array
import Data.LazyArray
Line 1,548:
printMpMdrs [123321, 7739, 893, 899998]
putStrLn ""
printMdrNums 5</langsyntaxhighlight>
{{out}}
Note that the values in the first column of the table are MDRs, as shown in the task's sample output, not MP as incorrectly stated in the task statement and column header.
Line 1,574:
 
Works in both languages:
<langsyntaxhighlight lang="unicon">procedure main(A)
write(right("n",8)," ",right("MP",8),right("MDR",5))
every r := mdr(n := 123321|7739|893|899998) do
Line 1,597:
while m > 0 do c *:= 1(m%10, m/:=10)
return c
end</langsyntaxhighlight>
 
{{out}}
Line 1,626:
First, we need something to split a number into digits:
 
<langsyntaxhighlight Jlang="j"> 10&#.inv 123321
1 2 3 3 2 1</langsyntaxhighlight>
 
Second, we need to find their product:
 
<langsyntaxhighlight Jlang="j"> */@(10&#.inv) 123321
36</langsyntaxhighlight>
 
Then we use this inductively until it converges:
 
<langsyntaxhighlight Jlang="j"> */@(10&#.inv)^:a: 123321
123321 36 18 8</langsyntaxhighlight>
 
MP is one less than the length of this list, and MDR is the last element of this list:
 
<langsyntaxhighlight Jlang="j"> (<:@#,{:) */@(10&#.inv)^:a: 123321
3 8
(<:@#,{:) */@(10&#.inv)^:a: 7739
Line 1,648:
3 2
(<:@#,{:) */@(10&#.inv)^:a: 899998
2 0</langsyntaxhighlight>
 
For the table, we don't need that whole list, we only need the final value. Then use these values to classify the original argument (taking the first five from each group):
 
<langsyntaxhighlight Jlang="j"> (5&{./.~ (*/@(10&#.inv)^:_)"0) i.20000
0 10 20 25 30
1 11 111 1111 11111
Line 1,662:
7 17 71 117 171
8 18 24 29 36
9 19 33 91 119</langsyntaxhighlight>
 
Note that since the first 10 non-negative integers are single digit values, the first column here doubles as a label (representing the corresponding multiplicative digital root).
Line 1,668:
=={{header|Java}}==
{{works with|Java|8}}
<langsyntaxhighlight lang="java">import java.util.*;
 
public class MultiplicativeDigitalRoot {
Line 1,718:
return new long[]{n, mdr, mp};
}
}</langsyntaxhighlight>
 
<pre>NUMBER MDR MP
Line 1,739:
 
=={{header|jq}}==
<langsyntaxhighlight lang="jq">def do_until(condition; next):
def u: if condition then . else (next|u) end;
u;
Line 1,770:
end;
 
[[], 0] | tab;</langsyntaxhighlight>
'''Example''':<langsyntaxhighlight lang="jq">
def neatly:
. as $in
Line 1,786:
"Tabulation",
"MDR: [n0..n4]",
(tabulate(5) | neatly)</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="sh">$ jq -n -r -c -f mdr.jq
 
i : [MDR, MP]
Line 1,807:
7: [7,17,71,117,171]
8: [8,18,24,29,36]
9: [9,19,33,91,119]</langsyntaxhighlight>
 
=={{header|Julia}}==
'''Function'''
<syntaxhighlight lang="julia">
<lang Julia>
function digitalmultroot{S<:Integer,T<:Integer}(n::S, bs::T=10)
-1 < n && 1 < bs || throw(DomainError())
Line 1,822:
return (pers, ds)
end
</syntaxhighlight>
</lang>
'''Main'''
<syntaxhighlight lang="julia">
<lang Julia>
const bs = 10
const excnt = 5
Line 1,859:
println(join([@sprintf("%6d", dmr[i, j]) for j in 1:excnt], ","))
end
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,885:
=={{header|Kotlin}}==
{{trans|FreeBASIC}}
<langsyntaxhighlight lang="scala">// version 1.1.2
 
fun multDigitalRoot(n: Int): Pair<Int, Int> = when {
Line 1,935:
println()
}
}</langsyntaxhighlight>
 
{{out}}
Line 1,959:
=={{header|M2000 Interpreter}}==
{{trans|FreeBASIC}}
<langsyntaxhighlight M2000lang="m2000 Interpreterinterpreter">multDigitalRoot=lambda (n as decimal) ->{
if n<0 then error "Negative numbers not allowed"
def decimal mdr, mp, nn
Line 2,010:
Print #-2, doc$
 
</syntaxhighlight>
</lang>
{{out}}
<pre> 123321 mdr = 8 MP = 3
Line 2,030:
</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<langsyntaxhighlight lang="mathematica">
ClearAll[mdr, mp, nums];
mdr[n_] := NestWhile[Times @@ IntegerDigits[#] &, n, # > 9 &];
Line 2,040:
TableForm[Table[{i, Take[nums[[i + 1]], 5]}, {i, 0, 9}],
TableHeadings -> {None, {"MDR", "First 5"}}, TableDepth -> 2]
</syntaxhighlight>
</lang>
 
{{out}}
Line 2,067:
=={{header|Nim}}==
{{trans|Python}}
<langsyntaxhighlight lang="nim">import strutils, sequtils, sugar
proc mdroot(n: int): tuple[mp, mdr: int] =
Line 2,088:
for mp, val in table:
echo mp, ": ", val[0..4]</langsyntaxhighlight>
 
{{out}}
Line 2,108:
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang="parigp">a(n)=my(i);while(n>9,n=factorback(digits(n));i++);[i,n];
apply(a, [123321, 7739, 893, 899998])
v=vector(10,i,[]); forstep(n=0,oo,1, t=a(n)[2]+1; if(#v[t]<5,v[t]=concat(v[t],n); if(vecmin(apply(length,v))>4, return(v))))</langsyntaxhighlight>
{{out}}
<pre>%1 = [[3, 8], [3, 8], [3, 2], [2, 0]]
Line 2,118:
inspired by [[Worthwhile_task_shaving]] :-)<BR>
Brute force speed up GetMulDigits.
<langsyntaxhighlight lang="pascal">program MultRoot;
{$IFDEF FPC}
{$MODE DELPHI}{$OPTIMIZATION ON,ALL}{$CODEALIGN proc=16}
Line 2,244:
readln;
{$ENDIF}
END.</langsyntaxhighlight>
{{out|@TIO.RUN}}
<pre>
Line 2,281:
=={{header|Perl}}==
{{trans|D}}
<langsyntaxhighlight Perllang="perl">use warnings;
use strict;
 
Line 2,308:
my @n = map { $i++ while (mdr($i))[1] != $target; $i++; } 1..5;
print " $target: [", join(", ", @n), "]\n";
}</langsyntaxhighlight>
{{out}}
<pre>Number: (MP, MDR)
Line 2,332:
 
=={{header|PicoLisp}}==
<langsyntaxhighlight lang="picolisp">(de mdr-mp (N)
"Returns the solutions in a list, i.e., '(MDR MP)"
(let MP 0
Line 2,367:
(tab Fmt "===" " " "======")
(for (I . S) *Solutions
(tab Fmt (dec I) ": " (glue ", " S)) ) )</langsyntaxhighlight>
 
{{out}}
Line 2,391:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">mdr_mp</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">)</span>
Line 2,436:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%2d %5d %5d %5d %5d %5d\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 2,461:
 
===Similar===
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">pdd</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%2d"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">product</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sq_sub</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">),</span><span style="color: #008000;">'0'</span><span style="color: #0000FF;">)))</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Product of the decimal digits of 1..100:\n%s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">100</span><span style="color: #0000FF;">),</span><span style="color: #000000;">pdd</span><span style="color: #0000FF;">),</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)})</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 2,484:
===version 1===
{{incomplete|PL/I|Missing second half of task!}}
<langsyntaxhighlight lang="pli">multiple: procedure options (main); /* 29 April 2014 */
 
declare n fixed binary (31);
Line 2,507:
end;
 
end multiple;</langsyntaxhighlight>
{{out}}
<pre>N= 123321 MDR= 8 MP= 3;
Line 2,515:
 
===version 2===
<langsyntaxhighlight lang="pli"> mdrt: Proc Options(main);
Dcl (x,p,r) Bin Fixed(31);
Put Edit('number persistence multiplicative digital root')(Skip,a);
Line 2,570:
End;
End;
End;</langsyntaxhighlight>
{{out}}
<pre>number persistence multiplicative digital root
Line 2,594:
=={{header|Python}}==
===Python: Inspired by the solution to the [[Digital root#Python|Digital root]] task===
<langsyntaxhighlight lang="python">try:
from functools import reduce
except:
Line 2,618:
print('\nMP: [n0..n4]\n== ========')
for mp, val in sorted(table.items()):
print('%2i: %r' % (mp, val[:5]))</langsyntaxhighlight>
 
{{out}}
Line 2,643:
===Python: Inspired by the [[Digital_root/Multiplicative_digital_root#More_Efficient_Version|more efficient version of D]].===
Substitute the following function to run twice as fast when calculating mdroot(n) with n in range(1000000).
<langsyntaxhighlight lang="python">def mdroot(n):
count, mdr = 0, n
while mdr > 9:
Line 2,652:
mdr = digitsMul
count += 1
return count, mdr</langsyntaxhighlight>
 
{{out}}
Line 2,659:
=={{header|Quackery}}==
 
<langsyntaxhighlight Quackerylang="quackery"> [ abs 1 swap
[ base share /mod
rot * swap
Line 2,692:
' [ 123321 7739 893 899998 ] witheach task.1
cr
10 task.2</langsyntaxhighlight>
 
{{out}}
Line 2,714:
 
=={{header|Racket}}==
<langsyntaxhighlight lang="racket">#lang racket
(define (digital-product n)
(define (inr-d-p m rv)
Line 2,736:
(for ((MDR (in-range 10)))
(define (has-mdr? n) (define-values (mdr mp) (mdr/mp n)) (= mdr MDR))
(printf "~a\t~a~%" MDR (for/list ((_ 5) (n (sequence-filter has-mdr? (in-naturals)))) n)))</langsyntaxhighlight>
{{out}}
<pre>Number MDR mp
Line 2,760:
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" perl6line>sub multiplicative-digital-root(Int $n) {
return .elems - 1, .[.end]
given cache($n, {[*] .comb} ... *.chars == 1)
Line 2,772:
say "$d : ", .[^5]
given (1..*).grep: *.&multiplicative-digital-root[1] == $d;
}</langsyntaxhighlight>
{{out}}
<pre>123321: 3 8
Line 2,790:
 
=={{header|Red}}==
<langsyntaxhighlight lang="rebol">Red ["Multiplicative digital root"]
 
mdr: function [
Line 2,828:
]
prin newline
]</langsyntaxhighlight>
{{out}}
<pre>
Line 2,851:
=={{header|REXX}}==
===idomatic version===
<langsyntaxhighlight lang="rexx">/*REXX program finds the persistence and multiplicative digital root of some numbers.*/
numeric digits 100 /*increase the number of decimal digits*/
parse arg x /*obtain optional arguments from the CL*/
Line 2,883:
y=r
end /*p*/ /* [↑] wash, rinse, and repeat ··· */
return p r /*return the persistence and the MDR. */</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 2,912:
===ultra-fast version===
This fast version can handle a target of five hundred numbers with ease for the 2<sup>nd</sup> part of the task's requirement.
<langsyntaxhighlight lang="rexx">/*REXX program finds the persistence and multiplicative digital root of some numbers.*/
numeric digits 2000 /*increase the number of decimal digits*/
parse arg target x /*obtain optional arguments from the CL*/
Line 2,993:
end /*p*/ /* [↑] wash, rinse, and repeat ··· */
if s==1 then return r /*return multiplicative digital root. */
return p r /*return the persistence and the MDR. */</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 34 </tt>}}
<pre>
Line 3,021:
 
===Similar===
<langsyntaxhighlight lang="rexx">/*REXX pgm finds positive integers when shown in hex that can't be written with dec digs*/
parse arg n cols . /*obtain optional argument from the CL.*/
if n=='' | n=="," then n = 100 /*Not specified? Then use the default.*/
Line 3,042:
 
if $\=='' then say center(idx, 7)"│" substr($, 2) /*possible display residual output.*/
say '───────┴'center("" , 1 + cols*(w+1), '─') /*display the foot sep for output. */</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 3,061:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
# Project : Digital root/Multiplicative digital root
 
Line 3,122:
end
next
</syntaxhighlight>
</lang>
Output:
<pre>
Line 3,145:
 
===Similar===
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl
Line 3,167:
 
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 3,197:
=={{header|Ruby}}==
{{works with|Ruby|2.4}}
<langsyntaxhighlight lang="ruby">def mdroot(n)
mdr, persist = n, 0
until mdr < 10 do
Line 3,215:
end
puts "", "MDR: [n0..n4]", "=== ========"
10.times{|i| puts "%3d: %p" % [i, counter[i].first(5)]}</langsyntaxhighlight>
{{out}}
<pre>
Line 3,242:
{{works with|Scala|2.9.x}}
 
<langsyntaxhighlight Scalalang="scala">import Stream._
 
object MDR extends App {
Line 3,268:
.foreach{p => printf("%3s: [%s]\n",p._2,p._1.mkString(", "))}
 
}</langsyntaxhighlight>
 
{{out}}
Line 3,295:
=={{header|Scheme}}==
{{works with|Chez Scheme}}
<langsyntaxhighlight lang="scheme">; Convert an integer into a list of its digits.
 
(define integer->list
Line 3,348:
(printf "~5@a" mdr)
(for-each (lambda (int) (printf "~7@a" int)) (vector-ref mdrslsts mdr))
(newline)))</langsyntaxhighlight>
{{out}}
<pre> Integer Root Pers.
Line 3,384:
=={{header|Sidef}}==
{{trans|Ruby}}
<langsyntaxhighlight lang="ruby">func mdroot(n) {
var (mdr, persist) = (n, 0)
while (mdr >= 10) {
Line 3,405:
 
say "\nMDR: [n0..n4]\n=== ========"
10.times {|i| "%3d: %s\n".printf(i, counter{i}.first(5)) }</langsyntaxhighlight>
 
{{out}}
Line 3,431:
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">proc mdr {n} {
if {$n < 0 || ![string is integer $n]} {
error "must be an integer"
Line 3,439:
}
return [list $i $n]
}</langsyntaxhighlight>
Demonstrating:
<langsyntaxhighlight lang="tcl">puts "Number: MP MDR"
puts [regsub -all . "Number: MP MDR" -]
foreach n {123321 7739 893 899998} {
Line 3,456:
for {set i 0} {$i < 10} {incr i} {
puts [format "%3d: (%s)" $i [join [lrange $accum($i) 0 4] ", "]]
}</langsyntaxhighlight>
{{out}}
<pre>
Line 3,482:
=={{header|Vlang}}==
{{trans|Go}}
<langsyntaxhighlight lang="vlang">// Only valid for n > 0 && base >= 2
fn mult(nn u64, base int) u64 {
mut n := nn
Line 3,530:
println("${i:3}: $l")
}
}</langsyntaxhighlight>
 
{{out}}
Line 3,561:
{{libheader|Wren-fmt}}
The size of some of the numbers here is such that we need to use BigInt.
<langsyntaxhighlight lang="ecmascript">import "/big" for BigInt
import "/fmt" for Fmt
 
Line 3,621:
Fmt.print("$3d: $s", i, l.toString)
i = i + 1
}</langsyntaxhighlight>
 
{{out}}
Line 3,649:
=={{header|zkl}}==
{{trans|Python}}
<langsyntaxhighlight lang="zkl">fcn mdroot(n){ // Multiplicative digital root
mdr := List(n);
while (mdr[-1] > 9){
Line 3,655:
}
return(mdr.len() - 1, mdr[-1]);
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">fcn mdroot(n){
count:=0; mdr:=n;
while(mdr > 9){
Line 3,669:
}
return(count, mdr);
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">println("Number: (MP, MDR)\n======= =========");
foreach n in (T(123321, 7739, 893, 899998))
{ println("%7,d: %s".fmt(n, mdroot(n))) }
Line 3,684:
foreach mp in (table.keys.sort()){
println("%2d: %s".fmt(mp, table[mp][0,5])); //print first five values
}</langsyntaxhighlight>
{{out}}
<pre>
Thundergnat
10,327

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/327354"