পাইথন 2.7
এই পদ্ধতির নিম্নলিখিত বিবেচনার সুবিধা গ্রহণ করে:
যে কোনও পূর্ণসংখ্যাকে দুটিয়ের যোগফল হিসাবে উপস্থাপন করা যেতে পারে। দু'এর ক্ষমতায় প্রকাশকারীকে দু'জনের শক্তি হিসাবেও প্রতিনিধিত্ব করা যায়। উদাহরণ স্বরূপ:
8 = 2^3 = 2^(2^1 + 2^0) = 2^(2^(2^0) + 2^0)
এই এক্সপ্রেশনগুলি যা আমরা শেষ করি সেটগুলির সেট হিসাবে উপস্থাপন করা যেতে পারে (পাইথনে, আমি অন্তর্নির্মিত ব্যবহার করেছি frozenset):
0খালি সেট হয়ে যায় {}।2^aউপস্থাপিত সেট সমেত সেট হয়ে যায় a। যেমন: 1 = 2^0 -> {{}}এবং 2 = 2^(2^0) -> {{{}}}।a+bপ্রতিনিধিত্ব করে সেটের সংমিশ্রণে পরিণত হয় aএবং b। যেমন,3 = 2^(2^0) + 2^0 -> {{{}},{}}
দেখা যাচ্ছে যে 2^2^...^2সংখ্যার মানটি একটি পূর্ণসংখ্যা হিসাবে সংরক্ষণের জন্য খুব বেশি বড় হলেও ফর্মের এক্সপ্রেশনগুলি তাদের অনন্য সেট উপস্থাপনায় সহজেই রূপান্তরিত হতে পারে।
কারণ n=20, এটি আমার মেশিনে সিপিথন ২.7.৫ এ 8.7 সেকেন্ডে চলেছে (পাইথন 3 এ কিছুটা ধীর এবং পিপাইতে অনেক ধীর):
"""Analyze the expressions given by parenthesizations of 2^2^...^2.
Set representation: s is a set of sets which represents an integer n. n is
given by the sum of all 2^m for the numbers m represented by the sets
contained in s. The empty set stands for the value 0. Each number has
exactly one set representation.
In Python, frozensets are used for set representation.
Definition in Python code:
def numeric_value(s):
n = sum(2**numeric_value(t) for t in s)
return n"""
import itertools
def single_arg_memoize(func):
"""Fast memoization decorator for a function taking a single argument.
The metadata of <func> is *not* preserved."""
class Cache(dict):
def __missing__(self, key):
self[key] = result = func(key)
return result
return Cache().__getitem__
def count_results(num_exponentiations):
"""Return the number of results given by parenthesizations of 2^2^...^2."""
return len(get_results(num_exponentiations))
@single_arg_memoize
def get_results(num_exponentiations):
"""Return a set of all results given by parenthesizations of 2^2^...^2.
<num_exponentiations> is the number of exponentiation operators in the
parenthesized expressions.
The result of each parenthesized expression is given as a set. The
expression evaluates to 2^(2^n), where n is the number represented by the
given set in set representation."""
# The result of the expression "2" (0 exponentiations) is represented by
# the empty set, since 2 = 2^(2^0).
if num_exponentiations == 0:
return {frozenset()}
# Split the expression 2^2^...^2 at each of the first half of
# exponentiation operators and parenthesize each side of the expession.
split_points = xrange(num_exponentiations)
splits = itertools.izip(split_points, reversed(split_points))
splits_half = ((left_part, right_part) for left_part, right_part in splits
if left_part <= right_part)
results = set()
results_add = results.add
for left_part, right_part in splits_half:
for left in get_results(left_part):
for right in get_results(right_part):
results_add(exponentiate(left, right))
results_add(exponentiate(right, left))
return results
def exponentiate(base, exponent):
"""Return the result of the exponentiation of <operands>.
<operands> is a tuple of <base> and <exponent>. The operators are each
given as the set representation of n, where 2^(2^n) is the value the
operator stands for.
The return value is the set representation of r, where 2^(2^r) is the
result of the exponentiation."""
# Where b is the number represented by <base>, e is the number represented
# by <exponent> and r is the number represented by the return value:
# 2^(2^r) = (2^(2^b)) ^ (2^(2^e))
# 2^(2^r) = 2^(2^b * 2^(2^e))
# 2^(2^r) = 2^(2^(b + 2^e))
# r = b + 2^e
# If <exponent> is not in <base>, insert it to arrive at the set with the
# value: b + 2^e. If <exponent> is already in <base>, take it out,
# increment e by 1 and repeat from the start to eventually arrive at:
# b - 2^e + 2^(e+1) =
# b + 2^e
while exponent in base:
base -= {exponent}
exponent = successor(exponent)
return base | {exponent}
@single_arg_memoize
def successor(value):
"""Return the successor of <value> in set representation."""
# Call exponentiate() with <value> as base and the empty set as exponent to
# get the set representing (n being the number represented by <value>):
# n + 2^0
# n + 1
return exponentiate(value, frozenset())
def main():
import timeit
print timeit.timeit(lambda: count_results(20), number=1)
for i in xrange(21):
print '{:.<2}..{:.>9}'.format(i, count_results(i))
if __name__ == '__main__':
main()
(স্মারক সজ্জাটির ধারণাটি http://code.activestate.com/recips/578231-probably-the-fastest-memoization-decorator-in-the-/ । থেকে অনুলিপি করা হয়েছে )
আউটপুট:
8.667753234
0...........1
1...........1
2...........1
3...........2
4...........4
5...........8
6..........17
[...]
19.....688366
20....1619087
বিভিন্ন সময় n:
n time
16 0.240
17 0.592
18 1.426
19 3.559
20 8.668
21 21.402
কোন nআমার মেশিনে উপরে 21 ফলাফল একটি মেমরি পথভ্রষ্টতায় পতিত আছে।
যদি কেউ এটিকে আলাদা ভাষায় অনুবাদ করে দ্রুত তৈরি করতে পারে তবে আমি আগ্রহী।
সম্পাদনা করুন:get_results ফাংশনটি অপ্টিমাইজড । এছাড়াও, 2.7.2 এর পরিবর্তে পাইথন ২. 2..৫ ব্যবহার করে এটি কিছুটা দ্রুত চালিত হয়েছে।
2^n, এবং তাই এটি বাদে অন্য কোনও কিছুর খোঁজ রাখা অপ্রয়োজনীয় হবেn। অর্থাত্, ক্ষমতার নিয়ম ব্যবহার করা বুদ্ধিমান বলে মনে হচ্ছে। তবে এটি করার জন্য অবশ্যই একটি চৌকস এবং সম্পূর্ণ বীজগণিতিক উপায় রয়েছে।