배경:

실제 세계의 기본 덧셈 및 곱셈과 같은 표준 연산 수학은 다음과 같이 작동합니다.

12 + 123 = 135

과

12 * 123 = 1476

재미 있고 지루하지 않습니다! 많은 학교들이 이미 이것을 공식 알고리즘의 연습, 연습, 연습으로 해석하고 있습니다. 그것은 매우 단단하고 지루한 수학적 다이어트를 의미 하며이 도전에서 의도 된 것이 아닙니다. 사랑하는 사이트에서 즐거운 시간을 보내십시오.

두 개의 양의 정수를 더한 다음 결과의 모든 숫자를 다시 추가하는 프로세스를 고려하십시오. 한 자릿수가 얻어 질 때까지 덧셈을 반복합니다. 예를 들면 다음과 같습니다.

1. 결과 12 + 123는 135입니다.
2. 우리가 얻는 135의 모든 자리수를 더 1 + 3 + 5 = 9합니다.

이 반복 가산에서 단일 숫자 값 9를 얻는 데 필요한 단계 수는 2입니다.

이전의 덧셈 과정과 마찬가지로 두 양의 정수의 곱셈도 같은 과정을 따릅니다. 결과의 모든 자리수를 곱한 다음 한 자리 만 남을 때까지이 과정을 반복하십시오. 위의 예를 보자.

1. 결과 12 * 123는 1476입니다.
2. 우리가 얻는 1476의 모든 자리수에 곱하십시오 1 * 4 * 7 * 6 = 168.
3. 우리가 구한 168의 모든 자리수에 다시 곱하십시오 1 * 6 * 8 = 48.
4. 우리가 얻는 48의 모든 자리수를 다시 곱하십시오 4 * 8 = 32.
5. 우리가 구한 32의 모든 자리수에 다시 한번 곱하십시오 3 * 2 = 6.

이 반복 곱셈의 단일 자릿수 값 6을 얻는 데 필요한 단계 수는 5입니다.

이 문제의 술과 수학 표기법의 오용을 피하기 위해, 나는이 두 더미 표기법을 소개 : (+)와 (*), 하지만 당신은 당신이 원하는 표기법을 사용할 수 있습니다 다음과 같은 일을 :

1. 단일 값을 얻기 위해 반복되는 가산 과정의 연산은입니다 12 (+) 123 = 9.
2. 단일 값을 얻기 위해 반복 된 곱셈 과정의 연산은입니다 12 (*) 123 = 6.

도전:

과제는 프로그램 또는 수행 할 수있는 기능 중 기입하는 동작 모두 : 배경 기술 부분에서 설명한 바와 같이 (+)및 (*).

입력:

프로그램이나 함수의 입력은 두 개의 양의 정수 한 조작이다 (+)하고 (*). 입력 형식은 프로그래머가 임의로 선택합니다 . 당신은 입력, 예를 들어, 포맷 할 수있다 a (+) b거나 F(a, (+), b)또는 여러분이 원하는 형식을.

산출:

프로그램 또는 기능의 출력에는 원하는대로 작업 결과 및 자유형 형식에 필요한 단계 수가 포함되어야합니다.

테스트 사례 (입력 및 출력 형식 무시) :

    81 (+) 31       -->   (4 ; 2)
    351 (+) 14568   -->   (6 ; 3)
    21 (*) 111      -->   (8 ; 3)
    136 (*) 2356    -->   (0 ; 2)

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 가장 짧은 대답이 도전에 이깁니다.
  esolangs가 일반 언어로 답변을 게시하지 못하게하지 마십시오. 프로그래밍 언어로 가능한 한 짧은 답변을 제공하여이 도전을 즐기십시오. 현명한 답변과 명확한 설명을 게시하면 사용하는 프로그래밍 언어에 관계없이 귀하의 답변에 감사하게됩니다 (따라서 공감).
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 기능 / 방법에 적절한 매개 변수, 전체 프로그램 등을 사용할 수 있습니다. 선택은 본인의 것입니다.
• 가능하면 프로그램이 많은 수를 올바르게 처리 할 수 ​​있습니다. 그렇지 않다면 괜찮을 것입니다.

게임을 시작하지!!

Dyalog APL , 33 32 30 29 바이트

이것은 접두사 표기법 +/A n₁ n₂과 를 포함하도록 APL을 확장 ×/A n₁ n₂합니다. (실제로의 왼쪽에있는 작업을 사용할 수 있습니다 /A.) {result, repetition count}의 목록을 반환합니다.

A←{(⊃,≢)⍺⍺{∪⍵,⍨⍺⍺⍎¨⍕⊃⍵}⍣≡⍺⍺⍵}

A←{left-hand function 과 right-hand argument 측면에서 고차 함수 정의⍺⍺⍵

(⊃,≢) 의 첫 번째 요소 다음에

⍺⍺{고차 함수에 공급 된 제공된 함수 ( +/합계 또는 ×/제품)

∪ 의 독특한 요소

⍵,⍨ 추가 된 인수

⍺⍺ 피드 기능을 적용

⍎¨ 각 캐릭터의 평가

⍕ 의 캐릭터 표현

⊃⍵ 인수의 첫 번째 요소

}⍣≡ 결과가 인수와 동일 할 때까지 반복해서 적용

⍺⍺⍵원래 인수에 적용된 원래 공급 된 함수 ( +/또는 ×/)

} [고차 함수 정의의 끝]

TryAPL 온라인! ( 보안상의 이유로 ⍎에뮬레이션되었습니다 e.)

바이트를 저장해 준 @ngn에게 감사합니다.

0 바이트 (Jest)

Dyalog APL은 실제로 Anastasiyan 수학을 완전히 지원합니다. 대신 (+)하고 (×), 그것을 사용 +{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/⍎¨⍕⍵}⍣=⍵⍺⍺⍨⍺}하고 ×{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/⍎¨⍕⍵}⍣=⍵⍺⍺⍨⍺}.

시도 81 +{(⊃,≢)⍺⍺{∪⍵,⍨⍺⍺e¨⍕⊃⍵}⍣≡⍺⍺/⍺⍵} 31와 21 ×{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/e¨⍕⍵}⍣=⍵⍺⍺⍨⍺} 111.

하스켈, 108 바이트

f=map(read.pure).show
g h=(\x->(h.f$last x,length x+1)).takeWhile(>10).iterate(h.f)
(a#b)o=g(foldr1 o)$o a b

함수 정의 #제 얻어 a및 b그 조작을하고 o. 재미있는 사실 : 이것은 원하는 모든 연산자 (실제로 모든 기능)와 함께 작동합니다!

파이크, 16 바이트

RE`DltImbRoKr)oh

여기 사용해보십시오!

RE               - evaluate the input as Pyke code
                 -  (`B` is product and `s` is sum, the second line is a tuple)
  `              - i = str(^)
    ltI      )   - if len(i) != 1:
       mb        -   map(i, int)
         R       -   get the `B` or `s` from input
          oK     -   o++
            r    -   goto_start()
              oh - o++ + 1

로 곱하고로 B추가합니다 s. 두 개의 숫자 입력은 쉼표로 구분됩니다.

자바 스크립트 (ES6), 59

재귀 함수, 입력 형식은 재귀 호출을 단순화하도록 조정됩니다.

• 연산자 : '+'또는 '*'
• 피연산자 : 두 값의 배열

f=(o,v,s=1,t=eval(v.join(o)))=>t>9?f(o,[...t+''],s+1):[t,s]

테스트

f=(o,v,s=1,t=eval(v.join(o)))=>t>9?f(o,[...t+''],s+1):[t,s]

;[
  [81,'+',31,     /* -> */ 4, 2]
, [351,'+',14568, /* -> */ 6, 3]
, [21,'*',111,    /* -> */ 8, 3]
, [136,'*',2356,  /* -> */ 0, 2]
].forEach(t=>{
  var [a,o,b,k1,k2] = t,
      [r,s]=f(o,[a,b]);
  console.log(k1==r && k2==s ? 'OK':'KO',a,o,b,'->',r,s)
})  
  

파이썬 2, 60 바이트

f=lambda s,c=0:s[1:]and f(min(s).join(`eval(s)`),c+1)or(s,c)

입력 문자열처럼 81+31출력은 싱글 캐릭터의 튜플과 카운터 (예이다 ('4', 2).

Ideone에서 테스트하십시오 .

피스, 16

eJ.uvjhQ`N.vQ)lJ

덧셈 "+ 123 12"과 "* 123 12"곱셈 처럼 입력을 받습니다. 와 같은 출력 result<linefeed>steps.

여기 에서 시도 하거나 Test Suite를 실행 하십시오 . 그러나 이것은 eval에 의존하므로 추가 변형 만 온라인 인터프리터에서 작동합니다. 곱셈은 ​​오프라인 인터프리터에서 올바르게 작동합니다.

이것은 누적 감소 함수를 사용하여 중간 결과 목록을 생성하므로 "+ 351 14568"얻을 수 [14919, 24, 6]있습니다. 한 자리 숫자는 Anastasiya 덧셈과 곱셈의 고정 소수점이기 때문에 작동합니다. 그런 다음 배열의 마지막 요소와 배열의 길이를 가져옵니다.

이것은 적어도 메모리가 부족할 때까지 임의로 많은 수의 경우 작동합니다.

R, 175 167 164 140 134 127 126 119 바이트

function(G,S,D){i=1;O=switch(S,"+"=sum,prod);x=O(G,D);while(x>9){i=i+1;x=O(strtoi(strsplit(paste(x),"")[[1]]))};c(x,i)}

언 골프 :

f=function(G,S,D) #The function takes : the left operand, the operation symbol (between quote marks)
                  #and then the right operand
i=1               #That's the counter

O=switch(S,"+"=sum,prod)     #`O` takes the value `sum` if `S` matches `+`, `prod` 
                             #(which is the next agument) if not. 

x=O(G,D)                     #Does the first operation

while(nchar(x)>1)                 #While the number of character of the result 
                                  #of the operation is not of length 1, i.e., an integer :

    i=i+1                                    #Increase the counter
    x=O(strtoi(strsplit(paste(x),"")[[1]]))  #Apply the operation `O` to the first operation and 
                                             #the eventual subsequent ones

c(x,i)                                 #Outputs the result and the counter

ifelse돌아왔다! 응!
놉

사용법 :

Special addition
> f(31,"+",81)
[1] 4 2

Special multiplication
> f(136,"*",2356)
[1] 0 2

24 바이트 를 골라 낸 @plannapus 에게 감사드립니다 ! @Vlo 의 좋은 아이디어 덕분에 -7 바이트 !

05AB1E , 20 15 바이트

[¼¹iOëP}Dg#S]¾‚

설명

[       Dg# ]    # loop until number is single digit
 ¼               # increase counter
  ¹iO            # if operation is addition, sum list
     ëP}         # else take product of list
           S     # split into a list of digits
             ¾‚  # pair final number with counter and output

연산자는 덧셈의 경우 1이고 곱셈의 경우 0입니다.

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

젤리 , 11 10 바이트

Dj⁹VµÐĿḊĖṪ

입력은 숫자 쌍 +또는 또는 ×입니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

Dj⁹VµÐĿḊĖṪ  Main link. Left argument: [x, y] (integers). Right argument: + or ×

    µÐĿ     Repeatedly execute the chain to the left, initially with argument
            [x, y], then with the previous return value. Stop when the results are
            no longer unique, and return the array of all intermediate results.
D           Decimal; convert the integers [x, y] or the return value z to base 10.
 j⁹         Join, separating by the link's right argument, i.e., '+' or '×'.
   V        Evaluate the result. This casts the previous return value to string,
            so, e.g., [8, 1, '+', 3, 1] becomes "81+31" before evaluation.
       Ḋ    Dequeue; discard the first intermediate result, i.e., [x, y].
        Ė   Enumerate; prefix each integer in the array with its 1-based index.
         Ṫ  Tail; extract the last index-value pair.

ARM 머신 코드, 48 바이트

육각 덤프 :

b570 2a00 bf0c 1840 4348 2101 230a e00c 3101 0015 fbb0 f6f3 fb06 0413 2a00 bf0c 192d 4365 0030 d1f5 0028 280a d2f0 bd70

이 함수는 시스템 호출이나 라이브러리 함수에 의존하지 않습니다. 이것은 Thumb-2 코드이며 32 비트 ARM에 대한 가변 길이 명령어 인코딩 (2 또는 4 바이트)입니다. 따라서 처리 할 수있는 최대 값은 2 ^ 32-1입니다. 처음에 레지스터를 스택 할 필요가 없으므로 AAPCS ( 46 bytes )를 준수하지 않으면 2 바이트를 삭제할 수 있습니다 .

언 골프 어셈블리 (GNU 구문) :

.syntax unified
.text
.global anastasiya
.thumb_func
anastasiya:
    @Input:
    @r0 - First number
    @r1 - Second number
    @r2 - 0 for add, 1 for multiply
    @Output:
    @r0 - Resultant value
    @r1 - Number of steps
    push {r4,r5,r6,lr}
    cmp r2,#0
    ite eq @if r2==0
    addeq r0,r0,r1 @r0+=r1
    mulne r0,r0,r1 @else r0*=r1
    movs r1,#1 @r1 is the number of steps
    movs r3,#10
    b endloop
    loop:
        adds r1,r1,#1 @Increment number of steps
        movs r5,r2 @r5=1 if multiply, 0 if add
        parseDigits:
            udiv r6,r0,r3 @r6=r0/r3
            mls r4,r6,r3,r0 @r4=r0 - r6*r3
            @Last two operations were r4=r0%r3 (r3==10)
            cmp r2,#0
            ite eq @if r2==0
            addeq r5,r5,r4 @r5+=r4
            mulne r5,r5,r4 @else r5*=r4
            movs r0,r6 @r0=r6 (Set r0 to r0/10)
            bne parseDigits @while (r0!=0)
        @Now our new total is in r5
        movs r0,r5 @Put it in r0
    endloop:
        cmp r0,#10
        bhs loop @while (r0 >=10)
    pop {r4,r5,r6,pc} @Return

C에서 스크립트 테스트 :

#include <stdio.h>
unsigned long long anastasiya(unsigned,unsigned,unsigned);

int main(void) {
    unsigned x,y,op;
    printf("Enter first operand, second operand, and 0 for addition or 1 for multiplication.\n");
    scanf("%u%u%u",&x,&y,&op);
    unsigned long long res = anastasiya(x,y,op);
    printf("Result = %u, steps = %u\n",(unsigned)res ,(unsigned)(res >> 32));
}

R, 130 개 124 문자

@ Frédéric 와는 약간 다른 접근법 :

f=function(a,f,b){b=c(a,b);n=1;while((m<-nchar(d<-switch(f,'(+)'=sum,prod)(b)))>1){b=d%%10^(1:m)%/%10^(1:m-1);n=n+1};c(d,n)}

줄 바꿈으로 들여 쓰기 :

f=function(a,f,b){
    b=c(a,b) # Take both numbers
    n=1 #Counter
    while((m<-nchar(d<-switch(f,'(+)'=sum,prod)(b)))>1){
#My own special digit splitter! (d is the result and m is the nb of char of d)
        b=d%%10^(1:m)%/%10^(1:m-1)
        n=n+1
    }
    c(d,n) #Print results
    }

4 행은 아마도 더 많은 설명이 필요할 것입니다 :

switch(f,'(+)'=sum,prod) #pick which operator to use
switch(f,'(+)'=sum,prod)(b) # apply it to b
d<-switch(f,'(+)'=sum,prod)(b) #Saves the result in d
nchar(d<-switch(f,'(+)'=sum,prod)(b))#Measures the number of character of d
m<-nchar(d<-switch(f,'(+)'=sum,prod)(b)) #Saves it in m
(m<-nchar(d<-switch(f,'(+)'=sum,prod)(b)))>1 #Checks if it is more than 1

테스트 사례 :

> f(12,"(+)",123)
[1] 9 2
> f(12,"(*)",123)
[1] 6 5
> f(351,"(+)",14568)
[1] 6 3

옥타브, 85 바이트 MATLAB, 123, 114, 105, 94 바이트

직접 인덱싱 및 증분 기능을 활용하기 위해 이것을 Octace로 변환하기로 결정했습니다. : 폼의 입력을 받고 f(a,operator), 여기서 a = [number1, number2], 및 operator==1제품을 제공하고, operator==2합계를 제공한다.

function[x,i]=f(a,o)
g={@prod,@sum}{o};x=g(a);i=1;while(x=g(num2str(x)-48))>9;i++;end

설명 :

g={@prod,@sum}{o} : 적절한 기능, 제품 또는 합계를 선택하여 g

x=g(a) 입력의 합 또는 곱을 취함

i=1; ... i++ : 단계 수를 계산하는 증분

while(x=g(num2str(x)-48))>9;
          num2str(x)-48)     % turns a number 123 into an array [1 2 3].
        g(num2str(x)-48))    % Takes the sum or product of the array
      x=g(num2str(x)-48))    % Assign that value to the variable x
      x=g(num2str(x)-48))>9  % Checks if x > 9, continue looping if yes

두 줄 바꿈, 공백을 제거하고 두 개의 입력 숫자를 별도의 인수 대신 벡터에 배치했습니다. pajonk 덕분에 9 바이트가 절약되었습니다! k=@(x)...beaker =) 덕분에 11 바이트를 더 절약하기 위해 제거 되었습니다. 마지막으로, 9 바이트를 모두 저장하기 위해 모든 것을 옥타브로 변환했습니다 ...

자바, 164 (159) 146 바이트

int[]p(int t,int m,String[]d){int r=m;for(String i:d){int x=Integer.decode(i);r=m<1?r+x:r*x;}return r>9?p(++t,m,(r+"").split("")):new int[]{r,t};}

첫 번째 인수는 카운터 일 뿐이며 항상 0입니다.

두 번째 인수는 method입니다. ADD는 0이고 MULTIPLY는 1입니다.

세 번째 인수는 추가 / 곱하기위한 값을 포함하는 문자열 배열입니다.

언 골프

public static int[] p(int t, int m, String[] d) {
    int r = m;
    for (String i : d) {
        int x = Integer.decode(i);
        r = m < 1 ? r + x : r * x;
    }
    return (r + "").length() > 1 ? p(++t, m, (r + "").split("")) : new int[]{r, t};
}

몇 바이트를 줄인 @Kevin Cruijssen에게 감사드립니다.

5 바이트를 면도 해 준 @milk 덕분입니다.

테스트 프로그램

public static final int ADD = 0;
public static final int MULTIPLY = 1;

public static void main(String[] args) {
    System.out.println(Arrays.toString(p(0, ADD, new String[]{"12", "123"}))); //9
    System.out.println(Arrays.toString(p(0, MULTIPLY, new String[]{"12", "123"}))); //6
}

public static int[] p(int t, int m, String[] d) {
    int r = m;
    for (String i : d) {
        int x = Integer.decode(i);
        r = m < 1 ? r + x : r * x;
    }
    return (r + "").length() > 1 ? p(++t, m, (r + "").split("")) : new int[]{r, t};
}

젤리 , 17 바이트

+×⁵?µDSP⁵?$ÐĿµL;Ṫ

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

같은 인수가 주어지면 x y 1아나스타시아 합계를 계산합니다 x (+) y.

같은 인수가 주어지면 x y 0, Anastasiya 제품을 계산합니다 x (*) y.

출력은로 주어집니다 [number of steps, result].

파이썬 160 146 129 바이트

def r(s):
 n=str(eval(s));c=0
 while n[1:]:exec("n=str(reduce(lambda a,b:a%sb,map(int,list(n))))"%"*+"["+"in s]);c+=1
 return n,c

곧 설명을 게시합니다.

입력의 형식은 12+12또는 5*35(정상과 +및 *징후), 그는 두 사업자가 있다고 가정합니다.

컴퓨터 메모리가 허용하는 한 많은 숫자 입력을 처리 할 수 ​​있습니다.

나는 이것이 더 나을 수 있다고 확신합니다.

편집 : @Copper 덕분에 16 31 바이트가 절약되었습니다.

R, 110 바이트

@plannapus 스플리터 사용.

function(A,F,B){r=Reduce;x=r(F,A,B);y=1;while(x>9){m=nchar(x);x=r(F,x%%10^(1:m)%/%10^(1:m-1));y=y+1};cat(x,y)}

f=function(A,F,B){
  r=Reduce                                  # Shortcut for Reduce
  x=r(F,A,B)                                # A operator B
  y=1                                       # Initiate counter
  while(x>9)                                # If number of digits > 2, or number > 9
  {m=nchar(x)                               # Count number of digits
    x=r(F,x%%10^(1:m)%/%10^(1:m-1))         # @plannapus's splitter, then feed into the A operator B operator C, etc while condition true
    y=y+1}                                  # Increment counter
  cat(x,y)}                                 # Print

산출

> f(136,"*",2356)
0 2
> f(31,"+",81)
4 2
> f(2,"+",3)
5 1
> (function(A,F,B){r=Reduce;x=r(F,A,B);y=1;while(x>9){m=nchar(x);x=r(F,x%%10^(1:m)%/%10^(1:m-1));y=y+1};cat(x,y)})(21,"*",111)
8 3

편집 : 나는 셀 수 없습니다.

클로저 126 바이트

(defn f [o a b] (loop [n (o a b) c 1] (if (< n 10) [n c] (recur (reduce #(o %1 %2) (map #(- (int %) 48) (str n))) (inc c)))))

함수는 다음과 같이 호출됩니다.

(f + 81 31)

다음은 코드를 ungolfed입니다.

(defn f [o a b]
  (loop [n (o a b) c 1]
    (if (< n 10)
      [n c]
      (recur (reduce #(o %1 %2)
                     (map #(- (int %) 48) (str n)))
             (inc c)))))

(def test-cases [[+ 81 31]
                 [+ 351 14568]
                 [* 21 111]
                 [* 136 2356]])

(map #(apply f %) test-cases)
;;=> ([4 2] [6 3] [8 3] [0 2])

Clojure는 여전히 나에게 새로운 것이므로 이것이 최선의 해결책은 아닐 것입니다. 도전은 모두 똑같이 재미있었습니다. 또한 코드는 어려움없이 매우 큰 숫자로 실행되었습니다.

펄 6 53 바이트

{$/=(&^b($^a,$^c),{[[&b]] .comb}...10>*);$/[*-1],+$/}

( 12, &[+], 123 )입력에 허용 되므로 53 바이트로 줄일 수 있습니다.
( 숫자 접미사 더하기 연산자에 대한 "경의"인 &[+]짧은 &infix:<+>)

두 번째 인수가 문자열 (+)이어야한다면 87 바이트입니다.

{my&b=::("&infix:<$^b.substr(1,1)>");$/=(b($^a,$^c),{[[&b]] .comb}...10>*);$/[*-1],+$/}

설명:

# bare block lambda with 3 parameters declared using placeholder syntax
{
  # store list into ｢$/｣
  # ( used ｢$/｣ so that I don't have to declare a variable )
  $/ = (

    # declare second placeholder parameter, and call it
    &^b(
      # with the first and third placeholder parameters
      $^a, $^c
    ),

    # bare block lambda with implicit parameter ｢$_｣
    {
      # list reduce using the second parameter from outer block
      [[&b]]

      # a list of the digits of ｢$_｣ (implicit method call)
      .comb
    }

    # keep doing that until
    ...

    # it produces something smaller than 10
    # ( Whatever lambda )
    10 > *
  );

  # returns

  # final result ( last value from list )
  $/[ * - 1 ],
  # and count of values in list
  +$/
}

테스트:

#! /usr/bin/env perl6
use v6.c;
use Test;

my &anastasiya-math = {$/=(&^b($^a,$^c),{[[&b]] .comb}...10>*);$/[*-1],+$/}

my @test = (
  (  81, &[+], 31    ) => (4, 2),
  ( 351, &[+], 14568 ) => (6, 3),
  (  21, &[*], 111   ) => (8, 3),
  ( 136, &[*], 2356  ) => (0, 2),
);

plan +@test;

for @test -> $_ ( :key(@input), :value(@expected) ) {
  cmp-ok anastasiya-math(|@input), &[»==«], @expected;
}

정상적인 사용법 :

# override built-in Bag operator ｢(+)｣ in current lexical scope
my &infix:<(+)> = &anastasiya-math.assuming: *, &[+], *;

# add a new operator
my &infix:<(*)> = &anastasiya-math.assuming: *, &[*], *;

say 12 (+) 123; # (9 2)
say 12 (*) 123; # (6 5)

파이썬 2, 107 97 바이트

g=lambda x,o,i=1:x<10and[x,i]or g(eval(o.join(`x`)),o,i+1)
lambda a,o,b:g(eval('%s'*3%(a,o,b)),o)

첫 번째 피연산자 a, 연산자 o( '+'또는 '*') 및 두 번째 피연산자의 인수를 통해 입력을 가져 와서 b형식의 목록을 반환 하는 익명 함수입니다 [result, steps].

작동 원리

익명 함수는 피연산자를 연산자와 연결하여 문자열을 만든 다음 평가합니다. 이것이 질문에 설명 된 첫 번째 단계입니다. 그런 다음이 값과 연산자는 재귀 함수로 전달됩니다 g. 여기서는 i모든 재귀 호출마다 증가 하는 카운터 가 사용됩니다. 입력이보다 작 으면 10한 자릿수에 도달 했으므로이 숫자 i가 반환됩니다. 그렇지 않은 경우 입력이 문자열로 변환되고이 문자열의 각 문자가 연산자와 결합되어 원하는 계산을 제공 한 다음 평가를 거쳐 재귀 적으로 함수에 전달됩니다.

Ideone에서 사용해보십시오

그루비, 102 바이트

def p,e,r;p={t,m,d->e=d*.toInteger();r=m<1?e.sum():e.inject{a,b->a*b};r>9?p(++t,m,""+r as List):[r,t]}

탈고

def p,e,r
p = { t, m, d ->
    e = d*.toInteger()
    r = (
            m<1
                ? e.sum()
                : e.inject { a, b -> a * b }
        )
    r > 9
        ? p(++t, m, "" + r as List)
        : [r,t]
}

설명

@Sean Bean의 탁월한 Java 솔루션을 기반으로합니다.

• p: 솔루션을 구현하는 클로저 (함수, 람다 등)
• t: 현재 호출 깊이 (반복 횟수) p는 항상 다음을 사용하여 호출해야합니다.t=1
• m: 0"추가"에 1대해 "곱하기" 에 수행 할 작업
• d: 피연산자 목록입니다. 각 피연산자는 String 객체입니다.
• e:의 요소는 d각각 정수로 변환됩니다.
• r: e작업에 따라 의 합 또는 곱m
• 다음으로 시작하는 결과 설명 r > 9:
  • 여러 자릿수 ( r > 9) 인 경우 다시 호출하고 깊이를 늘리고 숫자 문자열 목록으로 t변환 r한 다음 결과를 반환합니다.
  • 한 자리, 돌아 가면 r과 t목록으로.

테스트 프로그램

final ADD = 0
final MULTIPLY = 1
println p(1, ADD, ["12", "123"]) //9, 2
println p(1, MULTIPLY, ["12", "123"]) //6, 5
println p(1, ADD, ["2", "3"]) //5, 1

결과

[9, 2]
[6, 5]
[5, 1]

하스켈, 76 70 바이트

 (x#y)f=until(<[10])(\[s,i]->[foldr(f.read.pure)0$show s,i+1])[f x y,1]

결과 및 단계 수와 함께 두 개의 요소 목록을 리턴합니다. 임의의 큰 숫자에 적용됩니다. 사용 예 : (351#14568)(+)-> [6,3].

편집 : 6 바이트에 대한 @BlackCap 덕분에.

R, 91 바이트

@plannapus의 스플리터를 사용하는 @Vlo의 코드와 @ Frédéric의 답변을 골프를 치는 동안 생성 한 아이디어를 사용하면 이것은 가장 짧은 R 답변입니다. (오늘날 비정상적으로 많은 수의 R이 대답합니다 ...)

function(A,F,B){x=F(A,B);while(x>9){m=nchar(x);x=F(x%%10^(1:m)%/%10^(1:m-1));T=T+1};c(x,T)}

결정적으로, 이것은 연산자의 입력이 sum(+) 또는 prod(*)에 대한 것이어야합니다 . 도전의 규칙에 따라 이것은 괜찮은 것 같습니다.

들여 쓰기

function(A,F,B){
  x=F(A,B);
  while(x>9){
    m=nchar(x);
    x=F(x%%10^(1:m)%/%10^(1:m-1));
    T=T+1
  };
  c(x,T)
}

@Vlo의 대답과 주요 차이점은 다음과 같습니다.

1. 를 사용하는 대신 Reduce입력 인수를 함수로 사용하고 명시 적으로 호출하면됩니다. (함수가 일류 객체 인 함수에!)
2. 새로운 변수를 카운터로 초기화하는 대신 R의 내장을 악용 T하고 TRUE( 1)로 평가되는을 사용 하지만 예약 변수가 아니므로 변수를 수정할 수 있습니다. 따라서 T+T입니다 2. 그래서 우리는 그것을 카운터로 사용합니다.
3. cat출력 을 ing하는 대신을 사용 하여 벡터로 반환합니다 c. 2 바이트를 절약 할뿐만 아니라 출력이 벡터로 강제 적용된다는 사실은 그것이 T클래스 임을 보증합니다 numeric. 을 사용 cat하고 T증가하지 않은 경우 와 같이 잘못된 출력을 얻습니다 1 TRUE.

루비, 55 바이트

재귀 호출 @ edc65의 JavaScript 답변과는 매우 달랐지만 최적화 된 결과 궁극적으로 답변과 거의 독립적으로 개발 된 직접 포트가되었습니다. 이것은 전달되는 피연산자 목록의 길이 대신 평가 결과를 확인하는 최종 최적화를 뺀 것입니다 바이트 수를 능가했습니다.

입력은 연산자를 나타내는 문자열과 피연산자가 포함 된 배열입니다.

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

f=->o,x,i=1{y=eval x*o;y>9?f[o,y.to_s.chars,i+1]:[y,i]}

펄, 38 바이트

에 +2 포함 -ap

STDIN의 입력과 연산자 주위의 공백으로 실행하십시오.

amath.pl <<< "12 + 123"
amath.pl <<< "12 * 123"

출력은 숫자와 단계로 구분됩니다. +A

amath.pl:

#!/usr/bin/perl -ap
1while++$\,$_=eval."+A",s/\B/$F[1]/g

단항으로 단계를 출력해도 괜찮다면이 35 바이트 버전이 더 잘 작동합니다.

#!/usr/bin/perl -lap
1while$\.=1,$_=eval,s/\B/$F[1]/g

수학, 105 94 바이트

암호.

{x,y}=(c=0;f//.a_:>(c++;t=o@@IntegerDigits@a);{t,c})&/.{{f->#1+#2,o->Plus},{f->#1#2,o->Times}}

용법.

x[81, 31]
(* {4, 2} *)

x[351, 14568]
(* {6, 3} *)

y[21, 111]
(* {8, 3} *)

y[136, 2356]
(* {0, 2} *)

설명.

두 기능 x과 ((+)의 경우) y((*)에 대해) 파라미터로 대체하여 동시에 생성되는 f과 o의

(c = 0;
 f //. a_ :> (c++; t = o@@ IntegerDigits@a);
 {t, c}
)&

적절한 값으로. 들면 x, f해진다 #1 + #2과 o된다 Plus; 왜냐하면 y그들은 각각 #1 #2과가된다 Times. x설명의 마지막 부분에 대한 기능 재 작성 :

x = (
  c = 0;
  #1 + #2 //. a_ :> (c++; t = Plus@@IntegerDigits@a); 
  {t, c}
) &;

(* The symbol //. stands for ReplaceRepeated. 
   The rule a_ :> (c++; t = Plus@@IntegerDigits@a) is applied until the result no longer 
changed. Specifically, the rule increments the counter of 1 at each step (this is c++), 
then takes the sum of the digits of the previous result (this is Plus@@IntegerDigits@a). 
The rule stops to apply when the variable t is less than 10. We return the final result and 
the number of steps with {t, c}. *)

자바 7, 203 195 192 바이트

int c=1;String c(long a,long b,int o){return p(((o<1?a+b:a*b)+"",o)+","+c;}long p(String n,int o){long x=o,q;for(String s:n.split("")){q=new Long(s);x=o<1?x+q:x*q}c++;return x<10?x:p(x+"",o);}

그것은 사용 long(2 최대 값 ⁶³ -1). int대신 사용하면 (최대 값 2 ³¹ -1) 1 바이트 만 줄입니다 ( 191 바이트 ).

int c=1;String c(int a,int b,int o){return p(((o<1?a+b:a*b)+"",o)+","+c;}int p(String n,int o){int x=o,q;for(String s:n.split("")){q=new Integer(s);x=o<1?x+q:x*q}c++;return x<10?x:p(x+"",o);}

골프를 조금 더 할 수 있습니다. 두 연산자 모두에 대한 답과 단계를 인쇄해야하는 경우 약간의 바이트가 필요
합니다. 0 (for (+)) 및 1 (for (*))을 사용합니다.

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

class Main{
  static int c = 1;
  static String c(long a, long b, int o){
    return p((o < 1 ? a+b : a*b) + "", o) + "," + c;
  }

  static long p(String n, int o){
    long x = o,
         q;
    for(String s : n.split("")){
      q = new Long(s);
      x = o < 1
           ? x + q
           : x * q;
    }
    c++;
    return x < 10
            ? x
            : p(x+"", o);
  }

  public static void main(String[] a){
    System.out.println(c(81, 31, true));
    c = 1;
    System.out.println(c(351, 14568, true));
    c = 1;
    System.out.println(c(21, 111, false));
    c = 1;
    System.out.println(c(136, 2356, false));
  }
}

산출:

4,2
6,3
8,3
0,2