Encuentra el tren motriz!


29

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 ingrese la descripción de la imagen aquí..., el tren motriz del número es ingrese la descripción de la imagen aquí... (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

Se agradecerían algunos casos de prueba más.
Mego

¿Entonces la entrada tendrá 4 dígitos como máximo?
Denker

77
¿Qué sucede si se alcanza un ciclo, pero el período del ciclo no es 1 o el número de entrada no es parte del ciclo?
feersum

1
"Estoy seguro de que no hay ninguno en el ámbito de la viabilidad". ¿Podemos suponer que nunca sucederá? Es decir, ¿permitir que el ciclo continúe para siempre si se alcanza un ciclo de período> 1?
Stewie Griffin

66
Casos de prueba propuestos: 1100y -42es fácil pasar por alto las reglas sobre casos extremos si no se muestran en los casos de prueba.
Dennis

Respuestas:


4

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.

Esto podría hacerse más corto simplemente iterando ntiempos, pero no tengo una prueba de que funcione para todas las entradas posibles.
Dennis

1
Deberías aceptar cualquier número razonable. De hecho, es casi seguro que está bien para CUALQUIER número que use 16 iteraciones: oeis.org/A133503
Ton Hospel

@Dennis Hm, eso es lo que hago en mi respuesta
Luis Mendo

1
@DonMuesli Y ahora que lo he pensado, probablemente funcione. Las probabilidades de obtener un 0 y un índice impar son abrumadoras ...
Dennis

En Jelly moderno, esto podría hacerse en 7 bytes:D*2/Pµ¡
Dennis

5

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

1
((==)=<<g)ahorra dos bytes más (\n->g n==n).
Zgarb

Wow, no estoy familiarizado con la instancia ((->) r) de Monad. Gracias por el truco.
Damien

¡Este aluvión de signos de puntuación (>>=(==))>>=realmente se parece a un tren!
Andreï Kostyrka

4

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


3

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


1
¿Pyth es básicamente una versión de Python con golf, excepto con pequeños cambios?
clismique

1
@Jakube ¡Gracias por las pistas! :) Todavía temprano en la mañana para mí ...
Denker

@DerpfacePython Sí, un poco. Echa un vistazo a los documentos si quieres aprender al respecto.
Denker

No hay problema. ;-)
Jakube

44
@DerpfacePython Pyth comenzó como "Python acortado", pero llamarlo así ahora sería falso. Pyth se ha desviado significativamente de Python.
Mego

3

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).


Esto suena sesgado, pero ... voto positivo por ser Python 2. Y tiene una explicación.
clismique

@DerpfacePython ¡Gracias! (Supongo que esto funcionaría igual de bien en Python 3 ...)
Mathmandan

3

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

En su primer if ... else, if(n<10)return n;else{...}el else es innecesario ya que lógicamente todo en ese bloque else solo se ejecutaría de todos modos cuando n <10 es falso. Al eliminar el else y las 2 llaves coincidentes, se ahorrarán 6 bytes. Hay una situación similar con su último si ... de lo contrario, if(n==t)return n;else return p(t);elimine el else y el espacio después para guardar otros 5 bytes. De hecho, puedes acortarlo aún más si usas el operador triádico en lugar del si ... si no, asíreturn n==t?n:p(t);
Jack Ammo

puede guardar unos pocos bytes más (creo que 17) declarando t, s, r y el bucle for juntosint t=i=1,s=(int)Math.log10(n)+1,r[]=new int[s];for(;i<=s;){...}for(i=0;...)...
Jack Ammo

@JackAmmo No sabía que las variables pudieran declararse así, tendré que intentarlo ¡Gracias por tu ayuda!
Azul

sí, solo debes tener cuidado con el orden de declararlos si estás usando uno para inicializar otro (como r usa s para definir su longitud)
Jack Ammo

para números grandes arbitrarios, debe buscar en la clase BigInteger de java docs.oracle.com/javase/8/docs/api/java/math/BigInteger.html
Jack Ammo

2

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>


+'1'¡Qué bueno es matar dos pájaros de un tiro!
Neil

No sé si ya lo investigaste, pero lo mejor que pude hacer replacefue 1 byte más:f=n=>`${n}1`.replace(/../g,([x,y])=>r*=Math.pow(x,y),r=1)&&n-r?f(r):n
Neil

@Neil También lo intenté, pero esa cadena de plantilla es una idea nueva ...
edc65

1

Mathematica, 77 bytes

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

Función anónima. No muy complicado


Aun así, ¿puedo tener una explicación?
clismique

1

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.


¿Cuántos bytes más le tomará a la cosa ingresar números negativos?
clismique

No estoy seguro de ser honesto. Tuve algunos problemas con los números negativos y escribirlos en algún lugar de la cuadrícula. Lo intentaré de nuevo.
rael_kid

Acabo de encontrar otro error, también. Logré agregar soporte para números negativos. ¡Publicaré una actualización pronto! Probablemente será la misma cantidad de bytes, ya que cuento toda la cuadrícula.
rael_kid

1

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.


Algunos consejos: a) i(a:[])=aes i[a]=a, b) no es necesario max 1, porque 0^0 = 1en Haskell, c) reemplazar (:[])con pure, d) mover el letinterior ga una función separada y reemplazar if ... then ... elsecon guardias:h=i.map(read.pure).show ; g x|x==h x=x|1<2=h x
nimi

pureno está en Prelude, pero el resto de los consejos funcionan, gracias. Estaba tratando de hacerlo con los guardias, pero terminé usando ;antes que el guardia y eso no funcionó, pero ahora sé cómo debería funcionar.
Renzeee

pureestá en el Preludio que viene con base-4.8.2.0. No sé cuándo fue presentado. No es necesario el ( )en i([a])=a.
nimi

1

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.


La línea 2 no funciona (uso :=)
CalculatorFeline

¿Explicación, por favor?
clismique

@CatsAreFluffy No veo tu problema con la línea 2. ¡Funciona bien para mí!
murphy

SetDelayed::write: Tag Times in n f[a_,b_,c___] is Protected. >>, Set::write: Tag Times in 1 f[n_] is Protected. >>El segundo error desaparece cuando se utiliza :=vs =.
CalculatorFeline

Lo sentimos, no puedo reproducir ese error. Pero su salida indica que los saltos de línea son parte del problema. Pruebe la versión con ;s en lugar de los saltos de línea:0~f~0=f[]=1;f@n_=n;f[a_,b_,c___]:=f[c]a^b;#//.i_/;i>0:>f@@IntegerDigits@i&
murphy

1

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

Uh ... heh heh heh ... cuando dije "bucles de números", me refería a números que iban así: a, b, a, bad infinitum (más de un término). Si se repite un término, debe generar ese número. Lo siento si eso no fue realmente claro.
clismique

Si se repite un término, estoy generando ese número. Saco el resultado después de muchas iteraciones
Luis Mendo

Oh, ahora entiendo ... solo preguntando, ¿cuántas iteraciones serían (aprox.)? Porque cuando escribo en 2592la entrada, no parece producir nada durante bastante tiempo.
clismique

El número de iteraciones es el número de entrada, entonces 2592 en ese caso. Sí, lleva un tiempo
Luis Mendo

0

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']

@PeterTaylor fijo!
Erwan

Puede poner varias declaraciones en una línea si ;las separa con una de esta manera le ahorra espacios en blanco. También puede colocar el cuerpo del bucle for en esa misma línea.
Denker

Golf sugerido:def f(s,o=[['1',s]["-"in s]],n=int): 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*=n(i)**n(j) s=str(r) return o[-1]
CalculatorFeline

@CatsAreFluffy o=[['1',s]["-"in s]]en el argumento predeterminado no funciona para mí, genera un error `s no definido`
Erwan

Vaya, muévete a la siguiente línea.
CalculatorFeline

0

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.


¿Dónde está la explicación?
clismique
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.