El ganador (obviamente) es Dennis ♦, ¡quien usó Jelly con 10 bytes!

Este desafío seguirá estando aquí, sin embargo, los resultados ya no se tomarán.

El tren motriz de un número es un concepto de John Conway (que también es notable por hacer el Juego de la vida de Conway, pero ese no es el punto). Se define así:

Para cualquier número ..., el tren motriz del número es ... (es decir, cada 2do dígito, de izquierda a derecha, es una potencia del dígito anterior). Este proceso se repite hasta que el resultado sea un solo dígito.

EJEMPLOS

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

Su desafío es, para cualquier número nen la entrada, regresar powertrain(n)(es decir, ndespués de que la descomposición del tren motriz haya finalizado) como salida.

Este es el código de golf, por lo que gana la menor cantidad de bytes.

DESCARGO DE RESPONSABILIDAD:

• Puede tener un número impar de dígitos en la entrada, el último dígito simplemente no tendrá potencia.
• 0 ^ 0 es 1, porque si fuera 0, muchos números colapsarían instantáneamente a 0 o 1.
• Si el número es indestructible en cualquier parte del proceso de cómputo (por ejemplo, si termina con 2592), puede simplemente generar el número.
• Si la entrada es < 10( es decir, todos los números de un solo dígito y negativos), envíe la entrada.

Probablemente anunciaré un ganador después de unas pocas horas días.

Tabla de clasificación actual:

1. Gelatina ( 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 ) y 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

Jalea, 15 14 12 10 bytes

Ds2*/€Pµ³¡

Pruébalo en línea!

Cómo 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

(>> = (==)) >> = hasta que $ p.show es una función sin nombre que toma un entero como entrada y devuelve su tren motriz.

Guardado 3 bytes gracias a Zgarb

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

Perl, 42 48 bytes

Incluye +2 para -lp(también puedes descartarlo -lpero me gustan las líneas nuevas)

Ejecutar con entrada en STDIN, p. Ej.

perl -lp powertrain.pl <<< 1234

powertrain.pl:

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

(en perls anteriores también puede soltar el espacio entre la expresión regular y hasta)

Esto no podrá manejar el punto fijo, 24547284284866560000000000pero un valor tan grande no funcionará de todos modos porque en ese momento Perl cambió a notación exponencial.

De hecho, la versión anterior funcionará rápidamente (en la mayoría de los 2592bucles) para todos los números que Perl puede representar sin usar la notación exponencial, ya que está comprobado que no hay puntos fijos entre 2592y 24547284284866560000000000( https://oeis.org/A135385 )

Sin embargo, esto supone algo aún no probado. En principio, podría haber una reducción que lleva más de X=10^7pasos (se conjetura que ningún punto no fijo toma más de 16 pasos, https://oeis.org/A133503 ) cuyo valor cae por debajo X(pero arriba 10^7) y luego sube otra vez. Si ese es el caso, debo recurrir a:

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

Explicación

El código funciona poniendo **y *(alternando) entre los dígitos

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

así se 2592vuelve 2**5*9**2y se 12345vuelve 1**2*3**4*5. Estas son expresiones perl válidas que se pueden evaluar con

$_ = eval

( 0**0está 1en perl). Luego, simplemente ponga un bucle alrededor de eso con un contador que haga que caduque. Dado que a excepción de los puntos fijos, los valores bajan extremadamente rápido, la serie del tren motriz converge antes de que el contador tenga la oportunidad de comenzar realmente

Pyth, 25 18 11 16 bytes

?<Q0Qu*F^McjGT2Q

Pruébalo aquí!

7 14 bytes guardados con la ayuda de @Jakube

Explicación

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

? <Q0Q # Si la entrada es negativa, devuelva Q
     u Q # aplica la siguiente función hasta llegar a un ciclo               
                   # el valor inicial es Q y el valor actual está en G
           jGT # divide la entrada en una lista de dígitos
          c 2 # dividido en pares de 2
        ^ M # calcula la potencia de cada par
      * F # calcula el producto de todos los 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

La idea es hacer una cadena donde los dígitos de nestén separados por operaciones que alternan entre *y **, y luego evalesa cadena. (Otras soluciones utilizan esta misma idea; ver, por ejemplo, la respuesta Perl de Ton Hospel ).

Entonces, la operación cambia de ida y vuelta entre '**'[0:], que es **, y '**'[-1:], que es justo *.

Sin embargo, al final del forbucle, la cadena termina con una operación (una u otra), por lo que debemos eliminar la última operación o agregar otro dígito para que la cadena tenga sentido.

Afortunadamente, agregar un 1al final funcionará sin importar qué operación sea la última. (Si lo desea, 1es una identidad unilateral desde la derecha, tanto para la multiplicación como para la exponenciación. Otra forma de decir esto es powertrain(n) == powertrain(10*n + 1)para todos n>0).

Finalmente, si el resultado del resultado evales el mismo que el de la entrada (como en un 1ciclo de longitud ), la función termina. De lo contrario, la función se llama a sí misma en el resultado. (Se suspenderá para siempre en cualquier ciclo de duración > 1, pero de acuerdo con los comentarios del OP, puedo suponer que no existen tales ciclos).

(Nota: la explicación anterior funciona para los números enteros positivos de un solo dígito, ya una entrada de un dígito nse completará a n**1lo que se traducirá en un 1-Ciclo Sin embargo, también tenemos que aceptar la entrada no positivo, por lo que hay una condición en la. comenzando esos cortocircuitos si la entrada es menor que 1. Podríamos eliminar esa línea y ahorrar 17 bytes, si se garantizara que la entrada no es negativa).

Java 8, 265 244 229 bytes

Esta es mi primera respuesta, pero he estado leyendo este sitio por un tiempo y creo que sé lo que estoy haciendo. Al menos supera a befunge y SQL ...

Desafortunadamente, al igual que otras respuestas, esta no funciona para 24547284284866560000000000 debido a las restricciones incorporadas de java'a sobre qué tan grandes pueden ser los enteros.

Guardado 36 bytes gracias 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);}

Explicación sin golf

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

Una función recursiva, que se detiene cuando se encuentra una repetición. Esto no podría funcionar para bucles más largos (2 o más valores repetidos) pero parece que esto no podría suceder, al menos en el rango limitado de precisión del 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

Prueba

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~#&

Función anónima. No muy complicado

Befunge 720 490 bytes

No pude resistirme a hacer uno más después de lo de Nunca me digas las probabilidades . Entonces, he optimizado el "ASCII-fier" del anterior. En este caso, no vi la necesidad de dejar que el puntero de la instrucción recorriera los dígitos para leerlos, por lo que no he hecho el esfuerzo de hacerlos legibles para los humanos. Entonces es más un digitalizador, ahora.

Nuevamente, si quieren una explicación, háganmelo saber en los comentarios, intentaré crear algunas descripciones útiles. Puede copiar y pegar el código en el intérprete . Descubrí que el ejemplo 24547284284866560000000000 genera 0, pero eso parece ser un problema para obtener un valor tan grande de un punto en la cuadrícula, ya que puede ver claramente el valor correcto almacenado en los pasos finales.

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 versión también admite entrada negativa. Es una gran mejora en la versión anterior, si lo digo yo mismo. Se corrigió al menos 1 error y el tamaño se redujo considerablemente.

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

No golfizado:

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 función divide la entrada en dígitos y realiza el truco a través de i.

EDITAR: Gracias a nimi por algunos consejos.

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&

Explicación

Esta solución utiliza una función auxiliar f, que toma los dígitos del número como argumentos y aplica una iteración de la operación del tren de fuerza. La última línea es una función pura diseñada para explotar la ReplaceRepeatedfunción (o //.para abreviar), que aplica una regla a una expresión (en este caso, el argumento #de la función pura) hasta que ya no cambie. La regla i_/;i>0:>f@@IntegerDigits@ireemplaza cualquier cosa no negativa con la función faplicada a sus dígitos decimales.

MATL , 21 bytes

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

Puede tomar unos segundos para producir la salida.

EDITAR (30 de julio de 2016): el código vinculado se reemplaza 9Lpor 1Lpara adaptarse a los cambios recientes en el idioma.

Pruébalo en línea!

Utiliza los siguientes dos trucos para reducir el recuento de bytes a expensas de la eficiencia del código:

• Itere los ntiempos en lugar de esperar hasta que se encuentre un ciclo. Esto es aceptable según los comentarios de OP.
• Para un número impar de dígitos 1, se debe agregar una final para completar la operación de potencia final. En lugar de eso, el número agregado 1es el número de dígitos. Esto garantiza un número par, por lo que todas las operaciones de energía pueden realizarse (incluso si las últimas son 1^1operaciones innecesarias ).

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]

Sin oro

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;

Sin 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 es una vista recursiva, los parámetros son

n: número para dividir en partes de 2 dígitos

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

i: parte actual de 2 dígitos para calcular

f: cadena que concatena las potencias con * como separador

t: evaluación de f

Los DECODE cambian al siguiente número para dividir y calcular cuando se completan todas las partes del número actual.

XMLTABLE (f) toma una expresión y la evalúa, colocando el resultado en la pseudo columna "column_value". Es la versión de golf de http://tkyte.blogspot.fr/2010/04/evaluating-expression-like-calculator.html

CYCLE es la detección del ciclo de construcción oracle y se utiliza como condición de salida.

Como el resultado para: 1 <10 es: 1 yv no devuelve ninguna fila para esos casos, SUM fuerza una fila con NULL como valor. NVL devuelve: 1 como resultado si la fila es nula.