Esta pregunta es complicada (y en particular más difícil que ¿Qué gran número es mayor? ), Para aquellos a quienes les gustan los acertijos más desafiantes.

Entrada

Enteros a1, a2, a3, a4, a5, b1, b2, b3, b4, b5 cada uno en el rango de 1 a 10.

Salida

True if a1^(a2^(a3^(a4^a5))) > b1^(b2^(b3^(b4^b5))) and False otherwise.

^ es exponenciación en esta pregunta.

Reglas

Este es el código de golf. Su código debe terminar correctamente dentro de 10 segundos para cualquier entrada válida en TIO . Si su idioma no está en TIO, el código debería finalizar en menos de 10 segundos en su máquina.

Puede generar cualquier cosa Verdad para Verdadero y cualquier cosa Falsey para Falso.

Casos de prueba

Recuerde que según las reglas de exponenciación, a1 ^ (a2 ^ (a3 ^ (a4 ^ a5))) == a1 ^ a2 ^ a3 ^ a4 ^ a5.

10^10^10^10^10 > 10^10^10^10^9
1^2^3^4^5 < 5^4^3^2^1
2^2^2^2^3 > 10^4^3^2^2
6^7^8^9^10 is not bigger than 6^7^8^9^10
10^6^4^2^2 < 10^6^2^4^2
2^2^2^2^10 > 2^2^2^10^2
10^9^8^7^6 < 6^7^8^9^10 
3^1^10^10^10 > 2^1^10^10^10 
9^10^10^10^10 < 10^9^10^10^10

Nuevos casos de prueba de Kevin Cruijssen

[10,10,10,10,10, 10,10,10,10,9] #true
[2,2,2,2,3,      10,4,3,2,2]    #true
[2,2,2,2,10,     2,2,2,10,2]    #true
[10,10,10,10,10, 9,10,10,10,10] #true
[3,2,2,1,1,      2,5,1,1,1]     #true
[2,2,3,10,1,     2,7,3,9,1]     #true
[7,9,10,10,10,   6,9,10,10,10]  #true
[3,2,2,2,2,      2,2,2,2,2]     #true
[8,3,1,2,1,      2,2,3,1,1]     #true
[2,4,2,1,1,      3,3,2,1,1]     #true
[5,4,3,2,1,      1,2,3,4,5]     #true

[1,2,3,4,5,      5,4,3,2,1]     #false
[6,7,8,9,10,     6,7,8,9,10]    #false
[10,6,4,2,2,     10,6,2,4,2]    #false
[10,9,8,7,6,     6,7,8,9,10]    #false
[1,10,10,10,10,  1,10,10,10,9]  #false
[2,4,1,1,1,      2,2,2,1,1]     #false
[2,2,2,1,1,      2,4,1,1,1]     #false
[2,5,1,1,1,      3,2,2,1,1]     #false
[4,2,1,1,1,      2,4,1,1,1]     #false
[2,4,1,1,1,      4,2,1,1,1]     #false
[2,3,10,1,1,     8,3,9,1,1]     #false
[8,3,9,1,1,      2,3,10,1,1]    #false
[2,4,1,1,1,      3,3,1,1,1]     #false
[2,2,1,9,9,      2,2,1,10,10]   #false
[2,2,1,10,10,    2,2,1,9,9]     #false
[1,1,1,1,1,      1,2,1,1,1]     #false

Ruby, 150 bytes

Consulte las revisiones para los conteos de bytes anteriores.

->a,b,c,d,e,f,g,h,i,j{l=->s,t=c{Math.log(s,t)};y,z=l[l[g,b]]-d**e+l[h]*i**=j,l[l[a,f]*b**c,g];a>1?f<2?1:b<2||g<2?z>h:c<2||d<2?l[z,h]>i:y==0?a>f:y<0:p}

-10 bytes gracias a @ValueInk

+16 bytes gracias a @RosLuP por errores.

Pruébalo en línea .

¿Comparar diferentes torres de poder de base (de 'altura' cinco)?

Código sin golf:

-> a, b, c, d, e, f, g, h, i, j {
    l =-> s, t = c {Math.log(s, t)}
    i **= j
    y = l[l[g, b]] - d ** e + l[h] * i
    z = l[l[a, f] * b ** c, g]
    if a == 1
        return p
    elsif f == 1
        return 1
    elsif b == 1 || g == 1
        return z > h
    elsif d == 1 || c == 1
        return l[z, h] > i
    elsif y == 0
        return a > f
    else
        return y < 0
    end
}

Desglose del código:

l =-> s, t = c {Math.log(s, t)}

Este es el tlogaritmo base , que se utilizará para reducir el tamaño de los números que estamos comparando. El valor predeterminado es base ccuando solo se proporciona un argumento.

i **= j
y = l[l[g, b]] - d ** e + l[h] * i
z = l[l[a, f] * b ** c, g]

Esto se actualiza i = i ** jya que inunca se usa solo, y yes el resultado de iniciar sesión b^c^d^e == g^h^i(^j)dos veces y mover todo a un lado. Luego dejamos z = l[a, f] * b ** ccomo base gde registro de la base fde registro de a ** b ** c.

if a == 1
    return p
elsif f == 1
    return 1

1^b^c^d^e = 1nunca es mayor que f^g^h^i^j, y del mismo modo, a^b^c^d^esiempre es mayor que 1^g^h^i^j = 1si a != 1. Tenga en cuenta que return pvuelve nil, que es falsey, y return 1vuelve 1, que es verdad.

elsif b == 1
    return z > h

Si b == 1o g == 1, a continuación, esto se reduce a la comparación de a ** b ** ca f ** g ** h, que se realiza con dos troncos a ambos lados.

elsif d == 1 || c == 1
    return l[z, h] > i

Esto se compara a ** b ** ccon f ** g ** h ** ireordenando como log[log[b ** c * log[a, f], g], h]en comparación con i. (Recordemos eso i **= jal principio y z = log[b ** c * log[a, f], g].)

elsif y == 0
    return a > f
else
    return y < 0
end

Esto compara las 4 potencias más altas después de iniciar sesión en ambos lados dos veces. Si son iguales, compara la base.

Python 2, 671 612 495 490 611 597 bytes

lambda a,b:P(S(a,b))>P(S(b,a))if P(a)==P(b)else P(a)>P(b)
def S(a,b):
  if a and a[-1]==b[-1]:
    a.pop()
    b.pop()
    return S(a,b)
from math import*
L=log
E=exp
N=lambda m,n,x:N(m,n+1,L(x))if x>=1else N(m,n-1,E(x))if x<0else(m+n,x)
A=lambda a,n,x:(0,1)if a==1else(1,R(x,n)*L(a))if a<1else N(2,*C(L(L(a)),x,n-1))if n else(1,x*L(a))
def C(c,x,n):
 if c*n==0:return(0if c else n,x+c)
 z=R(x,n-1)
 if z<=L(abs(c)):return(0,E(z)+c)
 return N(1,*C(L(1-E(L(-c)-z)if c<0else 1+E(L(c)-z)),x,n-1))
def R(x,n):
 try:exec'x=E(x)'*n
 except:x=float('inf')
 return x
P=lambda b:b and N(0,*A(b[0],*P(b[1:])))or(0,1)

-59 bytes gracias a @EmbodimentOfIgnorance
-117 bytes gracias a @Neil
+121 bytes por cerca de cinco correcciones de errores, todos encontrados por @ngn

Toma las entradas como dos listas. NOTA: También funciona con listas más grandes o con longitudes desiguales. EDITAR: ya no es cierto; si todavía funciona P(a)y P(b)como resultado diferentes tuplas, pero si son lo mismo este código actualizado anterior sólo funciona con las listas con un tamaño fijo de 5 ahora.

Pruébalo en línea.

Explicación:

Versión de golf de esta respuesta en math.stackexchange.com , por lo que todo el crédito va a @ThomasAhle .

Para citar su respuesta:

$n$$(x\mid n) := exp^n(x)$$x\in[0,1)$ , este formato permite una fácil comparación entre números.

$a^{(x\mid n)}$$a$apow llamadas) y el registro iterado de su valor (número de llamadas recursivas).

$2^{2^{2^{2^0}}}<2^{2^{2^{2^{(1/2)^{2^{2^{2^2}}}}}}}$

Me interesarían las sugerencias para otros tipos de contraejemplos, especialmente los enteros.

Me parece que para que el problema esté en P, necesitamos métodos no numéricos. No parece improbable en absoluto, que ciertos casos analíticos sean más difíciles que P.

Ejemplos:

powtow([2,2,2,2,2,2,2,2,2,2,2,2,2,2,4,2,2,2]) = (0.1184590219613409, 18)
powtow([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]) = (0.10111176550354063, 18)

powtow([2,2,5,2,7,4,9,3,7,6,9,9,9,9,3,2]) = (0.10111176550354042, 17)
powtow([3,3,6,3,9,4,2,3,2,2,2,2,2,3,3,3]) = (0.19648862015624008, 17)

Ejemplos de contadores:

powtow([2,2,2,2,2,2,2]) = (0.8639310719129168, 6)
powtow([3,2,2,2,2,2,2]) = (0.8639310719129168, 6)

Con respecto a los contraejemplos, menciona lo siguiente en la sección de comentarios:

$1<a<100$ (o tal vez un límite superior mucho más grande) podemos usar mi método para comparar la altura 3 o 4 de la cabeza de la torre. Debería ser lo suficientemente fuerte como para decirnos si son iguales o si uno es más grande. El plan B es elegir la torre más alta. El plan C es interesante: en este punto, los valores del resto de la torre solo importan si las cabezas son iguales, por lo que podemos caminar por las torres en paralelo, deteniéndonos tan pronto como veamos un valor diferente.

Por lo tanto, lo principal que debe probarse es que una vez que la cabeza de una torre excede un cierto punto, y el resto de los exponentes están delimitados (e igualmente numerosos), simplemente podemos mirar el valor superior diferente. Es un poco intuitivo, pero parece muy probable por las simples desigualdades que obtienes.

Como el plan A y B son irrelevantes en este desafío, dado que la altura es 5 para ambas torres de potencia que ingresamos, el plan C lo es. Así que he cambiado P(a)>P(b)a P(S(a,b))>P(S(b,a))if P(a)==P(b)else P(a)>P(b)con la función recursiva S(a,b). Si P(a), y P(b)como resultado la misma tupla, el P(S(a,b))>P(S(b,a))primero será quitar los valores que son iguales en los mismos índices de salida, antes de hacerlo con el mismo P(A)>P(B)control sobre estas listas ahora más cortos.

05AB1E , 96 104 bytes

3èI4èmU8.$`m©I7èI2è.n*I6èI1è.nI2è.n+Vнi0ë5èi1ë2ô1èßi¦2£`mIнI5è.n*I6è.nDI7èDi\1›·<žm*ë.n}®›ëXYQiнI5è›ëXY›

Puerto de la respuesta de Ruby de @SimplyBeautifulArt , ¡así que asegúrate de votarlo!

$\log_1(x)$POSITIVE_INFINITY$x\gt1$NEGATIVE_INFINITY$x\lt1$0.0[3,2,2,1,1,2,5,1,1,1]POSITIVE_INFINITE[2,4,1,1,1,3,3,1,1,1]NEGATIVE_INFINITY

Entrada como una lista de números enteros diez: [a,b,c,d,e,f,g,h,i,j].

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

3èI4èm         # Calculate d**e
      U        # And pop and store it in variable `X`
8.$`m          # Calculate i**j
     ©         # Store it in variable `®` (without popping)
I7èI2è.n       # Calculate c_log(h)
 *             # Multiply it with i**j that was still on the stack: i**j * c_log(h)
I6èI1è.nI2è.n  # Calculate c_log(b_log(g))
 +             # And sum them together: i**j * c_log(h) + c_log(b_log(g))
  V            # Pop and store the result in variable `Y`

нi             # If `a` is 1:
 0             #  Push 0 (falsey)
ë5èi           # Else-if `f` is 1:
 1             #  Push 1 (truthy)
ë2ô1èßi        # Else-if the lowest value of [c,d] is 1:
 ¦2£`m         #  Calculate b**c
 IнI5è.n       #  Calculate f_log(a)
  *            #  Multiply them together: b**c * f_log(a)
   I6è.n       #  Calculate g_log(^): g_log(b**c * f_log(a))
 D             #  Duplicate it
  I7è          #  Push h
     Di        #  Duplicate it as well, and if h is exactly 1:
       \       #   Discard the duplicated h
       1›      #   Check if the calculated g_log(b**c * f_log(a)) is larger than 1
               #   (which results in 0 for falsey and 1 for truthy)
         ·<    #   Double it, and decrease it by 1 (it becomes -1 for falsey; 1 for truthy)
           žm* #   Multiply that by 9876543210 (to mimic POSITIVE/NEGATIVE INFINITY)
      ë        #  Else:
       .n      #   Calculate h_log(g_log(b**c * f_log(a))) instead
      }        #  After the if-else:
       ®›      #  Check whether the top of the stack is larger than variable `®`
ëXYQi          # Else-if variables `X` and `Y` are equal:
     нI5è›     #  Check whether `a` is larger than `f`
ë              # Else:
 XY›           #  Check whether `X` is larger than `Y`
               # (after which the top of the stack is output implicitly as result)

Si alguien quiere probar y jugar más al golf, aquí hay un programa auxiliar que he usado para obtener las variables correctas de la lista de entrada.

C, 168 180 bytes

C port de la respuesta de Kevin Cruijssen.

#define l(a,b)log(a)/log(b)
z(a,b,c,d,e,f,g,h,i,j){float t=pow(i,j),y=l(l(g,b),c)-pow(d,e)+l(h,c)*t,z=l(l(a,f)*pow(b,c),g);return~-a&&f<2|(b<2|g<2?z>h:c<2|d<2?l(z,h)>t:y?y<0:a>f);}

Pruébalo en línea

APL (NARS), caracteres 118, bytes 236

{p←{(a b c d)←⍵⋄a=1:¯1⋄b=1:⍟⍟a⋄(⍟⍟a)+(c*d)×⍟b}⋄(=/(a b)←{p 1↓⍵}¨⍺⍵)∧k←(∞ ∞)≡(m n)←{p(3↑⍵),*/3↓⍵}¨⍺⍵:(↑⍺)>↑⍵⋄k:a>b⋄m>n}

La función anterior llama a z, en "az w" devolvería 1 si el número en a es mayor que el número en w, de lo contrario devolvería 0.

Si tengo

f(a,b,c,d,e)=a^b^c^d^e

Será f (aa)> f (bb) con una matriz de 5 números positivos aa y bb si y solo si (si a> 1 de aa y bb) log (log (f (aa)))> log ( log (f (bb))) uno tiene que usar las leyes log ():

log(A*B)=log(A)+log(B)
log(A^B)=B*log(A)

para compilación v (aa) = log (log (aa)) = v (a, b, c, d, e) = log (log (a)) + log (b) (c ^ (d ^ e)) = {p (3 ↑ ⍵), / 3 ↓ ⍵} función y, por lo tanto, el ejercicio se encuentra cuando v (aa)> v (bb).

Pero hay un caso en el que v (aa) y v (bb) son infinitos (APL ha finalizado el espacio flotante) en ese caso, usaría la función no segura

s(a,b,c,d,e)=log(log(b))+log(c)*(d^e)={p 1↓⍵}

que no entiendo completamente si está bien y no toma en cuenta un parámetro también ... prueba:

  z←{p←{(a b c d)←⍵⋄a=1:¯1⋄b=1:⍟⍟a⋄(⍟⍟a)+(c*d)×⍟b}⋄(=/(a b)←{p 1↓⍵}¨⍺⍵)∧k←(∞ ∞)≡(m n)←{p(3↑⍵),*/3↓⍵}¨⍺⍵:(↑⍺)>↑⍵⋄k:a>b⋄m>n}
  10 10 10 10 10 z 10 10 10 10 9
1
  1 2 3 4 5 z 5 4 3 2 1
0
  2 2 2 2 3 z 10 4 3 2 2
1
  10 6 4 2 2 z 10 6 2 4 2
0
  2 2 2 2 10 z 2 2 2 10 2
1
  10 9 8 7 6 z 6 7 8 9 10
0
  10 10 10 10 10 z 10 10 10 10 9
1      
  2 2 2 2 3   z    10 4 3 2 2
1
  2 2 2 2 10   z   2 2 2 10 2
1
  10 10 10 10 10 z 9 10 10 10 10
1
  3 2 2 1 1   z    2 5 1 1 1
1
  2 2 3 10 1  z    2 7 3 9 1
1
  7 9 10 10 10 z   6 9 10 10 10
1
  3 2 2 2 2    z   2 2 2 2 2
1
  3 10 10 10 10 z  2 10 10 10 10
1
  8 3 1 2 1    z   2 2 3 1 1
1
  2 4 2 1 1    z   3 3 2 1 1
1
  5 4 3 2 1    z   1 2 3 4 5
1
  1 2 3 4 5    z   5 4 3 2 1
0
  6 7 8 9 10    z  6 7 8 9 10
0
  10 6 4 2 2 z     10 6 2 4 2
0
  10 9 8 7 6  z   6 7 8 9 10
0
  1 10 10 10 10 z 1 10 10 10 9
0
  2 4 1 1 1 z     2 2 2 1 1
0
  2 2 2 1 1    z  2 4 1 1 1
0
  2 5 1 1 1   z   3 2 2 1 1
0
  4 2 1 1 1   z   2 4 1 1 1
0
  2 4 1 1 1   z   4 2 1 1 1
0
  2 3 10 1 1  z   8 3 9 1 1
0
  8 3 9 1 1   z   2 3 10 1 1
0
  2 4 1 1 1   z   3 3 1 1 1
0
  2 2 1 9 9   z   2 2 1 10 10
0
  2 2 1 10 10 z   2 2 1 9 9
0
  1 1 1 1 1   z   1 2 1 1 1
0
  1 1 1 1 2   z   1 1 1 1 1
0
  1 1 1 1 1   z   1 1 1 1 1
0
  9 10 10 10 10 z  10 9 10 10 10
1
  9 10 10 10 10 z  10 10 10 10 10
0
  10 10 10 10 10 z  10 10 10 10 10
0
  11 10 10 10 10 z  10 10 10 10 10
1

Java 8, 299 288 286 252 210 208 224 bytes

Math M;(a,b,c,d,e,f,g,h,i,j)->{double t=M.pow(i,j),y=l(l(g,b),c)-M.pow(d,e)+l(h,c)*t,z=l(l(a,f)*M.pow(b,c),g);return a>1&&f<2|(b<2|g<2?z>h:c<2|d<2?l(z,h)>t:y==0?a>f:y<0);}double l(double...A){return M.log(A[0])/M.log(A[1]);}

Puerto de la respuesta de Ruby de @SimplyBeautifulArt , ¡así que asegúrate de votarlo!
-14 bytes gracias a @SimplyBeautifulArt .
+17 bytes para las mismas correcciones de errores que la respuesta de Ruby.

Pruébalo en línea.

Explicación:

Math M;                      // Math M=null on class-level to save bytes

(a,b,c,d,e,f,g,h,i,j)->{     // Method with ten integer parameters and boolean return-type
  double t=M.pow(i,j),       //  Temp `t` = `i` to the power `j`
    y=l(l(g,b),c)            //  Temp `y` = `c`_log(`b`_log(`g`))
      -M.pow(d,e)            //  - `d` to the power `e`
      +l(h,c)*t,             //  + `c`_log(`h`) * `t`
    z=l(l(a,f)*M.pow(b,c),g);//  Temp `z` = `g`_log(`f`_log(`a`) * `b` to the power `c`)
  return a>1&&               //  If `a` is 1:
                             //   Return false
   f<2|(                     //  Else-if `f` is 1:
                             //   Return true
    b<2|g<2?                 //  Else-if either `b` or `g` is 1:
     z>h                     //   Return whether `z` is larger than `h`
    :c<2|d<2?                //  Else-if either `c` or `d` is 1:
     l(z,h)>t                //    Return whether `h`_log(`z`) is larger than `t`
    :y==0?                   //   Else-if `y` is 0:
      a>f                    //    Return whether `a` is larger than `f`
    :                        //   Else:
     y<0);}                  //    Return whether `y` is negative

// Separated method to calculate `B`_log(`A`) for inputs `A,B`
double l(double...A){return M.log(A[0])/M.log(A[1]);}