Bu soru daha zor bulmacaları sevenler için zor (ve özellikle Hangi büyük sayı daha büyük? )

Giriş

A1, a2, a3, a4, a5, b1, b2, b3, b4, b5 tamsayılarının her biri 1 ila 10 aralığındadır.

Çıktı

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

^ bu sorudaki üssüdür.

kurallar

Bu kod golfü. TIO'da geçerli herhangi bir giriş için kodunuzun 10 saniye içinde doğru şekilde sonlandırılması gerekir . Diliniz TIO'da değilse, kod makinenizde 10 saniyenin altında bitmelidir.

True için Doğruluk ve False için Falsey herhangi bir şey çıktısı alabilirsiniz.

Test senaryoları

Üs kurallarına göre, 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

Kevin Cruijssen'den yeni test örnekleri

[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

Yakut, 150 bayt

Önceki bayt sayıları için düzeltmelere bakın .

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

@ValueInk sayesinde -10 bayt

Hatalar için @RosLuP sayesinde +16 bayt .

Çevrimiçi deneyin .

Farklı temel güç kulelerini karşılaştır ('yükseklik' beşten)?

Kod çözülmemiş kod:

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

Kod dökümü:

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

Bu, tkarşılaştırdığımız sayıların boyutunu azaltmak için kullanılacak temel logaritmadır. cYalnızca bir argüman verildiğinde varsayılan olarak temel alır .

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

Bu güncellemeler i = i ** jberi iasla kendi, ve üzerinde kullanılan alır ygiriş sonucudur b^c^d^e == g^h^i(^j)iki kez ve bir tarafa her şeyi hareketli. Sonra izin z = l[a, f] * b ** cgünlüğü üs olarak ggünlük tabanının farasında a ** b ** c.

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

1^b^c^d^e = 1daha asla büyüktür f^g^h^i^jve benzer şekilde, a^b^c^d^edaima daha büyüktür 1^g^h^i^j = 1eğer a != 1. Not return pdöner nilFalsey olduğunu ve return 1getiri 1truthy olan.

elsif b == 1
    return z > h

Eğer b == 1yoksa g == 1, o zaman bu karşılaştırma için azaltır a ** b ** ciçin f ** g ** hher iki tarafa iki günlükleri ile yapılır, hangi.

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

Bu, a ** b ** cile karşılaştırıldığında f ** g ** h ** iyeniden düzenleyerek log[log[b ** c * log[a, f], g], h]karşılaştırır i. ( i **= jBaşlangıçta hatırlayın ve z = log[b ** c * log[a, f], g].)

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

Bu, her iki tarafı iki kez kaydettikten sonra en yüksek 4 gücü karşılaştırır. Eşitse, tabanı karşılaştırır.

Python 2, 671 612 495 490 611 597 bayt

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 sayesinde bayt @EmbodimentOfIgnorance
-117 sayesinde bayt @Neil
beş hakkında hata düzeltmeleri için 121 bayt, herkes tarafından bulundu @ngn

Girdileri iki liste halinde alır. NOT: Ayrıca daha büyük veya eşit olmayan uzunluktaki listelerle de çalışır. EDIT: Artık doğru değil; yine de farklı tuples P(a)ile P(b)sonuçlanırsa çalışır , ancak bunlar aynıysa yukarıdaki bu güncellenmiş kod sadece 5 sabit boyutlu listelerle çalışır.

Çevrimiçi deneyin.

Açıklama:

Bu cevabın math.stackexchange.com'daki golf versiyonu, tüm kredi @ThomasAhle'a gidiyor .

Cevabını alıntılamak için:

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

Diğer tür karşı örneklere, özellikle de tamsayılara yönelik önerilerle ilgilenirim.

Bana öyle geliyor ki problemin P olması için sayısal olmayan yöntemlere ihtiyacımız var. Bazı analitik vakaların P'den daha zor olması pek olası görünmüyor.

Örnekler:

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)

Sayaç örnekleri:

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

Karşı örneklerle ilgili olarak, yorum bölümünde aşağıdakilerden bahseder:

$1<a<100$

Bu nedenle kanıtlanması gereken en önemli şey, bir kulenin başı belirli bir noktayı aştığında ve üslerin geri kalanı sınırlandığında (ve eşit olarak çok sayıda), en üstteki farklı değere bakabiliriz. Biraz sezgisel, ancak elde ettiğiniz basit eşitsizliklerden çok muhtemel görünüyor.

Plan A ve B bu zorlukta önemsiz olduğundan, girdiğimiz her iki güç kulesi için yükseklik 5 olduğundan, plan C'dir. Yani ben değiştim P(a)>P(b)için P(S(a,b))>P(S(b,a))if P(a)==P(b)else P(a)>P(b)özyinelemeli fonksiyonu ile S(a,b). Eğer P(a)ve P(b)aynı başlığın neden, P(S(a,b))>P(S(b,a))ilk aynı için yapmadan önce, aynı endeksleri eşit değerler sondaki kaldırır P(A)>P(B), bu artık daha kısa listelerinde kontrol.

05AB1E , 96 104 bayt

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'ın Ruby cevabı , bu yüzden onu oyladığınızdan emin olun!

$\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

On tamsayılar listesi olarak Girdi: [a,b,c,d,e,f,g,h,i,j].

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

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)

Herkes daha fazla denemek ve golf istiyorsa, İşte giriş listesinden doğru değişkenleri almak için kullandığım yardımcı bir program .

C, 168180 bayt

Kevin Cruijssen'in cevabından C limanı.

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

Çevrimiçi deneyin

APL (NARS), karakter 118, bayt 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'daki sayı w'deki sayıdan büyükse z çağrısının üzerindeki işlev, "az w" de 1 döndürür, aksi takdirde 0 döndürür.

Sahip olursam

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

F (aa)> f (bb) ile aa ve bb dizisi 5 pozitif sayı olacak ve sadece (aa ve bb a> 1 ise) log (log (f (aa)))) log ( log (f (bb))) log () yasalarını kullanmak zorundadır:

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

build v (aa) = log (log (aa)) = v (a, b, c, d, e) = log (log (a)) + log (b) (c ^ (d ^ e)) = {p (3 ↑ ⍵), / 3 ↓ ⍵} fonksiyonunu kullanır ve böylece v (aa)> v (bb) olduğunda egzersiz bulunur.

Ancak v (aa) ve v (bb) 'nin her ikisinin de sonsuz olduğu bir durum var (APL şamandıra alanını sonlandırdı), bu durumda güvenli olmayan fonksiyonu kullanacağım

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

Tamam olup olmadığını anlamak ve saymak bir parametre de çok almaz ki ... 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 bayt

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'ın Ruby cevabı , bu yüzden onu oyladığınızdan emin olun! @SimplyBeautifulArt
sayesinde -14 bayt . Ruby cevabı ile aynı hata düzeltmeleri için +17 bayt.

Çevrimiçi deneyin.

Açıklama:

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