Digital root/Multiplicative digital root: Difference between revisions

{{task|Mathematics}}

The [[wp:Multiplicative digital root|multiplicative digital root]] (MDR) and multiplicative persistence (MP) of a number, <math>n</math>, is calculated rather like the [[Digital root]] except digits are multiplied instead of being added:

# Set <math>m</math> to <math>n</math> and <math>i</math> to <math>0</math>.

#* Increment <math>i</math>.

# Return <math>i</math> (= MP) and <math>m</math> (= MDR)

 

;Task:

* Tabulate the MP and MDR of the numbers 123321, 7739, 893, 899998

* Tabulate MDR versus the first five numbers having that MDR, something like:

=== ========

0: [0, 10, 20, 25, 30]

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

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

Show all output on this page.

 

;References:

* [http://mathworld.wolfram.com/MultiplicativeDigitalRoot.html Multiplicative Digital Root] on Wolfram Mathworld.

* [http://oeis.org/A031347 Multiplicative digital root] on The On-Line Encyclopedia of Integer Sequences.

 

=={{header|Bracmat}}==

& ( MP/MDR

= prod L n

& put$\n

)

<pre>123321 : (3.8)

7739 : (3.8)

8 :8 18 24 29 36

9 :9 19 33 91 119</pre>

 

=={{header|D}}==

{{trans|Python}}

 

/// Multiplicative digital root.

writefln("%6d: (%s, %s)", n, n.mdRoot[]);

 

auto n = 0;

while (table.byValue.map!walkLength.reduce!min < 5) {

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 {

writefln("%6d: (%s, %s)", n, n.mdRoot[]);

 

auto n = 0;

while (table.byValue.map!walkLength.reduce!min < 5) {

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

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

 

===More Efficient Version===

 

/// Multiplicative digital root.

uint mdr = n;

uint count = 0;

writefln("%6d: %s", n, n.mdRoot);

 

auto n = 0;

while (table.byValue.map!walkLength.reduce!min < 5) {

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

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

The output is similar.

 

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

digits 0 = [0]

digits n = unfoldr step n

 

printMpMdrs :: [Integer] -> IO ()

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

 

<pre>

->drmdr

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|PL/I}}==

 

declare n fixed binary (31);

end;

 

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

N= 7739 MDR= 8 MP= 3;

N= 893 MDR= 2 MP= 3;

N= 899998 MDR= 0 MP= 2;</pre>

 

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

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

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

<pre>

number persistence multiplicative digital root

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>

 

say center('number',8) ' persistence multiplicative digital root'

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

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

 

 

 

 

 

 

<pre>

number persistence multiplicative digital root

893 3 2

899998 2 0

 

</pre>

 

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