Ich habe ein Problem mit dem Zählen, was die Fortsetzung von @ isDie frage. Ich bin nicht wirklich ein Mathematiker, also ist es wirklich schwer für mich, das herauszufindensubset sum problem was als Auflösung vorgeschlagen wurde.

Ich habe 4ArrayList in dem ich Daten halte: alId, alTransaction, alNumber, alPrice

Type | Transaktion | Nummer | Prei
8 | Kaufen | 95.00000000 | 305.00000000
8 | Kaufen | 126.00000000 | 305.00000000
8 | Kaufen | 93.00000000 | 306.00000000
8 | Übertragen | 221.00000000 | 305.00000000
8 | Übertragen in | 221.00000000 | 305.00000000
8 | Verkaufen | 93.00000000 | 360.00000000
8 | Verkaufen | 95.00000000 | 360.00000000
8 | Verkaufen | 126.00000000 | 360.00000000
8 | Kaufen | 276.00000000 | 380.00000000

m Ende versuche ich herauszufinden, was noch für den Kunden übrig ist und was noch übrig ist. Ich füge es in 3 Array-Listen ei
- alNewHowMuch (entspricht alNumber),
- alNewPrice (entspricht alPrice),
- alNewInID (entspricht alID)

        ArrayList alNewHowMuch = new ArrayList();
        ArrayList alNewPrice = new ArrayList();
        ArrayList alNewInID = new ArrayList();
        for (int i = 0; i < alTransaction.Count; i++) {
            string transaction = (string) alTransaction[i];
            string id = (string) alID[i];
            decimal price = (decimal) alPrice[i];
            decimal number = (decimal) alNumber[i];
            switch (transaction) {
                case "Transfer out":
                case "Sell":
                    int index = alNewHowMuch.IndexOf(number);
                    if (index != -1) {
                        alNewHowMuch.RemoveAt(index);
                        alNewPrice.RemoveAt(index);
                        alNewInID.RemoveAt(index);
                    } else {
                        ArrayList alTemp = new ArrayList();
                        decimal sum = 0;
                        for (int j = 0; j < alNewHowMuch.Count; j ++) {
                            string tempid = (string) alNewInID[j];
                            decimal tempPrice = (decimal) alNewPrice[j];
                            decimal tempNumbers = (decimal) alNewHowMuch[j];
                            if (id == tempid && tempPrice == price) {
                                alTemp.Add(j);
                                sum = sum + tempNumbers;
                            }
                        }
                        if (sum == number) {
                            for (int j = alTemp.Count - 1; j >= 0; j --) {
                                int tempIndex = (int) alTemp[j];
                                alNewHowMuch.RemoveAt(tempIndex);
                                alNewPrice.RemoveAt(tempIndex);
                                alNewInID.RemoveAt(tempIndex);
                            }
                        }
                    }
                    break;
                case "Transfer In":
                case "Buy":
                    alNewHowMuch.Add(number);
                    alNewPrice.Add(price);
                    alNewInID.Add(id);
                    break;
            }
        }

Grundsätzlich füge ich je nach Transaktionstyp, Transaktions-ID und Nummer Dinge hinzu und entferne sie aus dem Array. Ich füge Zahlen wie 156, 340 (wenn es TransferIn oder Buy ist) usw. zu ArrayList hinzu und entferne sie dann, indem ich es wie 156, 340 (wenn es TransferOut ist, Sell) tue. Meine Lösung funktioniert dafür problemlos. Das Problem, das ich habe, ist, dass Mitarbeiter für einige alte Daten Summen wie 1500 anstelle von 500 + 400 + 100 + 500 eingaben. Wie würde ich es so ändern, dass, wenn esSell/TransferOut oderBuy/Transfer In und es gibt keine Übereinstimmung in ArrayList. Es sollte versucht werden, mehrere Elemente aus @ hinzuzufügeArrayList und finde Elemente, die sich zu einem Aggregat verbinden.

Innerhalb meines Codes habe ich versucht, dieses Problem zu lösen, indem ich einfach alles summiere, wenn es keine Übereinstimmung gibt (index == 1)

                    int index = alNewHowMuch.IndexOf(number);
                    if (index != -1) {
                        alNewHowMuch.RemoveAt(index);
                        alNewPrice.RemoveAt(index);
                        alNewInID.RemoveAt(index);
                    } else {
                        ArrayList alTemp = new ArrayList();
                        decimal sum = 0;
                        for (int j = 0; j < alNewHowMuch.Count; j ++) {
                            string tempid = (string) alNewInID[j];
                            decimal tempPrice = (decimal) alNewPrice[j];
                            decimal tempNumbers = (decimal) alNewHowMuch[j];
                            if (id == tempid && tempPrice == price) {
                                alTemp.Add(j);
                                sum = sum + tempNumbers;
                            }
                        }
                        if (sum == number) {
                            for (int j = alTemp.Count - 1; j >= 0; j --) {
                                int tempIndex = (int) alTemp[j];
                                alNewHowMuch.RemoveAt(tempIndex);
                                alNewPrice.RemoveAt(tempIndex);
                                alNewInID.RemoveAt(tempIndex);
                            }
                        }
                    }

Aber es funktioniert nur, wenn bestimmte Bedingungen erfüllt sind, und schlägt im Übrigen fehl.

Bearbeiten Da einige von Ihnen von meinen polnischen Variablennamen so erstaunt (und geblendet) waren, übersetzte ich sie der Einfachheit und Sichtbarkeit halber alle ins Englische. Hoffentlich hilft mir das weiter :-)