O vencedor (obviamente) é Dennis ♦, que usou Jelly com 10 bytes!

Este desafio ainda estará aqui, no entanto, os resultados não serão mais aceitos.

O trem de força de um número é um conceito de John Conway (que também é notável por fazer o Game of Life de Conway, mas esse não é o ponto). É definido da seguinte forma:

Para qualquer número ..., o trem de força do número é ... (ou seja, todo segundo dígito, da esquerda para a direita, é um poder do dígito antes disso). Este processo é repetido até o resultado ser um único dígito.

EXEMPLOS:

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

Seu desafio é, para qualquer número nda entrada, retornar powertrain(n)(ou seja, napós a decomposição do trem de força terminar) como saída.

Isso é código de golfe, e a menor quantidade de bytes ganha.

AVISO LEGAL:

• Você pode ter um número ímpar de dígitos na entrada, o último dígito simplesmente não terá energia.
• 0 ^ 0 é 1, porque se fosse 0, muitos números seriam reduzidos instantaneamente para 0 ou 1.
• Se o número for indestrutível em qualquer parte do processo de computação (por exemplo, se terminar com 2592), você poderá simplesmente gerar o número.
• Se a entrada for < 10(ou seja, todos os números de um dígito e negativos), faça a saída.

Provavelmente anunciarei um vencedor depois de algumas horas .

Classificação atual:

1. Geléia ( 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 ) e Haskell ( Renzeee ): 77
9. Python 2 ( mathmandan ): 111
10. Python 3 ( Erwan ): 161
11. Java 8 ( Azul ): 229
12. Oracle SQL 11.2 ( Jeto ): 456
13. Befunge '93 ( Lex ): 490

Geléia, 15 14 12 10 bytes

Ds2*/€Pµ³¡

Experimente online!

Como funciona

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 bytes

(>> = (==)) >> = até $ p.show é uma função sem nome, recebendo um número inteiro como entrada e retornando seu trem de força.

Economizou 3 bytes graças ao Zgarb

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

Perl, 42 48 bytes

Inclua +2 para -lp(você pode soltar -ltambém, mas eu gosto de novas linhas)

Execute com entrada no STDIN, por exemplo

perl -lp powertrain.pl <<< 1234

powertrain.pl:

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

(em perls mais antigos, você também pode soltar o espaço entre a regex e até)

Isso não será capaz de lidar com o ponto fixo, 24547284284866560000000000mas um valor tão alto não funcionará de qualquer maneira, porque nesse momento o perl passou para a notação exponencial.

De fato, a versão acima funcionará rapidamente (na maioria dos 2592loops) para todos os números que o perl pode representar sem usar notação exponencial, pois está provado que não há pontos fixos entre 2592e 24547284284866560000000000( https://oeis.org/A135385 )

No entanto, isso pressupõe algo ainda não comprovado. Em princípio, pode haver uma redução que leva mais do que X=10^7etapas (é suposto que nenhum ponto não fixo execute mais de 16 etapas, https://oeis.org/A133503 ) cujo valor cai abaixo X(mas acima 10^7) e depois sobe novamente. Se for esse o caso, devo recorrer a:

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

Explicação

O código funciona colocando **e *(alternando) entre os dígitos

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

assim 2592se torna 2**5*9**2e 12345se torna 1**2*3**4*5. Essas são expressões perl válidas que podem ser avaliadas com

$_ = eval

( 0**0está 1em perl). Em seguida, basta colocar um loop em torno disso com um contador que faça com que ele expire. Como, exceto pelos pontos fixos, os valores diminuem extremamente rapidamente, a série do trem de força converge antes que o contador tenha a chance de realmente continuar

Pitão, 25 18 11 16 bytes

?<Q0Qu*F^McjGT2Q

Experimente aqui!

7 14 bytes salvos com a ajuda de @Jakube

Explicação

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

? <Q0Q # Se a entrada for negativa, retorne Q
     u Q # aplique a seguinte função até atingirmos um ciclo               
                   # valor inicial é Q e o valor atual está em G
           jGT # divide a entrada em uma lista de dígitos
          c 2 # dividido em pares de 2
        ^ M # calcula a potência de cada par
      * F # calcula o produto de todos os poderes

Python 2, 111 bytes

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

A idéia é criar uma string onde os dígitos de nsão separados por operações que alternam entre *e **, e depois evala string. (Outras soluções usam essa mesma idéia; veja, por exemplo, a resposta Perl de Ton Hospel .)

Portanto, a operação alterna entre o '**'[0:]que é **e o '**'[-1:]que é justo *.

No entanto, no final do forloop, a string termina com uma operação (uma ou outra), então precisamos soltar a última operação ou adicionar outro dígito, para que a string faça sentido.

Felizmente, anexar um 1no final funcionará, não importa qual operação seja a última. (Se você preferir, 1é uma identidade unilateral da direita, para multiplicação e exponenciação. Outra maneira de dizer isso é isso powertrain(n) == powertrain(10*n + 1)para todos n>0.)

Finalmente, se o resultado do resultado evalfor o mesmo que a entrada (como em um 1ciclo de duração ), a função será encerrada. Caso contrário, a função chama a si mesma no resultado. (Ele permanecerá para sempre em qualquer ciclo de duração > 1, mas, de acordo com os comentários do OP, posso assumir que não existem tais ciclos.)

(Nota: a explicação acima funciona para números inteiros positivos de um dígito, pois uma entrada de um dígito nserá concluída e n**1resultará em um 1ciclo. No entanto, também precisamos aceitar entradas não positivas, portanto, há uma condição no iniciando esse curto-circuito se a entrada for menor que 1. Nós poderíamos eliminar essa linha e economizar 17 bytes, se a entrada não fosse negativa.)

Java 8, 265 244 229 bytes

Esta é a minha primeira resposta, mas estou lendo este site há algum tempo e acho que sei o que estou fazendo. Pelo menos ele bate befunge e SQL ...

Infelizmente, como outras respostas, esta não funciona para 24547284284866560000000000 devido a java'a embutida em restrições sobre o tamanho de números inteiros grandes.

Guardado 36 bytes graças a @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);}

Explicação Ungolfed

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

Uma função recursiva, parando quando uma repetição é encontrada. Isso não pode funcionar para loops mais longos (2 ou mais valores repetidos), mas parece que isso não poderia acontecer, pelo menos no intervalo limitado de precisão do número de javascript (17 dígitos)

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

Teste

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 bytes

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

Função anônima. Não é muito complicado.

Baixar 720 490 bytes

Não pude resistir a fazer mais uma vez depois da coisa Nunca me diga as probabilidades . Então, eu otimizei o "ASCII-fier" do anterior. Nesse caso, não vi necessidade de deixar o ponteiro das instruções percorrer os dígitos para lê-los; portanto, não me esforcei para torná-los legíveis por humanos. Portanto, agora é mais um digitador.

Novamente, se vocês quiserem uma explicação, avise-me nos comentários, tentarei criar algumas descrições úteis. Você pode copiar e colar o código no intérprete . Descobri que o exemplo 24547284284866560000000000 gera 0, mas isso parece ser um problema ao obter um valor tão grande de um ponto na grade, pois é possível ver claramente o valor correto sendo armazenado nas etapas finais.

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

Esta versão também suporta entrada negativa. É uma grande melhoria em relação à versão anterior, se é que digo. Pelo menos 1 bug foi corrigido e o tamanho foi reduzido bastante.

Haskell, 100 79 77 bytes

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

Não jogou golfe:

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

Esta função divide a entrada em dígitos e faz o truque via i.

EDIT: Obrigado a nimi por algumas dicas.

Mathematica, 74 bytes

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

Explicação

Esta solução usa uma função auxiliar f, que aceita os dígitos do número como argumentos e aplica uma iteração da operação do trem de força. A última linha é uma função pura criada para explorar a ReplaceRepeatedfunção (ou //.abreviada), que aplica uma regra a uma expressão (nesse caso, o argumento #da função pura) até que ela não mude mais. A regra i_/;i>0:>f@@IntegerDigits@isubstitui qualquer coisa não negativa pela função faplicada aos seus dígitos decimais.

MATL , 21 bytes

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

Pode demorar alguns segundos para produzir a saída.

EDIT (30 de julho de 2016): o código vinculado substitui 9Lpor 1Lpara se adaptar às alterações recentes no idioma.

Experimente online!

Isso usa os dois truques a seguir para reduzir a contagem de bytes em detrimento da eficiência do código:

• Repita os ntempos em vez de esperar até que um ciclo seja encontrado. Isso é aceitável conforme os comentários do OP.
• Para um número ímpar de dígitos, uma final 1teria que ser anexada para concluir a operação final de energia. Em vez disso, o número adicionado 1é o número de dígitos. Isso garante um número par, para que todas as operações de energia possam ser realizadas (mesmo que as últimas sejam 1^1operações desnecessárias ).

Código:

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 bytes

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]

Resultados

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

Oracle SQL 11.2, 456 bytes

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;

Sem golfe

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 é uma visão recursiva, os parâmetros são

n: número a ser dividido em partes de 2 dígitos

c: número de partes de 2 dígitos

i: parte atual de 2 dígitos para calcular

f: string concatenando os poderes com * como separador

t: avaliação de f

Os DECODES alternam para o próximo número para dividir e calcular quando todas as partes do número atual forem concluídas.

XMLTABLE (f) pega uma expressão e a avalia, colocando o resultado na pseudo coluna "column_value". É a versão para golfe de http://tkyte.blogspot.fr/2010/04/evaluating-expression-like-calculator.html

CYCLE é o oráculo construído na detecção de ciclo e é usado como condição de saída.

Como o resultado para: 1 <10 é: 1 ev não retorna nenhuma linha para esses casos, SUM força uma linha com NULL como o valor. NVL retorna: 1 como resultado se a linha for nula.