พื้นหลัง:

คณิตศาสตร์การดำเนินงานมาตรฐานเช่นการบวกพื้นฐานและการคูณในโลกแห่งความเป็นจริงการทำงานเช่นนี้:

12 + 123 = 135

และ

12 * 123 = 1476

นั่นไม่น่าสนใจและน่าเบื่อ! โรงเรียนหลายแห่งกำลังตีความสิ่งนี้เป็นแบบฝึกหัดฝึกฝนแบบฝึกหัดที่เป็นทางการ นั่นหมายถึงอาหารทางคณิตศาสตร์ที่แข็งและน่าเบื่อและไม่ใช่สิ่งที่มีไว้สำหรับความท้าทายนี้ เตรียมพร้อมที่จะเล่นสนุก ๆ กับไซต์ที่เราชื่นชอบ

พิจารณากระบวนการเพิ่มตัวเลขจำนวนเต็มบวกสองตัวจากนั้นเพิ่มตัวเลขทั้งหมดของผลลัพธ์อีกครั้ง ทำซ้ำด้วยการเพิ่มจนกว่าจะมีเพียงตัวเลขเดียวเท่านั้น ตัวอย่างเช่น:

1. ผลลัพธ์ของ12 + 123คือ 135
2. 1 + 3 + 5 = 9การเพิ่มตัวเลขทั้งหมดของเราได้รับ 135

จำนวนขั้นตอนที่จำเป็นในการรับค่าตัวเลขหลักเดียว 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 (+) bF(a, (+), b)

เอาท์พุท:

ผลลัพธ์ของโปรแกรมหรือฟังก์ชั่นจะต้องมีผลการดำเนินงานและจำนวนขั้นตอนที่จำเป็นต้องใช้ในรูปแบบฟรีสไตล์ตามที่คุณต้องการ

กรณีทดสอบ (ละเว้นรูปแบบอินพุตและเอาต์พุต):

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

กฎทั่วไป:

• นี่คือรหัสกอล์ฟดังนั้นคำตอบสั้น ๆ เป็นไบต์จะเป็นผู้ชนะ
  อย่าปล่อยให้ esolang กีดกันคุณจากการโพสต์คำตอบด้วยภาษาปกติ สนุกกับความท้าทายนี้ด้วยการให้คำตอบสั้น ๆ กับภาษาโปรแกรมของคุณ หากคุณโพสต์คำตอบที่ฉลาดและคำอธิบายที่ชัดเจนคำตอบของคุณจะได้รับการชื่นชม (ดังนั้น upvotes) โดยไม่คำนึงถึงภาษาการเขียนโปรแกรมที่คุณใช้
• กฎมาตรฐานจะใช้สำหรับคำตอบของคุณดังนั้นคุณจึงได้รับอนุญาตให้ใช้ STDIN / STDOUT ฟังก์ชั่น / วิธีด้วยพารามิเตอร์ที่เหมาะสมโปรแกรมเต็มรูปแบบและอื่น ๆ ทางเลือกเป็นของคุณ
• ถ้าเป็นไปได้โปรแกรมของคุณสามารถจัดการกับจำนวนมากได้อย่างเหมาะสม ถ้าไม่เช่นนั้นจะไม่เป็นไร

ให้เกมเริ่มต้น !!

Dyalog APL , 33 32 30 29 ไบต์

เรื่องนี้ต้องขยาย APL จะรวมคำนำหน้าสัญกรณ์และ+/A n₁ n₂ ×/A n₁ n₂(อันที่จริงแล้วคุณสามารถใช้การดำเนินการใด ๆ ทางด้านซ้ายของ/A.) ส่งคืนรายการ {ผลลัพธ์จำนวนการทำซ้ำ}

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

A←{กำหนดฟังก์ชันลำดับสูงกว่าในแง่ของฟังก์ชั่น⍺⍺ซ้ายและอาร์กิวเมนต์ขวา⍵

(⊃,≢) องค์ประกอบแรกของตามด้วยจำนวน

⍺⍺{ฟังก์ชั่นที่ให้มา ( +/สำหรับผลรวมหรือ×/ผลิตภัณฑ์) ที่ป้อนเข้ากับฟังก์ชันการสั่งซื้อที่สูงขึ้น

∪ องค์ประกอบที่เป็นเอกลักษณ์ของ

⍵,⍨ อาร์กิวเมนต์ต่อท้าย

⍺⍺ ฟังก์ชั่นที่เลี้ยงนำไปใช้กับ

⍎¨ การประเมินผลของตัวละครแต่ละตัวของ

⍕ การแสดงตัวอักษรของ

⊃⍵ องค์ประกอบแรกของการโต้แย้ง

}⍣≡ ใช้ซ้ำ ๆ จนกว่าผลลัพธ์จะเหมือนกับอาร์กิวเมนต์เริ่มต้นด้วย

⍺⍺⍵ฟังก์ชั่นที่เลี้ยงเดิม ( +/หรือ×/) นำไปใช้กับข้อโต้แย้งเดิม

} [สิ้นสุดคำจำกัดความของฟังก์ชันลำดับสูงกว่า]

ลองใช้ออนไลน์! ( ⍎ถูกจำลองด้วยeเหตุผลด้านความปลอดภัย)

ขอบคุณ @ngn สำหรับการบันทึกไบต์

0 ไบต์ (ตลก)

Dyalog APL ได้รับการสนับสนุนอย่างเต็มที่สำหรับคณิตศาสตร์ Anastasiyan แล้ว แทน(+)และ(×)จะใช้และ+{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/⍎¨⍕⍵}⍣=⍵⍺⍺⍨⍺}×{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/⍎¨⍕⍵}⍣=⍵⍺⍺⍨⍺}

ลองและ81 +{(⊃,≢)⍺⍺{∪⍵,⍨⍺⍺e¨⍕⊃⍵}⍣≡⍺⍺/⍺⍵} 3121 ×{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และแล้วผู้ประกอบการb oความจริงแล้วสนุก: มันใช้ได้กับโอเปอร์เรเตอร์ใด ๆ (จริงๆแล้วฟังก์ชั่นใด ๆ ) ที่คุณต้องการ

Pyke ขนาด 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อินพุตตัวเลขสองตัวคั่นด้วยเครื่องหมายจุลภาค

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

Python 2, 60 ไบต์

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

การป้อนข้อมูลเป็นสตริงเช่น81+31การส่งออกเป็น tuple ของสตริงเดี่ยวและเคาน์เตอร์ ('4', 2)(เช่น

ทดสอบบนIdeone

Pyth, 16

eJ.uvjhQ`N.vQ)lJ

ใช้อินพุตเหมือน"+ 123 12"เพื่อเพิ่มและ"* 123 12"สำหรับการคูณ result<linefeed>stepsเอาท์พุทเช่น

ลองที่นี่หรือเรียกใช้ชุดทดสอบแต่โปรดทราบว่านี่ขึ้นอยู่กับการประเมินดังนั้นเฉพาะตัวแปรเพิ่มเติมเท่านั้นที่จะทำงานได้ในล่ามออนไลน์ การคูณจะทำงานได้อย่างถูกต้องกับล่ามออฟไลน์

นี้จะใช้ฟังก์ชั่นการลดการสะสมเพื่อสร้างรายการของผลกลางดังนั้นสำหรับการที่เราได้รับ"+ 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)}

Ungolfed:

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กลับมา ! ใช่!
nop

การใช้งาน:

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

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

ขอบคุณมากที่@plannapusสำหรับการเล่นกอล์ฟ24ไบต์!
-7ไบต์ขอบคุณความคิดที่ดีจาก@Vlo !

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 ไบต์

การถ่ายโอนข้อมูล Hex:

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 ซึ่งเป็นการเข้ารหัสคำสั่งที่มีความยาวผันแปร (2 หรือ 4 ไบต์) สำหรับ ARM 32 บิต ดังนั้นค่าสูงสุดที่สามารถประมวลผลได้คือ 2 ^ 32-1 อาจลดลง 2 ไบต์หากไม่เป็นไปตาม AAPCS ( 46 ไบต์ ) เนื่องจากเราไม่ต้องลงทะเบียนกองซ้อนในตอนเริ่มต้น

ชุดประกอบ Ungolfed (ไวยากรณ์ของ 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 chars

แนวทางที่แตกต่างจาก@ 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

ลบบรรทัดใหม่สองบรรทัดช่องว่างและวางทั้งสองหมายเลขอินพุตในเวกเตอร์แทนอาร์กิวเมนต์ที่แยกกัน บันทึกไปแล้ว 9 ไบต์ขอบคุณ pajonk! ลบออกk=@(x)...เพื่อบันทึกอีก 11 ไบต์ขอบคุณ beaker =) ในที่สุดแปลสิ่งทั้งหมดเป็นอ็อกเทฟเพื่อบันทึกอีก 9 ไบต์ ...

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 เสมอ

อาร์กิวเมนต์ที่สองคือเมธอด 0 สำหรับ ADD และ 1 สำหรับ MULTIPLY

อาร์กิวเมนต์ที่สามคืออาร์เรย์ของ Strings ซึ่งมีค่าที่จะเพิ่ม / ทวีคูณ

Ungolfed

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 สำหรับการตัดสักสองสามไบต์

ขอบคุณ @milk สำหรับการโกน 5 ไบต์

โปรแกรมทดสอบ

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 Anastasiyax (+) y

ข้อโต้แย้งได้รับชอบนี้คำนวณสินค้าx y 0 Anastasiyax (*) 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+12หรือ5*35(ที่มีปกติ+และ*สัญญาณ) และถือว่าเป็นเพียงสองตัวดำเนินการ

สามารถจัดการอินพุตที่มีขนาดใหญ่เท่าที่หน่วยความจำของคอมพิวเตอร์อนุญาต

ฉันเกือบจะมั่นใจอย่างแน่นอนว่าสิ่งนี้จะเป็นไปได้อีก

แก้ไข: 16 31 ไบต์บันทึกขอบคุณ @Copper

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)

นี่คือรหัส 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 ยังเป็นสิ่งใหม่สำหรับฉันดังนั้นนี่จึงไม่ใช่ทางออกที่ดีที่สุด ความท้าทายก็สนุกเหมือนกันทั้งหมด นอกจากนี้โค้ดยังรันด้วยตัวเลขที่มีขนาดใหญ่มากโดยไม่มีปัญหาใด ๆ

Perl 6 53 ไบต์

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

เนื่องจาก( 12, &[+], 123 )เป็นที่ยอมรับสำหรับอินพุตฉันสามารถลดขนาดลงเป็น 53 ไบต์
( &[+]ย่อมา&infix:<+>จากคำว่า "reverence" ของโอเปอเรเตอร์การเติมตัวเลข)

ถ้าอาร์กิวเมนต์ที่สองต้องเป็นสตริง(+)มันจะเป็น 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)

ฟังก์ชั่นที่ไม่ระบุชื่อที่ใช้เวลาการป้อนข้อมูลผ่านทางโต้แย้งของตัวถูกดำเนินการครั้งแรกaเป็นผู้ดำเนินการo( '+'หรือ'*') และถูกดำเนินการที่สองและส่งกลับรายการของรูปแบบb[result, steps]

มันทำงานอย่างไร

ฟังก์ชั่นที่ไม่ระบุชื่อสร้างสตริงโดยเชื่อมต่อตัวถูกดำเนินการกับตัวดำเนินการระหว่างพวกเขาแล้วประเมินมัน; นี่เป็นขั้นตอนแรกที่อธิบายไว้ในคำถาม จากนั้นค่านี้และโอเปอเรเตอร์จะถูกส่งไปยังฟังก์ชันเวียนgเกิด ที่นี่ตัวนับiซึ่งเพิ่มขึ้นสำหรับการโทรซ้ำทุกครั้งจะถูกใช้ หากอินพุตมีค่าน้อยกว่า10จะต้องมีตัวเลขหลักเดียวดังนั้นจึง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]}

Degolfed

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: รายการตัวถูกดำเนินการแต่ละตัวถูกดำเนินการเป็นวัตถุสตริง
• e: องค์ประกอบของdแต่ละส่วนถูกแปลงเป็นจำนวนเต็ม
• r: ผลรวมหรือผลิตภัณฑ์ของeขึ้นอยู่กับการดำเนินการm
• คำชี้แจงผลเริ่มต้นด้วยr > 9:
  • หากหลายหลัก ( r > 9), reinvoke, การเพิ่มความลึก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]

ส่งคืนรายการองค์ประกอบสองรายการพร้อมผลลัพธ์และจำนวนขั้นตอน ทำงานสำหรับจำนวนมากโดยพลการ ตัวอย่างการใช้งาน: ->(351#14568)(+)[6,3]

แก้ไข: ขอบคุณ @BlackCap เป็นเวลา 6 ไบต์

R, 91 ไบต์

ใช้รหัสของ @ Vlo ซึ่งใช้ประโยชน์จากตัวแยกสัญญาณของ @ plannapus และความคิดบางอย่างที่ฉันสร้างขึ้นขณะเล่นกอล์ฟกับคำตอบของ @ 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เราพึ่งพาอาร์กิวเมนต์อินพุตเป็นฟังก์ชันและเรียกมันอย่างชัดเจน (Yay สำหรับฟังก์ชั่นเป็นวัตถุชั้นหนึ่ง!)
2. แทนการเริ่มต้นตัวแปรใหม่เป็นตัวนับของเราเราใช้ builtins และการใช้งานของ R Tซึ่งประเมินTRUE(หรือที่รู้จัก1) แต่เนื่องจากไม่ใช่ตัวแปรที่สงวนไว้เราจึงสามารถแก้ไขได้ ดังนั้นจึงเป็นT+T 2ดังนั้นเราจึงใช้มันเป็นตัวนับของเรา
3. แทนที่จะไอเอ็นจีส่งออกเราก็กลับมาเป็นเวกเตอร์ด้วยcat cเช่นเดียวกับการประหยัดสองไบต์ความจริงที่ว่าการส่งออกจะถูกบังคับให้เป็นเวกเตอร์เพื่อให้แน่ใจว่าเป็นของชั้นT numericหากเราใช้catและTไม่ได้เพิ่มขึ้นเราก็จะได้ผลลัพธ์ที่ผิดพลาดเช่น1 TRUEนี้

Ruby, 55 ไบต์

โทรซ้ำ เคยแตกต่างจากคำตอบ JavaScript ของ @ edc65 แต่เมื่อฉันปรับให้เหมาะสมที่สุดในที่สุดก็กลายเป็นพอร์ตโดยตรงที่พัฒนาขึ้นโดยอิสระจากคำตอบของพวกเขาลบหนึ่งการเพิ่มประสิทธิภาพสุดท้ายที่เกี่ยวข้องกับการตรวจสอบผลลัพธ์ eval'ed แทนความยาวของรายการตัวถูกดำเนินการ ซึ่งทำให้ฉันเกินจำนวนไบต์ของพวกเขา

อินพุตคือสตริงที่แทนโอเปอเรเตอร์และอาร์เรย์ที่มีตัวถูกดำเนินการ

ลองออนไลน์

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 (สำหรับ(*))

Ungolfed & รหัสการทดสอบ:

ลองที่นี่

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