Kazanan (oldukça açık bir şekilde) Jelly'i 10 byte kullanan Dennis ♦!

Bu meydan okuma hala burada devam edecek, ancak sonuç alınmayacak.

Bir sayının güç kaynağı, John Conway (Conway'in Yaşam Oyununu yapmakta da kayda değer olan bir kavramdır) ama mesele bu değil. Bu şekilde tanımlanır:

Herhangi bir sayı için ..., sayının güç ... (yani her 2. basamak, soldan sağa, ondan önceki hanenin gücüdür). Bu işlem, sonuç tek bir rakam olana kadar tekrar edilir.

ÖRNEKLER:

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

Buradaki zorluk, ngirişteki herhangi bir sayı için, çıktı olarak geri dönüş powertrain(n)(yani ngüç aktarım sistemi ayrışma bittikten sonra).

Bu kod golf, bu yüzden en az bayt miktarı kazanır.

REDDİ-ŞEYLER:

• Girişte tek sayıda rakam olabilir, son rakamın bir gücü olmaz.
• 0 ^ 0, 1 ise, eğer 0 ise, o zaman birçok sayı anında 0 veya 1'e düşecektir.
• Sayı, hesaplama işleminin herhangi bir yerinde (örneğin, sona ererse 2592) tahrip edilemezse , sadece sayıyı yazdırabilirsiniz.
• Giriş ise < 10(yani tüm tek haneli sayılar ve negatifler) girişi girin.

Muhtemelen birkaç saat sonra bir kazanan ilan edeceğim .

Güncel afiş:

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

Jöle, 15 14 12 10 bayt

Ds2*/€Pµ³¡

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

(>> = (==)) >> = $ p.show , girdi olarak bir tamsayı alan ve güç aktarımını döndüren adsız bir işlev olana kadar .

Zgarb sayesinde 3 bayt kurtarıldı

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

Perl, 42 48 bayt

İçin +2'yi ekle -lp(siz de bırakabilirsiniz -lancak yeni satırları severim)

STDIN'deki giriş ile çalıştırın, örn.

perl -lp powertrain.pl <<< 1234

powertrain.pl:

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

(eski perls'de, regex ile kadar arasındaki boşluğu bırakabilirsiniz)

Bu, sabit noktanın üstesinden gelemez 24547284284866560000000000ancak bu büyük bir değer yine de işe yaramaz çünkü perl, üstel notasyona geçmiştir.

Yukarıdaki sürüm aslında 2592perl'in üssel notasyon kullanmadan temsil edebileceği tüm sayılar için hızlı bir şekilde çalışacaktır (en fazla döngüde), 2592ve 24547284284866560000000000( https://oeis.org/A135385 ) arasında sabit bir nokta olmadığı kanıtlanmıştır.

Ancak bu henüz kanıtlanmamış bir şeyi varsayar. Prensip olarak, X=10^7adımdan daha fazla bir azalma olabilir (sabit olmayan bir noktanın 16 basamaktan daha fazla sürmediği, https://oeis.org/A133503 ) ve değeri aşağıya inen X(ancak yukarıda kalan 10^7) bir azalma olabilir. tekrar. Bu durumda geri dönmeliyim:

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

açıklama

Kod , rakamların arasına koyarak **ve koyarak*

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

öyle 2592olur 2**5*9**2ve 12345olur 1**2*3**4*5. Bunlar, değerlendirilebilecek geçerli perl ifadeleridir.

$_ = eval

( 0**0Olup 1perl'de). Sonra bunun etrafına bir döngü koyarak süresinin dolmasına neden olan bir sayaç koyun. Sabit noktalar haricinde, değerler son derece hızlı bir şekilde düştüğü için, güç aktarma serisi, sayaç gerçekten ilerlemek için bir şans almadan önce birleşir.

Pyth, 25 18 11 16 bayt

?<Q0Qu*F^McjGT2Q

Burada dene!

7 14 byte @Jakube yardımı ile kaydedildi

açıklama

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

? <Q0Q # Giriş negatifse Q dönüşü
     Q # Bir döngüye ulaşana kadar aşağıdaki işlevi uygulayın               
                   # başlangıç ​​değeri Q, mevcut değer G cinsinden
           jGT # girişi bir basamak listesine bölme
          c 2 # 2 çiftine bölünmüş
        ^ M # her çiftin gücünü hesapla
      * F # tüm güçlerin ürününü hesaplar

Python 2,111 bayt

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

Fikir ve rakam bir dize yapmaktır narasında alternatif işlemleri ile ayrılır *ve **ve sonra evaldize söyledi. (Diğer çözümler de aynı fikri kullanıyor; örneğin Ton Hospel'in Perl cevabına bakınız .)

Bu nedenle, işlem '**'[0:], olan **ve '**'[-1:]sadece olan arasında gidip gelir *.

Bununla birlikte, for-loop'un sonunda , dize bir işlemle (biri ya da diğeri) sona erer, bu nedenle dizgenin anlam kazanması için son işlemi bırakmamız ya da başka bir rakam eklememiz gerekir.

Neyse ki, sonuna bir ekleme, 1hangi işlemin sonuncusu olursa olsun işe yarayacak. (İsterseniz, 1çarpma ve üstelik için sağdan tek taraflı bir kimliktir. Bunu söylemenin başka bir yolu da powertrain(n) == powertrain(10*n + 1)herkes içindir) n>0.

Son olarak, sonucun evalgirişi (aynı uzunluk 1döngüsündeki gibi) girişle aynı olursa , fonksiyon sona erer. Aksi takdirde, işlev sonuçtan kendisini çağırır. (Herhangi bir uzunluk döngüsünde sonsuza dek askıda > 1kalır, ancak OP'nin yorumlarına göre böyle bir döngü olmadığını kabul etmeme izin verilir.)

(Not: Yukarıdaki açıklama tek basamaklı pozitif tamsayılar için geçerlidir, çünkü tek basamaklı bir giriş ntamamlanır ve n**1bunun için bir 1döngü sağlar. Ancak, pozitif olmayan girişi de kabul etmemiz gerekir. Girdiden daha az olursa kısa devrelere başlamak 1. Bu çizgiyi ortadan kaldırabiliriz ve eğer girişin negatif olmadığından emin olursak 17 byte tasarruf edebiliriz.)

Java 8, 265 244 229 bayt

Bu benim ilk cevabım ama bu siteyi bir süredir okudum ve ne yaptığımı bildiğimi düşünüyorum. En azından befunge ve SQL'i yeniyor ...

Ne yazık ki, diğer cevaplar gibi, bu da tamsayıların ne kadar büyük olabileceğine dair kısıtlamalar getirilmiş olan java'a bağlı olarak 24547284284866560000000000 için çalışmıyor.

@JackAmmo sayesinde 36 bayt kaydedildi

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

Ungolfed Açıklama

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

Bir tekrarlama bulunduğunda durduran bir özyinelemeli işlev. Bu, daha uzun döngüler için işe yaramadı (2 veya daha fazla değer tekrarı), ancak bunun en azından javascript sayı hassasiyetinin sınırlı aralığında (17 basamak) olamayacağı görülüyor.

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

Ölçek

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 bayt

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

Anonim işlev Çok karmaşık değil.

Befunge 720 490 bayt

Bana asla bir şey söylemediğinden sonra bir daha yapmak için direnemedim . Bu yüzden öncekinin “ASCII-fier” ını optimize ettim. Bu durumda, talimat göstergesinin rakamları okumak için okumaya gerek duymadığımı gördüm, bu yüzden onları okunabilir hale getirmek için çaba harcamamıştım. Yani şimdi daha çok bir sayısallaştırıcı var.

Yine, bir açıklama yapmak istiyorsanız, yorumlarda bana bildirin, bazı yararlı açıklamalar oluşturmaya çalışacağım. Kodu kopyalayarak tercümana yapıştırabilirsiniz . 24547284284866560000000000 örneğinin 0 çıktı verdiğini buldum, ancak bu, son adımlarda doğru değeri görüldüğünü açıkça görebildiğiniz için, ızgara üzerindeki bir noktadan bu kadar büyük bir değer elde etmekle ilgili bir sorun gibi görünüyor.

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

Bu sürüm ayrıca negatif girişi de destekler. Kendim söylersem, önceki sürümde büyük bir gelişme var. En az 1 hata giderildi ve boyut büyük ölçüde azaltıldı.

Haskell, 100 79 77 bayt

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

Golf değil:

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

Bu fonksiyon girişi rakamlara böler ve numarayı yapar i.

EDIT: Bazı ipuçları için nimi teşekkürler.

Mathematica, 74 bayt

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

açıklama

Bu çözüm f, sayının basamaklarını argüman olarak alan ve güç aktarma işleminin bir yinelemesini uygulayan bir yardımcı işlev kullanır . Son satır, bir ifadeye kural uygulayan (bu durumda saf fonksiyonun argümanı ) artık değişmeyene kadar ReplaceRepeated(veya //.kısaca) işlevden yararlanmak için hazırlanmış #saf bir işlevdir. Kural, i_/;i>0:>f@@IntegerDigits@inegatif olmayan her şeyi fondalık basamaklarına uygulanan işlevle değiştirir.

MATL , 21 bayt

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

Çıktının üretilmesi birkaç saniye sürebilir.

DÜZENLEME (2016 30 Temmuz): bağlantılı kod cümledeki 9Ltarafından 1Ldilinde son değişikliklere uyum sağlamak.

Çevrimiçi deneyin!

Bu, kod verimliliği pahasına bayt sayısını azaltmak için aşağıdaki iki numarayı kullanır:

• Bıkmadan nyerine bir döngü beklemenin kez bulunur. OP'nin yorumlarına göre bu kabul edilebilir.
• Tek sayıda basamak için 1, son güç işlemini tamamlamak için bir final eklenmelidir. Bunun yerine, eklenen 1sayı, hane sayısıdır. Bu eşit bir sayı sağlar, böylece tüm güç işlemleri yapılabilir (sonuncusu gereksiz 1^1işlem olsa bile ).

Kod:

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 bayt

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]

Sonuçlar

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

Oracle SQL 11.2, 456 bayt

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;

Un-golfed

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 özyinelemeli bir görünümdür, parametreler

n: 2 basamak parçaya bölünecek sayı

c: 2 basamaklı parça sayısı

i: hesaplanacak mevcut 2 hane bölümü

f: güçleri * ile ayırıcı olarak birleştiren dize

t: f değerlendirmesi

DECODE'ler, mevcut sayının tüm bölümleri tamamlandığında bölmek ve hesaplamak için bir sonraki sayıya geçer.

XMLTABLE (f), sonucu “column_value” sözde sütununa koyarak, değerlendirir ve değerlendirir. Bu bir golfed versiyonu http://tkyte.blogspot.fr/2010/04/evaluating-expression-like-calculator.html

CYCLE döngü tespiti için kehanet inşa ve çıkış koşulu olarak kullanılır.

Şu sonuç için: 1 <10: 1 ve v, bu durumlar için satır döndürmez, SUM değer olarak NULL olan bir satırı zorlar. NVL döndürür: satır boşsa sonuç olarak 1.