পার্ল + ম্যাথ :: {মোডআইন্ট, বহুপদী, প্রধানমন্ত্রী :: ইউটিলি}, স্কোর ≤ 92819
$m=Math::Polynomial;sub l{($n,$b,$d)=@_;$n||$d||return;$n%$b,l($n/$b,$b,$d&&$d-1)}sub g{$p=$m->interpolate([grep ref$_[$_],0..$map{$p->evaluate($_)}0..$}sub p{prev_prime(128**$s)}sub e{($_,$r)=@_;length||return'';$s=$r+1;s/^[␀␁]/␁$&/;@l=map{mod($_,p$s)}l(Math::BigInt->from_bytes($_),p$s);$@l+$r>p($s)&&return e($_,$s);$a=0;join'',map{map{chr$_+$a}l($_->residue,128,$s,($a^=128))}g(@l)}sub d{@l=split/([␀-␡]+)/,$_[0];@l||return'';$s=vecmax map length,@l;@l=g map{length==$s&&mod($m->new(map{ord()%128}split//)->evaluate(128),p$s)}@l;$$_=$m->new(map{$_->residue}@l)->evaluate(p$s)->to_bytes;s/^␁//;$_}
নিয়ন্ত্রণের চিত্রগুলি সংশ্লিষ্ট নিয়ন্ত্রণ চরিত্রের প্রতিনিধিত্ব করতে ব্যবহৃত হয় (উদাঃ ␀আক্ষরিক NUL অক্ষর)। কোডটি পড়ার চেষ্টা করার বিষয়ে খুব বেশি চিন্তা করবেন না; নীচে আরও পাঠযোগ্য সংস্করণ রয়েছে।
সাথে চালাও -Mbigint -MMath::ModInt=mod -MMath::Polynomial -MNtheory=:all। -MMath::Bigint=lib,GMPপ্রয়োজনীয় নয় (এবং এভাবে স্কোরের অন্তর্ভুক্ত নয়) তবে আপনি অন্যান্য লাইব্রেরির আগে এটি যুক্ত করলে এটি প্রোগ্রামটিকে কিছুটা দ্রুত চালিত করে তুলবে।
স্কোর গণনা
এখানে অ্যালগোরিদম কিছুটা অসম্পূর্ণ, তবে এটি লিখতে বরং আরও শক্ত হবে (পার্লের উপযুক্ত লাইব্রেরি না থাকার কারণে)। এ কারণে, কোডে আমি কয়েকটি আকার / দক্ষতা ট্রেড অফ করেছি, এই ভিত্তিতে যে বকেটগুলি এনকোডিংয়ে সংরক্ষণ করা যায়, গল্ফিং থেকে প্রতিটি পয়েন্ট ছাঁটাই করার চেষ্টা করার কোনও মানে নেই।
প্রোগ্রামটিতে 600০০ বাইট কোড, এবং কমান্ড-লাইন বিকল্পের জন্য penalties বাইটের জরিমানা, একটি 678 পয়েন্ট জরিমানা রয়েছে। বাকি স্কোরটি সেরা-কেস এবং নিকৃষ্টতম ক্ষেত্রে (আউটপুট দৈর্ঘ্যের দিক থেকে) প্রতিটি দৈর্ঘ্যের 0 থেকে 99 এবং প্রতিটি বিকিরণ স্তর 0 থেকে 9 পর্যন্ত স্ট্রিং দ্বারা গণনা করা হয়েছিল; গড় কেস মাঝখানে কোথাও হয় এবং এটি স্কোরকে সীমা দেয়। (অনুরূপ স্কোর সহ অন্য কোনও এন্ট্রি না এলে সঠিক মান গণনা করার চেষ্টা করা উপযুক্ত নয়)
এর অর্থ হ'ল এনকোডিং দক্ষতা থেকে প্রাপ্ত স্কোর 91100 থেকে 92141 সমেত অন্তর্ভুক্ত, সুতরাং চূড়ান্ত স্কোরটি হ'ল:
91100 + 600 + 78 = 91778 ≤ স্কোর ≤ 92819 = 92141 + 600 + 78
কম গল্ফ করা সংস্করণ, মন্তব্য এবং পরীক্ষার কোড সহ
এটি হ'ল আসল প্রোগ্রামটি + নিউলাইনস, ইনডেন্টেশন এবং মন্তব্য। (প্রকৃতপক্ষে, গল্ফযুক্ত সংস্করণটি এই সংস্করণ থেকে নতুন লাইন / ইনডেন্টেশন / মন্তব্যগুলি সরিয়ে দিয়ে তৈরি করা হয়েছিল))
use 5.010; # -M5.010; free
use Math::BigInt lib=>'GMP'; # not necessary, but makes things much faster
use bigint; # -Mbigint
use Math::ModInt 'mod'; # -MMath::ModInt=mod
use Math::Polynomial; # -MMath::Polynomial
use ntheory ':all'; # -Mntheory=:all
use warnings; # for testing; clearly not necessary
### Start of program
$m=Math::Polynomial; # store the module in a variable for golfiness
sub l{ # express a number $n in base $b with at least $d digits, LSdigit first
# Note: we can't use a builtin for this because the builtins I'm aware of
# assume that $b fits into an integer, which is not necessarily the case.
($n,$b,$d)=@_;
$n||$d||return;
$n%$b,l($n/$b,$b,$d&&$d-1)
}
sub g{ # replaces garbled blocks in the input with their actual values
# The basic idea here is to interpolate a polynomial through all the blocks,
# of the lowest possible degree. Unknown blocks then get the value that the
# polynomial evaluates to. (This is a special case of Reed-Solomon coding.)
# Clearly, if we have at least as many ungarbled blocks as we did original
# elements, we'll get the same polynomial, thus we can always reconstruct
# the input.
# Note (because it's confusing): @_ is the input, $_ is the current element
# in a loop, but @_ is written as $_ when using the [ or # operator (e.g.
# $_[0] is the first element of @_.
# We waste a few bytes of source for efficiency, storing the polynomial
# in a variable rather than recalculating it each time.
$p=$m->interpolate([grep ref$_[$_],0..$#_],[grep ref,@_]);
# Then we just evaluate the polynomial for each element of the input.
map{$p->evaluate($_)}0..$#_
}
sub p{ # determines maximum value of a block, given (radiation+1)
# We split the input up into blocks. Each block has a prime number of
# possibilities, and is stored using the top 7 bits of (radiation+1)
# consecutive bytes of the output. Work out the largest possible prime that
# satisfies this property.
prev_prime(128**$s)
}
sub e{ # encoder; arguments: input (bytestring), radiation (integer)
($_,$r)=@_; # Read the arguments into variables, $_ and $r respectively
length||return''; # special case for empty string
$s=$r+1; # Also store radiation+1; we use it a lot
# Ensure that the input doesn't start with NUL, via prepending SOH to it if
# it starts with NUL or SOH. This means that it can be converted to a number
# and back, roundtripping correctly.
s/^[␀␁]/␁$&/; #/# <- unconfuse Stack Exchange's syntax highlighting
# Convert the input to a bignum, then to digits in base p$s, to split it
# into blocks.
@l=map{mod($_,p$s)}l(Math::BigInt->from_bytes($_),p$s);
# Encoding can reuse code from decoding; we append $r "garbled blocks" to
# the blocks representing the input, and run the decoder, to figure out what
# values they should have.
$#l+=$r;
# Our degarbling algorithm can only handle at most p$s blocks in total. If
# that isn't the case, try a higher $r (which will cause a huge increase in
# $b and a reduction in @l).
@l+$r>p($s)&&return e($_,$s);
# Convert each block to a sequence of $s digits in base 128, adding 128 to
# alternating blocks; this way, deleting up to $r (i.e. less than $s) bytes
# will preserve the boundaries between each block; then convert that to a
# string
$a=0; # we must initialize $a to make this function deterministic
join'',map{map{chr$_+$a}l($_->residue,128,$s,($a^=128))}g(@l)
}
sub d{ # decoder: arguments; encdng (bytestring)
# Reconstruct the original blocks by looking at their top bits
@l=split/([␀-␡]+)/,$_[0];
@l||return''; # special case for empty string
# The length of the longest block is the radiation parameter plus 1 (i.e.
# $s). Use that to reconstruct the value of $s.
$s=vecmax map length,@l;
# Convert each block to a number, or to undef if it has the wrong length.
# Then work out the values for the undefs.
@l=g map{
# Convert blocks with the wrong length to undef.
length==$s&&
# Convert other blocks to numbers, via removing any +128 and then
# using Math::Polynomial to convert the digit list to a number.
mod($m->new(map{ord()%128}split// #/# <- fix syntax highlighting
)->evaluate(128),p$s)
}@l;
# Remove the redundant elements at the end; now that they've reconstructed
# the garbled elements they have no further use.
$#l-=$s-1;
# Convert @l to a single number (reversing the conversion into blocks.)
$_=$m->new(map{$_->residue}@l)->evaluate(p$s)
# Convert that number into a string.
->to_bytes;
# Delete a leading SOH.
s/^␁//; #/# <- unconfuse Stack Exchange's syntax highlighting
# Finally, return the string.
$_
}
### Testing code
use Encode qw/encode decode/;
# Express a string using control pictures + IBM437, to make binary strings
# easier for a human to parse
sub format_string {
($_)=@_;
$_ = decode("Latin-1", $_);
s/[\0-\x1f]/chr (0x2400 + ord $&)/eag;
s/\x7f/chr 0x2421/eag;
s/[ -~\x80-\xff]/decode("IBM437",$&)/eag;
encode("UTF-8","\x{ff62}$_\x{ff63}")
}
sub test {
my ($string, $radiation, $samples) = @_;
say "Input: ", format_string($string);
my $encoding = e($string, $radiation);
say "Encoding: ", format_string($encoding);
say "Input length ", length($string), ", encoding length ", length($encoding), ", radiation $radiation";
my $decoding = d($encoding);
$decoding eq $string or die "Mistake in output!";
say "Decoding: ", format_string($decoding), " from ",
format_string($encoding);
# Pseudo-randomly generate $samples radiation-damaged versions.
srand 1;
for my $i (1..$samples) {
my $encdng = $encoding;
for my $r (1..$radiation) {
substr $encdng, int(rand(length $encdng)), 1, "";
}
my $newdecoding = d($encdng);
say "Decoding: ", format_string($newdecoding), " from ",
format_string($encdng);
$newdecoding eq $string or die "Mistake in output!";
}
say "";
length $encoding;
}
test "abcdefghijklm", 1, 10;
test "abcdefghijklm", 2, 10;
test "abcdefghijklm", 5, 10;
test "abcdefghijklm", 10, 10;
test "\0\0\0\0\0", 1, 10;
test "\5\4\3\2\1", 2, 10;
test "a", 10, 10;
my %minlength = ();
my %maxlength = ();
for my $length (0..99) {
my ($min, $max) = ("", "");
$length and ($min, $max) =
("\2" . "\0" x ($length - 1), "\1" . "\377" x ($length - 1));
for my $radiation (0..9) {
$minlength{"$length-$radiation"} = test $min, $radiation, 1;
$maxlength{"$length-$radiation"} = test $max, $radiation, 1;
}
}
say "Minimum score: ", vecsum values %minlength;
say "Maximum score: ", vecsum values %maxlength;
অ্যালগরিদম
সমস্যার সরলকরণ
মূল ধারণাটি হ'ল এই "ডিলিটেশন কোডিং" সমস্যাটি (যা কোনও বহুলাংশে অন্বেষণকৃত নয়) একটি ক্ষয় কোডিং সমস্যা (গণিতের একটি বিস্তৃত ক্ষেত্র) into ইরেজর কোডিংয়ের পিছনে ধারণাটি হ'ল আপনি কোনও "ইরেজর চ্যানেল" এর মাধ্যমে প্রেরণ করার জন্য ডেটা তৈরি করছেন, এমন একটি চ্যানেল যা মাঝে মাঝে এটি "গারবেল" অক্ষর দ্বারা প্রেরিত অক্ষরগুলিকে প্রতিস্থাপন করে যা ত্রুটির পরিচিত অবস্থান নির্দেশ করে। (অন্য কথায়, দুর্নীতিটি কোথায় ঘটেছে তা সর্বদা স্পষ্ট, যদিও মূল চরিত্রটি এখনও অজানা)) এর পিছনের ধারণাটি খুব সহজ: আমরা ইনপুটটিকে দৈর্ঘ্যের ব্লকে বিভক্ত করি ( বিকিরণ+ 1), এবং প্রতিটি ব্লকের আটটি বিটের মধ্যে সাতটি ডাটা ব্যবহারের জন্য ব্যবহার করুন, যখন বাকি একটি বিট (এই নির্মাণে, এমএসবি) পুরো ব্লকের জন্য সেট হওয়ার পরে, পুরো পরবর্তী ব্লকের জন্য পরিষ্কার হয়ে যাবে, ব্লকের জন্য সেট করা হবে তার পরে, এবং আরও। যেহেতু ব্লকগুলি বিকিরণ প্যারামিটারের চেয়ে দীর্ঘ হয়, প্রতিটি ব্লক থেকে কমপক্ষে একটি অক্ষর আউটপুটে টিকে থাকে; সুতরাং একই এমএসবি দিয়ে অক্ষরগুলি রানের মাধ্যমে আমরা প্রতিটি অক্ষর কোন ব্লকের অন্তর্ভুক্ত তা কার্যকর করতে পারি। ব্লকগুলির সংখ্যাও রেডিয়েশন প্যারামিটারের তুলনায় সর্বদা বেশি থাকে, সুতরাং আমাদের কাছে সর্বদা কমপক্ষে একটি এনডএনজেডে কমপক্ষে একটি অবিচ্ছিন্ন ব্লক থাকে; আমরা এইভাবে জানি যে সমস্ত ব্লক যেগুলি সবচেয়ে দীর্ঘ বা দীর্ঘায়িত জন্য আবদ্ধ, সেগুলি অকেজো করা হয়েছে, যাতে কোনও সংক্ষিপ্ত ব্লককে ক্ষতিগ্রস্থ হিসাবে গণ্য করতে দেওয়া হয় (সুতরাং গার্বল)। আমরা এটির মতো বিকিরণ প্যারামিটারও কমিয়ে আনতে পারি (এটি '
মুছে ফেলা কোডিং
সমস্যার ক্ষয়ের কোডিং অংশ হিসাবে, এটি রিড-সলোমন নির্মাণের একটি সাধারণ বিশেষ কেস ব্যবহার করে। এটি একটি নিয়মতান্ত্রিক নির্মাণ: আউটপুট (ইরেজর কোডিং অ্যালগরিদম এর) ইনপুট সমেত বেশ কয়েকটি অতিরিক্ত ব্লক, রেডিয়েশন প্যারামিটারের সমান। আমরা এই ব্লকগুলির জন্য প্রয়োজনীয় (এবং গল্ফ!) উপায়ে তাদেরকে গারবেল হিসাবে বিবেচনা করে, তারপরে ডিকোডিং অ্যালগরিদমকে তাদের মানটিকে "পুনর্গঠন" করার মাধ্যমে প্রয়োজনীয় মানগুলি গণনা করতে পারি।
নির্মাণের পিছনে আসল ধারণাটিও খুব সহজ: আমরা এনকোডিংয়ের সমস্ত ব্লকের (অন্যান্য উপাদানগুলির সাথে গলিত গার্বল সহ) ন্যূনতম সম্ভাব্য ডিগ্রির একটি বহুবচন ফিট করি; যদি বহুপদীটি চ হয় , প্রথম ব্লকটি চ (0), দ্বিতীয়টি চ (1), ইত্যাদি। এটি স্পষ্ট যে বহুবর্ষের ডিগ্রি ইনপুট বিয়োগ 1 এর ব্লকের সংখ্যার সমান হবে (কারণ আমরা প্রথম যেগুলির কাছে একটি বহুপদী ফিট করি, তারপরে এটি অতিরিক্ত "চেক" ব্লকগুলি তৈরি করতে ব্যবহার করি); এবং কারণ ডি +1 পয়েন্ট ডিগ্রি ডি এর একটি বহুবর্ষকে স্বতন্ত্রভাবে সংজ্ঞায়িত করে, কোনও সংখ্যক ব্লক (রেডিয়েশন প্যারামিটার অবধি) গার্বলিংয়ের ফলে মূল ইনপুটটির সমান অনেকগুলি অবিবাহিত ব্লক চলে যাবে, যা একই বহুপদী পুনর্গঠনের জন্য যথেষ্ট তথ্য। (তারপরে আমাদের কোনও ব্লকের প্রকোপটি বহন করার জন্য বহুপদী মূল্যায়ন করতে হবে))
বেস রূপান্তর
এখানে চূড়ান্ত বিবেচনাটি হ'ল ব্লকগুলির দ্বারা নেওয়া প্রকৃত মানগুলি নিয়ে কাজ করা; যদি আমরা পূর্ণসংখ্যার উপর বহুবর্ষীয় অন্তরঙ্গকরণ করি, ফলাফলগুলি ইনপুট মানগুলির চেয়ে অনেক বড়, বা অন্যথায় অনাকাঙ্ক্ষিত হতে পারে যুক্তি সংখ্যার (পূর্ণসংখ্যার চেয়ে বরং)। যেমন, পূর্ণসংখ্যা ব্যবহার না করে আমরা একটি সীমাবদ্ধ ক্ষেত্র ব্যবহার করি; এই প্রোগ্রামে, সীমাবদ্ধ ক্ষেত্রটি ব্যবহৃত হয় পূর্ণসংখ্যা মডুলো পি এর ক্ষেত্র , যেখানে পি 128 রেডিয়েশন +1 এর চেয়ে কম বড় প্রাইম(অর্থাৎ বৃহত্তম প্রাইম যার জন্য আমরা কোনও ব্লকের ডেটা অংশে সেই প্রধানের সমান বিভিন্ন স্বতন্ত্র মানগুলি ফিট করতে পারি)। সীমাবদ্ধ ক্ষেত্রগুলির বৃহত সুবিধা হ'ল বিভাগটি (0 বাদে) স্বতন্ত্রভাবে সংজ্ঞায়িত হয় এবং সর্বদা সেই ক্ষেত্রের মধ্যে একটি মান উত্পাদন করে; সুতরাং, বহুভুজগুলির আন্তঃবিবাহিত মানগুলি ইনপুট মানগুলির ঠিক একইভাবে একটি ব্লকের সাথে খাপ খায়।
অর্ডার ব্লক ডেটার একটি সিরিজের মধ্যে ইনপুট রুপান্তরিত করার আগে, তারপর, আমরা বেস রূপান্তর করতে হবে: বেস 256 থেকে ইনপুট রূপান্তর একটি সংখ্যা মধ্যে, তারপর ভিত্তিতে রূপান্তর পি (ক জন্য যেমন বিকিরণ 1 পরামিতি, আমরা পি= 16381)। এটি বেশিরভাগই পার্লের বেস রূপান্তর রুটিনের অভাব দ্বারা ধরা হয়েছিল (ম্যাথ :: প্রাইম :: ইউটিলে কিছু রয়েছে, তবে তারা বিগনাম বেসগুলির জন্য কাজ করে না, এবং আমরা এখানে যে প্রাইমগুলির সাথে কাজ করি তা অবিশ্বাস্যভাবে বড়)। যেহেতু আমরা ইতিমধ্যে ম্যাথ :: বহুবর্ষীয় অন্তরঙ্গকরণের জন্য বহুপদী ব্যবহার করছি, আমি এটিকে "ডিজিট সিকোয়েন্স থেকে রূপান্তর" ফাংশন হিসাবে ব্যবহার করতে সক্ষম হয়েছি (অঙ্কগুলি বহুবর্ষের সহগ হিসাবে এবং এটির মূল্যায়নের মাধ্যমে), এবং এটি বিগনামের জন্য কাজ করে শুধুই সুন্দর. অন্য দিকে যেতে, যদিও, আমাকে নিজেই ফাংশনটি লিখতে হয়েছিল। ভাগ্যক্রমে, এটি লেখার পক্ষে খুব কঠিন (বা ভার্বোস) নয়। দুর্ভাগ্যক্রমে, এই বেস রূপান্তরটির অর্থ হ'ল ইনপুটটি সাধারণত অপঠনযোগ্য রেন্ডার হয়। শীর্ষস্থানীয় জিরোগুলির সাথে একটি সমস্যাও রয়েছে;
এটি লক্ষ করা উচিত যে আমরা আউটপুটে পি ব্লকগুলির বেশি থাকতে পারি না (অন্যথায় দুটি ব্লকের সূচকগুলি সমান হয়ে যায় এবং তবুও সম্ভবত বিভিন্ন বহির্মুখগুলি বহুবচন গঠনের প্রয়োজন হয়)। এটি কেবল তখন ঘটে যখন ইনপুটটি অত্যন্ত বড় হয়। এই প্রোগ্রামটি সমস্যাটিকে খুব সহজ উপায়ে সমাধান করে: বর্ধমান রেডিয়েশন (যা ব্লকগুলি আরও বড় এবং পি আরও বৃহত্তর করে তোলে , যার অর্থ আমরা আরও অনেক বেশি ডেটা মাপতে পারি এবং এটি পরিষ্কারভাবে সঠিক ফলাফলের দিকে নিয়ে যায়)।
আর একটি বিষয় তৈরি করার মতো বিষয় হ'ল আমরা নাল স্ট্রিংটিকে নিজের মধ্যে এনকোড করি, কারণ লিখিত হিসাবে প্রোগ্রামটি এটি অন্যথায় ক্র্যাশ করবে। এটি স্পষ্টতই সেরা সম্ভাব্য এনকোডিং এবং এটি বিকিরণের পরামিতি কী তা বিবেচনা করে না।
সম্ভাব্য উন্নতি
এই প্রোগ্রামের মূল অ্যাসিম্পোটিক অদক্ষতা হ'ল প্রশ্নের মধ্যে সীমাবদ্ধ ক্ষেত্র হিসাবে মডুলো-প্রাইম ব্যবহার করা। আকার 2 এন এর সীমাবদ্ধ ক্ষেত্রগুলি বিদ্যমান (যা আমরা এখানে যা চাই ঠিক তাই, কারণ ব্লকের পেডলোডের আকারগুলি স্বাভাবিকভাবেই 128 এর শক্তি)। দুর্ভাগ্যক্রমে, তারা একটি সাধারণ মডুলো নির্মাণের চেয়ে আরও জটিল, যার অর্থ ম্যাথ :: ModInt এটি কাটবে না (এবং অ-প্রাইম আকারের সীমাবদ্ধ ক্ষেত্রগুলি পরিচালনা করার জন্য আমি সিপিএএন-তে কোনও গ্রন্থাগার খুঁজে পাইনি); গণিত :: বহুত্ববৈজ্ঞানিকভাবে এটি পরিচালনা করতে সক্ষম হবার জন্য আমাকে একটি সম্পূর্ণ শ্রেণি লিখতে হবে এবং সেই সময়ে বাইট ব্যয়টি 16384 এর পরিবর্তে 16381 এর পরিবর্তে ব্যবহারের ফলে (খুব ছোট) ক্ষয়কে পরাস্ত করতে পারে।
পাওয়ার-অফ -2 মাপ ব্যবহার করার আরেকটি সুবিধা হ'ল বেস রূপান্তরটি আরও সহজ হয়ে উঠবে। তবে, উভয় ক্ষেত্রেই ইনপুটটির দৈর্ঘ্যের প্রতিনিধিত্ব করার একটি আরও ভাল পদ্ধতি কার্যকর হবে; "অস্পষ্ট ক্ষেত্রে 1 টি প্রিপেন্ড করুন" পদ্ধতিটি সহজ তবে অপচয়যোগ্য। বাইজিক বেস রূপান্তরটি এখানে একটি প্রশংসনীয় পদ্ধতির ধারণা (ধারণাটি হ'ল আপনার একটি সংখ্যা হিসাবে বেস রয়েছে, এবং 0 হিসাবে একটি সংখ্যা হিসাবে নয়, যাতে প্রতিটি সংখ্যা একক স্ট্রিংয়ের সাথে মিলে যায়)।
যদিও এই এনকোডিংয়ের অ্যাসিম্পটোটিক পারফরম্যান্স খুব ভাল (উদাহরণস্বরূপ 99 দৈর্ঘ্যের ইনপুট এবং 3 এর রেডিয়েশন প্যারামিটারের জন্য, এনকোডিংটি সর্বদা 128 বাইট দীর্ঘ হয়, 400 ডলার বাইট যা পুনরাবৃত্তিভিত্তিক পদ্ধতিগুলি পেতে পারে তার চেয়ে বেশি) সংক্ষিপ্ত ইনপুটগুলিতে কম ভাল; এনকোডিংয়ের দৈর্ঘ্য সর্বদা কমপক্ষে (বিকিরণ প্যারামিটার + 1) এর বর্গ হয়। 9 খুব রেডিয়েশনে খুব সংক্ষিপ্ত ইনপুটগুলির জন্য (দৈর্ঘ্য 1 থেকে 8) তবে আউটপুটটির দৈর্ঘ্য তবে 100 হয় (দৈর্ঘ্যে, আউটপুটটির দৈর্ঘ্য কখনও কখনও 100 এবং কখনও কখনও 110 হয়) পুনরাবৃত্তি-ভিত্তিক পদ্ধতিগুলি পরিষ্কারভাবে এই ক্ষয়কে পরাজিত করে খুব ছোট ইনপুটগুলিতে কোডিং-ভিত্তিক পদ্ধতি; এটি ইনপুট আকারের উপর ভিত্তি করে একাধিক অ্যালগরিদমের মধ্যে পরিবর্তনযোগ্য হতে পারে।
পরিশেষে, এটি আসলে স্কোরিংয়ে আসে না, তবে খুব উচ্চ বিকিরণ পরামিতিগুলির সাথে, প্রতিটি বাইট (আউটপুট আকারের)) কিছুটা ব্যবহার করে ব্লকগুলি সীমিত করতে ব্যর্থ হয়; পরিবর্তে ব্লকের মধ্যে ডিলিমিটারগুলি ব্যবহার করা সস্তা হবে। বিকল্প-এমএসবি পদ্ধতির চেয়ে বিস্ময়করদের থেকে ব্লকগুলি পুনর্গঠন করা আরও শক্ত, তবে আমি বিশ্বাস করি এটি সম্ভব হবে, কমপক্ষে যদি ডেটা যথেষ্ট দীর্ঘ হয় (সংক্ষিপ্ত ডেটা সহ, আউটপুট থেকে বিকিরণ প্যারামিটারটি নির্ধারণ করা কঠিন) । প্যারামিটার নির্বিশেষে কোনও asympotically আদর্শ দৃষ্টিভঙ্গির লক্ষ্যে লক্ষ্য করা যায় তবে এটি দেখার মতো কিছু হবে।
(এবং অবশ্যই, একটি সম্পূর্ণ আলাদা অ্যালগরিদম হতে পারে যা এর চেয়ে ভাল ফলাফল দেয়!)
