Zwycięzcą (oczywiście) jest Dennis ♦, który użył Galaretki z 10 bajtami!

To wyzwanie będzie nadal aktualne, ale wyniki nie będą już brane.

Układ napędowy liczby jest konceptem Johna Conwaya (który jest również znany z tworzenia Gry życia Conwaya, ale nie o to chodzi). Jest tak zdefiniowany:

Dla dowolnej liczby ... układ napędowy liczby to ... (tj. Każda druga cyfra, od lewej do prawej, jest potęgą cyfry wcześniej). Proces ten powtarza się, aż wynikiem będzie jedna cyfra.

PRZYKŁADY:

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

Twoim wyzwaniem jest, dla dowolnej liczby nna wejściu, powrót powertrain(n)(tj. nPo zakończeniu rozkładu układu napędowego) jako wynik.

To jest kod golfowy, więc wygrywa najmniejsza ilość bajtów.

ZRZECZENIE SIĘ:

• Możesz mieć nieparzystą liczbę cyfr na wejściu, ostatnia cyfra po prostu nie będzie miała mocy.
• 0 ^ 0 to 1, ponieważ gdyby było 0, wiele liczb natychmiast zwinąłoby się do 0 lub 1.
• Jeśli liczba jest niezniszczalna w jakiejkolwiek części procesu obliczeniowego (np. Jeśli się skończy 2592), możesz po prostu wyprowadzić liczbę.
• Jeśli dane wejściowe to < 10(tzn. Wszystkie liczby jednocyfrowe i liczby ujemne), wyślij dane wejściowe.

Prawdopodobnie ogłoszę zwycięzcę po kilku godzinach .

Aktualny ranking:

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

Galaretka, 15 14 12 10 bajtów

Ds2*/€Pµ³¡

Wypróbuj online!

Jak to działa

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 bajtów

(>> = (==)) >> = dopóki $ p.show jest nienazwaną funkcją przyjmującą liczbę całkowitą jako dane wejściowe i zwracającą swój zespół napędowy.

Zaoszczędź 3 bajty dzięki Zgarbowi

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

Perl, 42 48 bajtów

Dodaj +2 do -lp(możesz też upuścić, -lale lubię nowe wiersze)

Uruchom z wejściem na STDIN, np

perl -lp powertrain.pl <<< 1234

powertrain.pl:

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

(na starszych perlach możesz także upuścić przestrzeń między wyrażeniem regularnym i do)

To nie będzie w stanie obsłużyć stałego punktu, 24547284284866560000000000ale tak duża wartość i tak nie będzie działać, ponieważ do tego czasu perl przeszedł na notację wykładniczą.

Powyższa wersja działa w rzeczywistości szybko (co najwyżej 2592pętle) dla wszystkich liczb, które Perl może reprezentować bez użycia wykładniczej notacji, ponieważ udowodniono, że nie ma stałych punktów między 2592i 24547284284866560000000000( https://oeis.org/A135385 )

Zakłada to jednak coś, co nie zostało jeszcze udowodnione. Zasadniczo może istnieć redukcja, która wymaga więcej niż X=10^7kroków (przypuszcza się, że żaden nieokreślony punkt zajmuje więcej niż 16 kroków, https://oeis.org/A133503 ), których wartość spada poniżej X(ale powyżej 10^7), a następnie rośnie jeszcze raz. W takim przypadku muszę wrócić do:

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

Wyjaśnienie

Kod działa poprzez wstawianie **i *(naprzemiennie) między cyframi

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

tak się 2592staje 2**5*9**2i 12345staje 1**2*3**4*5. Są to poprawne wyrażenia perla, które można oceniać za pomocą

$_ = eval

( 0**0jest 1w perlu). Następnie po prostu owiń pętlę za pomocą licznika, dzięki któremu wygasa. Ponieważ poza stałymi punktami wartości spadają bardzo szybko, seria układu napędowego zbiera się, zanim licznik naprawdę da szansę

Pyth, 25 18 11 16 bajtów

?<Q0Qu*F^McjGT2Q

Wypróbuj tutaj!

7 14 bajtów zapisanych przy pomocy @Jakube

Wyjaśnienie

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

? <Q0Q # Jeśli wejście jest ujemne, zwróć Q
     u Q # zastosuj następującą funkcję, aż osiągniemy cykl               
                   # wartością początkową jest Q, a bieżącą wartością jest G
           jGT # podziel dane wejściowe na listę cyfr
          c 2 # podzielone na pary po 2
        ^ M # obliczyć moc dla każdej pary
      * F # oblicza iloczyn wszystkich mocy

Python 2, 111 bajtów

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

Chodzi o to, aby utworzyć ciąg, w którym cyfry nsą oddzielone operacjami, które występują naprzemiennie między *i **, a następnie evalten ciąg. (Inne rozwiązania wykorzystują ten sam pomysł; patrz na przykład odpowiedź Perla Tona Hospela ).

Tak więc operacja przełącza się pomiędzy '**'[0:], co jest **i '**'[-1:]co jest sprawiedliwe *.

Jednak pod koniec forpętli łańcuch kończy się operacją (jedną lub drugą), więc albo musimy usunąć ostatnią operację, albo dodać kolejną cyfrę, aby łańcuch miał sens.

Na szczęście dołączenie 1na końcu będzie działać bez względu na to, która operacja jest ostatnia. (Jeśli chcesz, 1to jednostronna tożsamość z prawej strony, zarówno dla pomnożenia, jak i potęgowania. Innym sposobem powiedzenia tego jest to powertrain(n) == powertrain(10*n + 1)dla wszystkich n>0.)

Wreszcie, jeśli wynik evalzdarzenia jest taki sam jak na wejściu (jak w 1cyklu długości ), funkcja kończy się. W przeciwnym razie funkcja wywołuje się w wyniku. (Będzie wisiał wiecznie na dowolnym cyklu długości > 1, ale zgodnie z komentarzami PO mogę założyć, że takich cykli nie ma).

(Uwaga: powyższe wyjaśnienie działa na jednocyfrowe dodatnie liczby całkowite, ponieważ wprowadzane nbędą jednocyfrowe dane wejściowe, n**1w wyniku których powstanie 1cykl. Jednak musimy również zaakceptować wartości dodatnie, więc jest warunek zaczynając od zwarć, jeśli wejście jest mniejsze niż 1. Moglibyśmy wyeliminować tę linię i zaoszczędzić 17 bajtów, gdyby zagwarantowano, że wejście będzie nieujemne).

Java 8, 265 244 229 bajtów

To jest moja pierwsza odpowiedź, ale czytam tę stronę od dłuższego czasu i myślę, że wiem, co robię. Przynajmniej wyprzedza befunge i SQL ...

Niestety, podobnie jak inne odpowiedzi, ta nie działa dla 24547284284866560000000000 ze względu na wbudowane ograniczenia java'a dotyczące możliwości uzyskania dużych liczb całkowitych.

Zaoszczędź 36 bajtów dzięki @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);}

Wyjaśnienie bez golfa

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

Funkcja rekurencyjna, zatrzymująca się po znalezieniu powtórzenia. Nie może to działać w przypadku dłuższych pętli (powtarzanie co najmniej 2 wartości), ale wydaje się, że tak się nie stanie, przynajmniej w ograniczonym zakresie dokładności liczb javascript (17 cyfr)

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

Test

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 bajtów

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

Funkcja anonimowa. Niezbyt skomplikowane.

Befunge 720 490 bajtów

Nie mogłem się oprzeć, by zrobić jeszcze jedno po tym, co nigdy nie mów mi o szansach . Tak więc zoptymalizowałem „ASCII-fier” poprzedniego. W tym przypadku nie widziałem potrzeby, aby wskaźnik instrukcji przebiegał nad cyframi, aby je odczytać, więc nie starałem się, aby były czytelne dla ludzi. Więc teraz jest to raczej digitizer.

Ponownie, jeśli chcecie wyjaśnienia, dajcie znać w komentarzach, postaram się stworzyć kilka pomocnych opisów. Możesz skopiować wklej kod do tłumacza . Przekonałem się, że przykład 24547284284866560000000000 wyprowadza 0, ale wydaje się, że jest to problem z uzyskaniem tak dużej wartości z punktu na siatce, ponieważ wyraźnie widać prawidłową wartość przechowywaną w końcowych krokach.

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

Ta wersja obsługuje również wejście ujemne. To wielka poprawa w stosunku do poprzedniej wersji, jeśli sam tak mówię. Naprawiono co najmniej 1 błąd, a jego rozmiar znacznie się zmniejszył.

Haskell, 100 79 77 bajtów

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

Nie grał w golfa:

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

Ta funkcja dzieli dane wejściowe na cyfry i wykonuje lewę i.

EDYCJA: Dzięki nim za kilka wskazówek.

Mathematica, 74 bajty

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

Wyjaśnienie

To rozwiązanie wykorzystuje funkcję pomocniczą f, która przyjmuje cyfry liczby jako argumenty i stosuje jedną iterację działania układu napędowego. Ostatni wiersz jest czystą funkcją, która jest spreparowana w celu wykorzystania ReplaceRepeatedfunkcji (lub //.w skrócie), która stosuje regułę do wyrażenia (w tym przypadku argumentu #funkcji czystej), dopóki się nie zmieni. Reguła i_/;i>0:>f@@IntegerDigits@izastępuje wszystko, co nie jest ujemne, funkcją fstosowaną do cyfr dziesiętnych.

MATL , 21 bajtów

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

Wytworzenie wyjścia może zająć kilka sekund.

EDYCJA (30 lipca 2016 r.): Połączony kod zastępuje 9Lsię, 1Laby dostosować się do ostatnich zmian w języku.

Wypróbuj online!

Wykorzystuje dwie następujące sztuczki, aby zmniejszyć liczbę bajtów kosztem wydajności kodu:

• Powtarzaj nczasy zamiast czekać na znalezienie cyklu. Jest to dopuszczalne zgodnie z komentarzami OP.
• W przypadku nieparzystej liczby cyfr 1konieczne będzie dołączenie finału w celu dokończenia operacji zasilania końcowego. Zamiast tego liczba dodanych 1to liczba cyfr. Zapewnia to liczbę parzystą, dzięki czemu można wykonać wszystkie operacje na energii (nawet jeśli te ostatnie są niepotrzebne 1^1).

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 bajtów

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]

Niespełniony

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]

Wyniki

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

Oracle SQL 11.2, 456 bajtów

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;

Nie grał w golfa

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 jest widokiem rekurencyjnym, parametry to

n: liczba do podzielenia na 2 cyfry

c: liczba 2 cyfr części

i: bieżące 2 cyfry część do obliczenia

f: ciąg łączący moc z * jako separatorem

t: ocena f

Dekodery przełączają się na następny numer, aby podzielić i obliczyć, gdy wszystkie części bieżącego numeru zostaną wykonane.

XMLTABLE (f) przyjmuje wyrażenie i ocenia je, umieszczając wynik w pseudokolumnie „wartość_kolumny”. To wersja gry w golfa http://tkyte.blogspot.fr/2010/04/evaluating-expression-like-calculator.html

CYCLE to wbudowana funkcja wykrywania cyklu w wyroczni i służy jako warunek wyjścia.

Ponieważ wynik dla: 1 <10 wynosi: 1, a v nie zwraca wiersza dla tych przypadków, SUM wymusza wiersz z NULL jako wartością. NVL zwraca: 1 jako wynik, jeśli wiersz jest pusty.