Montag Minigolf: Eine Reihe von kurzen Code-Golf- Fragen, die (hoffentlich!) Jeden Montag gestellt werden.
^{(Tut mir leid, ich bin wieder zu spät. Ich war gestern und heute im Grunde nur von meinem Computer entfernt.)}

Wir Programmierer (insbesondere die Code-Golfer) lieben mit Sicherheit beliebige Ganzzahlsequenzen. Wir haben sogar eine ganze Website, die sich diesen Sequenzen widmet und derzeit rund 200.000 Einträge enthält. In dieser Herausforderung werden wir einen weiteren Satz dieser Sequenzen implementieren.

Herausforderung

Ihre Herausforderung besteht darin, ein Programm oder eine Funktion zu schreiben, die eine Ganzzahl N enthält und eine Folge von Ganzzahlen zur Basis 10 ausgibt, wobei jede nächste Ganzzahl folgendermaßen bestimmt wird:

• Beginnen Sie bei 1.

• Für jede Ziffer D in der Darstellung zur Basis 10 der vorherigen Ganzzahl:

  • Wenn D 0 ist, addieren Sie eins zur aktuellen Ganzzahl.
  • Andernfalls wird die aktuelle ganze Zahl von multiplizieren D .

Einzelheiten

• Sie können annehmen, dass 0 < N <2 ³¹ .
• Sie müssen jede Ganzzahl in der Sequenz ausgeben, beginnend mit der eingegebenen Nummer, bis eine Zahl unter 10 erreicht ist.
• Die Ausgabe kann ein Array oder eine durch Leerzeichen, Kommas, Zeilenumbrüche oder eine Kombination davon getrennte Zeichenfolge sein.
• Ein abschließendes Leerzeichen und / oder eine neue Zeile ist zulässig, jedoch kein abschließendes Komma.
• Es sollte niemals führende Nullen geben.

Beispiele

Beispiel 1: 77

Dieses Beispiel ist ziemlich einfach:

77 = 1*7*7 = 49
49 = 1*4*9 = 36
36 = 1*3*6 = 18
18 = 1*1*8 = 8

Somit ist die richtige Ausgabe 77 49 36 18 8.

Beispiel 2: 90

Hier haben wir:

90 = 1*9+1 = 10
10 = 1*1+1 = 2

So wäre die Ausgabe 90 10 2.

Beispiel 3: 806

Lesen Sie die Gleichungen von links nach rechts:

806 = 1*8+1*6 = 54 (((1*8)+1)*6)
 54 = 1*5*4   = 20
 20 = 1*2+1   = 3

Ausgabe sollte sein 806 54 20 3.

Testfälle

Die erste Zahl in jeder Zeile ist die Eingabe, und die vollständige Zeile ist die erwartete Ausgabe.

77 49 36 18 8
90 10 2
249 72 14 4
806 54 20 3
1337 63 18 8
9999 6561 180 9
10000 5
8675309 45369 3240 25 10 2
9999999 4782969 217728 1568 240 9
1234567890 362881 2304 28 16 6

Als Referenz sind hier die richtigen nächsten ganzen Zahlen von 10 bis 100:

Current | Next
--------+-----
     10 |  2
     11 |  1
     12 |  2
     13 |  3
     14 |  4
     15 |  5
     16 |  6
     17 |  7
     18 |  8
     19 |  9
     20 |  3
     21 |  2
     22 |  4
     23 |  6
     24 |  8
     25 | 10
     26 | 12
     27 | 14
     28 | 16
     29 | 18
     30 |  4
     31 |  3
     32 |  6
     33 |  9
     34 | 12
     35 | 15
     36 | 18
     37 | 21
     38 | 24
     39 | 27
     40 |  5
     41 |  4
     42 |  8
     43 | 12
     44 | 16
     45 | 20
     46 | 24
     47 | 28
     48 | 32
     49 | 36
     50 |  6
     51 |  5
     52 | 10
     53 | 15
     54 | 20
     55 | 25
     56 | 30
     57 | 35
     58 | 40
     59 | 45
     60 |  7
     61 |  6
     62 | 12
     63 | 18
     64 | 24
     65 | 30
     66 | 36
     67 | 42
     68 | 48
     69 | 54
     70 |  8
     71 |  7
     72 | 14
     73 | 21
     74 | 28
     75 | 35
     76 | 42
     77 | 49
     78 | 56
     79 | 63
     80 |  9
     81 |  8
     82 | 16
     83 | 24
     84 | 32
     85 | 40
     86 | 48
     87 | 56
     88 | 64
     89 | 72
     90 | 10
     91 |  9
     92 | 18
     93 | 27
     94 | 36
     95 | 45
     96 | 54
     97 | 63
     98 | 72
     99 | 81
    100 |  3

Sie können diese Liste zu 10000 erweitert finden hier .

Wertung

Das ist Code-Golf , also gewinnt der kürzeste gültige Code in Bytes. Tiebreaker geht zu einer Übermittlung über, die als erste ihre letzte Byteanzahl erreicht hat. Der Gewinner wird am kommenden Montag, den 19. Oktober, ermittelt. Viel Glück!

Bearbeiten: Herzlichen Glückwunsch an Ihren Gewinner, @isaacg , der Pyth noch einmal für 14 Bytes verwendet !

Pyth, 15 bis 14 Bytes

.uu|*GHhGjNT1Q

1 Byte danke an Dennis

Test Suite

Diese Herausforderung scheint für Pyths Reduktionsfunktionen gemacht zu sein. Eine Reduzierung über die Ziffern, eine Reduzierung, bis sich der Wert nicht mehr ändert, und wir sind gut.

PowerShell, 92 91 90 88 87 Byte

($n=$args);while($n-gt9){$x=1;[char[]]"$n"|%{$x=if($y=$_-48){$x*$y}else{$x+1}};($n=$x)}

Pip , 28 25 23 Bytes

Tt>Pa{Y1FdaYy*d|y+1a:y}

Nimmt eine Zahl als Befehlszeilenargument und gibt die Sequenz in aufeinanderfolgenden Zeilen aus.

Erläuterung:

                         a is cmdline arg; t is 10 (implicit)
Tt>Pa{                }  Loop till a<10, printing it each time the test is made:
      Y1                   Yank 1 into variable y
        Fda                For each digit d in a:
           Yy*d|y+1          If y*d is truthy (nonzero), yank it; otherwise, yank y+1
                   a:y     Assign value of y back to a

Jetzt bin ich froh, dass ich vor Peinigen Überarbeitungen von einer Anweisung zu einem Operator gewechselt habe. Paist ein Ausdruck, der aden Wert auswertet, ihn aber auch ausgibt, sodass ich mit drucken aund gleichzeitig testen kann, ob er weniger als zehn beträgt t>Pa.

CJam, 26 25 24 22 Bytes

riA,{_pAb{_2$*@)?}*j}j

oder

ri{_pAb{_2$*@)?}*_9>}g

Probieren Sie es online aus.

Wie es funktioniert

Beide Programme machen im Wesentlichen dasselbe; Der erste Ansatz ist rekursiv, der zweite iterativ. Ich erkläre das erste, was ich für interessanter halte.

ri                     Read an integer from STDIN and push it on the stack.
  A,{               }j Initialize a memoized, recursive function j with the array
                       [0 ... 9] as "base cases". If j is called on an integer
                       below 10, it returns the element at that index of the base
                       cases (which is same integer) and does not execute the code
                       block. The base case array is filled with new values as j is
                       called again and again, but we do not use this feature.
     _p                Copy and print the integer on the stack.
       Ab              Convert it into its base-10 digits.
         {       }*    Fold; push the first digit, for each remaining digit:
          _2$*         Multiply copies of the accumulator and the current digit.
              @)       Increment the original accumulator.
                ?      Select the product if the digit is non-zero, else the sum.
                   j   Call j on the result.
                       If the result was less than 10, it is retrieved from the
                       base cases and pushed on the stack. CJam prints it before
                       exiting the program.

Minkolang 0,7 , 52 46 Bytes

ndN((d25*%1R25*:)r11(x2~gd4&x1+!*I1-)dNd9`,?).

Woohoo verschachtelte Loops!

Erläuterung

ndN     Takes integer input and outputs it
(       Starts overall loop

 (        Starts loop that separates top of stack into digits
  d25*%   Modulus by 10
  1R      Rotates stack 1 unit to the right
  25*:    Divides by 10
 )

 r11   Reverses stack and pushes two 1s; 1 for the dump and 1 for the multiply
 (     Starts the multiply/add loop
  x    Dumps top value

      -This top-of-stack dump is because
       while loops end when the stack is
       empty or the top of stack is 0. The
       top of stack is *not* popped for
       this conditional check, so if the loop
       continues, I need to dump the left-over
       from the previous iteration.

  2~gd    Gets next-to-last stack value and duplicates for the conditional
  4&      Jumps 4 spaces if top of stack is positive
   x1+!   Dumps the 0 leftover, adds 1 to top of stack, and jumps the multiply
   *      Multiplies the top two elements of stack
  I1-     Pushes length of stack - 1
 )        Exits the loop if top of stack is 0 (i.e., len(stack)=1)
 dN       Outputs as integer
 d9`,?    Jumps out of the loop if top of stack <=9
)
.    Stop.

Mathematica, 66 Bytes

Most@FixedPointList[Fold[If[#2<1,#+1,1##]&,1,IntegerDigits@#]&,#]&

Python 3, 74, 76 Bytes

Es gab hier bereits eine Python-Antwort mit "Reduzieren", also wollte ich eine ohne diese Antwort machen. Es sollte mit einem int aufgerufen werden.

def j(n,m=1):
 print(n)
 if n>9:
  for d in str(n):m=m*int(d)or m+1
  j(m)

Python, 85 bis 80 Bytes

def g(n):y=reduce(lambda i,x:i*int(x)or i+1,`n`,1);return[n]+(g(y)if n>9else[])

Dies druckt nun korrekt die gesamte Liste aus, anstatt nur den ersten Wert.

K5 , 24 Bytes

(1{(x*y;x+1)@~y}/.:'$:)\

Genau das \erledigt der Scan-Operator, wenn er eine Liste von Elementen erstellt, während er zu einem festgelegten Punkt iteriert . Bei jeder Iteration habe ich zuerst die Zahl in eine Zeichenfolge umgewandelt und dann jedes Zeichen ( .:'$:) ausgewertet , wobei die Zahl in ihre Ziffern zerlegt wurde. Dann führe ich eine Reduktion ( /) durch, die mit 1 beginnt und das Lambda verwendet {(x*y;x+1)@~y}. In diesem Fall xist der reduzierende Wert und yist jeder aufeinanderfolgende Term der Sequenz.

In Aktion:

  f: (1{(x*y;x+1)@~y}/.:'$:)\

  f'77 90 249 806 1337 9999 10000 8685309 9999999 1234567890
(77 49 36 18 8
 90 10 2
 249 72 14 4
 806 54 20 3
 1337 63 18 8
 9999 6561 180 9
 10000 5
 8685309 51849 1440 17 7
 9999999 4782969 217728 1568 240 9
 1234567890 362881 2304 28 16 6)

Julia, 93 89 88 86 83 77 Bytes

f(n)=(println(n);if(d=n>9)for i=reverse(digits(n)) i<1?d+=1:d*=i end;f(d)end)

Dadurch wird eine rekursive Funktion erstellt f, die die Sequenzelemente in separaten Zeilen druckt.

Ungolfed:

function f(n::Int)
    println(n)
    if (d = n > 9)
        for i in reverse(digits(n))
            i < 1 ? d += 1 : d *= i
        end
        f(d)
    end
end

Probieren Sie es online aus

6 Bytes gespart dank Dennis!

Ruby 83 , 72 Bytes

Original als Funktion deklariert:

def f(d)loop{p d;break if d<10;d=d.to_s.bytes.inject(1){|r,i|i>48?r*(i-48):r+1}}end

Ich habe versucht, zu verwenden, Enumerator.newaber es verwendet so viele Bytes :-(

Verbessert mit Rekursion:

def f(d)p d;f(d.to_s.bytes.inject(1){|r,i|i>48?r*(i-48):r+1})if d>10 end

C # & LINQ, 165 146 Bytes

void j(int a){r.Add(a);var l=a.ToString().Select(d=>int.Parse(d.ToString()));int n=1;foreach(int i in l)n=i==0?n+1:n*i;if(n>9)j(n);else r.Add(n);}

j (für Jarvis) ist die rekursive Funktion. r ist die Liste von int des Ergebnisses.

in LINQPAD getestet:

void Main()
{
    j(806);
    r.Dump();
}
List<int> r = new List<int>();

void j(int a){r.Add(a);var l=a.ToString().Select(d=>int.Parse(d.ToString()));int n=1;foreach(int i in l)n=i==0?n+1:n*i;if(n>9)j(n);else r.Add(n);}

Haskell, 71 Bytes

x!'0'=x+1
x!c=x*read[c]
g x|h>9=x:g h|1<2=[x,h]where h=foldl(!)1$show x

Verwendung: g 8675309-> [8675309,45369,3240,25,10,2].

Matlab, 108

N=input('');disp(N)
k=1;while k
x=1;for n=num2str(N)-48
if n
x=x*n;else
x=x+1;end
end
disp(x)
N=x;k=x>9;
end

Java 8, 148 Bytes

String f(int j){String s="";Function r=i->(""+i).chars().map(x->x-48).reduce(1,(x,y)->y>0?x*y:x+1);while((j=(int)r.apply(j))>9)s+=j+" ";return s+j;}

formatiert

String f(int j) {
    String s = "";
    Function r = i -> ("" + i).chars().map(x -> x - 48).reduce(1, (x, y) -> y>0 ? x*y : x+1);
    while ((j = (int)r.apply(j)) > 9) s += j+" ";
    return s+j;
}

Gelee , 9 Bytes

Dבṛ?ƒ1ƊƬ

Probieren Sie es online!