Чисте зло: Евал
a=lambda x,y:(y<0)*x or eval("a("*9**9**9+"x**.1"+",y-1)"*9**9**9)
print a(input(),9**9**9**9**9)//1
Висловлювання всередині eval створює рядок довжиною 7 * 10 10 10 10 10 10 8,57, який складається не з нічого, а лише з викликів до функції лямбда, кожен з яких побудує рядок аналогічної довжини, yвмикатися і вмикатися, поки в кінцевому підсумку не стане 0. Начебто це має ту ж складність, що і метод Ешеу, наведений нижче, але замість того, щоб покладатися на логіку керування чи керування, він просто розбиває гігантські рядки разом (а чистий результат набирає більше стеків ... напевно?).
Найбільший y значення, яке я можу поставити та обчислити без помилки кидання Python, - це 2, що вже достатньо для зменшення введення max-float у повернення 1.
Рядок довжини 7,625,597,484,987 занадто великий: OverflowError: cannot fit 'long' into an index-sized integer.
Я повинен зупинитися.
Ешев Math.log : Переходячи до (10-го) кореня (проблеми), Оцінка: функція ефективно відрізняється від y = 1.
Імпорт математичної бібліотеки обмежує кількість байтів. Дозволяє усунути це і замінити log(x)функцію на щось приблизно еквівалентне: x**.1що коштує приблизно стільки ж символів, але імпорт не потребує. Обидві функції мають підлінійний вихід по відношенню до входу, але х 0,1 зростає ще повільніше . Однак нас не хвилює ціла партія, ми дбаємо лише про те, щоб вона мала однакову базову схему зростання щодо великої кількості, використовуючи при цьому порівнянну кількість символів (наприклад,x**.9 , така ж кількість символів, але росте швидше, тому там є деяка цінність, яка б демонструвала такий самий ріст).
Тепер, що робити з 16 символами. Як щодо ... розширення нашої лямбда-функції, щоб мати властивості Ackermann Sequence? Ця відповідь для великої кількості надихнула це рішення.
a=lambda x,y,z:(z<0)*x or y and a(x**.1,z**z,z-1)or a(x**.1,y-1,z)
print a(input(),9,9**9**9**99)//1
Розділ z**zтут заважає мені виконувати цю функцію з будь-якого місця, близького до здорових входів для, yі zнайбільші значення, які я можу використовувати, - це 9 і 3, для яких я отримую значення 1,0, навіть для найбільших плаваючих підтримків Python (зауважте: поки 1.0 чисельно перевищує 6,77538853089e-05, підвищені рівні рекурсії переміщують вихід цієї функції ближче до 1, залишаючись більшим за 1, тоді як попередня функція переміщувала значення ближче до 0, залишаючись більшими за 0, таким чином, навіть помірна рекурсія на цій функції призводить до такої кількості операцій, що число з плаваючою комою втрачає всі значущі біти).
Перенастройте вихідний лямбда-дзвінок на значення рекурсії 0 та 2 ...
>>>1.7976931348623157e+308
1.0000000071
Якщо порівняння робиться на «зміщення від 0» замість «зміщення від 1», ця функція повертається 7.1e-9, що, безумовно, менше, ніж 6.7e-05.
Фактичні програми базової рекурсії (г значення) 10 10 10 10 1.97 рівнів в глибину, як тільки сама у вихлопів, він отримує скидання з 10 10 10 10 10 1.97 (тому початкове значення 9 достатньо), так що я не Навіть не знаю, як правильно обчислити загальну кількість рекурсій, що виникають: я дійшов до кінця своїх математичних знань. Так само я не знаю, чи переміщення одного з **nекспоненцій з початкового вводу на вторинне z**zполіпшило б кількість рекурсій чи ні (ditto reverse).
Давайте ходити ще повільніше з ще більшою рекурсією
import math
a=lambda x,y:(y<0)*x or a(a(a(math.log(x+1),y-1),y-1),y-1)
print a(input(),9**9**9e9)//1
n//1 - економить на 2 байти int(n)import math, math.економить 1 байтfrom math import*a(...) економить загалом 8 байт m(m,...)(y>0)*x зберігає байт за кадромy>0and x9**9**99збільшує кількість байтів на 4 і збільшує глибину рекурсії приблизно на ту, 2.8 * 10^xде xзнаходиться стара глибина (або глибина, що наближається до googolplex за розміром: 10 10 94 ).9**9**9e9збільшує кількість байтів на 5 і збільшує глибину рекурсії на ... божевільну кількість. Глибина рекурсії зараз 10 10 10 9,93 , для довідки, гугоплекс становить 10 10 10 2 .- Лямбда декларація збільшує рекурсию на додатковий крок:
m(m(...))на a(a(a(...)))витрати 7 байт
Нове вихідне значення (при 9 глибинах рекурсії):
>>>1.7976931348623157e+308
6.77538853089e-05
Глибина рекурсії вибухнула до того моменту, коли цей результат буквально безглуздий, за винятком порівняно з попередніми результатами з використанням одних і тих же вхідних значень:
- Оригінал називався
log25 разів
- Перше поліпшення називає це 81 раз
- Поточна програма буде називати його 1e99 2 або близько 10 10 2,3 рази
- Ця версія називає її 729 разів
- Поточна програма буде називати його (9 - 99 ) 3 або трохи менше , ніж 10 10 95 разів).
Лембда, початок, оцінка: ???
Я чув, як ти любиш лямбда, так що ...
from math import*
a=lambda m,x,y:y<0and x or m(m,m(m,log(x+1),y-1),y-1)
print int(a(a,input(),1e99))
Я навіть не можу це запустити, я складаю переповнення навіть з 99-ма шарами рекурсії.
Старий метод (нижче) повертається (пропускаючи перетворення до цілого числа):
>>>1.7976931348623157e+308
0.0909072713593
Новий метод повертається, використовуючи лише 9 шарів вторгнення (а не повний гугол з них):
>>>1.7976931348623157e+308
0.00196323936205
Я думаю, що це виходить таким же складним, як послідовність Акермана, лише невелике, а не велике.
Також завдяки ETHproductions за 3-байтну економію в просторах, які я не знав, можна було видалити.
Стара відповідь:
Ціле усікання журналу функції (i + 1) повторювалося 20 25 разів (Python) за допомогою лямбда-лямбда.
Відповідь PyRulez можна стиснути, ввівши другу лямбда і склавши її:
from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(x(x(i)))))
print int(y(y(y(y(y(input()))))))
99 100 використаних символів.
Це призводить до ітерації 20 25, порівняно з початковою 12. Додатково це економить 2 символи, використовуючи int()замість floor()яких дозволений додатковий x()стек. Якщо пробіли після лямбда можна видалити (наразі не можу перевірити), то y()можна додати 5-ю . Можливо!
Якщо є спосіб пропустити from mathімпорт, використовуючи повністю кваліфіковане ім’я (наприклад, x=lambda i: math.log(i+1))), це дозволить зберегти ще більше символів і дозволити ще один стек, x()але я не знаю, чи підтримує Python такі речі (я підозрюю, що це не так). Готово!
Це, по суті, той самий трюк, який використовується у публікації блогу XCKD у великій кількості , однак накладні витрати в оголошенні лямбдаз виключають третій стек:
from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(i)))
z=lambda i:y(y(y(i)))
print int(z(z(z(input()))))
Це найменша можлива рекурсія з 3 лямбдами, що перевищує обчислену висоту стеку на 2 лямбда (зменшення будь-якої лямбда на два виклики знижує висоту стека до 18, нижче, ніж у 2-лямбда-версії), але, на жаль, вимагає 110 символів.
