Wkład

Każda liczba całkowita a1, a2, a3, b1, b2, b3 w zakresie od 1 do 20.

Wydajność

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

^ jest potęgowaniem w tym pytaniu.

Zasady

To jest golf golfowy. Twój kod musi zostać poprawnie zakończony w ciągu 10 sekund dla każdego ważnego wejścia na standardowym komputerze stacjonarnym.

Możesz wypisać dowolną wartość Prawda dla Prawdy i dowolną Falsey dla False.

Możesz przyjąć dowolną kolejność wprowadzania danych, o ile podana jest w odpowiedzi i zawsze taka sama.

W przypadku tego pytania Twój kod powinien zawsze być poprawny. Oznacza to, że nie powinno to zawieść z powodu niedokładności zmiennoprzecinkowych. Ze względu na ograniczony zakres danych wejściowych nie powinno to być zbyt trudne do osiągnięcia.

Przypadki testowe

3^(4^5) > 5^(4^3)
1^(2^3) < 3^(2^1)
3^(6^5) < 5^(20^3)
20^(20^20) > 20^(20^19)
20^(20^20) == 20^(20^20)
2^2^20 > 2^20^2
2^3^12 == 8^3^11
1^20^20 == 1^1^1
1^1^1 == 1^20^20

Perl 6 , 31 29 bajtów

-2 bajty dzięki Grimy

*.log10* * ***>*.log10* * ***

Wypróbuj online!

Wierzcie lub nie, to nie jest esolang, nawet jeśli składa się głównie z gwiazdek. To używa formuły Arnaulda , z log10 zamiast ln.

R , 39 bajtów

function(x,y,z)rank(log2(x)*(y^z))[1]<2

Wypróbuj online!

Zwraca FAŁSZ, gdy a > bi PRAWDA, jeślib < a

05AB1E , 11 9 11 7 bajtów

.²Šm*`›

Port @Arnauld 's JavaScript i @digEmAll R' s podchodzi (widziałem je dodawać w tym samym czasie)
-2 bajty dzięki @Emigna
+2 bajtów jak bug-fix po @Arnauld 's i @digEmAll odpowiedzi jest zawarta błąd
-4 bajty teraz, gdy dozwolona jest inna kolejność wprowadzania po komentarzach @LuisMendo

Wejście jak [a1,b1], [a3,b3], [a2,b2]w trzech oddzielonych wejść.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

.²       # Take the logarithm with base 2 of the implicit [a1,b1]-input
  Š      # Triple-swap a,b,c to c,a,b with the implicit inputs
         #  The stack order is now: [log2(a1),log2(b1)], [a2,b2], [a3,b3]
   m     # Take the power, resulting in [a2**a3,b2**b3]
    *    # Multiply it with the log2-list, resulting in [log2(a1)*a2**a3,log2(b1)*b2**b3]
     `   # Push both values separated to the stack
      ›  # And check if log2(a1)*a2**a3 is larger than log2(b1)*b2**b3
         # (after which the result is output implicitly)

Java (JDK) , 56 bajtów

(a,b,c,d,e,f)->a>Math.pow(d,Math.pow(e,f)/Math.pow(b,c))

Wypróbuj online!

Kredyty

• @ Ørjan Johansen za znalezienie błędu w moim rozwiązaniu.
• Zaoszczędzono 10 bajtów, ponownie wykorzystując korzystne operandy @ tsh .

Wolfram Language (Mathematica) , 23 bajty

#2^#3Log@#>#5^#6Log@#4&

Wypróbuj online!

J , ¹¹ 9 bajtów

>&(^.@^/)

Wypróbuj online!

Argumenty podane jako listy.

• > czy lewy jest większy?
• &(...) ale najpierw przekształć odpowiednio każdy argument:
• ^.@^/zmniejszaj go od prawej do lewej z eksponencją. Ale ponieważ zwykłe potęgowanie ograniczy błąd nawet dla liczb rozszerzonych, bierzemy logi obu stron

Czysty , 44 bajty

import StdEnv
$a b c d e f=b^c/e^f>ln d/ln a

Wypróbuj online!

Wykorzystuje adaptację formuły Arnaulda.

Python 3 , 68 bajtów

lambda a,b,c,d,e,f:log(a,2)*(b**c)>log(d,2)*(e**f)
from math import*

Wypróbuj online!

Port odpowiedzi @Arnualds, ale zmieniono bazę logów.

05AB1E , 13 bajtów

Wykorzystuje metodę z odpowiedzi JS Arnaulda

2F.²IIm*ˆ}¯`›

Wypróbuj online!

Excel, 28 bajtów

=B1^C1*LOG(A1)>E1^F1*LOG(D1)

Implementacja Excel tej samej formuły, która już była używana.

JavaScript, 51 bajtów

f=(a,b,c,h,i,j)=>(l=Math.log)(a)*b**c-l(h)*i**j>1e-8

Co zaskakujące, przypadki testowe nie wykazują błędów zmiennoprzecinkowych. Nie wiem, czy kiedykolwiek tak się stanie.

To po prostu porównuje logarytm liczb.

Tolerancja równości jest równa 1e-8.

bc -l, 47 bajtów

l(read())*read()^read()>l(read())*read()^read()

z wejściem odczytanym z STDIN, jedna liczba całkowita na linię.

bcjest dość szybki; obsługuje a = b = c = d = e = f = 1 000 000 w nieco ponad sekundę na moim laptopie.

C ++ (gcc) , 86 bajtów

Dzięki @ ØrjanJohansen za wskazanie błędu w tym i @Ourous za naprawienie.

#import<cmath>
int a(int i[]){return pow(i[1],i[2])/pow(i[4],i[5])>log(i[3])/log(*i);}

Wypróbuj online!

$a^{b^c} > d^{e^f}$

Galaretka , 8 bajtów

l⁵×*/}>/

Wypróbuj online!

Na podstawie odpowiedzi JS Arnaulda . Oczekuje jako danych wejściowych [a1, b1]jako argument lewy i [[a2, b2], [a3, b3]]argument prawy.

Teraz zmieniono na używanie logu do bazy 10, która, o ile poprawnie obsługuje wszystkie możliwe dane wejściowe w określonym zakresie. Dzięki Ørjan Johansen za znalezienie oryginalnego problemu!

TI-BASIC, 27 31 bajtów

ln(Ans(1))Ans(2)^Ans(3)>Ans(5)^Ans(6)(ln(Ans(4

$6$Ans

Przykłady:

{3,4,5,5,4,3
   {3 4 5 5 4 3}
prgmCDGF16
               1
{20,20,20,20,20,19       ;these two lines go off-screen
{20 20 20 20 20 19}
prgmCDGF16
               1
{3,6,5,5,20,3
  {3 6 5 5 20 3}
prgmCDGF16
               0

Wyjaśnienie:

ln(Ans(1))Ans(2)^Ans(3)>Ans(5)^Ans(6)(ln(Ans(4   ;full program
                                                 ;elements of input denoted as:
                                                 ; {#1 #2 #3 #4 #5 #6}

ln(Ans(1))Ans(2)^Ans(3)                          ;calculate ln(#1)*(#2^#3)
                        Ans(5)^Ans(6)(ln(Ans(4   ;calculate (#5^#6)*ln(#4)
                       >                         ;is the first result greater than the
                                                 ; second result?
                                                 ; leave answer in "Ans"
                                                 ;implicit print of "Ans"

Uwaga: TI-BASIC jest językiem tokenizowanym. Liczba znaków nie jest równa liczbie bajtów.

APL (NARS), znaki 36, bajty 72

{>/{(a b c)←⍵⋄a=1:¯1⋄(⍟⍟a)+c×⍟b}¨⍺⍵}

Tutaj poniżej funkcja z w (abc) z (xyt) zwróci 1, jeśli a ^ (b ^ c)> x ^ (y ^ t) w przeciwnym razie zwróci 0; test

  z←{>/{(a b c)←⍵⋄a=1:¯1⋄(⍟⍟a)+c×⍟b}¨⍺⍵}
  3 4 5 z 5 4 3
1
  1 2 3 z 3 2 1
0
  3 6 5 z 5 20 3
0
  20 20 20 z 20 20 19
1
  20 20 20 z 20 20 20
0
  2 2 20 z 2 20 2
1
  2 3 12 z 8 3 11
0
  1 20 20 z 1 1 1
0
  1 1 1 z 1 20 20
0
  1 4 5 z 2 1 1
0

{(abc) ← ⍵⋄a = 1: ¯1⋄ (⍟⍟a) + c × ⍟b} to funkcja p (a, b, c) = log (log (a)) + c * log (b ) = log (log (a ^ b ^ c)), a jeśli aa = a ^ (b ^ c) z a, b, c> 0 oraz a> 1 bb = x ^ (y ^ t) z x, y, t> 0 i x> 1 niż

aa>bb <=> log(log(a^b^c))>log(log(x^y^t))  <=>  p(a,b,c)>p(x,y,t)

Wystąpił problem z funkcją p: Gdy a ma wartość 1, dziennik log 1 nie istnieje, więc wybieram reprezentowanie go liczbą -1; gdy a = 2, więc dziennik a jest liczbą ujemną, ale> -1.

PS. Widział funkcję w swoim większym zestawie, w którym jest zdefiniowana

p(a,b,c)=log(log(a))+c*log(b)

pojawia się zakres dla a, b, cw 1..20 jest za mało ... Jeśli ktoś widzi, kiedy przepełnia się logarytmiczną podstawą 10, zakres dla a, b, c może wynosić 1..10000000 lub większy dla 64 bitów typ pływaka.