Какой действительно большой номер больше?

11

Этот вопрос сложен (и, в частности, сложнее, чем Какая большая цифра больше? ), Для тех, кто любит более сложные головоломки.

вход

Целые числа a1, a2, a3, a4, a5, b1, b2, b3, b4, b5, каждое в диапазоне от 1 до 10.

Вывод

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

^ это возведение в степень в этом вопросе.

правила

Это код-гольф. Ваш код должен завершаться правильно в течение 10 секунд для любого действительного ввода на TIO . Если ваш язык не на TIO, код должен завершиться менее чем за 10 секунд на вашем компьютере.

Вы можете вывести что-нибудь Truthy для True и что-нибудь Falsey для False.

Контрольные примеры

Напомним, что по правилам экспоненты 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

Новые тестовые случаи от Кевина Круйссена

[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
Ануш
источник
5
Я VTC'ing это, хотя это не дурак; это слишком близко к задаче, которую вы опубликовали за 4 часа до этого, и показывает отсутствие усилий для придумывания уникальных задач.
Волшебная урна осьминога
3
Я чувствую, что 9 человек согласились с моей точкой зрения с их голосами; но, как вы говорите, это ваш выбор, чтобы сохранить его, хотя он имеет 9 голосов. Просто пролил некоторый свет на то, почему могут быть отрицательные голоса.
Волшебная Урна Осьминога
3
Честно говоря, это были мои два цента. нам не нужно вдаваться в подробности здесь. Сожалею, что даже что-то сказал; последнее, что я хотел, это аргументированный ответ. Я просто заявил, почему я дал -1.
Волшебная урна осьминога
7
Я голосую, чтобы вновь открыть этот пост, потому что он имеет другой параметр сложности и требуемый подход для его решения очень отличается. Мета пост .
user202729
3
Предлагаемые тестовые случаи (для крайних случаев, с которыми сталкиваются ответы Python, Ruby, Java и 05AB1E)
Кевин Круйссен

Ответы:

8

Рубин, 150 байт

Смотрите ревизии для количества предыдущих байтов.

->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 байт благодаря @ValueInk

+16 байт благодаря @RosLuP за ошибки.

Попробуйте онлайн .

Сравните разные базовые державы-башни (высотой пять)?

Код Ungolfed:

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

Разбивка кода:

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

Это базовый tлогарифм, который будет использоваться для уменьшения размера сравниваемых чисел. По умолчанию используется основание, cесли указан только один аргумент.

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

Это обновление, i = i ** jпоскольку оно iникогда не используется yсамо по себе, и является результатом b^c^d^e == g^h^i(^j)двойной регистрации и перемещения всего в одну сторону. Затем мы z = l[a, f] * b ** cв качестве базы gжурнала базы fданных a ** b ** c.

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

1^b^c^d^e = 1никогда не бывает больше f^g^h^i^j, а также a^b^c^d^eвсегда больше, чем 1^g^h^i^j = 1если бы a != 1. Обратите внимание, что return pвозвращается nil, что ложно, и return 1возвращается 1, что правда.

elsif b == 1
    return z > h

Если b == 1или g == 1, то это сводится к сравнению a ** b ** cс f ** g ** h, что делается с двумя бревнами с обеих сторон.

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

Это сравнивается a ** b ** cс f ** g ** h ** iперестановкой по log[log[b ** c * log[a, f], g], h]сравнению с i. (Напомним, что i **= jв начале и z = log[b ** c * log[a, f], g].)

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

Это сравнивает 4 высшие силы после входа в обе стороны дважды. Если они равны, он сравнивает базу.

Просто Красивое Искусство
источник
5

Python 2 671 612 495 490 611 597 байт

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 байт благодаря @EmbodimentOfIgnorance
-117 байт благодаря @Neil
+121 байт примерно для пяти исправлений ошибок, все найдены @ngn

Принимает входные данные в виде двух списков. ПРИМЕЧАНИЕ. Также работает с большими списками или списками неравной длины. РЕДАКТИРОВАТЬ: больше не правда; это все еще работает, если P(a)и P(b)приводит к различным кортежам, но если они одинаковы, этот обновленный код выше работает только со списками с фиксированным размером 5.

Попробуйте онлайн.

Объяснение:

Гольф-версия этого ответа на math.stackexchange.com , поэтому вся заслуга принадлежит @ThomasAhle .

Процитирую его ответ:

N(Икс|N)знак равноеИкспN(Икс)Икс[0,1)

a(Икс|N)aapow

22220<2222(1/2)2222

Я был бы заинтересован в предложениях к другим типам встречных примеров, особенно целочисленных.

Мне кажется, что для того, чтобы задача была в P, нам нужны нечисловые методы. Не кажется маловероятным, что некоторые аналитические случаи сложнее, чем P.

Примеры:

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)

Встречные примеры:

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

Что касается встречных примеров, он упоминает следующее в разделе комментариев:

1<a<100

Следовательно, главное, что нужно доказать, состоит в том, что как только головка башни превышает определенную точку, а остальные показатели ограничены (и одинаково многочисленны), мы можем просто посмотреть на верхнее отличающееся значение. Это немного противоречит интуиции, но, скорее всего, из-за простых неравенств, которые вы получаете.

Так как планы A и B не имеют значения в этой задаче, так как высота для обеих вводимых башен равна 5, план C это так. Поэтому я изменил P(a)>P(b)к P(S(a,b))>P(S(b,a))if P(a)==P(b)else P(a)>P(b)с рекурсивной функцией S(a,b). Если P(a)и в P(b)результате P(S(a,b))>P(S(b,a))получится один и тот же кортеж, он сначала удалит конечные значения, равные по тем же индексам, а затем выполнит ту же P(A)>P(B)проверку в этих теперь более коротких списках.

Кевин Круйссен
источник
1
Я тоже сосу в гольф на питоне, но вот 612 байт
Воплощение Невежества
1
495 байтов
Нейл
2
Неудача для[10,10,10,10,10]>[9,10,10,10,10]
Воплощение Невежества
1
Вы используете функцию Rтолько один раз, так что, может быть, вы можете просто встроить ее?
Воплощение неведения
1
@EmbodimentofIgnorance На Rлинии 5 все еще есть громкий звонок ...
Нил
4

05AB1E , 96 104 байта

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›

Порт @SimplyBeautifulArt 's Ruby answer , так что обязательно проголосуйте за него!

журнал1(Икс)POSITIVE_INFINITYИкс>1NEGATIVE_INFINITYИкс<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

Ввод в виде списка из десяти целых чисел: [a,b,c,d,e,f,g,h,i,j].

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

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)

Если кто-то захочет попробовать это в дальнейшем, вот вспомогательная программа, которую я использовал, чтобы получить правильные переменные из списка ввода.

Кевин Круйссен
источник
1
Очень впечатлило это под 100! И большое спасибо за добавление награды.
Ануш
2
@ Ануш, я на самом деле чувствую, что 96 - это довольно долго, учитывая, что язык без игры в гольф Руби получил 151.; p И np о награде. Это в основном для подхода @SimplyBeautifulArt , но в то же время, чтобы уделить вызову некоторое внимание. Причиной того, что за него проголосовали, является то, что вы опубликовали его через несколько часов после предыдущего ответа с 3 полномочиями. Мне лично нравится этот вызов, и я был первым, кто поддержал его и ответил на него, но я все еще могу увидеть правду в самом первом комментарии под сообщением в то же время. Надеюсь, щедрость сделает ваш вызов 0 или положительным, хотя :)
Кевин Круйссен
Я мечтаю получить 0! :)
Ануш
1
[2,1,1,1,1,3,1,1,1,1] результат 1 вместо этого должен приводить к 0
РосЛюП
1
Lог1(Икс)
3

C 168 180 байт

С портом от ответа Кевина Круйссена.

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

Попробуйте онлайн

Йохан дю Туа
источник
2
Хммм ... порт из порта * спасибо *
Просто Красивое Искусство
Не подходит,3,1,10,10,10,2,1,10,10,10 как и мой Java-ответ. И это на самом деле порт Ruby-ответа @ SimplyBeautifulArt, поскольку именно он придумал все и исправил ошибки ..
Кевин Круйссен
2

APL (NARS), символы 118, байты 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}

Функция выше вызова z в «az w» вернет 1, если число в a больше, чем число в w, в противном случае вернет 0.

Если у меня есть

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

Это будет f (aa)> f (bb) с массивом aa и bb из 5 положительных чисел тогда и только тогда, когда (если a> 1 для aa и bb) log (log (f (aa)))> log ( log (f (bb))) нужно использовать законы log ():

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

для сборки v (aa) = log (log (aa)) = v (a, b, c, d, e) = log (log (a)) + log (b) (c ^ (d ^ e)) = {p (3 ↑ ⍵), / 3 ↓ ⍵}, и поэтому упражнение найти, когда v (aa)> v (bb).

Но есть случай, когда v (aa) и v (bb) оба бесконечны (APL имеет конец пространства с плавающей запятой), в этом случае я бы использовал небезопасную функцию

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

что я не совсем понимаю, если это нормально, и это не принимать во внимание параметр тоже ... 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
источник
В тестах в описании задачи отсутствуют некоторые крайние случаи. Не могли бы вы проверить, что он также работает для всех этих тестов ?
Кевин Круйссен
1
@KevinCruijssen Вот ваш тест, если исключить приведенный выше, кажется нормальным ...
RosLuP
1
Если все тесты верны, то +1 от меня. Ждем объяснения вашего кода. :)
Кевин Круйссен
1
Вы сказали, что рассчитали каждый, взяв log(log()), но для этого тестового случая разница между log(log(10^10^10^10^10))и log(log(9^10^10^10^10))потребовала бы абсурдной точности, чтобы уловить. Вам нужно иметь с плавающей запятой примерно 2e1010 цифр точности. И это игнорирует тот факт, что обе стороны примерно равны друг другу 10^10^10, и мне трудно поверить, что вы смогли вычислить.
Просто Красивое Искусство
1
Возможно, это терпит неудачу 9, 10, 10, 10, 10, 10, 9, 10, 10, 10, которая должна вернуться 1, но s(9,10,10,10,10) < s(10,9,10,10,10).
Просто Красивое Искусство
1

Java 8, 299 288 286 252 210 208 224 байта

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

Порт @SimplyBeautifulArt 's Ruby answer , так что обязательно проголосуйте за него!
-14 байт благодаря @SimplyBeautifulArt .
+17 байт за те же исправления ошибок, что и ответ Ruby.

Попробуйте онлайн.

Объяснение:

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]);}
Кевин Круйссен
источник
Кажется, работает нормально, если вы используете x==yвместо M.abs(x-y)<1e-9.
Просто Красивое Искусство
@SimplyBeautifulArt Подождите, это так? .. Wtf. Когда у меня была моя версия без гольфа, она не работала ни для одного теста. Вывод строки был таким же, но внутри он немного отличался. Версия без гольфа была вашей версией без гольфа, прежде чем я сменил ее на троичную гольф для гольфа, которая есть и в вашем ответе на Ruby. Тупая точность с плавающей точкой. Изменит ее, так как она действительно работает для тестовых случаев в текущем подходе. Спасибо.
Кевин Круйссен
Lol, пока ты на нем, ты можешь посмотреть мои обновления: ^)
Просто Красивое Искусство
1
tЭто можно удалить, чтобы сохранить один байт, поместив его, yкак я сделал. TIO
Просто Красивое Искусство
1
@SimplyBeautifulArt Nvm об обновлении моего ответа 05AB1E с тем же изменением. Счетчик байтов останется 96.
Кевин Круйссен