Pemenangnya (cukup jelas) adalah Dennis ♦, yang menggunakan Jelly dengan 10 byte!

Tantangan ini masih akan ada di sini, namun hasilnya tidak akan diambil lagi.

Kekuatan sebuah angka adalah konsep oleh John Conway (yang juga terkenal karena membuat Permainan Kehidupan Conway, tetapi bukan itu intinya). Ini didefinisikan sebagai:

Untuk angka apa pun ..., powertrain nomornya adalah ... (yaitu setiap digit ke-2, dari kiri ke kanan, adalah kekuatan digit sebelum itu). Proses ini diulang sampai hasilnya satu digit.

CONTOH:

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

Tantangan Anda adalah, untuk angka apa pun ndalam input, kembalikan powertrain(n)(yaitu nsetelah dekomposisi powertrain selesai) sebagai output.

Ini adalah kode golf, sehingga jumlah terpendek byte menang.

HAL-HAL DISCLAIMER:

• Anda dapat memiliki jumlah digit ganjil dalam input, digit terakhir tidak akan memiliki kekuatan.
• 0 ^ 0 adalah 1, karena jika itu 0, maka banyak angka akan langsung runtuh ke 0 atau 1.
• Jika angka tersebut tidak dapat dihancurkan di bagian mana pun dari proses perhitungan (mis. Jika berakhir dengan 2592), maka Anda dapat menampilkan nomor tersebut.
• Jika inputnya < 10(yaitu semua angka dan negatif satu digit), output input.

Saya mungkin akan mengumumkan pemenang setelah beberapa jam hari.

Papan peringkat saat ini:

1. Jelly ( Dennis ♦ ): 10
2. Pyth ( DenkerAffe ): 16
3. MATL ( Don Muesli ): 21
4. Perl ( Ton Hospel ): 42
5. Haskell ( Damien ): 64
6. Javascript ES6 ( edc65 ): 71
7. Mathematica ( murphy ): 74
8. Mathematica ( LegionMammal978 ) dan Haskell ( Renzeee ): 77
9. Python 2 ( mathmandan ): 111
10. Python 3 ( Erwan ): 161
11. Java 8 ( Biru ): 229
12. Oracle SQL 11.2 ( Jeto ): 456
13. Befunge '93 ( Lex ): 490

Jelly, 15 14 12 10 byte

Ds2*/€Pµ³¡

Cobalah online!

Bagaimana itu bekerja

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 byte

(>> = (==)) >> = hingga $ p.show adalah fungsi tanpa nama yang mengambil integer sebagai input dan mengembalikan powertrainnya.

Disimpan 3 byte berkat Zgarb

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

Perl, 42 48 byte

Sertakan +2 untuk -lp(Anda juga bisa menghapus -ltapi saya suka baris baru)

Jalankan dengan input pada STDIN, mis

perl -lp powertrain.pl <<< 1234

powertrain.pl:

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

(pada perl yang lebih lama Anda juga dapat menjatuhkan spasi antara regex dan sampai)

Ini tidak akan dapat menangani titik tetap 24547284284866560000000000tetapi nilai sebesar itu tidak akan bekerja karena pada saat itu perl beralih ke notasi eksponensial.

Versi di atas sebenarnya akan bekerja cepat (paling banyak 2592loop) untuk semua angka yang perl dapat wakili tanpa menggunakan notasi eksponensial karena terbukti tidak ada titik tetap antara 2592dan 24547284284866560000000000( https://oeis.org/A135385 )

Namun ini mengasumsikan sesuatu yang belum terbukti. Pada prinsipnya mungkin ada pengurangan yang membutuhkan lebih dari X=10^7langkah - langkah (diperkirakan bahwa tidak ada titik tidak-tetap mengambil lebih dari 16 langkah, https://oeis.org/A133503 ) yang nilainya turun di bawah X(tetapi di atas 10^7) dan kemudian naik lagi. Jika itu masalahnya saya harus kembali ke:

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

Penjelasan

Kode berfungsi dengan menempatkan **dan *(berganti-ganti) di antara digit

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

sehingga 2592menjadi 2**5*9**2dan 12345menjadi 1**2*3**4*5. Ini adalah ekspresi perl yang valid yang dapat dievaluasi dengan

$_ = eval

( 0**0Adalah 1di perl). Kemudian letakkan lingkaran di sekelilingnya dengan penghitung yang membuatnya kedaluwarsa. Karena kecuali untuk titik-titik tertentu, nilainya turun dengan sangat cepat, seri powertrain menyatu sebelum penghitung mendapat kesempatan untuk benar-benar berjalan

Pyth, 25 18 11 16 byte

?<Q0Qu*F^McjGT2Q

Coba di sini!

7 14 byte disimpan dengan bantuan dari @ Jakube

Penjelasan

? <Q0Qu * F ^ McjGT2Q # Q = eval (input)

? <Q0Q # Jika input negatif, pengembalian Q
     u Q # menerapkan fungsi berikut sampai kita mencapai satu siklus               
                   # nilai awal adalah Q dan nilai saat ini di G
           jGT # membagi input menjadi daftar digit
          c 2 # dibagi menjadi 2 pasangan
        ^ M # menghitung daya untuk setiap pasangan
      * F # menghitung produk dari semua kekuatan

Python 2, 111 byte

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

Idenya adalah untuk membuat string di mana digit ndipisahkan oleh operasi yang bergantian antara *dan **, dan kemudian evalstring itu. (Solusi lain menggunakan ide yang sama; lihat misalnya jawaban Ton Hospel's Perl .)

Jadi, operasi berganti-ganti antara '**'[0:], yang mana **, dan '**'[-1:]mana yang adil *.

Namun, pada akhir for-loop, string berakhir dengan operasi (satu atau yang lain), jadi kita harus menghentikan operasi terakhir, atau menambahkan digit lain, agar string masuk akal.

Untungnya, menambahkan huruf a 1pada akhirnya akan bekerja tidak peduli operasi mana yang terakhir. (Jika Anda suka, 1adalah identitas sepihak dari kanan, untuk penggandaan dan eksponensial. Cara lain untuk mengatakan ini adalah powertrain(n) == powertrain(10*n + 1)untuk semua n>0.)

Akhirnya, jika hasil evalkebetulan sama dengan input (seperti dalam 1siklus panjang), fungsi berakhir. Jika tidak, fungsi memanggil dirinya sendiri pada hasilnya. (Ini akan menggantung selamanya pada siklus panjang apa pun > 1, tetapi menurut komentar OP, saya diizinkan mengasumsikan tidak ada siklus seperti itu.)

(Catatan: penjelasan di atas berfungsi untuk bilangan bulat positif satu digit, karena input satu digit nakan selesai n**1yang akan menghasilkan 1siklus-. Namun, kami juga perlu menerima input non-positif, sehingga ada kondisi di memulai hubung-pendek itu jika inputnya kurang dari 1. Kita bisa menghilangkan garis itu, dan menghemat 17 byte, jika inputnya dijamin non-negatif.)

Java 8, 265 244 229 byte

Ini adalah jawaban pertama saya, tetapi saya telah membaca situs ini sebentar dan berpikir saya tahu apa yang saya lakukan. Setidaknya itu mengalahkan befunge dan SQL ...

Sayangnya, seperti jawaban lain, jawaban ini tidak berfungsi untuk 24547284284866560000000000 karena java'a bawaan pembatasan bagaimana bilangan bulat besar bisa didapat.

Disimpan 36 byte berkat @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);}

Penjelasan Tidak Dikunci

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

Fungsi rekursif, berhenti ketika pengulangan ditemukan. Ini tidak dapat bekerja untuk loop yang lebih lama (2 pengulangan nilai atau lebih) tetapi tampaknya ini tidak dapat terjadi, setidaknya dalam kisaran ketepatan jumlah javascript terbatas (17 digit)

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

Uji

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 byte

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

Fungsi anonim. Tidak terlalu rumit.

Melewati 720 490 byte

Tidak bisa menolak untuk melakukan satu lagi setelah Never tell me odds . Jadi, saya sudah mengoptimalkan "ASCII-fier" dari yang sebelumnya. Dalam hal ini saya melihat tidak perlu membiarkan penunjuk instruksi berjalan di atas angka untuk membacanya, jadi saya belum mengambil upaya untuk membuat mereka dapat dibaca manusia. Jadi sekarang lebih digitifier.

Sekali lagi, jika kalian ingin penjelasan, beri tahu saya di komentar, saya akan mencoba membuat beberapa deskripsi yang bermanfaat. Anda dapat menyalin rekatkan kode ke juru bahasa . Saya telah menemukan bahwa contoh 2454728428486656000000000000 menghasilkan 0, tetapi itu tampaknya menjadi masalah dengan mendapatkan nilai sebesar itu dari suatu titik di grid, karena Anda dapat dengan jelas melihat nilai yang benar disimpan dalam langkah-langkah terakhir.

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

Versi ini juga mendukung input negatif. Ini merupakan peningkatan besar pada versi sebelumnya, jika saya mengatakannya sendiri. Setidaknya 1 bug diperbaiki dan ukurannya sangat berkurang.

Haskell, 100 79 77 byte

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

Tidak golf:

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

Fungsi ini membagi input menjadi digit dan melakukan trik melalui i .

Sunting: Terima kasih kepada nimi untuk beberapa kiat.

Mathematica, 74 byte

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

Penjelasan

Solusi ini menggunakan fungsi helper f, yang mengambil digit nomor sebagai argumen dan menerapkan satu iterasi dari operasi power train. Baris terakhir adalah fungsi murni yang dibuat untuk mengeksploitasi ReplaceRepeatedfungsi (atau //.singkatnya), yang menerapkan aturan pada ekspresi (dalam hal ini argumen #fungsi murni) hingga tidak berubah lagi. Aturan ini i_/;i>0:>f@@IntegerDigits@imenggantikan apa pun yang tidak negatif dengan fungsi yang fditerapkan ke digit desimalnya.

MATL , 21 byte

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

Mungkin butuh beberapa detik untuk menghasilkan output.

EDIT (30 Juli 2016): kode tertaut menggantikan 9Ldengan 1Luntuk beradaptasi dengan perubahan terbaru dalam bahasa.

Cobalah online!

Ini menggunakan dua trik berikut untuk mengurangi jumlah byte dengan mengorbankan efisiensi kode:

• Ulangi nwaktu alih-alih menunggu hingga ditemukan siklus. Ini dapat diterima sesuai komentar OP.
• Untuk jumlah digit ganjil, final 1harus ditambahkan untuk menyelesaikan operasi daya final. Alih-alih itu, jumlah yang ditambahkan 1adalah jumlah digit. Ini memastikan angka genap, sehingga semua operasi daya dapat dilakukan (bahkan jika yang terakhir adalah 1^1operasi yang tidak perlu ).

Kode:

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 byte

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]

Hasil

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

Oracle SQL 11.2, 456 byte

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;

Tidak bermain golf

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 adalah tampilan rekursif, parameternya adalah

n: angka untuk dibagi menjadi 2 digit bagian

c: jumlah bagian 2 digit

i: bagian 2 digit saat ini untuk dihitung

f: string menyatukan kekuatan dengan * sebagai pemisah

t: evaluasi f

DECODEs beralih ke nomor berikutnya untuk dipecah dan dihitung ketika semua bagian dari angka saat ini selesai.

XMLTABLE (f) mengambil ekspresi dan mengevaluasinya, menempatkan hasilnya di kolom semu "column_value". Ini adalah versi golf dari http://tkyte.blogspot.fr/2010/04/evaluating-expression-like-calculator.html

CYCLE adalah build oracle dalam pendeteksian siklus dan digunakan sebagai kondisi keluar.

Karena hasil untuk: 1 <10 adalah: 1 dan v tidak mengembalikan baris untuk kasus tersebut, SUM memaksa baris dengan NULL sebagai nilainya. NVL mengembalikan: 1 sebagai hasilnya jika barisnya nol.