Digital root/Multiplicative digital root: Difference between revisions

</pre>

Show all output on this page.

 

 

=={{header|11l}}==

{{trans|Python}}

V count = 0

V mdr = n

L(val) table

print(‘#2: ’.format(L.index), end' ‘’)

 

=={{header|Ada}}==

The solution uses the Package "Generic_Root" from the additive digital roots [[http://rosettacode.org/wiki/Digital_root#Ada]].

 

 

procedure Multiplicative_Root is

TIO.New_Line;

end loop;

 

{{out}}

 

=={{header|ALGOL 68}}==

print md root( 123321 );

print md root( 7739 );

print md root( 899998 );

tabulate mdr( 5 )

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% calculate the Multiplicative Digital Root (mdr) and Multiplicative Persistence (mp) of n %

procedure getMDR ( integer value n

end

 

{{out}}

<pre>

 

=={{header|AWK}}==

 

BEGIN {

} # for pos

 

{{out}}

<pre>

 

=={{header|Bracmat}}==

& ( MP/MDR

= prod L n

& put$\n

)

{{out}}

<pre>123321 : (3.8)

 

=={{header|C}}==

#include <stdio.h>

 

return 0;

}

{{out}}

<pre>

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Linq;

Console.WriteLine(" {0} : [{1}]", i, string.Join(", ", table[i]));

}

{{out}}

<pre>123321 has multiplicative persistence 3 and multiplicative digital root 8

 

=={{header|C++}}==

#include <iomanip>

#include <map>

return system( "pause" );

}

{{out}}

<pre>

+-------+------------------------------------+

</pre>

 

=={{header|Common Lisp}}==

(defun mdr/p (n)

"Return a list with MDR and MP of n"

do (format t "~6@a: ~{~3@a ~}~%" el (mdr/p el)))

(format t "~%MDR: [n0..n4]~%")

{{out}}

<pre>

=={{header|Component Pascal}}==

{{Works with| BlackBox Component Builder}}

MODULE MDR;

IMPORT StdLog, Strings, TextMappers, DevCommanders;

 

END MDR.

Execute:

^Q MDR.Do 123321 7739 893 899998 ~

9: 9 19 33 91 119

</pre>

=={{header|D}}==

{{trans|Python}}

 

/// Multiplicative digital root.

foreach (const mp; table.byKey.array.sort())

writefln("%2d: %s", mp, table[mp].take(5));

{{out}}

<pre>Number: (MP, MDR)

 

===Alternative Version===

 

uint digitsProduct(uint n) pure nothrow @nogc {

foreach (const mp; table.byKey.array.sort())

writefln("%2d: %s", mp, table[mp].take(5));

 

===More Efficient Version===

 

/// Multiplicative digital root.

foreach (const mp; table.byKey.array.sort())

writefln("%2d: %s", mp, table[mp].take(5));

The output is similar.

 

=={{header|Elixir}}==

def mdroot(n), do: mdroot(n, 0)

 

Digital.task1([123321, 7739, 893, 899998])

 

{{out}}

</pre>

 

=={{header|Factor}}==

math.text.utils prettyprint sequences ;

IN: rosetta-code.multiplicative-digital-root

{ 123321 7739 893 899998 } [ print-mdr ] each nl first5-table ;

 

{{out}}

<pre>

 

=={{header|Fortran}}==

!Implemented by Anant Dixit (Oct, 2014)

program mdr

end subroutine

 

 

<pre>

 

=={{header|FreeBASIC}}==

 

Function multDigitalRoot(n As UInteger, ByRef mp As Integer, base_ As Integer = 10) As Integer

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|Go}}==

 

import "fmt"

fmt.Printf(tableFmt, i, l)

}

{{out}}

<pre>

=={{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.

import Data.Array

import Data.LazyArray

printMpMdrs [123321, 7739, 893, 899998]

putStrLn ""

{{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.

 

Works in both languages:

write(right("n",8)," ",right("MP",8),right("MDR",5))

every r := mdr(n := 123321|7739|893|899998) do

while m > 0 do c *:= 1(m%10, m/:=10)

return c

 

{{out}}

First, we need something to split a number into digits:

 

 

Second, we need to find their product:

 

 

Then we use this inductively until it converges:

 

 

MP is one less than the length of this list, and MDR is the last element of this list:

 

3 8

(<:@#,{:) */@(10&#.inv)^:a: 7739

3 2

(<:@#,{:) */@(10&#.inv)^:a: 899998

 

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):

 

0 10 20 25 30

1 11 111 1111 11111

7 17 71 117 171

8 18 24 29 36

 

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).

=={{header|Java}}==

{{works with|Java|8}}

 

public class MultiplicativeDigitalRoot {

return new long[]{n, mdr, mp};

}

 

<pre>NUMBER MDR MP

 

=={{header|jq}}==

def u: if condition then . else (next|u) end;

u;

end;

 

def neatly:

. as $in

"Tabulation",

"MDR: [n0..n4]",

{{out}}

 

i : [MDR, MP]

7: [7,17,71,117,171]

8: [8,18,24,29,36]

 

=={{header|Julia}}==

'''Function'''

function digitalmultroot{S<:Integer,T<:Integer}(n::S, bs::T=10)

-1 < n && 1 < bs || throw(DomainError())

return (pers, ds)

end

'''Main'''

const bs = 10

const excnt = 5

println(join([@sprintf("%6d", dmr[i, j]) for j in 1:excnt], ","))

end

 

{{out}}

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

fun multDigitalRoot(n: Int): Pair<Int, Int> = when {

println()

}

 

{{out}}

9: 9 19 33 91 119

</pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

ClearAll[mdr, mp, nums];

mdr[n_] := NestWhile[Times @@ IntegerDigits[#] &, n, # > 9 &];

TableForm[Table[{i, Take[nums[[i + 1]], 5]}, {i, 0, 9}],

TableHeadings -> {None, {"MDR", "First 5"}}, TableDepth -> 2]

 

{{out}}

=={{header|Nim}}==

{{trans|Python}}

var mdr = @[n]

while mdr[mdr.high] > 9:

mdr.add n

(mdr.high, mdr[mdr.high])

for n in [123321, 7739, 893, 899998]:

echo align($n, 6)," ",mdroot(n)

echo ""

var table = newSeqWith(10, newSeq[int]())

for n in 0..int.high:

if table.map((x: seq[int]) => x.len).min >= 5: break

table[mdroot(n).mdr].add n

for mp, val in table:

{{out}}

<pre>123321 (mp: 3, mdr: 8)

 

=={{header|PARI/GP}}==

apply(a, [123321, 7739, 893, 899998])

{{out}}

<pre>%1 = [[3, 8], [3, 8], [3, 2], [2, 0]]

%2 = [[0, 10, 20, 25, 30], [1, 11, 111, 1111, 11111], [2, 12, 21, 26, 34], [3, 13, 31, 113, 131], [4, 14, 22, 27, 39], [5, 15, 35, 51, 53], [6, 16, 23, 28, 32], [7, 17, 71, 117, 171], [8, 18, 24, 29, 36], [9, 19, 33, 91, 119]]</pre>

 

=={{header|Perl}}==

{{trans|D}}

use strict;

 

my @n = map { $i++ while (mdr($i))[1] != $target; $i++; } 1..5;

print " $target: [", join(", ", @n), "]\n";

{{out}}

<pre>Number: (MP, MDR)

9: [9, 19, 33, 91, 119]</pre>

 

 

 

 

 

 

 

 

{{out}}

<pre>

8 8 18 24 29 36

9 9 19 33 91 119

</pre>

 

===version 1===

{{incomplete|PL/I|Missing second half of task!}}

 

declare n fixed binary (31);

end;

 

{{out}}

<pre>N= 123321 MDR= 8 MP= 3;

 

===version 2===

Dcl (x,p,r) Bin Fixed(31);

Put Edit('number persistence multiplicative digital root')(Skip,a);

End;

End;

{{out}}

<pre>number persistence multiplicative digital root

=={{header|Python}}==

===Python: Inspired by the solution to the [[Digital root#Python|Digital root]] task===

from functools import reduce

except:

print('\nMP: [n0..n4]\n== ========')

for mp, val in sorted(table.items()):

 

{{out}}

===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).

count, mdr = 0, n

while mdr > 9:

mdr = digitsMul

count += 1

 

{{out}}

(Exactly the same as before).

 

=={{header|Racket}}==

(define (digital-product n)

(define (inr-d-p m rv)

(for ((MDR (in-range 10)))

(define (has-mdr? n) (define-values (mdr mp) (mdr/mp n)) (= mdr MDR))

{{out}}

<pre>Number MDR mp

8 (8 18 24 29 36)

9 (9 19 33 91 119)</pre>

 

=={{header|REXX}}==

===idomatic version===

numeric digits 100 /*increase the number of decimal digits*/

parse arg x /*obtain optional arguments from the CL*/

say right(n,8) center(mp,13) center(mdr,30) /*display a number, persistence, MDR.*/

end /*j*/ /* [↑] show MP & MDR for each number. */

say 'MDR first ' target " numbers that have a matching MDR"

say '═══ ═══════════════════════════════════════════════════'

say " "k': ['strip(_, , ',')"]" /*display the K (MDR) and the list. */

end /*k*/ /* [↑] done with the K MDR list. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

MDR: procedure; parse arg y; y=abs(y) /*get the number and determine the MDR.*/

y=r

end /*p*/ /* [↑] wash, rinse, and repeat ··· */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

893 3 2

899998 2 0

 

MDR first 5 numbers that have a matching MDR

8: [8, 18, 24, 29, 36]

9: [9, 19, 33, 91, 119]

</pre>

 

===ultra-fast version===

This fast version can handle a target of five hundred numbers with ease for the 2^nd part of the task's requirement.

numeric digits 2000 /*increase the number of decimal digits*/

parse arg target x /*obtain optional arguments from the CL*/

say copies('─' ,8) ' ─────────── ───────────────────────────'

/* [↑] the title and the separator. */

say 'MDR first ' target " numbers that have a matching MDR"

say '═══ ' copies("═",(target+(target+1)**2)%2) /*display a separator line (for title).*/

 

_=

else do m=k until hits==target /*find target numbers with an MDR of K.*/

parse var m '' -1 ? /*obtain the right─most digit of M. */

if k\==0 then if ?==0 then iterate

if k==5 then if ?//2==0 then iterate

else if MDR(m, 1)\==k then iterate

if k==3 then do; o=strip(m, 'T', 1) /*strip trailing ones from M*/

end /* [↑] shift the "3" 1 place left.*/

end /* [↑] a shortcut to adj DO index*/

end /*m*/ /* [↑] built a list of MDRs = K */

 

say " "k': ['_"]" /*display the K (MDR) and the list. */

end /*k*/ /* [↑] done with the K MDR list. */

 

@.= /* [↓] handle MDR of "9" special. */

@3= /*assign null string before building. */

 

do j=1 for words(@9) /*process each number for MDR 9 case.*/

new= /*these are the new numbers (so far). */

 

if @.z\=='' then iterate /*if already define, ignore the number.*/

end /*i*/ /* [↑] end of 2nd insertion of "3".*/

end /*k*/ /* [↑] " " 1st " " " */

 

end /*j*/ /* [↑] end of insertion of the "3"s. */

@= /* [↓] merge two lists, 3s and 9s. */

do while a1\=='' & a2\=='' /*process while the lists aren't empty.*/

if x=='' | y=='' then leave /*are X or Y empty? */

end /*while*/ /* [↑] only process just enough nums. */

 

say " "9': ['@"]" /*display the "9" (MDR) and the list.*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

do p=1 until y<10; parse var y r 2

end /*k*/

end /*p*/ /* [↑] wash, rinse, and repeat ··· */

if s==1 then return r /*return multiplicative digital root. */

<pre>

number persistence multiplicative digital root

893 3 2

899998 2 0

 

MDR first 34 numbers that have a matching MDR

8: [8 18 24 29 36 38 42 46 49 63 64 66 67 76 77 79 81 83 88 92 94 97 99 118 124 129 136 138 142 146 149 163 164 166]

9: [9 19 33 91 119 133 191 313 331 911 1119 1133 1191 1313 1331 1911 3113 3131 3311 9111 11119 11133 11191 11313 11331 11911 13113 13131 13311 19111 31113 31131 31311 33111]

</pre>

 

=={{header|Ring}}==

# Project : Digital root/Multiplicative digital root

 

end

next

Output:

<pre>

8 => 8 18 24 29 36

9 => 9 19 33 91 119

</pre>

 

=={{header|Ruby}}==

mdr, persist = n, 0

until mdr < 10 do

persist += 1

end

end

puts "", "MDR: [n0..n4]", "=== ========"

{{out}}

<pre>

8: [8, 18, 24, 29, 36]

9: [9, 19, 33, 91, 119]

</pre>

 

{{works with|Scala|2.9.x}}

 

 

object MDR extends App {

.foreach{p => printf("%3s: [%s]\n",p._2,p._1.mkString(", "))}

 

 

{{out}}

8: [8, 18, 24, 29, 36]

9: [9, 19, 33, 91, 119]</pre>

 

=={{header|Sidef}}==

{{trans|Ruby}}

var (mdr, persist) = (n, 0)

while (mdr >= 10) {

 

say "\nMDR: [n0..n4]\n=== ========"

 

{{out}}

 

=={{header|Tcl}}==

if {$n < 0 || ![string is integer $n]} {

error "must be an integer"

}

return [list $i $n]

Demonstrating:

puts [regsub -all . "Number: MP MDR" -]

foreach n {123321 7739 893 899998} {

for {set i 0} {$i < 10} {incr i} {

puts [format "%3d: (%s)" $i [join [lrange $accum($i) 0 4] ", "]]

{{out}}

<pre>

8: (8, 18, 24, 29, 36)

9: (9, 19, 33, 91, 119)

</pre>

 

=={{header|zkl}}==

{{trans|Python}}

mdr := List(n);

while (mdr[-1] > 9){

}

return(mdr.len() - 1, mdr[-1]);

count:=0; mdr:=n;

while(mdr > 9){

}

return(count, mdr);

foreach n in (T(123321, 7739, 893, 899998))

{ println("%7,d: %s".fmt(n, mdroot(n))) }

foreach mp in (table.keys.sort()){

println("%2d: %s".fmt(mp, table[mp][0,5])); //print first five values

{{out}}

<pre>