Questa domanda è difficile (e in particolare più difficile di Quale grande numero è più grande? ), Per coloro a cui piacciono i puzzle più impegnativi.

Ingresso

Numeri interi a1, a2, a3, a4, a5, b1, b2, b3, b4, b5 ciascuno nell'intervallo da 1 a 10.

Produzione

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

^ è esponenziazione in questa domanda.

Regole

Questo è code-golf. Il codice deve terminare correttamente entro 10 secondi per qualsiasi input valido su TIO . Se la tua lingua non è su TIO, il codice dovrebbe terminare in meno di 10 secondi sul tuo computer.

Puoi produrre qualsiasi cosa Verità per vero e qualsiasi cosa Falsey per falso.

Casi test

Ricordiamo che secondo le regole dell'esponente, 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

Nuovi casi di test di 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

Rubino, 150 byte

Vedere le revisioni per i conteggi di byte precedenti.

->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 byte grazie a @ValueInk

+16 byte grazie a @RosLuP per i bug.

Provalo online .

Confronta le diverse torri di potenza base (di "altezza" cinque)?

Codice non golfato:

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

Analisi del codice:

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

Questo è il tlogaritmo di base , che verrà utilizzato per ridurre la dimensione dei numeri che stiamo confrontando. Il valore predefinito è base cquando viene fornito un solo argomento.

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

Questo aggiornamenti i = i ** jdal inon viene mai usato su di essa la propria, ed yè il risultato di registrare b^c^d^e == g^h^i(^j)due volte e in movimento tutto da una parte. Lasciamo quindi z = l[a, f] * b ** ccome base gdi registro della base fdi registro di a ** b ** c.

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

1^b^c^d^e = 1non è mai maggiore di f^g^h^i^j, e allo stesso modo, a^b^c^d^eè sempre maggiore di 1^g^h^i^j = 1se a != 1. Nota che return prestituisce nil, che è falso, e return 1restituisce 1, che è vero.

elsif b == 1
    return z > h

Se b == 1o g == 1, questo si riduce al confronto a ** b ** ccon f ** g ** h, che viene eseguito con due registri su entrambi i lati.

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

Questo si confronta a ** b ** ccon f ** g ** h ** iriordinandolo log[log[b ** c * log[a, f], g], h]rispetto a i. (Ricordalo i **= jall'inizio e z = log[b ** c * log[a, f], g].)

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

Questo confronta i 4 poteri più alti dopo aver registrato due lati entrambi i lati. Se sono uguali, confronta la base.

Python 2, 671 612 495 490 611 597 byte

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 byte grazie a @EmbodimentOfIgnorance
-117 byte grazie a @Neil
+121 byte per circa cinque correzioni di bug, tutte trovate da @ngn

Prende gli input come due elenchi. NOTA: funziona anche con elenchi più grandi o di lunghezza diversa. EDIT: non più vero; funziona ancora se P(a)e P(b)risulta in diverse tuple, ma se sono uguali questo codice aggiornato sopra funziona solo con elenchi con una dimensione fissa di 5 ora.

Provalo online.

Spiegazione:

Versione giocata a golf di questa risposta su math.stackexchange.com , quindi tutto il merito va a @ThomasAhle .

Per citare la sua risposta:

$n$$(x\mid n) := exp^n(x)$$x\in[0,1)$

$a^{(x\mid n)}$$a$apow

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

Sarei interessato a suggerimenti per altri tipi di esempi di contatore, in particolare quelli interi.

Mi sembra che il problema sia in P, abbiamo bisogno di metodi non numerici. Non sembra affatto improbabile che alcuni casi analitici siano più difficili di P.

Esempi:

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)

Esempi contrari:

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

Per quanto riguarda gli esempi contrari, egli menziona quanto segue nella sezione commenti:

$1<a<100$

Quindi la cosa principale da dimostrare è che una volta che la testa di una torre supera un certo punto, e il resto degli esponenti è limitato (e altrettanto numeroso), possiamo semplicemente guardare al valore diverso in alto. È un po 'contro intuitivo, ma sembra molto probabile dalle semplici disuguaglianze che si ottengono.

Poiché i piani A e B sono irrilevanti in questa sfida, poiché l'altezza è 5 per entrambe le torri di potenza che inseriamo, il piano C lo è. Quindi sono passato 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 funzione ricorsiva S(a,b). Se P(a)e P(b)risulta nella stessa tupla, P(S(a,b))>P(S(b,a))rimuoveranno innanzitutto i valori finali uguali agli stessi indici, prima di fare lo stesso P(A)>P(B)controllo su questi elenchi ora più brevi.

05AB1E , 96 104 byte

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›

Port of @SimplyBeautifulArt 's Ruby answer , quindi assicurati di 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

Ingresso come una lista di interi dieci: [a,b,c,d,e,f,g,h,i,j].

Provalo online o verifica tutti i casi di test .

Spiegazione:

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)

Se qualcuno vuole provare a giocare a golf, ecco un programma di aiuto che ho usato per ottenere le variabili corrette dalla lista di input.

C, 168 180 byte

Porta C dalla risposta di 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);}

Provalo online

APL (NARS), caratteri 118, byte 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 funzione sopra la chiamata z, in "az w" restituirà 1 se il numero in a è maggiore del numero in w, altrimenti restituirebbe 0.

Se ho

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

Sarà f (aa)> f (bb) con array sia aa che bb di 5 numeri positivi se e solo se (se a> 1 di aa e bb) log (log (f (aa)))> log ( log (f (bb))) si devono usare le leggi log ():

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

per build v (aa) = log (log (aa)) = v (a, b, c, d, e) = log (log (a)) + log (b) (c ^ (d ^ e)) = {p (3 ↑ ⍵), / 3 ↓ ⍵} e quindi l'esercizio viene trovato quando v (aa)> v (bb).

Ma c'è un caso in cui v (aa) e v (bb) sono entrambi infiniti (APL ha terminato lo spazio float) in quel caso userei la funzione non sicura

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

che non capisco perfettamente se va bene e non tiene conto anche di un parametro ... test:

  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 byte

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

Port of @SimplyBeautifulArt 's Ruby answer , quindi assicurati di votarlo!
-14 byte grazie a @SimplyBeautifulArt .
+17 byte per le stesse correzioni di bug della risposta Ruby.

Provalo online.

Spiegazione:

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