कुछ अन्य ऑब्जेक्ट्स वाली ऑब्जेक्ट्स की सूची/सरणी को देखते हुए, मैं पैरामीटर में से किसी एक का उपयोग करके सॉर्ट करना चाहता हूं। उदाहरण के लिए, यदि मेरे पास इनट्स की बहु-आयामी सरणी है और मैं उनके मध्य बिंदु से क्रमबद्ध करना चाहता हूं।

जिस तरह से मैं इसे कर रहा हूं वह एक अज्ञात वस्तु बनाना है जिसमें 1. मध्य बिंदु और 2. प्रत्येक प्रविष्टि के लिए 2 इंच की एक सूची है। फिर इन ऑब्जेक्ट्स को सूचीबद्ध करें और मिडपॉइंट पैरामीटर द्वारा एक्सेस और सॉर्ट करने के लिए प्रतिबिंब का उपयोग करें।

क्या इस समस्या के लिए कोई और मानक दृष्टिकोण है? यह थोड़ा अनाड़ी है क्योंकि मुझे इसे करने के लिए एक डमी बनाना है और अनाम सूची ऑब्जेक्ट को साफ़ करना है।

class Program
{
    static void Main(string[] args)
    {
        int[,] input = new int[,] { { 5, 6 }, { 0, 1 }, { 2, 20 } };

        var itemList = new []{ 
          new { sortVar = 0.1f, item = new List<int>() } }.ToList();

        itemList.Clear();

        for(int i=0; i<input.GetLength(0); i++)
        {
            List <int> temp = new List<int> (new int[] { input[i,0], input[i, 1] });

            var item = new { 
              sortVar = float.Parse((input[i,0]+input[i,1]).ToString())/2,
              item = temp };

            itemList.Add(item);
        }

        var itemList2 = itemList.OrderBy(x => x.sortVar);
    }
}
1
Totoro 5 सितंबर 2017, 10:36

2 जवाब

सबसे बढ़िया उत्तर

आपके दृष्टिकोण का एक संक्षिप्त linq संस्करण औसत विधि सीधे OrderBy खंड में (यदि आप 2-डी सूची का उपयोग करने के इच्छुक हैं):

List<List<int>> input_List = new List<List<int>> 
{
    new List<int>{ 5, 6 }, 
    new List<int>{ 0, 1 }, 
    new List<int>{ 2, 20 } 
};

var output = input_List.OrderBy(x=>x.Average()).ToList();   

संपादित करें:

यदि आपको इसे माध्यिका द्वारा आदेश देने की आवश्यकता है तो आप इस अभिव्यक्ति का उपयोग कर सकते हैं:

var output = input_List.OrderBy(x=>x.OrderBy(y=>y).ElementAt(x.Count / 2)).ToList();    
1
Mong Zhu 5 सितंबर 2017, 14:00

मैं 2D सरणी को दांतेदार एक (सरणी की सरणी) में बदलने का सुझाव देता हूं:

   int[][] input = new int[][] { 
     new int[]{ 5,  6 }, 
     new int[]{ 0,  1 }, 
     new int[]{ 2, 20 } }; 

और एक विधि के रूप में मानदंड (MidPoint) निकालें

   private static double MidPoint(IEnumerable<int> value) {
      int[] sorted = value.OrderBy(item => item).ToArray(); 

      // / 2.0: we don't want integer division: (1 + 4) / 2 == 2 when (1 + 4) / 2.0 == 2.5
      return sorted.Length % 2 == 0
        ? (sorted[sorted.Length / 2 - 1] + sorted[sorted.Length / 2]) / 2.0
        : sorted[sorted.Length / 2];
    } 

यदि आप स्थान पर क्रमबद्ध करना चाहते हैं तो Array वर्ग का उपयोग करें:

 // input will be sorted 
 Array.Sort(input, (a, b) => MidPoint(a).CompareTo(MidPoint(b)));

यदि आप एक नया क्रमबद्ध सरणी बनाना चाहते हैं:

 // we'll have to arrays: initial (unsorted) input, and sorted sortedInput
 var sortedInput = input
   .OrderBy(line => MidPoint(line))
   .ToArray();
1
Dmitry Bychenko 5 सितंबर 2017, 11:48