¿Qué número realmente grande es más grande?

11

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
Anush
fuente
55
Estoy VTC'ing esto, a pesar de que no es un engaño; está demasiado cerca de un desafío que publicaste 4 horas antes y muestra una falta de esfuerzo para pensar en desafíos únicos.
Urna mágica de pulpo
3
Siento que 9 personas acordaron mi punto con sus votos; pero, como usted dice, es su elección mantenerlo a pesar de que tiene 9 votos negativos. Estaba arrojando algo de luz sobre por qué puede haber votos negativos.
Urna mágica de pulpo
3
Era solo mi hombre de dos centavos, sinceramente; No necesitamos entrar en detalles aquí. Lamento incluso dije algo; Lo último que quería era una respuesta argumentativa. Solo decía por qué le di un -1.
Urna mágica de pulpo
77
Estoy votando para volver a abrir esta publicación porque tiene un parámetro de dificultad diferente y el enfoque requerido para resolverlo es muy diferente. Meta post .
user202729
3
Casos de prueba sugeridos (para los casos extremos encontrados por las respuestas de Python, Ruby, Java y 05AB1E)
Kevin Cruijssen

Respuestas:

8

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.

Simplemente hermoso arte
fuente
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 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:

norte(Xnorte): =miXpagnorte(X)X[0 0,1) , este formato permite una fácil comparación entre números.

una(Xnorte)unaapow llamadas) y el registro iterado de su valor (número de llamadas recursivas).

22220 0<2222(1/ /2)2222

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

Kevin Cruijssen
fuente
1
También apestaba al golf en Python, pero aquí hay un byte 612
Encarnación de la ignorancia
1
495 bytes
Neil
2
Fracasa en[10,10,10,10,10]>[9,10,10,10,10]
Encarnación de la ignorancia
1
Solo usa la función Runa vez, ¿así que tal vez solo puede alinearla?
Encarnación de la ignorancia
1
@EmbodimentofIgnorance Todavía hay una llamada pendiente Ren la línea 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›

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

Iniciar sesión1(X)POSITIVE_INFINITYX>1NEGATIVE_INFINITYX<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 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.

Kevin Cruijssen
fuente
1
Muy impresionado esto tiene menos de 100! Y muchas gracias por agregar la recompensa.
Anush
2
@Anush De hecho, tengo la sensación de que 96 es bastante largo, teniendo en cuenta el lenguaje no relacionado con el golf que Ruby obtuvo 151.; p y np sobre la recompensa. Es principalmente para el enfoque de @SimplyBeautifulArt , pero al mismo tiempo para darle un poco de atención al desafío. La razón por la que se votó negativamente es porque lo publicaste unas horas después de tu respuesta anterior con 3 poderes. Personalmente, me gusta este desafío, y fui el primero en votar y responderlo, pero todavía puedo ver la verdad en el primer comentario en la publicación del desafío al mismo tiempo. Con suerte la generosidad hará que su desafío 0 o positivo, aunque :)
Kevin Cruijssen
¡Sueño con obtener 0! :)
Anush
1
[2,1,1,1,1,3,1,1,1,1] resultado 1 en su lugar tiene que resultar 0
RosLuP
1
losol1(X)
3

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

Johan du Toit
fuente
2
Hmmm ... un puerto de un puerto * gracias *
Simply Beautiful Art
También falla3,1,10,10,10,2,1,10,10,10 mi respuesta Java como antes. Y en realidad es un puerto de la respuesta de Ruby de @ SimplyBeautifulArt, ya que él fue quien inventó todo y corrigió los errores ...
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}

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
RosLuP
fuente
Las pruebas en la descripción del desafío carecen de algunos casos extremos. ¿Podría verificar que también está funcionando para todos estos casos de prueba ?
Kevin Cruijssen
1
@KevinCruijssen Aquí su prueba, si excluye la anterior, parece correcta ...
RosLuP
1
Si todos los casos de prueba son correctos, entonces +1 de mi parte. Esperamos ver una explicación de su código. :)
Kevin Cruijssen
1
Dijiste que calculabas cada uno tomando log(log()), pero para ese caso de prueba, la diferencia entre log(log(10^10^10^10^10))y log(log(9^10^10^10^10))requeriría una cantidad absurda de precisión para recoger. Necesitaría tener un punto flotante con aproximadamente 2e1010 dígitos de precisión. Y esto ignora el hecho de que ambos lados son aproximadamente tan grandes como 10^10^10, lo que me resulta difícil de creer que haya podido calcular.
Simply Beautiful Art
1
Quizás falla 9, 10, 10, 10, 10, 10, 9, 10, 10, 10, lo que debería volver 1, pero 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]);}

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]);}
Kevin Cruijssen
fuente
Parece funcionar bien si lo usa en x==ylugar de M.abs(x-y)<1e-9.
Simply Beautiful Art
@SimplyBeautifulArt Espera, lo hace? .. Wtf. Cuando tuve mi versión sin golf no funcionó para un caso de prueba. La salida de la cadena era la misma, pero internamente era muy diferente. La versión sin golf fue tu versión sin golf, antes de cambiarla al ternario de golf que tienes también en tu respuesta de Ruby. Estúpida precisión de coma flotante. La cambiará, ya que funciona para los casos de prueba en el enfoque actual. Gracias.
Kevin Cruijssen
Lol, mientras lo haces, quizás quieras ver mis actualizaciones: ^)
Simply Beautiful Art
1
tSe puede eliminar para guardar un byte poniéndolo ycomo lo hice. TIO
Simply Beautiful Art
1
@SimplyBeautifulArt Nvm acerca de actualizar mi respuesta 05AB1E con el mismo cambio. El recuento de bytes seguirá siendo 96.
Kevin Cruijssen