バックグラウンド：

現実の世界での基本的な加算や乗算などの標準演算は、次のように機能します。

12 + 123 = 135

そして

12 * 123 = 1476

それは面白くて退屈ではありません！多くの学校では、これをすでに公式アルゴリズムの実践、実践、実践として解釈しています。これは、かなり厳格で退屈な数学的食事を意味し、この課題で意図されているものではありません。私たちの最愛のサイトでいくつかの楽しみをする準備をしてください。

2つの正の整数を追加し、その結果のすべての数字を再度追加するプロセスを検討してください。1桁のみが取得されるまで、追加を繰り返します。例えば：

1. 結果12 + 123は135です。
2. 135のすべての数字を追加して取得し1 + 3 + 5 = 9ます。

この繰り返し加算で1桁の値9を取得するために必要なステップ数は2です。

前の加算プロセスと同様に、2つの正の整数の乗算は同じプロセスに従います。結果のすべての数字を乗算し、1桁だけが残るまでこのプロセスを繰り返します。上記の例を見てください。

1. 結果12 * 123は1476です。
2. 取得する1476のすべての数字を乗算します1 * 4 * 7 * 6 = 168。
3. 168のすべての桁を再度乗算します1 * 6 * 8 = 48。
4. 取得し4 * 8 = 32た48のすべての桁を再度乗算します。
5. 取得し3 * 2 = 6た32のすべての数字をもう一度乗算します。

この繰り返される乗算で1桁の値6を取得するために必要なステップ数は5です。

この挑戦の酒と数学表記の誤用を避けるために、私はこれらの2つのダミーの表記を導入：(+)そして(*)、あなたはあなたが好きな表記を使用する以下のように、仕事を：

1. 単一の値を取得するための繰り返し加算プロセスの操作は12 (+) 123 = 9です。
2. 単一の値を取得するために繰り返される乗算プロセスの操作は12 (*) 123 = 6です。

チャレンジ：

課題は、実行可能なプログラムまたは機能のいずれか書くことにある操作の両方を背景技術の項で説明したように：(+)および(*)。

入力：

プログラムまたは関数の入力は、2つの正の整数と1つの演算で、(+)とのいずれか(*)です。入力の形式は、プログラマーの任意の選択です。たとえば、入力をフォーマットするa (+) bか、F(a, (+), b)または任意のフォーマットを使用できます。

出力：

プログラムまたは関数の出力には、操作の結果と、必要に応じてフリースタイル形式で必要なステップ数が含まれている必要があります。

テストケース（入力および出力形式を無視）：

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

一般的なルール：

• これはcode-golfであるため、バイト単位の最短回答が課題に勝ちます。
  esolangが通常の言語で回答を投稿することを妨げないようにしてください。プログラミング言語で可能な限り短い回答を提供することにより、この課題をお楽しみください。賢明な回答と明確な説明を投稿すると、使用するプログラミング言語に関係なく、回答が高く評価されます（したがって、賛成票になります）。
• 回答には標準ルールが適用されるため、STDIN / STDOUT、適切なパラメーターを使用した関数/メソッド、完全なプログラムなどを使用できます。選択はユーザー次第です。
• 可能であれば、プログラムは大きな数値を適切に処理できます。そうでない場合は、それで十分です。

ゲームを始めましょう！！

Dyalog APL、33 32 30 29 バイト

これにより、APLが拡張され、プレフィックス表記+/A n₁ n₂とが含まれます×/A n₁ n₂。（実際、の左側の任意の操作を使用でき/Aます。）{result、repeat count}のリストを返します。

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

A←{左辺関数、および右辺引数の観点から高階関数を定義する⍺⍺⍵

(⊃,≢) の最初の要素とそれに続くカウント

⍺⍺{高階関数に供給される提供された関数（+/和または×/積）

∪ のユニークな要素

⍵,⍨ に追加される引数

⍺⍺ 与えられた関数

⍎¨ の各文字の評価

⍕ の文字表現

⊃⍵ 引数の最初の要素

}⍣≡ 結果が引数と同じになるまで繰り返し適用され、

⍺⍺⍵元の引数に適用された元の供給関数（+/または×/）

} [高階関数定義の終わり]

TryAPLオンライン！（セキュリティ上の理由で⍎エミュレートされていeます。）

バイトを保存してくれた@ngnに感謝します。

0バイト（jest内）

Dyalog APLは、実際にアナスタシヤンの数学を完全にサポートしています。(+)andの代わりにand (×)を使用+{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/⍎¨⍕⍵}⍣=⍵⍺⍺⍨⍺}し×{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/⍎¨⍕⍵}⍣=⍵⍺⍺⍨⍺}ます。

試してみてください81 +{(⊃,≢)⍺⍺{∪⍵,⍨⍺⍺e¨⍕⊃⍵}⍣≡⍺⍺/⍺⍵} 31と21 ×{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/e¨⍕⍵}⍣=⍵⍺⍺⍨⍺} 111。

Haskell、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となる関数を定義します。楽しい事実：これは、任意の演算子（実際には、任意の関数）で機能します！bo

パイク、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ます。2つの数値入力はコンマで区切られます。

JavaScript（ES6）、59

再帰関数。入力形式は、再帰呼び出しを簡素化するように調整されています。

• 演算子：「+」または「*」
• オペランド：2つの値の配列

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

Python 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でテストします。

Pyth、16

eJ.uvjhQ`N.vQ)lJ

"+ 123 12"加算や"* 123 12"乗算のような入力を受け取ります。のような出力result<linefeed>steps。

ここで試してみるか、テストスイートを実行しますが、これはevalに依存しているため、追加のバリアントのみがオンラインインタープリターで機能することに注意してください。乗算は、オフラインインタープリターで正しく機能します。

これは、累積リダクション関数を使用して中間結果のリストを作成するため、"+ 351 14568"取得し[14919, 24, 6]ます。これは、1桁の数字がアナスタシアの加算および乗算の固定小数点であるため機能します。次に、配列の最後の要素と配列の長さを取得します。

これは、少なくともメモリが不足するまで、任意の大きな数に対して機能します。

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バイト）に準拠していない場合、最初にレジスタをスタックする必要がないため、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

2つの改行、スペースを削除し、別々の引数ではなくベクトルに両方の入力番号を配置しました。これにより、pajonkのおかげで9バイトが節約されました！k=@(x)...ビーカー=）のおかげでさらに11バイトを節約するために削除されました最後に、さらに9バイトを節約するためにすべてをOctaveに変換しました...

Javaの、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です

2番目の引数はメソッドで、ADDの場合は0、MULTIPLYの場合は1です。

3番目の引数は、加算/乗算する値を含む文字列の配列です。

非ゴルフ

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、これはアナスタシヤ積を計算しますx (*) y。

出力はとして与えられます[number of steps, result]。

Python、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+12or 5*35（通常の記号+と*記号）の形式であり、これらが2つの演算子のみであると想定しています。

お使いのコンピューターのメモリが許す限り大きな数値入力を処理できます。

私は、これがさらに大きくなることをほぼ確実に確信しています。

編集： @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

編集：私は数えられない。

Clojure 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)

コードは次のとおりです。

(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は私にとってまだ新しいので、これはおそらく最良の解決策ではないことに留意してください。挑戦はすべて楽しかったです。さらに、コードは非常に大きな数で問題なく実行されました。

Perl 6 53バイト

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

以来( 12, &[+], 123 )入力のために許容され、私は53バイトにそれを得ることができます。
（&[+]短縮形&infix:<+>は数値中置加算演算子に対する「敬意」です）

2番目の引数を文字列(+)にする必要がある場合、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)

Python 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)

第1オペランドa、演算子o（'+'または'*'）、および第2オペランドの引数を介して入力を受け取り、次bの形式のリストを返す無名関数[result, steps]。

使い方

無名関数は、オペランドと演算子を連結して文字列を作成し、評価します。これは質問で説明されている最初のステップです。次に、この値と演算子が再帰関数に渡されますg。ここでは、i再帰呼び出しごとに増分されるcounter が使用されます。入力が未満の場合10、1桁に達している必要があるため、これiが返されます。そうでない場合、入力は文字列に変換され、この文字列内の各文字が演算子と結合されて、目的の計算が行われ、評価されて再帰的に関数に渡されます。

Ideoneでお試しください

Groovy、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]

Haskell、76 70バイト

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

結果とステップ数を含む2要素リストを返します。任意の大きな数で動作します。使用例：(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出力を行う代わりに、でベクトルとして返しcます。2バイトを保存するだけでなく、出力がベクトルに強制されるという事実によりT、クラスが確実にクラスになりnumericます。を使用しcat、Tインクリメントされていない場合、のような誤った出力が得られます1 TRUE。

Ruby、55バイト

再帰呼び出し。以前は@ edc65のJavaScriptの回答とは非常に異なっていましたが、最適化すると、最終的には回答からほとんど独立して開発された直接ポートになりました。 、バイトカウントを超えることができました。

入力は、演算子を表す文字列、およびオペランドを含む配列です。

オンラインでお試しください。

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

Perl、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

Mathematica、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}. *)

Java 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（のために使用します(+)）と1（のために(*)）。

未ゴルフ＆テストコード：

ここで試してみてください。

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