সি #, কোনও লুপ নেই
ঠিক আছে, আমি এই লিঙ্কগুলির একটি বেশ কয়েকটি স্কিম করেছিলাম, তবে সত্যি বলতে কী তারা কিছুটা বিরক্তিকর ছিল। হ্যাশ টেবিল এবং হোয়াট নোটের সাহায্যে আমি এর থেকে নরকটিকে অপ্টিমাইজ করতে আগ্রহী নই। আমার কেন দরকার হবে? আপনি একটি গডড্যাম সুপার কম্পিউটার পেয়েছেন!
জাহান্নাম, আমি এমনকি লুপগুলি বিরক্ত করতে চাই না! এই সমাধানটি নো-লুপস বিধি অনুসরণ করবে ।
দয়া করে নোট করুন যে আমি যে কোডটি লিখতে চলেছি তা ভাল কোড নয়, বা আমি বাস্তবে যে জাতীয় কোড লিখতে চাইছি (যদি কোনও সম্ভাব্য নিয়োগকারীরা এটি পড়তে পারে)। এই কোডটি সংকীর্ণতা এবং একটি আখ্যানটিতে কাজ করার দক্ষতার উপর জোর দেয় এবং যথাযথ সম্মেলনগুলি এবং আচারগুলি এবং লুপগুলি বিবেচনা করে।
আমি যা বলছি তা প্রদর্শনের জন্য, আমরা সমীকরণটির অপারেশনগুলি সঞ্চয় করার জন্য পাবলিক ফিল্ডগুলির সাথে একটি শকিং ক্লাস দিয়ে শুরু করব:
class BealOperands
{
public BigInteger A, B, C, x, y, z;
}
ঠিক আছে, আমরা সম্ভবত এটিই সবচেয়ে কঠিন চ্যালেঞ্জটি দিয়ে শুরু করব। আমাদের সেই অপারেশনগুলির প্রতিটি সংমিশ্রণের মধ্য দিয়ে ক্রমিট করার একটি উপায় বের করতে হবে। নিঃসন্দেহে প্রতিটি আদেশের পরীক্ষা করার চেয়ে আরও দক্ষতার সাথে এটি করার উপায় রয়েছে তবে আমি সেগুলি খুঁজে বের করে বিরক্ত করতে পারি না। আর কেন করব? আমরা একটি গডমডন সুপার কম্পিউটার পেয়েছি!
এখানে আমি এলগোরিদিমটি নিয়ে এসেছি। এটি অবিশ্বাস্যরূপে অদক্ষ, এবং একই অপারেশনগুলি বারবার ঘুরে দেখা যায়, তবে কে যত্ন করে? সুপারকম্প্যুটার!
- ছয়টি অপারেন্ডকে বেস -২ নম্বর হিসাবে বিবেচনা করুন এবং প্রতিটি সংমিশ্রণের মাধ্যমে ক্রমবর্ধমান করুন।
- ছয়টি অপারেন্ডকে একটি বেস -3 নম্বর হিসাবে বিবেচনা করুন এবং প্রতিটি সংমিশ্রণের মাধ্যমে ক্রম করুন।
- ছয়টি অপারেন্ডকে বেস -4 নম্বর হিসাবে বিবেচনা করুন এবং প্রতিটি সংমিশ্রণের মাধ্যমে ক্রমবর্ধমান করুন।
- (...)
লুপগুলি ছাড়াই কীভাবে এই সব করা যায়? সহজ! কেবল একটি বাস্তবায়ন করুন IEnumerableএবং IEnumeratorঅনুমতিগুলি পাম্প করার সাথে যুক্ত । পরে, আমরা এটি জিজ্ঞাসা করতে লিনকিউ ব্যবহার করব।
class BealOperandGenerator : IEnumerable<BealOperands>
{
// Implementation of IEnumerable<> and IEnumerable -- basically boilerplate to get to BealOperandGeneratorEnumerator.
public IEnumerator<BealOperands> GetEnumerator() { return new BealOperandGeneratorEnumerator(); }
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }
}
class BealOperandGeneratorEnumerator : IEnumerator<BealOperands>
{
public BealOperandGeneratorEnumerator() { Reset(); }
private BealOperands operands;
private BigInteger @base;
public void Reset()
{
// A is set to 0, which is "before" its minimum value, because IEnumerators are supposed to
// point to their first element *after* the first call to MoveNext().
// All other operands are set to their minimum values.
operands = new BealOperands { A = 0, B = 1, C = 1, x = 3, y = 3, z = 3 };
@base = 2;
}
public BealOperands Current
{
get
{
// We need to return a copy, since we'll be manipulating our internal one.
return new BealOperands {
A = operands.A, B = operands.B, C = operands.C,
x = operands.x, y = operands.y, z = operands.z };
}
}
public bool MoveNext()
{
// Increment the lowest "digit" and "carry" as necessary.
operands.A++;
if (operands.A - 1 >= @base)
{
operands.A = 1; operands.B++;
if (operands.B - 1 >= @base)
{
operands.B = 1; operands.C++;
if (operands.C - 1 >= @base)
{
operands.C = 1; operands.x++;
if (operands.x - 3 >= @base)
{
operands.x = 3; operands.y++;
if (operands.y - 3 >= @base)
{
operands.y = 3; operands.z++;
if (operands.z - 3 >= @base)
{
operands.z = 3; @base++;
}
}
}
}
}
}
// There will always be more elements in this sequence.
return true;
}
// More boilerplate
object System.Collections.IEnumerator.Current { get { return Current; } }
public void Dispose() { }
}
এখন আমরা ব্যবসা করছি! আমাদের যা করতে হবে তা হ'ল BealOperandGeneratorবিলের অনুমানের একটি পাল্টা নমুনা খুঁজে বের করা।
আমাদের পরবর্তী বড় সমস্যাটি হ'ল এটির BigIntegerশক্তি বাড়ানোর কোনও অন্তর্নির্মিত উপায় বলে মনে হচ্ছে না BigInteger। অন্যটির ক্ষমতায় মডেলো অনন্তের শক্তি বাড়ানোর জন্য BigInteger.Pow(BigInteger value, int exponent)এবং আছে BigInteger.ModPow(BigInteger value, BigInteger exponent, BigInteger modulus)তবে কোনও পদ্ধতি বাড়াতে BigIntegerপারে না BigInteger।
কি সমস্যার চকচকে নখ! দেখে মনে হচ্ছে এটি আমাদের IEnumerable/ IEnumeratorহাতুড়ি দিয়ে সমাধান করা হয়েছিল !
class BigIntegerPowerEnumerable : IEnumerable<Tuple<BigInteger, BigInteger>>
{
public BigIntegerPowerEnumerable(BigInteger @base, BigInteger exponent) { this.@base = @base; this.exponent = exponent; }
BigInteger @base, exponent;
public IEnumerator<Tuple<BigInteger, BigInteger>> GetEnumerator() { return new BigIntegerPowerEnumerator(@base, exponent); }
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }
}
class BigIntegerPowerEnumerator : IEnumerator<Tuple<BigInteger, BigInteger>>
{
public BigIntegerPowerEnumerator(BigInteger @base, BigInteger exponent)
{
originalBase = @base;
originalExponent = exponent;
Reset();
}
BigInteger originalBase, currentBase, originalExponent, currentExponent;
bool finished;
public void Reset()
{
// IEnumerable.Reset() is a silly method. You're required to implement it when you implement IEnumerable,
// but it isn't used by foreach or LINQ or anything. If you want to re-enumerate the enumerable, just get
// a brand new enumerator.
// In this case it gets in the way. The only reason I'm storing the original values is so I can implement
// this useless method properly. I supposed I could just throw a NotImplementedException or something,
// but it's done now.
currentBase = originalBase;
currentExponent = originalExponent;
finished = false;
}
public bool MoveNext()
{
if (finished) return false;
if (currentExponent <= Int32.MaxValue)
{
currentBase = BigInteger.Pow(currentBase, (Int32)currentExponent);
currentExponent = 1;
finished = true;
}
else
{
currentBase = BigInteger.Pow(currentBase, Int32.MaxValue);
currentExponent -= Int32.MaxValue;
}
return true;
}
public Tuple<BigInteger, BigInteger> Current
{
get { return new Tuple<BigInteger, BigInteger>(currentBase, currentExponent); }
}
object System.Collections.IEnumerator.Current { get { return Current; } }
public void Dispose() { }
}
static class BigIntegerPowExtension
{
public static BigInteger Pow(this BigInteger @base, BigInteger exponent)
{
return new BigIntegerPowerEnumerable(@base, exponent).Last().Item1;
}
}
এখন আমরা একটি এক্সটেনশন পদ্ধতি পেয়েছি Pow, এটিকে একটি বলা যেতে পারে BigIntegerএবং এটি গ্রহণ করেBigInteger এক্সপোনেন্ট এবং কোনও মডুলাস ।
ঠিক আছে, ফিরে আসা যাক। কোনও বিশেষ BealOperandsলোক বিলের অনুমানের পাল্টা নমুনা কিনা তা আমরা কীভাবে বলতে পারি ? ঠিক আছে, দুটি বিষয় সত্য হওয়া দরকার:
- অপারেন্ডগুলি, যখন পৃষ্ঠার শীর্ষে সেই সূত্রটিতে প্লাগ ইন করা হয় তখন অবশ্যই একটি সত্য সমীকরণ গঠন করতে হবে।
- A, B, এবং C এর অবশ্যই একটি সাধারণ প্রধান উপাদান নেই (অর্থাত্ তাদের জিসিডি 1)।
প্রথম শর্তটি যাচাই করার জন্য আমাদের যা প্রয়োজন তা আমরা পেয়েছি। এবং এটি দেখা যাচ্ছে যে দ্বিতীয় শর্তটি শোনার চেয়ে চেক করা অনেক সহজ। BigIntegerএকটি সুন্দর সরবরাহ করেGreatestCommonDivisor পদ্ধতি সরবরাহ করে, যা লুপগুলি ছাড়াই এটি বাস্তবায়নের চেষ্টা করার পুরো দুঃস্বপ্নকে আমাদের সুবিধামতভাবে পাশ কাটাতে দেয়।
সুতরাং আমরা BealOperandsএকটি কাউন্টারিক নমুনা কিনা তা পরীক্ষা করার জন্য একটি পদ্ধতি লিখতে প্রস্তুত । এখানে যায় ...
static class BealOperandsExtensions
{
public static bool IsBealsConjectureCounterExample(this BealOperands o)
{
// If the equation isn't even true, we don't have a counter example unfortunately
if (o.A.Pow(o.x) + o.B.Pow(o.y) != o.C.Pow(o.z))
{
return false;
}
// We have a counterexample if A, B and C are coprime
return BigInteger.GreatestCommonDivisor(o.A, o.B) == 1 &&
BigInteger.GreatestCommonDivisor(o.A, o.C) == 1 &&
BigInteger.GreatestCommonDivisor(o.B, o.C) == 1;
}
}
এবং অবশেষে আমরা এটির পরিবর্তে এই চটজলদি Mainপদ্ধতিতে এটি একসাথে আনতে পারি :
static class Program
{
static void Main()
{
var bealOperandGenerator = new BealOperandGenerator();
if (bealOperandGenerator.Any(o => o.IsBealsConjectureCounterExample()))
{
Console.WriteLine("IN YOUR FACE, BEAL!");
}
}
}
যেখানে যদি A, B, C, x, y এবং z এর x, y, z> 2 এর সাথে ধনাত্মক পূর্ণসংখ্যা হয় তবে A, B এবং C এর একটি সাধারণ মৌলিক কারণ রয়েছে।