Monday Mini-Golf : 매주 월요일에 게시 되는 일련의 짧은 코드 골프 질문입니다.
^{(죄송합니다. 다시 늦었습니다. 기본적으로 어제와 오늘 모두 컴퓨터에서 멀었습니다.)}

우리 프로그래머 (특히 코드 골퍼)는 임의의 정수 시퀀스를 좋아합니다. 우리는 심지어이 이 시퀀스에 전념 전체 사이트 현재 약 20 만 항목이 있습니다. 이 과제에서 우리는 이러한 시퀀스의 또 다른 세트를 구현할 것입니다.

도전

당신의 도전은 정수 N 을 취하고 기본 10 정수 시퀀스를 출력 하는 프로그램이나 함수를 작성하는 것입니다.

• 1에서 시작하십시오.

• 이전 정수의 기본 10 표현에서 각 숫자 D 에 대해 :

  • 경우 D가 0이고, 현재의 정수에 1을 추가합니다.
  • 그렇지 않으면 현재 정수에 D를 곱하십시오 .

세부

• 0 < N <2 ³¹ 이라고 가정 할 수 있습니다 .
• 10보다 작은 수에 도달 할 때까지 입력 숫자부터 시작하여 순서대로 각 정수를 출력해야합니다.
• 출력은 배열이거나 공백, 쉼표, 개행 또는 이들의 조합으로 구분 된 문자열 일 수 있습니다.
• 후행 공백 및 / 또는 줄 바꾸기는 허용되지만 후행 쉼표 는 사용할 수 없습니다 .
• 선행 0이 없어야합니다.

예

예 1 : 77

이 예제는 매우 간단합니다.

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

따라서 올바른 출력은 77 49 36 18 8입니다.

예 2 : 90

여기에 우리가 있습니다 :

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

따라서 출력은입니다 90 10 2.

예 3 : 806

왼쪽에서 오른쪽으로 방정식을 읽으십시오.

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

출력은이어야합니다 806 54 20 3.

테스트 사례

각 줄의 첫 번째 숫자는 입력이고 전체 줄은 예상 출력입니다.

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

참고로 다음은 10에서 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

이 목록은 여기 에서 10000으로 확장되었습니다 .

채점

이것은 code-golf 이므로 바이트 단위의 가장 짧은 유효한 코드가 이깁니다. Tiebreaker는 최종 바이트 수에 먼저 도달 한 제출에갑니다. 우승자는 다음주 10 월 19 일 월요일에 선발됩니다. 행운을 빌어 요!

편집 : 14 바이트 동안 Pyth를 다시 사용하여 우승자 @isaacg 에게 축하드립니다 !

Pyth, 15 14 바이트

.uu|*GHhGjNT1Q

Dennis 덕분에 1 바이트

테스트 스위트

이 도전은 Pyth의 Reduce 기능을 위해 만들어진 것처럼 느껴집니다. 하나는 자릿수를 줄이고, 하나는 값 변경이 멈출 때까지 감소하며, 우리는 좋습니다.

PowerShell, 92 91 90 88 87 바이트

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

핍 , 28 25 23 바이트

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

숫자를 명령 행 인수로 사용하여 연속 행에 순서를 출력합니다.

설명:

                         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

이제 P몇 가지 수정 전에 문장에서 연산자로 변경하게 되어 기쁩니다 . Pa는 a값으로 평가되고 출력 되는 표현식 이므로를 a사용하여 10 미만인지 인쇄 하고 동시에 테스트 할 수 있습니다 t>Pa.

CJam, 26 25 24 22 바이트

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

또는

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

온라인으로 사용해보십시오.

작동 원리

두 프로그램 모두 본질적으로 동일합니다. 첫 번째는 재귀 적 접근이고, 두 번째는 반복적 인 접근입니다. 더 흥미로운 것으로 생각되는 첫 번째를 설명하겠습니다.

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 바이트

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

Woohoo 중첩 루프!

설명

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.

매스 매 티카, 66 바이트

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

파이썬 3, 74, 76 바이트

여기에 이미 축소 된 파이썬 답변이 있었으므로 그것을하지 않고 그것을하고 싶었습니다. int로 호출해야합니다.

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

파이썬, 85 80 바이트

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

이제 첫 번째 값 대신 전체 목록을 올바르게 인쇄합니다.

K5 , 24 바이트

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

고정 소수점까지 반복하면서 항목 목록을 수집하는 것은 스캔 연산자 \가하는 일입니다. 각 반복에서 먼저 숫자를 문자열로 캐스팅 한 다음 각 문자 ( .:'$:) 를 평가 하여 숫자를 숫자로 분해합니다. 그런 다음 /1부터 람다를 사용하여 축소 ( )를 수행합니다 {(x*y;x+1)@~y}. 이 경우 x감소 값이며 y시퀀스의 각 연속 항입니다.

실제로 :

  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)

줄리아, 93 89 88 86 83 77 바이트

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

이것은 재귀 함수를 만듭니다 f시퀀스 요소를 별도의 줄에 인쇄 를 .

언 골프 드 :

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

온라인으로 사용해보십시오

Dennis 덕분에 6 바이트를 절약했습니다!

루비 83 , 72 바이트

함수로 선언 된 원본 :

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

사용하려고했지만 Enumerator.new너무 많은 바이트를 사용합니다 :-(

재귀를 사용하여 개선 :

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, 165146 바이트

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 (jarvis의 경우)는 재귀 함수입니다. r 은 결과의 int 목록입니다.

LINQPAD에서 테스트 :

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);}

하스켈, 71 바이트

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

사용법 : 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

자바 8, 148 바이트

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

형식화

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

젤리 , 9 바이트

Dבṛ?ƒ1ƊƬ

온라인으로 사용해보십시오!