( Verwandte )

Gegeben eine ganze Zahl n > 1,
1) Konstruieren Sie den Bereich von Zahlen n, n-1, n-2, ... 3, 2, 1und berechnen Sie die Summe
2) Nehmen Sie die einzelnen Ziffern dieser Zahl und berechnen das Produkt
3) Nehmen Sie die einzelnen Ziffern dieser Zahl und berechnen die Summe
4) Wiederholen Sie die Schritte 2 und 3 , bis Sie eine einstellige Zahl erreichen. Diese Ziffer ist das Ergebnis.

Die ersten zwanzig Terme der Sequenz sind unten:

3, 6, 0, 5, 2, 7, 9, 2, 7, 9, 1, 9, 0, 0, 9, 6, 7, 0, 0, 6

Hinweis: Diese Sequenz ist NICHT in OEIS.

I / O und Regeln

• Zahlen werden schnell sehr groß, daher muss die Lösung in der Lage sein, Eingabezahlen von bis zu 100.000 ohne Fehler zu verarbeiten (es ist in Ordnung, wenn Ihr Code darüber hinausgeht).
• Die Eingabe und Ausgabe kann durch jede bequeme Methode erfolgen .
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

n     output
1234   9
3005   3
5007   5
9854   8
75849  8
100000 0

Python 2 , 77 72 71 62 60 Bytes

lambda n:reduce(lambda x,c:eval(c.join(`x`)),'*+'*n,-n*~n/2)

Vielen Dank an @xnor für das Golfen mit 2 Bytes!

Probieren Sie es online!

05AB1E , 7 Bytes

LOΔSPSO

Probieren Sie es online!

Exlpanation

L         # push range [1 ... input]
 O        # sum range
  Δ       # loop until top of stack stops changing
   SP     # product of digits
     SO   # sum of digits

Gelee , 8 Bytes

RSDPDƲÐL

Probieren Sie es online!

Vollständiges Programm (es gibt ein Singleton-Array mit dem Ergebnis zurück, die Klammern sind jedoch in STDOUT nicht sichtbar).

MATL , 15 13 Bytes

Zu Ehren der Sprache des Monats :

:`sV!UpV!Utnq

Probieren Sie es online!

Ich glaube nicht, dass es eine einfachere Möglichkeit gibt, die Ziffern einer Zahl zu ermitteln, als die Zahl in eine Zeichenfolge umzuwandeln V, sie dann zu transponieren !und diesen vertikalen Vektor wieder in einen numerischen Vektor umzuwandeln U.

2 Bytes gespart dank dem Creator ¹ selbst! Ich habe das implizite Ende vergessen, das heißt, ich konnte es entfernen ], und anstatt die Anzahl der Elemente mit zu vergleichen 1, konnte ich diesen Wert einfach dekrementieren und ihn direkt als Booleschen Wert verwenden.

Die Erklärung lautet also wie folgt:

                 % Grab input n implicitly
:                % Range from 1 ... n inclusive
 `               % Do ... while
  s               % sum the vector
   V!U            % Convert the number to digits
      p           % Take the product of these digits
       V!U        % Convert the product into digits
          t       % Duplicate the result
           n      % Count the number of elements
            q     % Decrement the number of elements
                  % Loop until the number of elements is 1
                 % Implicit end

¹ ... von MATL, Luis Mendo.

JavaScript (ES6), 60 Byte

f=(n,k=n*++n/2)=>k>9?f(!n,eval([...k+''].join('*+'[+!n]))):k

Probieren Sie es online!

Kommentiert

f = (                     // f = recursive function taking:
  n,                      //   n = original input
  k = n * ++n / 2         //   k = current value, initialized to sum(i=1..n)(i)
) =>                      //
  k > 9 ?                 // if k has more than 1 digit:
    f(                    //   recursive call to f() with:
      !n,                 //     a logical NOT applied to n
      eval(               //     the result of the expression built by:
        [...k + '']       //       turning k into a list of digits
        .join('*+'[+!n])  //       joining with '*' on even iterations or '+' on odd ones
      )                   //     end of eval()
    )                     //   end of recursive call
  :                       // else:
    k                     //   stop recursion and return the last value

Alternative Version, 59 Bytes (nicht konkurrierend)

Eine nicht rekursive Version, die nur für n <236172 funktioniert . (Es deckt den angeforderten Bereich ab, ist jedoch kein gültiger generischer Algorithmus.)

n=>[...'*+*+'].map(o=>n=eval([...n+''].join(o)),n*=++n/2)|n

Probieren Sie es online!

Haskell , 72 71 63 Bytes

g=map(read.pure).show
f n=until(<10)(sum.g.product.g)$sum[1..n]

Danke an @BMO für ein Byte und @nimi für 8 Bytes!

Probieren Sie es online!

Stax , 14 13 10 Bytes

ñu┌↕a√äJ²┐

Führen Sie es aus und debuggen Sie es

War ziemlich lustig zu machen. Ich frage mich, ob es eine präzisere Möglichkeit gibt, den Vergleich am Ende durchzuführen.

Erläuterung

|+wE:*E|+c9>                 # Full Program Unpacked
|+                           # Create range and sum it
   wE:*                      # Start loop, digitize number, product of digits
       E|+                   # Digitize number, sum digits
          c9>                # Duplicate, check length is = 1
                             # Otherwise loop back to the 'w' character

-1 Bytes dank ovs

-3 Bytes dank Scrooble

R , 152 130 109 Bytes

function(w,x=w*(w+1)/2,y=prod(d(x)),z=sum(d(y)))"if"(z>9,f(,z),z)
d=function(x)x%/%10^(0:max(0,log10(x)))%%10

Probieren Sie es online!

@ Giuseppe hat 21 42 Bytes mit verschiedenen R-Dingen gefunden, an die ich noch nicht gewöhnt bin, zusammen mit einer Möglichkeit, die Ziffern einer Zahl zu erhalten, ohne sie auf String und Back zu zwingen, und mit weniger Bytes!

# Old
d=function(x)strtoi(el(strsplit(paste(x),"")))
# New
d=function(x)x%/%10^(0:max(0,log10(x)))%%10

options(scipen=9) wird wurde für den Fall von 9854 für die alte Funktion erforderlich, weil das erste Produkt der Bühne als 80000 endet, die R druckt als 8e + 05.

Pyth , 11 Bytes

usj*FjGTTsS

Probieren Sie es hier aus!

usj * FjGTTsS - Volles Programm. N = Die Eingabe.
          S - Bereich. Ausbeute [1, N] ⋂ ⋂.
         s - Summe.
u - Während keine zwei aufeinanderfolgenden Iterationen dasselbe Ergebnis liefern, tun Sie (var: G):
   * FjGT - Digitales Produkt.
 sj T - Digitale Summe.

Kohle , 18 Bytes

≔Σ…·¹ＮθＷ›θ⁹≔ΣΠθθＩθ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

≔Σ…·¹Ｎθ

Summiere die ganzen Zahlen bis zur Eingabe.

 Ｗ›θ⁹≔ΣΠθθ

Während das Ergebnis größer als 9 ist, nehmen Sie die Summe der Ziffern des Produkts der Ziffern.

Ｉθ

Wandeln Sie das Ergebnis in eine Zeichenfolge um und drucken Sie es implizit aus.

Gaia , 8 Bytes

┅⟨Σ₸∨Π⟩°

Probieren Sie es online!

Die alte Erklärung (vor dem Beheben eines Fehlers, der Gaias Fehler ist IMO: P):

┅⟨ΣΠ⟩ ° - Volles Programm. N = Die Eingabe.
┅ - Reichweite. Schieben Sie [1, N] ⋂ ⋂ zum Stapel.
 ⟨⟩ ° - Während keine zwei aufeinander folgenden Iterationen das gleiche Ergebnis liefern, tun Sie Folgendes:
  Σ - Summe (oder digitale Summe, wenn auf eine ganze Zahl angewendet).
   Π - Digitales Produkt.

Dank Dennis 1 Byte gespeichert .

F #, 175 Bytes

let d n=seq{for i in(string n).ToCharArray() do yield string i|>uint64}
let c n=
 let mutable r=Seq.sum{1UL..n}
 while r>9UL do r<-d r|>Seq.reduce(fun a x->x*a)|>d|>Seq.sum
 r

Probieren Sie es online!

Der einzige Nachteil der Funktion ist, dass der Eingabewert vom Typ sein muss uint64.

Ungolfed ist es ein bisschen so:

let d n=seq{for i in(string n).ToCharArray() do yield string i|>uint64}

let c n =
 let mutable r = Seq.sum {1UL..n}
 while r > 9UL do
  r<-d r
  |> Seq.reduce(fun a x->x*a)
  |> d
  |> Seq.sum
 r

Die Funktion d nwandelt die Zahl nin ihre Bestandteile um. Es wird zuerst in eine Zeichenfolge konvertiert und dann jedes Zeichen in der Zeichenfolge abgerufen. Jedes Zeichen muss dann wieder in eine Zeichenfolge konvertiert werden, andernfalls werden die Zeichen in ihre ASCII-Werte anstelle ihrer "echten" Werte konvertiert.

Die c nFunktion ist die Hauptfunktion mit ndem Anfangswert. In dieser Funktion rliegt unser laufender Wert. Die whileSchleife führt Folgendes aus:

• Konvertieren Sie rin die entsprechenden Ziffern ( d r).
• Erhalten Sie das Produkt all dieser Ziffern. Dabei wird verwendet, Seq.reducewas eine Funktion mit dem akkumulierten Wert ( a) und dem nächsten Wert in der Sequenz ( x) übernimmt und in diesem Fall das Produkt zurückgibt. Der Anfangswert ist das erste Element in der Sequenz.
• Konvertieren Sie diesen Produktwert in die entsprechenden Ziffern ( d).
• Summieren Sie die Ziffern von zuvor und weisen Sie diese zu r.

Befunge, 136 Bytes

101p&::*+2/>:82+%01g*01p82+/:#v_$01gv
X      v_v# #:/+82p10+g10%+82: <p100<
v:g10$ >#<#^                 #<^
>82+/#v_.@
      >101p^

Sie können es hier ausprobieren .

Obwohl nicht alle Dolmetscher eine ausreichend große Zelle haben, funktioniert es mit kleinen Zahlen für so ziemlich jeden da draußen. Für eine größere Anzahl nbenötigen Sie möglicherweise einen Dolmetscher wie BefunExec .

Gol> <> , ₃₅ 33 Bytes

1AY:P*2,TYMR*YR+:a(?Bt
:a(qlBaSD$

Probieren Sie es online!

-2 Bytes von Jo King.

Umfangreiche Nutzung von Funktionen und impliziten Endlosschleifen.

Beispiel volles Programm & wie es funktioniert

1AGIE;GN
2AY:P*2,YlMR*YlR+:a(?B8R!
:a(?BaSD$

<main program>
1AG       Register row 1 as function G
   IE;    Take number input; halt on EOF
      GN  Call G and print the result as number
          Repeat indefinitely

<function G>
2AY            Register row 2 as function Y
   :P*2,       Sum of 1 to n
        Y      Call Y (break into digits)
         lMR*  Product
Y              Call Y
 lR+           Sum (an implicit zero is used)
    :a(?B      Return if the result is less than 10
         8R!   Skip initial 8 commands
               Repeat indefinitely

<function Y>
:a(?B      Return if the top is less than 10
     aSD   Divmod by 10; [... n] => [... n/10 n%10]
        $  Swap top two, so the "div" goes to the top

Japt, 16 14 13 Bytes

_ì ×ìx}gN®õ x

Versuch es

Erläuterung

                  :Implicit input of integer U
         ®        :Map
        N         :The array of inputs (which just contains U)
          õ       :  Range [1,U]
            x     :  Reduce by addition
_     }g          :Take the last element of N, run it through the following function and push the result to N
                  : Repeat U times and then return the last element of N
 ì                :  Split to an array of digits
   ×              :  Reduce by multiplication
    ìx            :  Split to an array of digits and reduce by addition

Schale , 7 Bytes

ωöΣdΠdΣ

Probieren Sie es online!

PHP 7, 89 Bytes

for($a=$argn*-~+$argn/2;$a>9;)$a=array_sum(($s=str_split)(array_product($s($a))));echo$a;

Laufen Sie als Pipe mit -roder versuchen Sie es online .

• PHP nimmt Eingaben immer als Zeichenkette, also muss ich sie verwenden +, um nach int umzuwandeln, damit ~sie wie gewünscht funktionieren.
• Pre-Increment würde nicht funktionieren: Egal wo ich es platziere, es würde beide Operanden beeinflussen.
• Aber: Es ist egal, ob die einzelne Ziffer vor oder nach der Iteration stattfindet (zusätzliche Iterationen würden nichts ändern); also kann ich for()statt verwenden do ... while().
• Für die Inline-Vergabe des Funktionsnamens wird PHP 7 oder höher benötigt.
  Für älteres PHP ist ein weiteres Byte erforderlich: for($s=str_split,$a=...;$a>9;)$a=array_sum($s(...));
  (Wenn Sie str_spliteiner Variablen nichts zuweisen , wird ein weiteres Byte verschwendet.)

Perl 6 , 49 Bytes

{($_*.succ/2,{[+] ([*] .comb).comb}...9>=*).tail}

Probieren Sie es online!

Tcl , 118 Bytes

proc S n {set r [expr $n*($n+1)/2]
while \$r>9 {set r [expr [join [split [expr [join [split $r ""] *]] ""] +]]}
set r}

Probieren Sie es online!

PowerShell Core , 91 101 93 Byte

Function F($a){$o=$a*($a+1)/2;1,2|%{$o=[char[]]"$([char[]]"$o"-join'*'|iex)"-join'+'|iex};$o}

Probieren Sie es online!

Ein wenig ungolfed ...

Function F ($a)
{
    $o=$a*($a+1)/2;
    1..2 | % {
        $o = [char[]]"$o"-join '*' | iex;
        $o = [char[]]"$o"-join '+' | iex;
    }
    $o | Write-Output
}

Die ersten Schritte bestanden darin, die Ganzzahlen in Ziffern aufzuteilen. Dazu wurde die Ganzzahl in ein Array von Zeichenfolgen aufgeteilt . Fügen Sie anschließend den Operanden ein und werten Sie den String als Befehl aus. Dann ist es eine Frage des Mehrfachadditionszyklus, bis die Eingabe eine Ziffer ist.

iexist ein Alias, bei Invoke-Commanddem ein String ausgewertet wird, der an die erste Parameterposition übergeben wurde.

Bearbeiten: Wie von @AdmBorkBork angefordert , habe ich der Byteanzahl einen Funktionsheader hinzugefügt. Außerdem habe ich ein wenig nachgerechnet und festgestellt, dass eine Obergrenze für die Anzahl der Iterationen vorliegt < log log 10^6 < log 6 < 2, sodass weitere sechs Bytes eingespart wurden.

Edit x2: @AdmBorkBork hat eine genauere Möglichkeit gefunden, die Ganzzahl in einen mathematischen Ausdruck umzuwandeln, und hat dann vorgeschlagen, sie mit Pipes zu versehen iex. Dies sparte 8 Bytes. Vielen Dank!

Perl 5 -p , 61 Bytes

$_*=$_/2+.5;$_=eval((eval s/./$&*/gr.1)=~s/./+$&/gr)while$_>9

Probieren Sie es online!

Ruby , 57 Bytes

->n{("*+"*n).chars.reduce(-~n*n/2){|x,y|eval x.digits*y}}

Probieren Sie es online!

Java 8, 129 Bytes

n->{long r=1,i=n;for(;i>1;r+=i--);for(;r>9;r=(i+"").chars().map(p->p-48).sum(),i=1)for(int s:(r+"").getBytes())i*=s-48;return r;}

Probieren Sie es online aus.

Erläuterung:

n->{            // Method with integer parameter and long return-type
  long r=1,     //  Result-long, starting at 1
       i=n;     //  Temp integer, starting at the input `n`
  for(;i>1;     //  Loop as long as `i` is not 1 yet
      r+=i--);  //   And increase `r` by `i`
  for(;r>9      //  Loop as long as `r` is not a single digit yet
      ;         //    After every iteration:
       r=(i+"").chars().map(p->p-48).sum(),
                //     Set `r` to the sum of digits of `i`
       i=1)     //     And reset `i` to 1
    for(int s:(r+"").getBytes())i*=s-48;
                //    Set `i` to the product of the digits of `r`
  return r;}    //  Return `r` as result

Julia 0,6 , 56 Bytes

f(n,k=(n+1)n÷2)=k>9?f(0,sum(digits(prod(digits(k))))):k

Probieren Sie es online!

Ganz einfach: Berechnen Sie die (n+1)n÷2Summe aus 1..n. Prüfen Sie, ob es sich um eine einstellige Zahl handelt ( >9). Wenn dies nicht der Fall ist , versuchen Sie es erneut, indem Sie k auf die Summe der Stellen des Produkts der Stellen von k setzen. Anderenfalls geben Sie k zurück.