순수한 악 : 평가
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
평가 내부의 문장은 길이가 7 * 10 10 10 10 10 인 문자열을 만듭니다. 10 8.57 인람다 함수에 대한 더 많은 호출로 구성되며각각은 0이될 때까지 계속해서비슷한길이의 문자열을 구성합니다y이것은 아래의 Eschew 방법과 동일한 복잡성을 가지고 있지만 if-and-or-control 논리에 의존하기보다는 거대한 문자열을 함께 뭉칩니다 (그리고 결과는 더 많은 스택을 얻습니다 ... 아마도?).
y파이썬없이 오류를 발생시키지 않고 제공하고 계산할 수 있는 가장 큰 값은 2입니다.
길이가 7,625,597,484,987 인 문자열은 너무 큽니다 : OverflowError: cannot fit 'long' into an index-sized integer.
나는 멈춰야한다.
Eschew Math.log: (문제의) 10 번째 근점으로 이동하여 점수 : y = 1과 효과적으로 구분할 수없는 기능.
수학 라이브러리를 가져 오면 바이트 수가 제한됩니다. 그것을 없애고 log(x)함수를 대략 동등한 것으로 대체하십시오 : x**.1그리고 거의 같은 수의 문자가 필요하지만 가져 오기는 필요하지 않습니다. 두 함수 모두 입력과 관련하여 부분 선형 출력을 갖지만 x 0.1 은 훨씬 느리게 증가 합니다 . 그러나 우리는 많은 것을 신경 쓰지 않으며, 비슷한 수의 문자를 소비하면서 (예 : x**.9동일한 문자 수이지만 더 빨리 자라므로) 많은 숫자에 대해 동일한 기본 성장 패턴을 갖는 것만 걱정합니다. 정확히 같은 성장을 보이는 가치입니다).
이제 16 자로 처리하십시오. Ackermann Sequence 속성을 갖도록 lambda 함수를 확장하는 것은 어떻습니까? 많은 수의 답변 이이 솔루션에 영감을주었습니다.
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 : 값은 1.0) 숫자가 6.77538853089e-05보다 크면 재귀 수준이 증가하면이 함수의 출력이 1에 가깝게 이동하는 반면 1보다 크게 유지되는 반면, 이전 함수는 0보다 큰 값을 유지하면서 0에 가깝게 이동하여이 함수에 대한 중간 정도의 재귀도 발생합니다 부동 소수점 숫자가 모든 유효 비트를잃을 정도로 많은 연산이 발생합니다.
재귀 값이 0과 2가되도록 원래 람다 호출을 재구성하는 중 ...
>>>1.7976931348623157e+308
1.0000000071
"1에서 오프셋"대신 "0에서 오프셋"을 비교하면이 함수는 7.1e-9 . 이는 확실히보다 작습니다 6.7e-05.
실제 프로그램의 기본 재귀 (z 값)는 10 10 10 10 1.97 수준이며, y 자체가 소모되는 즉시 10 10 10 10 10 1.97 (초기 값 9로 충분 함)으로 재설정됩니다. 발생하는 총 재귀 수를 올바르게 계산하는 방법조차 알지 못합니다. 수학적 지식의 끝에 도달했습니다. 마찬가지로 나는 중 하나를 이동하면 몰라**n 초기 입력에서 보조 입력으로 지수z**z 재귀 수가 향상 수 없습니다 (반전).
더 많은 재귀로 더 느리게 갈 수 있습니다.
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만큼 늘리고 이전 깊이 (또는 구골 플렉스 근처의 깊이 : 10 10 94 )의 대략적인 2.8 * 10^x위치 만큼 재귀 깊이를 증가시킵니다 .x9**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 부를 것이다 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
나는 이것이 Ackerman 시퀀스와 비슷한 복잡성으로 작용한다고 생각합니다.
또한 ETHproduction 덕분에 3 바이트 절약 공간을 절약 할 수 있었으므로 제거 할 수 없었습니다.
이전 답변 :
함수 log (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 자 사용
이렇게하면 원래 12보다 20 25 의 반복이 생성됩니다 . 또한 추가 스택 을 허용 하는 int()대신 사용하여 2자를 저장 합니다. 람다 뒤의 공백을 제거 할 수 있다면 (현재 확인할 수 없습니다) 5 를 추가 할 수 있습니다. 가능한!floor()x()y()
from math정규화 된 이름 (예 :)을 사용하여 가져 오기 를 건너 뛸 수있는 방법이 있다면 x=lambda i: math.log(i+1))더 많은 문자를 저장하고x() 하지만 파이썬이 그런 것들을 지원하는지 알 수 없습니다 (의심하지 않습니다). 끝난!
이것은 본질적으로 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()))))
이것은 계산 된 스택 높이가 2 람다를 초과하는 3 개의 람다에서 가능한 가장 작은 재귀입니다 (2 개의 호출로 람다를 줄이면 스택 높이가 2- 람다 버전의 것보다 18로 떨어짐). 불행히도 110자가 필요합니다.
