Digital root/Multiplicative digital root: Difference between revisions

</pre>

Show all output on this page.

 

 

* [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.

<br><br>

 

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

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

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

</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}}

 

=={{header|PL/I}}==

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

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>

 

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

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

 

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