सी #, नो लूप्स
ठीक है, मैंने उन लिंक के एक जोड़े को स्किम किया, लेकिन सच कहूं तो वे थोड़े उबाऊ थे। मुझे हैश टेबल्स और व्हाट्सएप के साथ नरक से इसके अनुकूलन में कोई दिलचस्पी नहीं है। मुझे क्यों चाहिए? आपको एक गॉडडैम सुपर कंप्यूटर मिला है!
नरक, मैं भी छोरों के साथ परेशान नहीं करना चाहता! यह समाधान नो-लूप नियम का पालन करेगा ।
कृपया ध्यान दें कि मैं जिस कोड के बारे में लिखने जा रहा हूं वह अच्छा कोड नहीं है, या जिस तरह का कोड मैं वास्तविक जीवन में लिखूंगा (यदि कोई संभावित नियोक्ता इसे पढ़ने के लिए होता है)। यह कोड संक्षिप्तता और एक कथा में काम करने की क्षमता पर जोर देता है, और उचित सम्मेलनों और अनुष्ठानों और छोरों और इतने पर deemphasises।
यह दिखाने के लिए कि मैं किस बारे में बात कर रहा हूं, हम समीकरण के ऑपरेंड को संग्रहीत करने के लिए सार्वजनिक क्षेत्रों के साथ एक चौंकाने वाली कक्षा से शुरू करेंगे:
class BealOperands
{
public BigInteger A, B, C, x, y, z;
}
ठीक है, हम शायद सबसे कठिन चुनौती है। हमें उन ऑपरेंड के हर संयोजन के माध्यम से अनुमति देने का एक तरीका निकालने की जरूरत है। प्रत्येक क्रमपरिवर्तन की जाँच करने की तुलना में निस्संदेह इसे और अधिक कुशलता से करने के तरीके हैं, लेकिन मुझे उन्हें समझकर परेशान नहीं किया जा सकता है। और मुझे क्यों करना चाहिए? हमें एक गॉडडैम सुपर कंप्यूटर मिला है!
यहाँ मैं जिस एल्गोरिथ्म के साथ आया हूं। यह अविश्वसनीय रूप से अक्षम है, और बार-बार एक ही ऑपरेंड पर चला जाता है, लेकिन कौन परवाह करता है? सुपर कंप्यूटर!
- एक आधार -2 नंबर के रूप में छह ऑपरेंड्स का इलाज करें, और हर संयोजन के माध्यम से अनुमति दें।
- एक आधार -3 नंबर के रूप में छह ऑपरेंड्स का इलाज करें, और हर संयोजन के माध्यम से अनुमति दें।
- एक आधार -4 नंबर के रूप में छह ऑपरेंड्स का इलाज करें, और हर संयोजन के माध्यम से अनुमति दें।
- (...)
बिना छोरों के यह सब कैसे करें? आसान! बस लागू करें IEnumerableऔर IEnumeratorक्रमपरिवर्तन से बाहर पंप करने के लिए जुड़े । बाद में, हम इसे क्वेरी करने के लिए LINQ का उपयोग करेंगे।
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, modulo अनंत की शक्ति को बढ़ाने के लिए कोई विधि नहीं है ।
क्या एक समस्या का एक चमकदार नाखून! ऐसा लगता है कि इसे हमारे 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 के पास एक सामान्य अभाज्य कारक नहीं होना चाहिए (अर्थात उनका GCD 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 में एक सामान्य अभाज्य गुणक है।