Abbildung N -> N

Neue Frage »

Dopap Auf diesen Beitrag antworten »
Abbildung N -> N
Was wäre, wenn man zwischen den Ziffern einer Zahl Malpunkte setzt und das dann fortlaufend ausrechnet, bis nur noch eine Ziffer übrig bleibt, z.B.

( 2 Runden ) oder

(2 Runden ) schnell stellt man fest, dass auch größere Zahlen in wenigen Runden einziffrig werden. Die Zahl mit der größten Rundenzal ist bisher



mit 8 Runden. Wer bietet mehr Augenzwinkern
Finn_ Auf diesen Beitrag antworten »

Ein super Anwendungsfall für meine kleine Programmiersprache Moss:

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
digits_product = |n| list(str(n)).map(int).prod()

orbit = |n| digits_product.orbit(n).until(|x| x<10)

count = |n| orbit(n).count()

k0 = 0
for n in (1..)
   k = count(n)
   if k>k0
      k0 = k
      print("{:r12} | {}"%[n,orbit(n).list()])
   end
end

Ausgabe:
          10 | [10]
          25 | [25, 10]
          39 | [39, 27, 14]
          77 | [77, 49, 36, 18]
         679 | [679, 378, 168, 48, 32]
        6788 | [6788, 2688, 768, 336, 54, 20]
       68889 | [68889, 27648, 2688, 768, 336, 54, 20]
     2677889 | [2677889, 338688, 27648, 2688, 768, 336, 54, 20]
    26888999 | [26888999, 4478976, 338688, 27648, 2688, 768, 336, 54, 20]
IfindU Auf diesen Beitrag antworten »

Interessant. Die größeren Beispiele enden alle mit [27648, 2688, 768, 336, 54, 20]. Kannst du uns noch ein paar mehr Zahlen geben? Big Laugh
Finn_ Auf diesen Beitrag antworten »

Eine Zahl mehr geht noch naiv, jetzt in Rust, Rechenzeit war ca. 15min.

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
fn digits_product(mut n: u64) -> u64 {
    let mut p: u64 = 1;
    while n>0 {
        p = p*(n%10);
        n = n/10;
    }
    return p;
}

fn count(mut n: u64) -> u32 {
    let mut k: u32 = 0;
    while n>=10 {
        n = digits_product(n);
        k += 1;
    }
    return k;
}

fn orbit(mut n: u64) -> Vec<u64> {
    let mut v: Vec<u64> = vec![n];
    while n>=10 {
        n = digits_product(n);
        v.push(n);
    }
    return v;
}

fn main() {
    let mut k0: u32 = 0;
    for n in 1.. {
        let k = count(n);
        if k>k0 {
            k0 = k;
            println!("{:>12} | {:?}",n,orbit(n));
        }
    }
}

Ausgabe:
          10 | [10, 0]
          25 | [25, 10, 0]
          39 | [39, 27, 14, 4]
          77 | [77, 49, 36, 18, 8]
         679 | [679, 378, 168, 48, 32, 6]
        6788 | [6788, 2688, 768, 336, 54, 20, 0]
       68889 | [68889, 27648, 2688, 768, 336, 54, 20, 0]
     2677889 | [2677889, 338688, 27648, 2688, 768, 336, 54, 20, 0]
    26888999 | [26888999, 4478976, 338688, 27648, 2688, 768, 336, 54, 20, 0]
  3778888999 | [3778888999, 438939648, 4478976, 338688, 27648, 2688, 768, 336, 54, 20, 0]
IfindU Auf diesen Beitrag antworten »

Das Muster scheint nur länger zu werden. Was auch sinnvoll zu sein scheint. Es gibt bei n-stelligen Dezimalstellen nur endlich viele Zahlen welche man nach einem Schritt von Dopaps Prozedur trifft. Dann trifft man natürlich die Zahl, welche sich möglichst "sträubt" klein zu werden.

Inzwischen habe ich einen passenden Wikipedia-Artikel gefunden: Link.
Darin wird auch auf OEIS verwiesen: Link
Finn_ Auf diesen Beitrag antworten »

Die Fragestellung ist auch im Artikel Querprodukt beschrieben.
 
 
Dopap Auf diesen Beitrag antworten »

Wiki ist Fluch und Segen zugleich.
Ja gut, dann ist das klar, eine Zahl liefert 11 Runden und dann ist für mindestens 20000 Stellen nicht mehr zu erwarten. So richtig verstanden ?
Iorek Auf diesen Beitrag antworten »

Numberphile hat da ein ganz nettes Video zu.
HAL 9000 Auf diesen Beitrag antworten »

Jeden Tag ne andere Sau durchs Dorf ... und die alten Tiere werden vergessen.
Neue Frage »
Antworten »



Verwandte Themen

Die Beliebtesten »
Die Größten »
Die Neuesten »