খাঁটি দুষ্টতা: ইভাল
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 10 8.57 যা ল্যাম্বডা ফাংশনে আরও কিছু কল ছাড়া আর কিছুই থাকে না যার প্রতিটি একই ধরণের দৈর্ঘ্যের একটি স্ট্রিং তৈরি করবে এবং অবশেষে y0 হয়ে যায় Os এটি নীচে এস্কো পদ্ধতির মতোই জটিলতা রয়েছে তবে তবে-এবং-বা নিয়ন্ত্রণ যুক্তির উপর নির্ভর করার পরিবর্তে এটি কেবল একসাথে বিশালাকার স্ট্রিংগুলি টুকরো টুকরো করছে (এবং নেট ফলাফল আরও স্ট্যাক পাচ্ছে ... সম্ভবত?)।
yপাইথন ত্রুটি না ফেলেই আমি যে সরবরাহ করতে পারি এবং গণনা করতে পারি তার বৃহত্তম মানটি 2 যা ইতিমধ্যে 1-এ ফিরে আসার ক্ষেত্রে সর্বোচ্চ-ফ্লোটের একটি ইনপুট হ্রাস করতে যথেষ্ট।
দৈর্ঘ্য 7.625.597.484.987 একটি স্ট্রিং শুধু অত্যন্ত বড়: OverflowError: cannot fit 'long' into an index-sized integer।
আমার থামানো উচিত
এশহো Math.log: (সমস্যার দশ) দশকে গিয়ে স্কোর: y = 1 থেকে কার্যকরীভাবে পৃথক পৃথক function
গণিতের পাঠাগারটি আমদানি করা বাইট গণনাটিকে সীমাবদ্ধ করে দিচ্ছে। এটি থেকে দূরে চলে আসুন এবং log(x)ফাংশনটিকে মোটামুটি সমতুল্য কিছু দিয়ে প্রতিস্থাপন করুন : x**.1এবং যার জন্য প্রায় একই সংখ্যক অক্ষর ব্যয় হয়, তবে আমদানির প্রয়োজন হয় না। উভয় ফাংশনের ইনপুট সম্পর্কিত সম্মিলিত আউটপুট রয়েছে তবে এক্স 0.1 আরও ধীরে ধীরে বৃদ্ধি পায় । তবে আমরা পুরোটা যত্ন নিই না, তুলনীয় সংখ্যক অক্ষর ব্যবহার করার সময় এটির বৃহত সংখ্যার সাথে একই ভিত্তি বৃদ্ধির ধরণ রয়েছে (যেমন x**.9, একই সংখ্যক অক্ষর, তবে আরও দ্রুত বৃদ্ধি পায় তাই) হ'ল কিছু মান যা সঠিক একই বৃদ্ধি প্রদর্শিত হবে) same
এখন, 16 টি অক্ষর দিয়ে কী করবেন। কীভাবে ... অ্যাকারম্যান সিকোয়েন্স বৈশিষ্ট্য থাকতে আমাদের ল্যাম্বদা ফাংশনটি বাড়িয়ে দিচ্ছেন? বিপুল সংখ্যক এই উত্তরটি এই সমাধানটিকে অনুপ্রাণিত করে।
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 সংখ্যার তুলনায় 7.383838৮8589০৮০৯ এ -০০ এর চেয়ে বেশি, পুনরাবৃত্তির বৃদ্ধি বর্ধিত স্তরগুলি এই ফাংশনটির আউটপুটটিকে 1 এর কাছাকাছি নিয়ে যায়, যেখানে আগের ফাংশনটি 0-এর কাছাকাছি অবস্থিত থাকে তবে 0 এর চেয়ে বেশি থাকে, সুতরাং এই ফাংশনটিতে এমনকি মধ্যম পুনরাবৃত্তিও ঘটে এতগুলি ক্রিয়াকলাপের ফলাফল যা ভাসমান পয়েন্ট সংখ্যাটি সমস্ত উল্লেখযোগ্য বিট হারিয়ে ফেলে ) l
0 এবং 2 এর পুনরাবৃত্তির মানগুলি পেতে মূল ল্যাম্বদা কলটি পুনরায় কনফিগার করা হচ্ছে ...
>>>1.7976931348623157e+308
1.0000000071
যদি তুলনাটি "1 থেকে অফসেট" এর পরিবর্তে "0 থেকে অফসেট" করা হয় তবে এই ফাংশনটি ফিরে আসে 7.1e-9, যা অবশ্যই তুলনায় ছোট 6.7e-05।
আসল প্রোগ্রামের বেস রিকার্সন (জেড ভ্যালু) 10 10 10 10 1.97 স্তর গভীর হয়, আপনি নিজেই ক্লান্ত হয়ে পড়লে এটি 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 এবং বৃদ্ধি পুনরাবৃত্তির গভীরতা দ্বারা COUNT বাইট 2.8 * 10^xযেখানে xপুরাতন গভীরতা (: 10 বা গভীরতা মাপের একটি googolplex শেষের কাছাকাছি হয় 10 94 )।9**9**9e9বাইট গণনাটি 5 দ্বারা বৃদ্ধি করে এবং পুনরাবৃত্তির গভীরতা বৃদ্ধি করে ... একটি পাগল পরিমাণ। পুনরাবৃত্তির গভীরতা এখন 10 10 10 9.93 , রেফারেন্সের জন্য, একটি গুগলপ্লেক্স 10 10 10 2 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
আমি মনে করি এটি একারম্যান সিক্যুয়েন্সের মতো জটিলতার চেয়ে বড় আকারের পরিবর্তে কেবল ছোট works
এছাড়াও যে জায়গাগুলি আমি বুঝতে পারি নি যেগুলি অপসারণ করা যেতে পারে এমন জায়গাগুলিতে 3-বাইট সঞ্চয় করার জন্য ETH প্রোডাকশনকে ধন্যবাদ।
পুরানো উত্তর:
ল্যাম্বডা ল্যাম্বডাস ব্যবহার করে ফাংশন লগ (i + 1) এর পূর্ণসংখ্যার কাটা 20 25 বার (পাইথন) পুনরাবৃত্তি হয়েছিল ।
পাইআরুলেজের উত্তরটি দ্বিতীয় ল্যাম্বদা প্রবর্তন করে এবং এটি স্ট্যাক করে সংকুচিত করা যেতে পারে:
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 টি অক্ষর ব্যবহৃত হয়েছে।
এটি মূল 12 এর চেয়ে 20 25 এর পুনরাবৃত্তি তৈরি করে , অতিরিক্তভাবে এটি অতিরিক্ত স্ট্যাকের জন্য অনুমতিপ্রাপ্ত int()পরিবর্তে 2 অক্ষর সংরক্ষণ করে । ল্যাম্বদার পরে থাকা স্পেসগুলি যদি সরানো যায় (আমি এই মুহুর্তে চেক করতে পারি না) তবে 5 তম যোগ করা যেতে পারে। সম্ভব!floor()x()y()
যদি from mathপুরোপুরি যোগ্যতাসম্পন্ন নাম ব্যবহার করে আমদানি বাদ দেওয়ার কোনও উপায় থাকে (উদাঃ)x=lambda i: math.log(i+1)) ) আরও বেশি অক্ষর বাঁচাতে পারে এবং অন্য স্ট্যাকের অনুমতি দেবে x()তবে পাইথন এ জাতীয় জিনিস সমর্থন করে কিনা তা আমি জানি না (সন্দেহ করি না)। সম্পন্ন!
এটি মূলত এক্সসি কেডি এর ব্লগ পোস্টে প্রচুর সংখ্যায় ব্যবহৃত একই কৌশল , তবে ল্যাম্বডাস ঘোষণার ক্ষেত্রে ওভারহেড তৃতীয় স্ট্যাককে আটকায় :
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 টি অক্ষর প্রয়োজন।
