Tengo un problema con el conteo, que es la continuación deesta pregunta. No soy realmente una persona matemática, así que es muy difícil para mí resolver estosubset sum problem que se sugirió como resolución.

Estoy teniendo 4ArrayList en el que tengo datos: alId, alTransaction, alNumber, alPrice

Tipo | Transacción | Número | Precio
8 | Comprar | 95.00000000 | 305.00000000
8 | Comprar | 126.00000000 | 305.00000000
8 | Comprar | 93.00000000 | 306.00000000
8 | Transferir fuera | 221.00000000 | 305.00000000
8 | Transferencia en | 221.00000000 | 305.00000000
8 | Vender | 93.00000000 | 360.00000000
8 | Vender | 95.00000000 | 360.00000000
8 | Vender | 126.00000000 | 360.00000000
8 | Comprar | 276.00000000 | 380.00000000

Al final, trato de obtener lo que queda para el cliente y lo que me queda lo puse en 3 listas de matrices:
- alNewHowMuch (corresponde a alNumber),
- alNewPrice (corresponde a alPrice),
- alNewInID (corresponde a 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;
            }
        }

Básicamente, estoy agregando y eliminando cosas de la matriz según el tipo de transacción, la identificación de la transacción y los números. Estoy agregando números a ArrayList como 156, 340 (cuando es TransferIn o Buy), etc. y luego los elimino haciéndolo como 156, 340 (cuando es TransferOut, Sell). Mi solución funciona para eso sin ningún problema. El problema que tengo es que, para algunos datos antiguos, los empleados ingresaban sumas como 1500 en lugar de 500 + 400 + 100 + 500. ¿Cómo lo cambiaría para que cuando hayaSell/TransferOut oBuy/Transfer In y no hay coincidencia dentro de ArrayList, debería intentar agregar múltiples elementos desde eseArrayList y encuentra elementos que se combinan en agregado.

Dentro de mi código, traté de resolver ese problema con una simple suma de todo cuando no hay coincidencia (índice == 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);
                            }
                        }
                    }

Pero solo funciona si se cumplen ciertas condiciones y falla por el resto.

Editar: Dado que algunos de ustedes estaban tan asombrados (y cegados) por mis nombres de variables polacos, los traduje todos al inglés por simplicidad y visibilidad. Espero que esto me ayude a obtener ayuda :-)