obliczyć (skomplikowaną) tablicę liczb dziesiętnych w C#

Question

Witam wszystkich i Wesołych Świąt dla osób świętujących dzisiaj.
Mam problem i może ktoś może mi pomóc.
Mam pole listy, w którym użytkownicy mogą wprowadzać liczby dziesiętne.
Powiedzmy oni wprowadzić 5 numerów:

1.1 
1.2 
1.3 
1.4 
1.5 

muszę się sumę wszystkich zmian w tych 5 numerów. Na przykład suma 1.1 and 1.2, następnie 1.1 1.2 1.3, następnie 1.1 1.2 1.3 1.4, następnie 1.2 1.4 1.5, następnie 1.1 1.3 1.5.
zacząłem coś ale który przechodzi przez wszystkich wariacji tylko pomijając jeden numer na raz:

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); 
} 

muszę znaleźć sposób, jak obliczyć tak, jak chcesz, jeśli ktoś może mi dać Sime pojęcia, że ​​będzie być wspaniałym prezentem na Boże Narodzenie :) Z góry dziękuję, Laziale

Answer 1

Podczas pierwszej próby, twój kod oblicza tylko sumę wszystkich możliwych par. Z Twojego opisu, chcesz również znaleźć sumę trzech liczb, itd.

Jeśli zawsze jest 5 liczb dziesiętnych, możesz po prostu mieć 5 dla pętli. Jednak bardziej ogólny projekt będzie czystsze

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; 
    } 
} 

tutaj jest bez kodu dla uniknięcia dodanie tego samego numeru dwa razy (dam ci starają się zakończyć, że off.WSKAZ :WKA: Możesz to zrobić po sekcji liczników przyrostów, zawierającej sekcję "Liczniki przyrostu" i nową sekcję "Sprawdzaj liczniki" w pętli while, z przerwą poza pętlą while, gdy liczniki są unikatowe ...

UWAGA: Nie testowałem tego kodu, ale będzie on blisko i prawdopodobnie będzie zawierał jeden lub dwa błędy - daj mi znać, jeśli potrzebujesz pomocy z tymi błędami.

Answer 2

Chociaż nie jestem biegły w C#, jestem pewien, że istnieje znacznie prostszy sposób robienia tego, co chcesz robić; chyba, że ​​oczywiście czegoś mi brakuje.

Dlaczego nie utworzyć pętli for dla każdego elementu na liście lub tablicy, a następnie powiedzieć, aby pomijał sam siebie. Przykład:

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. 
     } 
    } 
} 

Powinieneś być w stanie zrozumieć, co mam na myśli, badając ten przykład. Oczywiście, jest to bardzo prosty prototyp, wystarczy, że rozwiniesz go, aby sprawdzić wstecz, w zależności od wartości x, i mieć wiele zmiennych "sum" do przechowywania twoich sum - w zależności od rodzaju wyników " szukam ponownie.

- Mam nadzieję, że to pomoże, Wesołych Świąt.

Answer 3

tylko zarys, jak jestem na moim telefonie:

start z listy wejściowego i wyjściowego, że lista zawiera zero.

Dla każdej liczby na swoim wejściu utwórz nową listę podwójną, dodając bieżący numer wejściowy do każdej z liczb na bieżącej liście wyjściowej; następnie połącz tę listę z końcem listy wyników.

Ewentualnie usunięcia zera i pierwszy przykład każdego z liczby wejściowych oraz duplikaty:

Np dla przykładowego wejścia do 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

Take Your listBox, a przed każdym numerem, albo umieścić 0 aby wskazać, że nie będzie to uczestniczyć do sumy lub 1 aby wskazać, że będzie uczestniczyć do sumy. Z przykładowej liście 1.1, 1.2, 1.3, 1.4, 1.5 i sumami 1.1, 1.2 następnie 1.1 1.2 1.3 następnie 1.1 1.2 1.3 1.4 następnie 1.2 1.4 1.5 następnie 1.1 1.3 1.5 byłoby to daje (piszę 1 s dla jasności myśli 0 tylko puste przestrzenie):

  |  |  | 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 

Jak można teraz zobaczyć z takiej reprezentacji, wymieniając wszystkie kombinacje tych liczb jest teraz podobna do liczenia w zakresie od 0 do 31 (11111 w systemie binarnym, 2⁵ - 1). Jeśli nie interesuje Cię pusta sekwencja, zacznij liczyć od 1.

Oto przykładowy kod, aby przekształcić to zliczanie w dowolną liczbę. Proszę wybaczyć składni, ponieważ nie wiem C#. Oznacza to również, że jest to nietestowany kod.

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]); 
}