सी #

Question

में दशमलव संख्याओं की गणना (जटिल) सरणी आज पीपीएल के लिए सभी को नमस्कार और मेरी क्रिसमस।
मुझे समस्या है और शायद कोई मेरी मदद कर सकता है।
मेरे पास एक सूची बॉक्स है जहां उपयोगकर्ता दशमलव संख्या दर्ज कर सकते हैं।

1.1 
1.2 
1.3 
1.4 
1.5 

मैं उन 5 संख्या में सभी रूपों की राशि प्राप्त करने की आवश्यकता:
कहना है कि वे 5 संख्या में प्रवेश करेंगे देता है। उदाहरण के लिए 1.1 and 1.2 का योग 1.1 1.2 1.3 फिर 1.1 1.2 1.3 1.4, फिर 1.2 1.4 1.5 फिर 1.1 1.3 1.5।
मैंने शुरू किया कुछ लेकिन वह सभी रूपों केवल एक समय में एक नंबर लंघन के माध्यम से चला जाता है:

List<Double[]> listNumber = new List<double[]>();    
Double[] array;    
for (int i = 0; i < listBox1.Items.Count; i++) 
{ 
    array = new Double[listBox1.Items.Count];     
    for (int k = 0; k < listBox1.Items.Count; k++) 
    { 
     if (!k.Equals(i)) 
     { 
      array[k] = (Convert.ToDouble(listBox1.Items[k]));      
     } 
    } 
    listNumber.Add(array); 
} 

मैं एक तरह से कैसे रास्ता मैं चाहता हूँ की गणना करने के खोजने की जरूरत है, अगर कोई मुझे साइम विचार दे सकते हैं कि यह होगा महान क्रिसमस उपहार बनें :) अग्रिम धन्यवाद, Laziale

Answer 1

आपके प्रारंभिक प्रयास में, आपका कोड केवल सभी संभावित जोड़े के योग की गणना करता है। आपके विवरण से, आप तीन संख्याओं का योग भी प्राप्त करना चाहते हैं, आदि ..

यदि हमेशा 5 दशमलव संख्याएं हैं, तो आपके पास केवल 5 लूप के लिए हो सकता है। हालांकि एक अधिक सामान्य डिजाइन किया जाएगा क्लीनर

double[] input = double[5]; //Pretend the user has entered these 
int[] counters = int[input.Length]; //One for each "dimension" 
List<double> sums = new List<double>(); 

for (int i = 0; i < counters.Length; i++) 
    counters[i] = -1; //The -1 value allows the process to begin with sum of single digits, then pairs, etc.. 

while (true) 
{ 
    double thisSum = 0; 
    //Apply counters 
    for (int i = 0; i < counters.Length; i++) 
    { 
     if (counters[i] == -1) continue; 

     thisSum += input[counters[i]]; 
    } 

    //Increment counters 
    counters[0]++; //Increment at base 
    for (int i = 0; i < counters.Length; i++) 
    { 
     if (counters[i] >= counters.Length) 
     { 
      if (i == counters.Length - 1) //Check if this is the last dimension 
       return sums; //Exhausted all possible combinations 

      counters[i] = 0; 
      counters[i+1]++; 
     } 
     else 
      break; 
    } 
} 

यहाँ यह एक ही नंबर के अलावा दो बार से बचने के लिए किसी भी कोड के बिना है (मैं आपको लगता है कि खत्म बंद करने की कोशिश दूँगा।HINT: आप वृद्धिशील काउंटर अनुभाग के बाद ऐसा कर सकते हैं, जिसमें "वृद्धि काउंटर" अनुभाग और कुछ "लूप काउंटर" अनुभाग शामिल हैं, जबकि थोड़ी देर के अंदर, काउंटर अद्वितीय होने पर लूप के बाहर तोड़ते हैं ...

नोट: मैंने इस कोड का परीक्षण नहीं किया है, लेकिन यह बंद हो जाएगा, और इसमें एक या दो बग होंगे - अगर आपको बग के साथ किसी भी मदद की ज़रूरत है तो मुझे बताएं।

Answer 2

जबकि मैं सी # में बहुत कुशल नहीं हूं, मुझे सकारात्मक यकीन है कि आप जो करना चाहते हैं उसका एक और आसान तरीका है; बेशक, मुझे कुछ याद आ रहा है।

सूची या ऐरे में प्रत्येक तत्व के लिए लूप क्यों न बनाएं, और फिर इसे स्वयं छोड़ने के लिए कहें। उदाहरण:

Double[] array = new Double[3]; 
array[0] = 1,1; 
array[1] = 1,2; 
array[2] = 1,3; 

Double sum = 0; 

for (int i = 0; i < array.Length ; i++) 
{ 
    for (int x = 0 ; x < array.Length ; x++) { 
     if (array[i] != array[x]) 
     { 
      sum = array[x] + array[x+1] // or [x-1] depending on the value of x, you should be able to work this out. 
     } 
    } 
} 

आप समझने के लिए मैं इस उदाहरण का परीक्षण करके मतलब सक्षम होना चाहिए। बेशक, यह एक बहुत ही बुनियादी प्रोटोटाइप है, आप एक्स के मान के आधार पर पीछे की ओर जांचने के लिए इसका विस्तार करेंगे, और अपने रकम को स्टोर करने के लिए कई "योग" चर रखने के लिए इसका विस्तार करें - इस पर निर्भर करता है कि आप किस प्रकार के परिणाम ' फिर से देख रहे हैं

-मुझे उम्मीद है कि यह मेरी क्रिसमस में मदद करता है।

Answer 3

बस एक रूपरेखा मैं अपने फोन पर हूँ के रूप में:

अपने इनपुट की सूची के साथ आरंभ और एक आउटपुट सूची है कि एक शून्य होता है।

अपने इनपुट में प्रत्येक नंबर के लिए, वर्तमान आउटपुट सूची में प्रत्येक संख्या में वर्तमान इनपुट नंबर जोड़कर युगल की एक नई सूची बनाएं; फिर आउटपुट सूची के अंत तक इस सूची को जोड़ दें।

वैकल्पिक रूप से, शून्य और इनपुट संख्या में से प्रत्येक का पहला उदाहरण है, और किसी भी डुप्लिकेट निकालने:

जैसे आपके उदाहरण के लिए इनपुट 1.4:

0 
0 1.1 
0 1.1 1.2 2.3 
0 1.1 1.2 2.3 1.3 2.4 2.5 3.6 
0 1.1 1.2 2.3 1.3 2.4 2.5 3.6 1.4 2.5 2.6 3.7 2.7 3.8 3.9 5.0 
     1.2 2.3  2.4 2.5 3.6   2.6 3.7 2.7 3.8 3.9 5.0      

Answer 4

प्रत्येक संख्या के सामने अपने listBox ले लो और, या तो संकेत मिलता है कि यह संकेत मिलता है कि यह अपने योग के भाग लेंगे अपने जोड़ या किसी 1 को भाग नहीं होगा एक 0 डाल दिया। 1.1 के अपने उदाहरण सूची, 1.2, 1.3, 1.4, 1.5 और 1.1 की रकम, 1.2 तो 1.1 1.2 1.3 तब तो 1.1 1.2 1.3 1.4 साथ 1.2 1.4 1.5 तो 1.1 1.3 1.5 यह आप देना होगा (मैं केवल बारे में स्पष्टता के लिए 1 रों, खाली स्थान 0 मतलब):

  |  |  | 1.1 |  | 
     |  | 1.1 | 1.2 | 1.2 | 1.1 
     |  | 1.2 | 1.3 | 1.4 | 1.3 
    1.1 | 1.2 | 1.3 | 1.4 | 1.5 | 1.5 
---+-----+-----+-----+-----+-----+----- 
1.1| 1   1  1   1 
1.2|  1  1  1  1 
1.3|    1  1   1 
1.4|     1  1 
1.5|       1  1 

अब आप इस तरह के एक प्रतिनिधित्व के साथ देख सकते हैं, इन नंबरों के सभी संयोजनों लिस्टिंग अब 31 (11111 बाइनरी में, 2⁵ - 1) 0 से में गिनती के समान है। यदि आप खाली अनुक्रम में रूचि नहीं रखते हैं तो 1.

इस गिनती को listNumber में बदलने के लिए नमूना कोड यहां दिया गया है। कृपया वाक्यविन्यास क्षमा करें क्योंकि मुझे सी # नहीं पता है। इसका यह भी अर्थ है कि यह अवांछित कोड है।

Double[] array = new Double[listBox1.Items.Count]; 
for (int i = 0; i < listBox1.Items.count; i++) 
    array[k] = Convert.ToDouble(listBox1.Items[i]); 
int count = 2^array.Items.Count; 
List<Double>[] listNumber = new List<Double>[count]; 
for (int i = 0; i < listNumber.Items.Count; i++) { 
    listNumber[i] = new List<Double>(); 
    for (j = 0; j < array.Items.Count) 
     if (i & (1 << j) != 0) 
      listNumber[i].Add(array[j]); 
}