ผู้ชนะ (ค่อนข้างชัดเจน) คือเดนนิส♦ผู้ใช้ Jelly ขนาด 10 ไบต์!

ความท้าทายนี้จะยังคงอยู่ที่นี่ แต่ผลลัพธ์จะไม่ได้รับอีกต่อไป

Powertrain ของตัวเลขเป็นแนวคิดโดย John Conway (ผู้ที่โดดเด่นในการทำเกมชีวิตของ Conway แต่นั่นไม่ใช่ประเด็น) มันถูกกำหนดไว้ดังนี้:

สำหรับหมายเลขใด ๆ... ระบบส่งกำลังของตัวเลขคือ... (เช่นทุกหลักที่ 2 จากซ้ายไปขวาคือกำลังของตัวเลขก่อนหน้านั้น) กระบวนการนี้ซ้ำจนกว่าผลลัพธ์จะเป็นตัวเลขหลักเดียว

ตัวอย่าง:

2592 => (2^5)(9^2) = 2592 <= Cannot be further decomposed 135 => (1^3)5 = 5 1234 => (1^2)(3^4) = 81 => (8^1) = 8 1100 => (1^1)(0^0) = 1 # (0^0) = 1 -42 => -42 # Negative numbers output the input

ความท้าทายของคุณคือสำหรับตัวเลขใด ๆnในอินพุตให้ส่งคืนpowertrain(n)(เช่นnหลังจากการย่อยสลายระบบส่งกำลังเสร็จ) เป็นเอาต์พุต

นี่คือรหัสกอล์ฟดังนั้นจำนวนไบต์ที่สั้นที่สุดจึงชนะ

การปฏิเสธความรับผิด-สิ่ง:

• คุณสามารถมีตัวเลขคี่ในอินพุต, หลักสุดท้ายก็จะไม่มีอำนาจ
• 0 ^ 0 คือ 1 เพราะถ้าเป็น 0 ดังนั้นจำนวนมากจะยุบเป็น 0 หรือ 1 ทันที
• หากหมายเลขนั้นไม่สามารถทำลายได้ในส่วนใด ๆ ของกระบวนการคำนวณ (เช่นถ้าสิ้นสุด2592) คุณก็สามารถส่งออกตัวเลขได้
• หากอินพุตคือ< 10(เช่นตัวเลขหลักเดียวและเนกาทีฟทั้งหมด) ให้ส่งสัญญาณอินพุต

ฉันอาจจะประกาศผู้ชนะหลังจากนั้นไม่กี่ชั่วโมงวัน

กระดานแต้มนำปัจจุบัน:

1. เยลลี่ ( เดนนิส♦ ): 10
2. Pyth ( DenkerAffe ): 16
3. MATL ( Don Muesli ): 21
4. Perl ( Ton Hospel ): 42
5. Haskell ( ดาเมียน ): 64
6. Javascript ES6 ( edc65 ): 71
7. Mathematica ( murphy ): 74
8. Mathematica ( LegionMammal978 ) และ Haskell ( Renzeee ): 77
9. Python 2 ( คณิตศาสตร์ ): 111
10. Python 3 ( Erwan ): 161
11. Java 8 ( สีน้ำเงิน ): 229
12. Oracle SQL 11.2 ( Jeto ): 456
13. Befunge '93 ( Lex ): 490

เยลลี่, 15 14 12 10 ไบต์

Ds2*/€Pµ³¡

ลองออนไลน์!

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

Ds2*/€Pµ³¡  Main link. Argument: n

D           Convert n into the array of its decimal digits.
 s2         Split into pairs of digits.
   */€      Reduce each pair by exponentiation.
      P     Take the product of the resulting powers.
       µ    Push the preceding chain as a link, and start a new one.
        ³¡  Execute the link n times and return the last result.

Haskell, 67 64 ไบต์

(>> = (==)) >> = จนกระทั่ง $ p.showเป็นฟังก์ชันที่ไม่มีชื่อซึ่งใช้จำนวนเต็มเป็นอินพุตและส่งคืนระบบส่งกำลัง

บันทึกแล้ว 3 ไบต์ขอบคุณ Zgarb

p(x:y:r)=p[x]^p[y]*p r;p[]=1;p x=read x
(>>=(==))>>=until$p.show

Perl, 42 48ไบต์

รวม +2 สำหรับ-lp(คุณสามารถดรอปได้-lด้วย แต่ฉันชอบการขึ้นบรรทัดใหม่)

เรียกใช้ด้วยอินพุตบน STDIN เช่น

perl -lp powertrain.pl <<< 1234

powertrain.pl:

s/\B/1&pos?"**":"*"/eg until++$.>($_=eval)

(สำหรับ perls รุ่นเก่าคุณสามารถวางช่องว่างระหว่าง regex และจนกว่า)

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

เวอร์ชันข้างต้นนั้นใช้งานได้จริง (อย่างมาก2592ลูป) สำหรับตัวเลขทั้งหมดที่ perl สามารถแสดงได้โดยไม่ต้องใช้สัญกรณ์แบบเอ็กซ์โปเนนเชียลเพราะมันพิสูจน์แล้วว่าไม่มีคะแนนคงที่ระหว่าง2592และ24547284284866560000000000( https://oeis.org/A135385 )

อย่างไรก็ตามสิ่งนี้ถือว่าบางสิ่งบางอย่างเป็นยังไม่พิสูจน์ ในหลักการอาจมีการลดลงที่ใช้เวลามากกว่าX=10^7ขั้นตอน (มันเป็นที่คาดเดาว่าไม่มีจุดไม่คงที่ใช้เวลามากกว่า 16 ขั้นตอนhttps://oeis.org/A133503 ) ที่มีค่าลดลงด้านล่างX(แต่ด้านบน10^7) แล้วขึ้นไป อีกครั้ง หากเป็นกรณีที่ฉันต้องถอยกลับไปที่:

s/\B/1&pos?"**":"*"/eg until$s{$_=eval}++||/-/

คำอธิบาย

รหัสทำงานโดยการใส่**และ*(สลับ) ระหว่างตัวเลข

s/\B/1&pos?"**":"*"/eg

เพื่อให้2592กลายเป็น2**5*9**2และจะกลายเป็น12345 1**2*3**4*5นี่เป็นนิพจน์ Perl ที่ถูกต้องที่สามารถประเมินผลได้

$_ = eval

( 0**0อยู่1ใน perl) จากนั้นก็ใส่วนรอบที่มีตัวนับที่ทำให้มันหมดอายุ เนื่องจากยกเว้นจุดคงที่ค่าจะลดลงอย่างรวดเร็วมากชุด powertrain ลู่เข้าหากันก่อนที่เคาน์เตอร์จะได้รับโอกาสที่จะได้ไปจริงๆ

Pyth, 25 18 11 16 ไบต์

?<Q0Qu*F^McjGT2Q

ลองที่นี่!

7 14 ไบต์บันทึกไว้ด้วยความช่วยเหลือจาก @Jakube

คำอธิบาย

? <Q0Qu * F ^ McjGT2Q # Q = eval (อินพุต)

? <Q0Q # ถ้าอินพุตเป็นผลตอบแทนติดลบ Q
     u Q # ใช้ฟังก์ชั่นต่อไปนี้จนกว่าเราจะถึงรอบ               
                   # ค่าเริ่มต้นคือ Q และค่าปัจจุบันอยู่ใน G
           jGT # แยกการป้อนข้อมูลลงในรายการของตัวเลข
          c 2 # แบ่งออกเป็นคู่ 2
        ^ M # คำนวณพลังงานสำหรับทุกคู่
      * F # คำนวณผลคูณของกำลังทั้งหมด

Python 2, 111 ไบต์

def p(n,b=0,o=''):
 if n<1:return n
 for c in str(n):o+=c+'**'[b:];b=~b
 j=eval(o+'1');return p(j)if j-n else j

ความคิดที่จะทำให้สตริงที่หลักที่nถูกแยกออกจากการดำเนินงานที่สลับกันระหว่าง*และ**แล้วevalว่าสตริง (โซลูชันอื่นใช้แนวคิดเดียวกันนี้ดูตัวอย่างคำตอบ Perl ของ Ton Hospel )

ดังนั้นการดำเนินการสลับไปมาระหว่าง'**'[0:]ซึ่งเป็น**และซึ่งเป็นเพียง'**'[-1:]*

อย่างไรก็ตามในตอนท้ายของfor-loop สตริงจะจบลงด้วยการดำเนินการ (อย่างใดอย่างหนึ่ง) ดังนั้นเราจึงต้องปล่อยการดำเนินการครั้งสุดท้ายหรืออื่นเพิ่มตัวเลขอื่นเพื่อให้สตริงเหมาะสม

โชคดีที่การ1ต่อท้ายจะทำงานไม่ว่าการดำเนินการใดจะเป็นครั้งสุดท้าย (หากคุณต้องการ1มันคืออัตลักษณ์ด้านเดียวจากด้านขวาสำหรับการคูณและการยกกำลังอีกวิธีหนึ่งในการพูดแบบนี้คือpowertrain(n) == powertrain(10*n + 1)สำหรับทุกคนn>0)

ในที่สุดหากผลลัพธ์ของสิ่งที่evalเกิดขึ้นเหมือนกับอินพุต (ใน1รอบความยาว) ฟังก์ชันจะสิ้นสุดลง มิฉะนั้นฟังก์ชันจะเรียกตัวเองตามผลลัพธ์ (มันจะแขวนตลอดไปในรอบความยาวใด ๆ> 1แต่ตามความคิดเห็นของ OP ฉันได้รับอนุญาตให้ถือว่าไม่มีรอบดังกล่าว)

(หมายเหตุ: คำอธิบายข้างต้นใช้ได้กับเลขจำนวนเต็มบวกหลักเดียวเนื่องจากอินพุตหลักเดียวnจะเสร็จสมบูรณ์n**1ซึ่งจะส่งผลให้ - 1รถจักรยานยนต์อย่างไรก็ตามเราต้องยอมรับอินพุตที่ไม่เป็นบวกดังนั้นจึงมีเงื่อนไขที่ เริ่มต้นลัดวงจรนั้นถ้าอินพุตน้อยกว่า1เราสามารถกำจัดบรรทัดนั้นและบันทึก 17 ไบต์หากอินพุตรับประกันว่าจะไม่เป็นลบ)

Java 8, 265 244 229 ไบต์

นี่เป็นคำตอบแรกของฉัน แต่ฉันได้อ่านเว็บไซต์นี้มาระยะหนึ่งแล้วและคิดว่าฉันรู้ว่าฉันกำลังทำอะไรอยู่ อย่างน้อยก็เต้นก่อนและ SQL ...

น่าเสียดายที่เช่นเดียวกับคำตอบอื่น ๆ อันนี้ใช้ไม่ได้กับ 24547284284866560000000000 เนื่องจากมีจาวาสร้างขึ้นในข้อ จำกัด เกี่ยวกับจำนวนเต็มขนาดใหญ่ที่จะได้รับ

บันทึกแล้ว 36 ไบต์ขอบคุณ @JackAmmo

public int p(int n){if(n<10)return n;int i=1,t=1,s=(int)Math.log10(n)+1,r[]=new int[s];for(;i<=s;){int a=(int)Math.pow(10,i);r[s-i++]=n%a/(a/10);}for(i=0;i<s-1;i++)t*=Math.pow(r[i],r[++i]);if(s%2==1)t*=r[s-1];return n==t?n:p(t);}

คำอธิบายที่ไม่ดี

public int powertrain(int input){
    //handles negative and 1-digit cases
    if(input<10)return input;
    //initialize output variable       
    int total=1;
    // get "length" of number. Shorter than getting length of string representation
    int size=(int)Math.log10(input)+1;
    //initialize array to store digits
    int[] array=new int[size];
    //Now, because Java doesn't have support
    // for the "**" operation, and the way of turning
    // an integer into a string takes too many bytes,
    // I decided just to put every digit into an array with
    // math and iterate from there
    for(int i=1;i<=size;){
        int place=(int)Math.pow(10,i);
        //crazy math. Saved 1 byte by incrementing i when accessed
        array[size-i++]=input%place/(place/10);
    }
    for(int i=0;i<size-1;i++)
        //This is where the train happens.
        //Saved 1 byte by incrementing while accessing 
        //again, instead of i+=2 and i+1
        total*=Math.pow(array[i],array[++i]);
    //Make sure last number isn't left out if size is odd
    if(size%2==1)
        total*=array[size-1];
    //if we end up with same number, stop.
    //otherwise, keep recurring
    return input==total?input:powertrain(total);
}

JavaScript (ES6) 71

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

f=n=>[...n+'1'].map((c,i)=>i&1?r*=Math.pow(d,c):d=c,r=1)&&n-r?f(r):n

ทดสอบ

f=n=>[...n+'1'].map((c,i)=>i&1?r*=Math.pow(d,c):d=c,r=1)&&n-r?f(r):n

function go()
{
  v=+I.value
  R.textContent=f(v)
}  

go()

<input id=I value="1234"><button onclick="go()">Go</button>
<span id=R></span>

Mathematica, 77 ไบต์

Times@@(If[#2<1,1,#^#2]&)@@@Partition[IntegerDigits@#,2,2,1,1]&~FixedPoint~#&

ฟังก์ชั่นไม่ระบุชื่อ ไม่ซับซ้อนเกินไป

Befunge 720 490 ไบต์

ไม่สามารถต้านทานที่จะทำอีกครั้งหนึ่งหลังจากที่ไม่เคยบอกฉันอัตราต่อรองสิ่งที่ ดังนั้นฉันจึงปรับ "ASCII-fier" ให้เหมาะสมกับหน้าที่แล้ว ในกรณีนี้ฉันไม่เห็นว่าต้องให้ตัวชี้คำสั่งวิ่งไปที่ตัวเลขเพื่ออ่านมันดังนั้นฉันจึงไม่ได้ใช้ความพยายามที่จะทำให้พวกมันอ่านง่าย ตอนนี้มันเป็นตัวแปลงจำนวนมากกว่าตอนนี้

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

v                                                    //top row is used for "variables"
>&:0`#v_.@                                           //initialize the counter                          
v     <                           g01_v#-p01:  <     //on our way back to the digitifier, check if we're done
>::>210p>55+%:10g0p-55+/:v            >10g.@         //digitifier, creates a series of ASCII characters at the top line, one for each digit in the source
        ^p01+1g01    _v#:<
v1$$                  <                              //forget some remainders of the digitifier, put 1 on the stack as a base of calculation
                      v p0-1g01-1g0-1g01*g0g01<      //taking powers of each pair of digit
>10g2-!#v_10g1-!#v_  1>                10g1-0g|
^                                  p01-2g01  *<
        >10g0g*  >                             ^     //extra multiplication with last digit if the number of digits was odd

รุ่นนี้ยังรองรับอินพุตเชิงลบ มันเป็นการปรับปรุงที่ดีเยี่ยมในเวอร์ชั่นก่อนหน้านี้ถ้าฉันพูดอย่างนั้น อย่างน้อย 1 ข้อผิดพลาดได้รับการแก้ไขและขนาดลดลงอย่างมาก

Haskell, 100 79 77 ไบต์

g x|x==h x=x|1<2=g$h x;h=i.map(read.(:[])).show;i[]=1;i[a]=a;i(a:b:c)=a^b*i c

ไม่เล่นกอล์ฟ:

g x|x==h x=x|1<2=g$h x
h=i.map(read.(:[])).show
i[]=1
i[a]=a
i(a:b:c)=a^b*i c

ฟังก์ชั่นนี้แยกอินพุตเป็นตัวเลขและใช้กลอุบายผ่าน iฟังก์ชั่นนี้แยกการป้อนข้อมูลลงในตัวเลขและไม่หลอกลวงผ่าน

แก้ไข: ขอบคุณ nimi สำหรับเคล็ดลับบางอย่าง

Mathematica, 74 ไบต์

0~f~0=f[]=1
f@n_=n
f[a_,b_,c___]:=f[c]a^b
#//.i_/;i>0:>f@@IntegerDigits@i&

คำอธิบาย

โซลูชันนี้ใช้ฟังก์ชันตัวช่วยfซึ่งใช้ตัวเลขของตัวเลขเป็นอาร์กิวเมนต์และใช้การวนซ้ำหนึ่งครั้งของการดำเนินการรถไฟพลัง บรรทัดสุดท้ายคือฟังก์ชั่นแท้ที่สร้างขึ้นเพื่อใช้ประโยชน์จากReplaceRepeatedฟังก์ชั่น (หรือ//.สั้น ๆ ) ซึ่งใช้กฎกับการแสดงออก (ในกรณีนี้อาร์กิวเมนต์#ของฟังก์ชั่นบริสุทธิ์) จนกว่ามันจะไม่เปลี่ยนแปลงอีกต่อไป กฎi_/;i>0:>f@@IntegerDigits@iจะแทนที่สิ่งที่ไม่เป็นลบด้วยฟังก์ชันที่fใช้กับตัวเลขทศนิยม

MATL , 21 ไบต์

tt0>*:"V!UtQgv9L2#)^p

อาจใช้เวลาสองสามวินาทีในการสร้างเอาต์พุต

แก้ไข (30 กรกฎาคม 2016): รหัสที่เชื่อมโยงแทนที่9Lด้วย1Lเพื่อปรับให้เข้ากับการเปลี่ยนแปลงล่าสุดในภาษา

ลองออนไลน์!

ใช้สองเทคนิคต่อไปนี้เพื่อลดจำนวนไบต์ที่มีค่าใช้จ่ายของประสิทธิภาพของรหัส:

• ทำซ้ำnครั้งแทนที่จะรอจนกว่าจะพบรอบ สิ่งนี้ยอมรับได้ตามความคิดเห็นของ OP
• สำหรับเลขคี่เลขตัวสุดท้าย1จะต้องมีการต่อท้ายเพื่อให้การใช้พลังงานขั้นสุดท้ายเสร็จสมบูรณ์ แทนที่จะเป็นเช่นนั้นจำนวนที่เพิ่ม1คือจำนวนหลัก สิ่งนี้ทำให้มั่นใจได้ถึงจำนวนคู่ดังนั้นการใช้พลังงานทั้งหมดสามารถทำได้ (แม้ว่าสุดท้ายจะเป็นการ1^1ดำเนินการที่ไม่จำเป็น)

รหัส:

t         % implicitly take input x. Duplicate
t0>*      % duplicate. Is it greater than 0? Multiply. This gives 0 if input is negative,
          % or leaves the input unchanged otherwise
:         % Generate array [1,2,...,x]
"         % for each (repeat x times)
  V       %   convert x to string
  !       %   transpose into column char array
  U       %   convert each char into number
  tQg     %   duplicate. Add 1 so that no entry is zero. Convert to logical: gives ones
  v       %   concatenate vertically
  9L2#)   %   separate odd-indexed and even-indexed entries
  ^       %   element-wise power
  p       %   product of all entries
          % implicitly end for each
          % implicitly display

Python 3, 169 161 ไบต์

def f(s):
 o=[['1',s]['-'in s]]
 while s not in o:
  o+=[s];s+='1'*(len(s)%2==1);r=1;
  for i,j in zip(s[::2],s[1::2]):r*=int(i)**int(j);s=str(r);
 return o[-1]

Ungoldfed

def f(s):
 o=[['1',s]['-'in s]]
 while s not in o:
  o+=[s]
  s+='1'*(len(s)%2==1)
  r=1
  for i,j in zip(s[::2],s[1::2]):
   r*=int(i)**int(j)
  s=str(r)
 return o[-1]

ผล

>>> [f(i) for i in ['135', '1234', '642', '2592', '-15']]
['5', '8', '2592', '2592', '-15']

Oracle SQL 11.2, 456 ไบต์

WITH v(n,c,i,f,t)AS(SELECT:1+0,CEIL(LENGTH(:1)/2),1,'1',0 FROM DUAL UNION ALL SELECT DECODE(SIGN(c-i+1),-1,t,n),DECODE(SIGN(c-i+1),-1,CEIL(LENGTH(t)/2),c),DECODE(SIGN(c-i+1),-1,1,i+1),DECODE(SIGN(c-i+1),-1,'1',RTRIM(f||'*'||NVL(POWER(SUBSTR(n,i*2-1,1),SUBSTR(n,i*2,1)),SUBSTR(n,i*2-1,1)),'*')),DECODE(SIGN(c-i+1),-1,0,TO_NUMBER(column_value))FROM v,XMLTABLE(f)WHERE i<=c+2 AND:1>9)CYCLE n,c,i,f,t SET s TO 1 DEFAULT 0SELECT NVL(SUM(n),:1) FROM v WHERE s=1;

ยกเลิกแข็งแรงเล่นกอล์ฟ

WITH v(n,c,i,f,t) AS
(
  SELECT :1+0,CEIL(LENGTH(:1)/2),1,'1',0 FROM DUAL
  UNION ALL
  SELECT DECODE(SIGN(c-i+1),-1,t,n),
         DECODE(SIGN(c-i+1),-1,CEIL(LENGTH(t)/2),c),
         DECODE(SIGN(c-i+1),-1,1,i+1),
         DECODE(SIGN(c-i+1),-1,'1',RTRIM(f||'*'||NVL(POWER(SUBSTR(n,i*2-1,1),SUBSTR(n,i*2,1)),SUBSTR(n,i*2-1,1)),'*')),
         DECODE(SIGN(c-i+1),-1,0,TO_NUMBER(column_value))
  FROM v,XMLTABLE(f) WHERE i<=c+2 AND :1>9 
)  
CYCLE n,c,i,f,t SET s TO 1 DEFAULT 0
SELECT NVL(SUM(n),:1) FROM v WHERE s=1;

v คือมุมมองแบบเรียกซ้ำพารามิเตอร์คือ

n: ตัวเลขที่จะแบ่งเป็น 2 ส่วน

c: จำนวน 2 หลักส่วน

i: ส่วน 2 หลักปัจจุบันเพื่อคำนวณ

f: สตริงเชื่อมต่อพาวเวอร์ด้วย * เป็นตัวคั่น

t: การประเมินผลของ f

ถอดรหัสเพื่อสลับไปยังหมายเลขถัดไปเพื่อแยกและคำนวณเมื่อส่วนทั้งหมดของหมายเลขปัจจุบันเสร็จสิ้น

XMLTABLE (f) รับนิพจน์ที่ประเมินผลโดยใส่ผลลัพธ์ลงในคอลัมน์หลอก "column_value" มันเป็นรุ่น golfed ของhttp://tkyte.blogspot.fr/2010/04/evaluating-expression-like-calculator.html

CYCLE เป็น oracle build ในการตรวจจับรอบและใช้เป็นเงื่อนไขการออก

เนื่องจากผลลัพธ์สำหรับ: 1 <10 คือ: 1 และ v ไม่ส่งคืนแถวสำหรับกรณีเหล่านั้น SUM จึงบังคับให้แถวที่มีค่า NULL เป็นค่า NVL ส่งคืน: 1 เป็นผลลัพธ์หากแถวนั้นเป็นโมฆะ