Qual número realmente grande é maior?

11

Essa pergunta é complicada (e em particular mais difícil do que Qual é o maior número? ), Para quem gosta de quebra-cabeças mais desafiadores.

Entrada

Inteiros a1, a2, a3, a4, a5, b1, b2, b3, b4, b5, cada um no intervalo de 1 a 10.

Resultado

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

^ é exponenciação nesta questão.

Regras

Isso é código-golfe. Seu código deve terminar corretamente em 10 segundos para qualquer entrada válida no TIO . Se o seu idioma não estiver no TIO, o código deverá terminar em menos de 10 segundos na sua máquina.

Você pode produzir qualquer coisa Truthy for True e qualquer coisa Falsey for False.

Casos de teste

Lembre-se de que, pelas regras de exponenciação, 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

Novos casos de teste 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
Anush
fonte
5
Estou passando por isso, mesmo que não seja um idiota; é muito perto de um desafio que você postou quatro horas antes e mostra uma falta de esforço para pensar em desafios únicos.
Urna de polvo mágico
3
Sinto que 9 pessoas concordaram com o meu ponto de vista; mas, como você diz, é sua escolha mantê-lo, mesmo que ele tenha 9 votos negativos. Estava apenas esclarecendo por que pode haver votos negativos.
Magic Octopus Urn
3
Era apenas meu homem de dois centavos, honestamente; não precisamos entrar em detalhes aqui. Lamento até ter dito alguma coisa; a última coisa que eu queria era uma resposta argumentativa. Eu estava apenas dizendo por que dei -1.
Magic Octopus Urn
7
Estou votando para reabrir este post porque ele tem um parâmetro de dificuldade diferente e a abordagem necessária para resolvê-lo é muito diferente. Meta post .
user202729
3
Casos de teste sugeridas (para os casos de ponta encontrados pelo Python, Ruby, Java, e 05AB1E respostas)
Kevin Cruijssen

Respostas:

8

Ruby, 150 bytes

Veja as revisões para contagens 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 graças a @ValueInk

+16 bytes graças a @RosLuP por erros.

Experimente online .

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

Código não destruído:

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

Repartição do código:

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

Este é o tlogaritmo base , que será usado para reduzir o tamanho dos números que estamos comparando. O padrão é basear cquando apenas um argumento é fornecido.

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

Isso é atualizado i = i ** jporque inunca é usado por si próprio e yé o resultado do registro b^c^d^e == g^h^i(^j)duas vezes e da movimentação de tudo para um lado. Deixamos então z = l[a, f] * b ** ccomo a base gde log da base fde log de a ** b ** c.

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

1^b^c^d^e = 1nunca é maior que f^g^h^i^j, e da mesma forma, a^b^c^d^eé sempre maior que 1^g^h^i^j = 1se a != 1. Observe que return pretorna nil, que é falsey, e return 1retorna 1, que é verdade.

elsif b == 1
    return z > h

Se b == 1or g == 1, isso reduz a comparação a ** b ** ccom f ** g ** h, o que é feito com dois logs para os dois lados.

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

Isso se compara a ** b ** ccom f ** g ** h ** ireorganizando-lo como log[log[b ** c * log[a, f], g], h]em comparação com i. (Lembre-se disso i **= jno começo e z = log[b ** c * log[a, f], g].)

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

Isso compara os quatro poderes mais altos depois de registrar os dois lados duas vezes. Se eles são iguais, ele compara a base.

Arte simplesmente bonita
fonte
5

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 graças a @EmbodimentOfIgnorance
-117 bytes graças a @Neil +121
bytes por aproximadamente cinco correções de erros, todas encontradas por @ngn

Toma as entradas como duas listas. NOTA: Também funciona com listas maiores ou de comprimento desigual. EDIT: não é mais verdade; ainda funciona se P(a)e P(b)resultar em tuplas diferentes, mas se forem iguais, este código atualizado acima funcionará apenas com listas com um tamanho fixo de 5 agora.

Experimente online.

Explicação:

Versão simplificada desta resposta em math.stackexchange.com , portanto todo o crédito vai para @ThomasAhle .

Para citar sua resposta:

n(xn): =expn(x)x[0 0,1 1)

uma(xn)umaapow chamadas) e ao log iterado de seu valor (número de chamadas recursivas).

22220 0<2222(1 1/2)2222

Eu estaria interessado em sugestões para outros tipos de exemplos de contador, especialmente os inteiros.

Parece-me que, para o problema estar em P, precisamos de métodos não numéricos. Não parece improvável que certos casos analíticos sejam mais difíceis que P.

Exemplos:

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)

Exemplos de contadores:

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

Em relação aos exemplos contrários, ele menciona o seguinte na seção de comentários:

1 1<uma<100

Portanto, o principal a ser provado é que, uma vez que a cabeça de uma torre excede um certo ponto e o resto dos expoentes são delimitados (e igualmente numerosos), podemos simplesmente observar o valor mais alto. É um pouco contra-intuitivo, mas parece muito provável pelas simples desigualdades que você obtém.

Como os planos A e B são irrelevantes nesse desafio, uma vez que a altura é 5 para as duas torres de energia que inserimos, o plano C é. Então, mudei P(a)>P(b)para P(S(a,b))>P(S(b,a))if P(a)==P(b)else P(a)>P(b)com a função recursiva S(a,b). Se P(a)e P(b)resultar na mesma tupla, P(S(a,b))>P(S(b,a))primeiro removeremos os valores finais iguais aos mesmos índices, antes de fazer a mesma P(A)>P(B)verificação nessas listas agora mais curtas.

Kevin Cruijssen
fonte
11
Eu também sou péssima no golfe em python, mas aqui está uma 612 Byter
Personificação da Ignorância
11
495 bytes
Neil
2
Falha em [10,10,10,10,10]>[9,10,10,10,10]
Modalidade de Ignorância
11
Você só usa a função Ruma vez, então talvez você possa simplesmente incorporá-la?
Modalidade de ignorância
11
@EmbodimentofIgnorance Ainda há uma chamada pendente para Ra linha 5 ...
Neil
4

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›

Porto da resposta Ruby de @SimplyBeautifulArt , por isso, certifique-se de votar nele!

registro1 1(x)POSITIVE_INFINITYx>1 1NEGATIVE_INFINITYx<1 10.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 uma lista de inteiros dez: [a,b,c,d,e,f,g,h,i,j].

Experimente online ou verifique todos os casos de teste .

Explicação:

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 alguém quiser tentar jogar mais, aqui está um programa auxiliar que eu usei para obter as variáveis ​​corretas na lista de entrada.

Kevin Cruijssen
fonte
11
Muito impressionado isso tem menos de 100! E muito obrigado por adicionar a recompensa.
Anush 16/05/19
2
@ Anush Na verdade, tenho a sensação de que 96 é bastante longo, considerando a linguagem que não é do golfe, Ruby tem 151.; p E np sobre a recompensa. É principalmente para a abordagem do @SimplyBeautifulArt , mas ao mesmo tempo para dar alguma atenção ao desafio. A razão pela qual a votação foi reduzida foi porque você a postou algumas horas após a resposta anterior com 3 poderes. Pessoalmente, gosto desse desafio e fui o primeiro a votar e responder, mas ainda posso ver a verdade no primeiro comentário no post de desafio ao mesmo tempo. Esperamos que a recompensa vai fazer o seu desafio 0 ou positivo, embora :)
Kevin Cruijssen
Eu sonho com um 0! :)
Anush 16/05/19
11
[2,1,1,1,1,3,1,1,1,1] resultado 1 em vez disso tem que resultar 0
RosLuP
11
euog1 1(x)
3

C, 168 180 bytes

Porta C da resposta 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);}

Experimente online

Johan du Toit
fonte
2
Hmmm ... um porto de um porto * thonks *
Simply Beautiful Art
Falha3,1,10,10,10,2,1,10,10,10 como a minha resposta Java costumava também. E é realmente um porto de @ resposta Ruby SimplyBeautifulArt, já que ele é o único que veio com tudo e fixa os erros ..
Kevin Cruijssen
2

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}

A função acima da chamada z, em "az w", retornaria 1 se o número em a for maior que o número em w, caso contrário, retornaria 0.

Se eu tiver

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

Será f (aa)> f (bb) com a matriz aa e bb de 5 números positivos se e somente se (se a a> 1 de aa e bb) log (log (f (aa)))> log ( log (f (bb))) é preciso usar as leis log ():

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

Para construir v (aa) = log (log (aa)) = v (a, b, c, d, e) = log (log (a)) + log (b) (c ^ (d ^ e)) = {p (3 ↑ ⍵), / 3 ↓ ⍵} funcionam e, portanto, o exercício é encontrado quando v (aa)> v (bb).

Mas há um caso em que v (aa) e v (bb) são infinitos (o APL encerra o espaço de flutuação); nesse caso, eu usaria a função não segura

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

que eu não entendo completamente se está ok e não leva em conta um parâmetro também ... 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
RosLuP
fonte
Os testes na descrição do desafio estão faltando alguns casos extremos. Você pode verificar se também está funcionando para todos esses casos de teste ?
Kevin Cruijssen 17/05/19
11
@KevinCruijssen Aqui o teste, se excluir a citada acima parece ok ...
RosLuP
11
Se todos os casos de teste estiverem corretos, +1 de mim. Ansioso para ver uma explicação do seu código. :)
Kevin Cruijssen 17/05/19
11
Você disse que calculou cada uma delas log(log()), mas, para esse caso de teste, a diferença entre log(log(10^10^10^10^10))e log(log(9^10^10^10^10))exigiria uma quantidade absurda de precisão para perceber. Você precisaria ter um ponto flutuante com cerca de 2e1010 dígitos de precisão. E isso está ignorando o fato de que ambos os lados são aproximadamente tão grandes quanto 10^10^10, o que acho difícil acreditar que você foi capaz de calcular.
Simply Beautiful Art
11
Talvez falhe 9, 10, 10, 10, 10, 10, 9, 10, 10, 10, o que deve retornar 1, mas s(9,10,10,10,10) < s(10,9,10,10,10).
Simply Beautiful Art
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]);}

Porto da resposta Ruby de @SimplyBeautifulArt , por isso, certifique-se de votar nele!
-14 bytes graças a @SimplyBeautifulArt .
+17 bytes para as mesmas correções de bugs que a resposta do Ruby.

Experimente online.

Explicação:

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]);}
Kevin Cruijssen
fonte
Parece funcionar bem se você usar em x==yvez de M.abs(x-y)<1e-9.
Arte simplesmente linda
@SimplyBeautifulArt Espere, faz? .. Wtf. Quando eu tive minha versão não-gasta, ela não funcionou para um caso de teste. A saída da string era a mesma, mas internamente ela diferia um pouco. A versão não-gasta era a sua versão não-gasta, antes de eu mudar para o ternário de golfe que você tem na sua resposta Ruby também. Precisão estúpida de ponto flutuante. Mudará, pois funciona para os casos de teste na abordagem atual. Obrigado.
Kevin Cruijssen
Lol, enquanto você está nisso, você pode querer olhar para as minhas atualizações: ^)
Simply Beautiful Art
11
tIsso pode ser removido para salvar um byte, colocando-o ycomo eu fiz. TIO
Arte simplesmente linda
11
@SimplyBeautifulArt Nvm sobre como atualizar minha resposta 05AB1E com a mesma alteração. O byte-count permaneceria 96.
Kevin Cruijssen