यह निर्धारित करने के लिए कि क्या तीन इन्स सभी बराबर हैं

Question

हाय कहते हैं कि मेरे पास तीन इन्ट्स हैं: value1, value2 और value3।

मैं कैसे निर्धारित कर सकता हूं कि वे सभी समान हैं या नहीं?

मैंने कोशिश की:

return value1 == value2 == value3 

लेकिन इस ने कहा:

ऑपरेटर '==' प्रकार 'bool' और 'int' की ऑपरेंड के लिए लागू नहीं किया जा सकता।

तो मुझे लगता है कि यह पहले दो की तुलना करता है जो एक बुलियन लौटाता है जो यह तीसरे से तुलना करने की कोशिश करता है।

मैं जा सकते हैं:

return value1 == value2 && value2 == value3; 

लेकिन यह गन्दा हो रही किया जा रहा है।

किसी के पास कोई अच्छा सुझाव है?

Answer 1

दूसरा मुझे ठीक लगता है।

चूंकि सूची अधिक हो जाती है, जो अनावश्यक हो सकती है। इस मामले में मैं AllSame की लाइनों के साथ एक विस्तार विधि लिखूंगा।

bool AllSame(params int[] list) 
{ 
    return (list as IEnumerable<int>).AllSame(); 
} 

तो फिर तुम सिर्फ लिख सकते हैं::

if (AllSame(value1, value2, value3, value4, value5)) ... 

Answer 2

कि मेरे लिए ठीक लग रहा है

bool AllSame(this IEnumerable<int> list) 
{ 
    bool first = true; 
    int comparand = 0; 
    foreach (int i in list) { 
     if (first) comparand = i; 
     else if (i != comparand) return false; 
     first = false; 
    } 
    return true; 
} 

या params कीवर्ड का उपयोग करें। मेरे पास एकमात्र टिप्पणी यह ​​है कि आपको समीकरण के लिए 'व्याख्या करने वाला चर' पेश करना चाहिए। गणना की व्याख्या करने के अलावा, परिणाम की जांच करते समय वापसी अब ब्रेकपॉइंट या ट्रेसपॉइंट के लिए एक अच्छी जगह प्रदान करती है।

bool allThreeAreEqual = value1 == value2 && value2 == value3; 
return allThreeAreEqual; 

Answer 3

तुम सिर्फ भव्यता के लिए देख रहे हैं (ध्यान में रखते हुए अपने पहले से ही एक समाधान इसके साथ कुछ भी गलत नहीं है कि है), तो आप good'ol LINQ के साथ जा सकते हैं। यह तीन या अधिक संभाल सकता है।

class Program 
    { 
     static void Main(string[] args) 
     { 
      List<int> mylist = new List<int>(); 
      mylist.Add(1); 
      mylist.Add(1); 
      mylist.Add(1); 
      mylist.Add(1); 

      bool allElementsAreEqual = mylist.All(x => (x == mylist.First())); 
     } 
    } 

Answer 4

मैं अपने मूल जवाब संशोधित एक विधि अधिक सामान्य उद्देश्य है और वह LINQ या विस्तार के तरीकों पर निर्भर नहीं करता है कि शामिल करने के लिए। मुझे लगता है कि यह मानना ​​सुरक्षित है कि यह विधि इस तथ्य के आधार पर अधिक सक्षम होगी कि सूची में अलग-अलग मूल्य होने पर विशिष्टता निर्धारित करने के लिए इसे पूरी सूची को गिनने की आवश्यकता नहीं है।

class Program 
{ 
    static void Main(string[] args) 
    { 
     int value1 = 1, value2 = 2, value3 = 1; 
     Console.WriteLine(AllAreEqual<int>(value1, value2, value3)); 

     Console.Write("V2: 1 value "); 
     Console.WriteLine(AllAreEqual_V2<int>(1)); 

     Console.Write("V2: no value "); 
     Console.WriteLine(AllAreEqual_V2<int>()); 

     Console.Write("V2: 3 values, same "); 
     Console.WriteLine(AllAreEqual_V2<int>(1, 1, 1)); 

     Console.Write("V2: 3 values, different "); 
     Console.WriteLine(AllAreEqual_V2<int>(1, 1, 2)); 

     Console.Write("V2: 2 values, same "); 
     Console.WriteLine(AllAreEqual_V2<int>(1, 1)); 

     Console.Write("V2: 2 values, different "); 
     Console.WriteLine(AllAreEqual_V2<int>(1, 2)); 

     Console.ReadKey(); 
    } 

    static bool AllAreEqual<T>(params T[] args) 
    { 
     return args.Distinct().ToArray().Length == 1; 
    } 

    static bool AllAreEqual_V2<T>(params T[] args) 
    { 
     if (args.Length == 0 || args.Length == 1) 
     { 
      return true; 
     } 

     if (args.Length == 2) 
     { 
      return args[0].Equals(args[1]); 
     } 

     T first = args[0]; 

     for (int index = 1; index < args.Length; index++) 
     { 
      if (!first.Equals(args[index])) 
      { 
       return false; 
      } 
     } 

     return true; 
    } 
} 

Answer 5

int nOneInput = 5; 
int nTwoInput = 5; 
int nThreeInput = 5; 
if ((nOneInput + nTwoInput + nThreeInput)/3 == nOneInput) 
{ 
    // all 3 sides are equal when... 
    // the sum of all 3 divided by 3 equals one of the values 
} 

Answer 6

LINQ का उपयोग करते हुए यह हमारे Any() के लिए सबसे अच्छा होगा। के बजाय Any() क्यों है क्योंकि All() संग्रह के सभी आइटमों पर पूर्वानुमान का परीक्षण करेगा जबकि Any() जैसे ही आइटम अनुमानित होगा और आइटम से बाहर निकल जाएगा।

यहां मैं एक रिवर्स चेक का उपयोग करता हूं। मैं किसी भी वस्तु की तलाश में हूं जो आइटम "ए" से अलग होगा।तो जैसे ही यह एक अलग मिल जाए, हम जानते हैं कि वे सभी बराबर नहीं हैं इसलिए यह बाहर निकलता है और सत्य लौटाता है। तो यह केवल आइटम "बी", "सी" और "डी" का परीक्षण करेगा।

// all values to compare 
var a = 4; 
var b = 4; 
var c = 4; 
var d = 8; 
var e = 6; 
var f = 4; 

// return if any of the following is different and negate to get a true 
var areSame = (!new[] { b, c, d, e, f}.Any(i => i != a)); 

आप ओवरराइड के बराबर होती है तो आप इस कि पुन: प्रयोज्य है और (केवल भाषा मैं उन्हें लागू करने के रूप में IEqualityComparer<T>