Υπολογισμός συνδυασμών αθροισμάτων

basilis5 · 28 Απριλίου 2022

Κοβεσαι με τετοια απαντηση

29 Απριλίου 2022

άκυρο

Επεξ/σία 1 Μαΐου 2022 από LppToLss

demessakis · 30 Απριλίου 2022

Λοιπόν, έχω ασχοληθεί με παρόμοια θέματα στο excel, οπότε κάτι μπορεί να γίνει.

Η προσέγγισή μου:

- Βρίσκουμε όλους τους πιθανούς συνδυασμούς. Στο αρχικό παράδειγμα, βγαίνουν 540. Πως προκύπτει, αυτός ο αριθμός... Ας πάρω για παράδειγμα το 120. Για μια χιλιάδα, το μέγιστο δυνατό είναι 8 (8*120=960), αλλά θέλουμε να συμπεριλάβουμε και το 0, οπότε έχουμε 9 για το 120 και αντίστοιχα 6 για το 200 και 10 για το 110. Οπότε 9*6*10=540.

- Φτιάχνουμε στο excel τις στήλες με όλους τους πιθανούς συνδυασμούς. 0,0,0, 0,0,1, 0,0,2... 9,5,8. Με τύπους μπορεί να αυτοματοποιηθεί αυτό το βήμα.

- Σε δίπλα στήλη, το άθροισμα των γινομένων 110*Α+200*Β+120*Γ

- Προαιρετικός νέος πίνακας με την MATCH, επιστρέφουμε τις σειρές που το παραπάνω άθροισμα είναι 1000, και

- αν δεν έγινε στο προηγούμενο βήμα, νέος πίνακας με την INDEX, που να επιστρέφει τα αντίστοιχα Α,Β και Γ, για να είναι πιο άμεση η ανάγνωση των αποτελεσμάτων.

Στο αρχικό παράδειγμα και για τιμή 1000, οι πιθανοί συνδυασμοί είναι:

2*200+5*120
5*200
4*110+1*200+3*120
8*110+1*120

adi32 · 30 Απριλίου 2022

36 λεπτά πριν, demessakis είπε

Λοιπόν, έχω ασχοληθεί με παρόμοια θέματα στο excel, οπότε κάτι μπορεί να γίνει.

Η προσέγγισή μου:

- Βρίσκουμε όλους τους πιθανούς συνδυασμούς. Στο αρχικό παράδειγμα, βγαίνουν 540. Πως προκύπτει, αυτός ο αριθμός... Ας πάρω για παράδειγμα το 120. Για μια χιλιάδα, το μέγιστο δυνατό είναι 8 (8*120=960), αλλά θέλουμε να συμπεριλάβουμε και το 0, οπότε έχουμε 9 για το 120 και αντίστοιχα 6 για το 200 και 10 για το 110. Οπότε 9*6*10=540.

- Φτιάχνουμε στο excel τις στήλες με όλους τους πιθανούς συνδυασμούς. 0,0,0, 0,0,1, 0,0,2... 9,5,8. Με τύπους μπορεί να αυτοματοποιηθεί αυτό το βήμα.

- Σε δίπλα στήλη, το άθροισμα των γινομένων 110*Α+200*Β+120*Γ

- Προαιρετικός νέος πίνακας με την MATCH, επιστρέφουμε τις σειρές που το παραπάνω άθροισμα είναι 1000, και

- αν δεν έγινε στο προηγούμενο βήμα, νέος πίνακας με την INDEX, που να επιστρέφει τα αντίστοιχα Α,Β και Γ, για να είναι πιο άμεση η ανάγνωση των αποτελεσμάτων.

Στο αρχικό παράδειγμα και για τιμή 1000, οι πιθανοί συνδυασμοί είναι:

2*200+5*120
5*200
4*110+1*200+3*120
8*110+1*120

Πολύ καλό ακούγεται.

Θα προσπαθήσω να το φτιάξω

DrKo · 30 Απριλίου 2022

Αυτό το thread είναι ένα καλό παράδειγμα για να γίνει αντιληπτή η διαφορά μεταξύ ενός CS και ενός programmer/coder/developer. Έγραψα κάτι αλλά δεν έγινε αντιληπτό. Θα το κάνω πιο απλό και με έτοιμο κώδικα.

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from numpy import abs, array, ndarray
from scipy.optimize import minimize


def f(x: ndarray) -> float:
  items = array([110., 200., 120.])
  max_val = 1000.
  return abs(x.dot(items.T)- max_val).item()


def main() -> None:
  solutions = [
    minimize(f, array([x1, x2, x3]))
    for x1 in range(10)
    for x2 in range(10)
    for x3 in range(10)
  ]
  
  solutions = [
    i.x
    for i in solutions
    if i.fun == 0.0
  ]
  
  print(f'Solutions are: {solutions}')
  
  
if __name__ == '__main__':
  main()

Φυσικά το από πάνω είναι ένα εντελώς toy example. Μπορεί κανείς να βάλει ένα κάρο constraints για να το κάνει εντελώς applicable σε μία πραγματική ανάγκη.

Επεξ/σία 30 Απριλίου 2022 από DrKo

Directx · 30 Απριλίου 2022

Στις 26/4/2022 στις 1:37 ΜΜ, adi32 είπε

Δοκιμασα αυτο σε excel

https://www.extendoffice.com/product/kutools-for-excel/excel-find-all-combinations-that-equal-given-sum.html

αλλα μου δε βλεπω να μου βγαζει συνδυασμους με επαναλήψεις

πχ το 100Χ10 ή το 200Χ5

Spoiler

Πως μπορώ να το τρέξω αυτό σε browser?

Καλησπέρα, δυστυχώς ασχολούμαι σπάνια με Javascript / Web Programming παρόλα αυτά από περιέργεια δοκίμασα να κάνω ένα quick & dirty port τον αρχικό κώδικα μου σε Javascript ώστε να τρέχει σε browsers (το δοκίμασα σε FireFox και Edge) , ιδού λοιπόν..

Spoiler

<!--- Επιλυτής σε Javascript by xdir --->
<!DOCTYPE html>
<HTML>
    <BODY>  
        <H2>Solver for Javascript v1</H2>
        
        <P ID="RESULT"/>
    
        <SCRIPT>            
            document.getElementById("RESULT").innerHTML = 
                Solver([110, 200, 120], 1000, 9);                        
            
            /* 
             * Quantity      = ποσότητες, 
             * TargetValue   = ζητούμενη τιμή
             * MaxMultiplier = μέγιστος επιτρεπτός πολλαπλασιαστής
             *
             * Επιστροφή αλφαριθμητικού
             */
            function Solver(Quantity, TargetValue, MaxMultiplier) { 
                // flag τερματισμού while-loop
                var Final = false;
                
                // Προετοιμασία μετρητή πολλαπλασιαστών
                var Counter = new Array(Quantity.length).fill(1);

                // Αλφαριθμητικό αποτελέσματος
                var strResult = "";

                while (true) {
                    // Υπολογισμός αθροίσματος..
                    var Sum = 0;
                    
                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++)
                        Sum += (Quantity[iCnt] * Counter[iCnt]);
                        
                    /*
                     * Έλεγχος αθροίσματος, αν πρόκειται για το ζητούμενο άθροισμα,
                     *  εκτύπωση της λύσης στο αλφαριθμητικό 'strResult' και τέλος συνάρτησης
                     */
                    if (Sum == TargetValue) {
                        strResult = "Solution: ";                        

                        for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                            strResult += "(" + Quantity[iCnt].toString() + " * " + 
                                               Counter[iCnt].toString()
                                             + (iCnt < Quantity.length - 1 ? ") + ": ")")
                        }

                        strResult += " = " + Sum;

                        break;
                    }
                    
                    // Τέλος λύσεων, δίχως εύρεση του ζητούμενου TargetValue :-(
                    if (Final) { 
                        strResult = "Solution unobtainable within established parameters";
                        break;
                    }
                    
                    /*
                     * Προσαύξηση του πρώτου πολλαπλασιαστή +1, αν έφτασε στον μέγιστο
                     *  επιτρεπτό πολλαπλασιαστή τότε προσαύξηση των αμέσως επόμενων του
                     * όταν/αν πρέπει..
                     */
                    if (++Counter[0] > MaxMultiplier) {
                        Counter[0] = 1;

                        // 'Flag' προσαύξησης του επόμενου πολλαπλασιαστή (από αριστερά προς δεξιά..)
                        var Advance = true;

                        // Προσαύξηση κάθε επόμενου πολλαπλασιαστή? (τα δυο Advance μπορεί να γίνουν ένα για σύμπτυξη κώδικα)
                        for (var iCnt = 1; iCnt < Quantity.length && Advance; iCnt++) {
                            if (Counter[iCnt] + 1 > MaxMultiplier) {
                                Counter[iCnt] = 1;
                                Advance = true; // ναι!
                            } else {
                                Counter[iCnt]++;
                                Advance = false;// όχι..
                            }
                        }
                    }
                    
                    /*
                     * Ολοκλήρωση διαδικασίας? ναι όταν όλοι οι πολλαπλασιαστές του μετρητή
                     *  φτάσουν στην τιμή MaxMultiplier..
                     */
                    Final = true;

                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                        if (Counter[iCnt] != MaxMultiplier) {
                            Final = false;
                            break;
                        }
                    }                   
                }
                return strResult;
            }            
        </SCRIPT>    
    </BODY>
</HTML>

ΥΓ.
Όπως πάντα μπορεί να υπάρχουν προβλήματα ή άλλες αβλεψίες (ειδικά με μια γλώσσα που δεν ασχολούμαι συστηματικά) και φυσικά ουδεμία υποστήριξη.

Καλή συνέχεια!

Επεξ/σία 30 Απριλίου 2022 από Directx

adi32 · 30 Απριλίου 2022

1 ώρα πριν, Directx είπε

Καλησπέρα, δυστυχώς ασχολούμαι σπάνια με Javascript / Web Programming παρόλα αυτά από περιέργεια δοκίμασα να κάνω ένα quick & dirty port τον αρχικό κώδικα μου σε Javascript ώστε να τρέχει σε browsers (το δοκίμασα σε FireFox και Edge) , ιδού λοιπόν..

Απόκρυψη περιεχομένων

<!--- Επιλυτής σε Javascript by xdir --->
<!DOCTYPE html>
<HTML>
    <BODY>  
        <H2>Solver for Javascript v1</H2>
        
        <P ID="RESULT"/>
    
        <SCRIPT>            
            document.getElementById("RESULT").innerHTML = 
                Solver([110, 200, 120], 1000, 9);                        
            
            /* 
             * Quantity      = ποσότητες, 
             * TargetValue   = ζητούμενη τιμή
             * MaxMultiplier = μέγιστος επιτρεπτός πολλαπλασιαστής
             *
             * Επιστροφή αλφαριθμητικού
             */
            function Solver(Quantity, TargetValue, MaxMultiplier) { 
                // flag τερματισμού while-loop
                var Final = false;
                
                // Προετοιμασία μετρητή πολλαπλασιαστών
                var Counter = new Array(Quantity.length).fill(1);

                // Αλφαριθμητικό αποτελέσματος
                var strResult = "";

                while (true) {
                    // Υπολογισμός αθροίσματος..
                    var Sum = 0;
                    
                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++)
                        Sum += (Quantity[iCnt] * Counter[iCnt]);
                        
                    /*
                     * Έλεγχος αθροίσματος, αν πρόκειται για το ζητούμενο άθροισμα,
                     *  εκτύπωση της λύσης στο αλφαριθμητικό 'strResult' και τέλος συνάρτησης
                     */
                    if (Sum == TargetValue) {
                        strResult = "Solution: ";                        

                        for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                            strResult += "(" + Quantity[iCnt].toString() + " * " + 
                                               Counter[iCnt].toString()
                                             + (iCnt < Quantity.length - 1 ? ") + ": ")")
                        }

                        strResult += " = " + Sum;

                        break;
                    }
                    
                    // Τέλος λύσεων, δίχως εύρεση του ζητούμενου TargetValue :-(
                    if (Final) { 
                        strResult = "Solution unobtainable within established parameters";
                        break;
                    }
                    
                    /*
                     * Προσαύξηση του πρώτου πολλαπλασιαστή +1, αν έφτασε στον μέγιστο
                     *  επιτρεπτό πολλαπλασιαστή τότε προσαύξηση των αμέσως επόμενων του
                     * όταν/αν πρέπει..
                     */
                    if (++Counter[0] > MaxMultiplier) {
                        Counter[0] = 1;

                        // 'Flag' προσαύξησης του επόμενου πολλαπλασιαστή (από αριστερά προς δεξιά..)
                        var Advance = true;

                        // Προσαύξηση κάθε επόμενου πολλαπλασιαστή? (τα δυο Advance μπορεί να γίνουν ένα για σύμπτυξη κώδικα)
                        for (var iCnt = 1; iCnt < Quantity.length && Advance; iCnt++) {
                            if (Counter[iCnt] + 1 > MaxMultiplier) {
                                Counter[iCnt] = 1;
                                Advance = true; // ναι!
                            } else {
                                Counter[iCnt]++;
                                Advance = false;// όχι..
                            }
                        }
                    }
                    
                    /*
                     * Ολοκλήρωση διαδικασίας? ναι όταν όλοι οι πολλαπλασιαστές του μετρητή
                     *  φτάσουν στην τιμή MaxMultiplier..
                     */
                    Final = true;

                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                        if (Counter[iCnt] != MaxMultiplier) {
                            Final = false;
                            break;
                        }
                    }                   
                }
                return strResult;
            }            
        </SCRIPT>    
    </BODY>
</HTML>

ΥΓ.
Όπως πάντα μπορεί να υπάρχουν προβλήματα ή άλλες αβλεψίες (ειδικά με μια γλώσσα που δεν ασχολούμαι συστηματικά) και φυσικά ουδεμία υποστήριξη.

Καλή συνέχεια!

Ωραια μια χαρα δουλευει σε browser αλλα βγαζει μονο μια λυση

Οποτε αν ψαχνω εγω καποιες λυσεις κοντα στη ζητηση δεν βοηθιεμαι και πολυ

Directx · 30 Απριλίου 2022

15 λεπτά πριν, adi32 είπε

Ωραια μια χαρα δουλευει σε browser αλλα βγαζει μονο μια λυση

Οποτε αν ψαχνω εγω καποιες λυσεις κοντα στη ζητηση δεν βοηθιεμαι και πολυ

Σωστά , ο κώδικας διακόπτει πάντα στην πρώτη λύση , ο ακόλουθος κώδικας συνεχίζει την αναζήτηση και για άλλες λύσεις τις οποίες προσθέτει στο αλφαριθμητικό 'strResult' και τελικά "εκτυπώνει" στην σελίδα..

Spoiler

<!--- Επιλυτής σε Javascript by xdir v2 --->
<!DOCTYPE html>
<HTML>
    <BODY>  
        <H2>Solver for Javascript v2</H2>
        
        <P ID="RESULT"/>
    
        <SCRIPT>            
            document.getElementById("RESULT").innerHTML = 
                Solver([100, 100, 120], 1000, 9);                        
            
            /* 
             * Quantity      = ποσότητες, 
             * TargetValue   = ζητούμενη τιμή
             * MaxMultiplier = μέγιστος επιτρεπτός πολλαπλασιαστής
             *
             * Επιστροφή αλφαριθμητικού
             */
            function Solver(Quantity, TargetValue, MaxMultiplier) { 
                // flag τερματισμού while-loop
                var Final = false;
                            
                // v2; flag εύρεσης κάποιας λύσης?
                var aSolution = false;                
                
                // Προετοιμασία μετρητή πολλαπλασιαστών
                var Counter = new Array(Quantity.length).fill(1);

                // Αλφαριθμητικό αποτελέσματος
                var strResult = "";

                while (true) {
                    // Υπολογισμός αθροίσματος..
                    var Sum = 0;
                    
                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++)
                        Sum += (Quantity[iCnt] * Counter[iCnt]);
                        
                    /*
                     * Έλεγχος αθροίσματος, αν πρόκειται για το ζητούμενο άθροισμα,
                     *  εκτύπωση της λύσης στο αλφαριθμητικό 'strResult' και τέλος συνάρτησης
                     */
                    if (Sum == TargetValue) {
                        // v2; προσαύξηση (+=) λύσεων
                        strResult += "Solution: ";                        

                        for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                            strResult += "(" + Quantity[iCnt].toString() + " * " + 
                                               Counter[iCnt].toString()
                                             + (iCnt < Quantity.length - 1 ? ") + ": ")")
                        }

                        // v2; (+=) προσαύξηση λύσεων
                        strResult += " = " + Sum.toString() + "<BR>";

                        // v2; βρέθηκε έστω μια λύση
                        aSolution = true;

                        // break; // v2; δεν διακόπτουμε πλέον
                    }
                    
                    // Τέλος λύσεων, δίχως εύρεση του ζητούμενου TargetValue :-(
                    if (Final) { 
                        // v2; δεν βρέθηκε ούτε μια λύση?
                        if (!aSolution) {
                            strResult = "Solution unobtainable within established parameters";
                        }
                        break;
                    }
                    
                    /*
                     * Προσαύξηση του πρώτου πολλαπλασιαστή +1, αν έφτασε στον μέγιστο
                     *  επιτρεπτό πολλαπλασιαστή τότε προσαύξηση των αμέσως επόμενων του
                     * όταν/αν πρέπει..
                     */
                    if (++Counter[0] > MaxMultiplier) {
                        Counter[0] = 1;

                        // 'Flag' προσαύξησης του επόμενου πολλαπλασιαστή (από αριστερά προς δεξιά..)
                        var Advance = true;

                        // Προσαύξηση κάθε επόμενου πολλαπλασιαστή? (τα δυο Advance μπορεί να γίνουν ένα για σύμπτυξη κώδικα)
                        for (var iCnt = 1; iCnt < Quantity.length && Advance; iCnt++) {
                            if (Counter[iCnt] + 1 > MaxMultiplier) {
                                Counter[iCnt] = 1;
                                Advance = true; // ναι!
                            } else {
                                Counter[iCnt]++;
                                Advance = false;// όχι..
                            }
                        }
                    }
                    
                    /*
                     * Ολοκλήρωση διαδικασίας? ναι όταν όλοι οι πολλαπλασιαστές του μετρητή
                     *  φτάσουν στην τιμή MaxMultiplier..
                     */
                    Final = true;

                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                        if (Counter[iCnt] != MaxMultiplier) {
                            Final = false;
                            break;
                        }
                    }
                    
                }
                return strResult;
            }            
        </SCRIPT>    
    </BODY>
</HTML>

Ελπίζω να σε βοηθήσει κάπως , καλή συνέχεια!

adi32 · 30 Απριλίου 2022

9 λεπτά πριν, Directx είπε

Σωστά , ο κώδικας διακόπτει πάντα στην πρώτη λύση , ο ακόλουθος κώδικας συνεχίζει την αναζήτηση και για άλλες λύσεις τις οποίες προσθέτει στο αλφαριθμητικό 'strResult' και τελικά "εκτυπώνει" στην σελίδα..

Εμφάνιση κρυμμένου περιεχομένου

<!--- Επιλυτής σε Javascript by xdir v2 --->
<!DOCTYPE html>
<HTML>
    <BODY>  
        <H2>Solver for Javascript v2</H2>
        
        <P ID="RESULT"/>
    
        <SCRIPT>            
            document.getElementById("RESULT").innerHTML = 
                Solver([100, 100, 120], 1000, 9);                        
            
            /* 
             * Quantity      = ποσότητες, 
             * TargetValue   = ζητούμενη τιμή
             * MaxMultiplier = μέγιστος επιτρεπτός πολλαπλασιαστής
             *
             * Επιστροφή αλφαριθμητικού
             */
            function Solver(Quantity, TargetValue, MaxMultiplier) { 
                // flag τερματισμού while-loop
                var Final = false;
                            
                // v2; flag εύρεσης κάποιας λύσης?
                var aSolution = false;                
                
                // Προετοιμασία μετρητή πολλαπλασιαστών
                var Counter = new Array(Quantity.length).fill(1);

                // Αλφαριθμητικό αποτελέσματος
                var strResult = "";

                while (true) {
                    // Υπολογισμός αθροίσματος..
                    var Sum = 0;
                    
                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++)
                        Sum += (Quantity[iCnt] * Counter[iCnt]);
                        
                    /*
                     * Έλεγχος αθροίσματος, αν πρόκειται για το ζητούμενο άθροισμα,
                     *  εκτύπωση της λύσης στο αλφαριθμητικό 'strResult' και τέλος συνάρτησης
                     */
                    if (Sum == TargetValue) {
                        // v2; προσαύξηση (+=) λύσεων
                        strResult += "Solution: ";                        

                        for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                            strResult += "(" + Quantity[iCnt].toString() + " * " + 
                                               Counter[iCnt].toString()
                                             + (iCnt < Quantity.length - 1 ? ") + ": ")")
                        }

                        // v2; (+=) προσαύξηση λύσεων
                        strResult += " = " + Sum.toString() + "<BR>";

                        // v2; βρέθηκε έστω μια λύση
                        aSolution = true;

                        // break; // v2; δεν διακόπτουμε πλέον
                    }
                    
                    // Τέλος λύσεων, δίχως εύρεση του ζητούμενου TargetValue :-(
                    if (Final) { 
                        // v2; δεν βρέθηκε ούτε μια λύση?
                        if (!aSolution) {
                            strResult = "Solution unobtainable within established parameters";
                        }
                        break;
                    }
                    
                    /*
                     * Προσαύξηση του πρώτου πολλαπλασιαστή +1, αν έφτασε στον μέγιστο
                     *  επιτρεπτό πολλαπλασιαστή τότε προσαύξηση των αμέσως επόμενων του
                     * όταν/αν πρέπει..
                     */
                    if (++Counter[0] > MaxMultiplier) {
                        Counter[0] = 1;

                        // 'Flag' προσαύξησης του επόμενου πολλαπλασιαστή (από αριστερά προς δεξιά..)
                        var Advance = true;

                        // Προσαύξηση κάθε επόμενου πολλαπλασιαστή? (τα δυο Advance μπορεί να γίνουν ένα για σύμπτυξη κώδικα)
                        for (var iCnt = 1; iCnt < Quantity.length && Advance; iCnt++) {
                            if (Counter[iCnt] + 1 > MaxMultiplier) {
                                Counter[iCnt] = 1;
                                Advance = true; // ναι!
                            } else {
                                Counter[iCnt]++;
                                Advance = false;// όχι..
                            }
                        }
                    }
                    
                    /*
                     * Ολοκλήρωση διαδικασίας? ναι όταν όλοι οι πολλαπλασιαστές του μετρητή
                     *  φτάσουν στην τιμή MaxMultiplier..
                     */
                    Final = true;

                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                        if (Counter[iCnt] != MaxMultiplier) {
                            Final = false;
                            break;
                        }
                    }
                    
                }
                return strResult;
            }            
        </SCRIPT>    
    </BODY>
</HTML>

Ελπίζω να σε βοηθήσει κάπως , καλή συνέχεια!

Σορρυ αν σε κουράζω μια παρατηρηση.

Μπορεί να γίνει να δίνει και λύσεις με άθροισμα 990 έως 1000?

Επίσης δεν βγάζει και τους απλούς συδυασμους πχ 100*10

Directx · 30 Απριλίου 2022

47 λεπτά πριν, adi32 είπε

Σορρυ αν σε κουράζω μια παρατηρηση.

Μπορεί να γίνει να δίνει και λύσεις με άθροισμα 990 έως 1000?

Επίσης δεν βγάζει και τους απλούς συδυασμους πχ 100*10

Μπορείς να ορίσεις την μέγιστη τιμή των πολλαπλασιαστών στην είσοδο της συνάρτησης (MaxMultiplier ) από 9 που ήταν πριν (τυχαία επιλεχθείσα τιμή για τις αρχικές ανάγκες του θέματος) πχ σε 10 κοκ.

Επίσης πλέον μπορείς να ορίσεις διαφορετική συνθήκη στόχου όπου αντί για την ισότητα == TargetValue ορίζεις ένα αποδεκτό πεδίο τιμών πχ. Sum >= TargetValueMin && Sum <= TargetValueMax κλπ..

Συνεπώς η νέα μορφή εισόδου της συνάρτησης Solver είναι :

function Solver(Quantity, TargetValueMin, TargetValueMax, MaxMultiplier)

Spoiler

<!--- Επιλυτής σε Javascript by xdir v3 --->
<!DOCTYPE html>
<HTML>
    <BODY>  
        <H2>Solver for Javascript v3</H2>
        
        <P ID="RESULT"/>
    
        <SCRIPT>            
            document.getElementById("RESULT").innerHTML = 
                // v3; μέγιστη τιμή πολλαπλασιαστών 10, ελάχιστη τιμή στόχου 990 , μέγιστη τιμή στόχου 1000
                Solver([110, 200, 120], 990, 1000, 10); 
            
            /* 
             * Quantity       = ποσότητες, 
             * TargetValueMin = ελάχιστη ζητούμενη τιμή ; v3
             * TargetValueMax = μέγιστη ζητούμενη τιμή  ; v3
             * MaxMultiplier  = μέγιστος επιτρεπτός πολλαπλασιαστής
             *
             * Επιστροφή αλφαριθμητικού
             */
            function Solver(Quantity, TargetValueMin, TargetValueMax, MaxMultiplier) { 
                // flag τερματισμού while-loop
                var Final = false;
                            
                // v2; flag εύρεσης κάποιας λύσης?
                var aSolution = false;                
                
                // Προετοιμασία μετρητή πολλαπλασιαστών
                var Counter = new Array(Quantity.length).fill(1);

                // Αλφαριθμητικό αποτελέσματος
                var strResult = "";

                while (true) {
                    // Υπολογισμός αθροίσματος..
                    var Sum = 0;
                    
                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++)
                        Sum += (Quantity[iCnt] * Counter[iCnt]);
                        
                    /*
                     * Έλεγχος αθροίσματος, αν πρόκειται για το ζητούμενο άθροισμα,
                     *  εκτύπωση της λύσης στο αλφαριθμητικό 'strResult' και τέλος συνάρτησης
                     *
                     * v3; νέα συνθήκη με όρια επίλυσης μεταξύ TargetValueMin .. TargetValueMax
                     */
                    if (Sum >= TargetValueMin && Sum <= TargetValueMax) {
                        // v2; προσαύξηση (+=) λύσεων
                        strResult += "Solution: ";                        

                        for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                            strResult += "(" + Quantity[iCnt].toString() + " * " + 
                                               Counter[iCnt].toString()
                                             + (iCnt < Quantity.length - 1 ? ") + ": ")")
                        }

                        // v2; (+=) προσαύξηση λύσεων
                        strResult += " = " + Sum.toString() + "<BR>";

                        // v2; βρέθηκε έστω μια λύση
                        aSolution = true;

                        // break; // v2; δεν διακόπτουμε πλέον
                    }
                    
                    // Τέλος λύσεων, δίχως εύρεση του ζητούμενου TargetValue :-(
                    if (Final) { 
                        // v2; δεν βρέθηκε ούτε μια λύση?
                        if (!aSolution) {
                            strResult = "Solution unobtainable within established parameters";
                        }
                        break;
                    }
                    
                    /*
                     * Προσαύξηση του πρώτου πολλαπλασιαστή +1, αν έφτασε στον μέγιστο
                     *  επιτρεπτό πολλαπλασιαστή τότε προσαύξηση των αμέσως επόμενων του
                     * όταν/αν πρέπει..
                     */
                    if (++Counter[0] > MaxMultiplier) {
                        Counter[0] = 1;

                        // 'Flag' προσαύξησης του επόμενου πολλαπλασιαστή (από αριστερά προς δεξιά..)
                        var Advance = true;

                        // Προσαύξηση κάθε επόμενου πολλαπλασιαστή? (τα δυο Advance μπορεί να γίνουν ένα για σύμπτυξη κώδικα)
                        for (var iCnt = 1; iCnt < Quantity.length && Advance; iCnt++) {
                            if (Counter[iCnt] + 1 > MaxMultiplier) {
                                Counter[iCnt] = 1;
                                Advance = true; // ναι!
                            } else {
                                Counter[iCnt]++;
                                Advance = false;// όχι..
                            }
                        }
                    }
                    
                    /*
                     * Ολοκλήρωση διαδικασίας? ναι όταν όλοι οι πολλαπλασιαστές του μετρητή
                     *  φτάσουν στην τιμή MaxMultiplier..
                     */
                    Final = true;

                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                        if (Counter[iCnt] != MaxMultiplier) {
                            Final = false;
                            break;
                        }
                    }
                    
                }
                return strResult;
            }            
        </SCRIPT>    
    </BODY>
</HTML>

Καλή συνέχεια.

Επεξ/σία 30 Απριλίου 2022 από Directx

adi32 · 1 Μαΐου 2022

2 ώρες πριν, Directx είπε

Μπορείς να ορίσεις την μέγιστη τιμή των πολλαπλασιαστών στην είσοδο της συνάρτησης (MaxMultiplier ) από 9 που ήταν πριν (τυχαία επιλεχθείσα τιμή για τις αρχικές ανάγκες του θέματος) πχ σε 10 κοκ.

Επίσης πλέον μπορείς να ορίσεις διαφορετική συνθήκη στόχου όπου αντί για την ισότητα == TargetValue ορίζεις ένα αποδεκτό πεδίο τιμών πχ. Sum >= TargetValueMin && Sum <= TargetValueMax κλπ..

Συνεπώς η νέα μορφή εισόδου της συνάρτησης Solver είναι :

function Solver(Quantity, TargetValueMin, TargetValueMax, MaxMultiplier)

Απόκρυψη περιεχομένων

<!--- Επιλυτής σε Javascript by xdir v3 --->
<!DOCTYPE html>
<HTML>
    <BODY>  
        <H2>Solver for Javascript v3</H2>
        
        <P ID="RESULT"/>
    
        <SCRIPT>            
            document.getElementById("RESULT").innerHTML = 
                // v3; μέγιστη τιμή πολλαπλασιαστών 10, ελάχιστη τιμή στόχου 990 , μέγιστη τιμή στόχου 1000
                Solver([110, 200, 120], 990, 1000, 10); 
            
            /* 
             * Quantity       = ποσότητες, 
             * TargetValueMin = ελάχιστη ζητούμενη τιμή ; v3
             * TargetValueMax = μέγιστη ζητούμενη τιμή  ; v3
             * MaxMultiplier  = μέγιστος επιτρεπτός πολλαπλασιαστής
             *
             * Επιστροφή αλφαριθμητικού
             */
            function Solver(Quantity, TargetValueMin, TargetValueMax, MaxMultiplier) { 
                // flag τερματισμού while-loop
                var Final = false;
                            
                // v2; flag εύρεσης κάποιας λύσης?
                var aSolution = false;                
                
                // Προετοιμασία μετρητή πολλαπλασιαστών
                var Counter = new Array(Quantity.length).fill(1);

                // Αλφαριθμητικό αποτελέσματος
                var strResult = "";

                while (true) {
                    // Υπολογισμός αθροίσματος..
                    var Sum = 0;
                    
                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++)
                        Sum += (Quantity[iCnt] * Counter[iCnt]);
                        
                    /*
                     * Έλεγχος αθροίσματος, αν πρόκειται για το ζητούμενο άθροισμα,
                     *  εκτύπωση της λύσης στο αλφαριθμητικό 'strResult' και τέλος συνάρτησης
                     *
                     * v3; νέα συνθήκη με όρια επίλυσης μεταξύ TargetValueMin .. TargetValueMax
                     */
                    if (Sum >= TargetValueMin && Sum <= TargetValueMax) {
                        // v2; προσαύξηση (+=) λύσεων
                        strResult += "Solution: ";                        

                        for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                            strResult += "(" + Quantity[iCnt].toString() + " * " + 
                                               Counter[iCnt].toString()
                                             + (iCnt < Quantity.length - 1 ? ") + ": ")")
                        }

                        // v2; (+=) προσαύξηση λύσεων
                        strResult += " = " + Sum.toString() + "<BR>";

                        // v2; βρέθηκε έστω μια λύση
                        aSolution = true;

                        // break; // v2; δεν διακόπτουμε πλέον
                    }
                    
                    // Τέλος λύσεων, δίχως εύρεση του ζητούμενου TargetValue :-(
                    if (Final) { 
                        // v2; δεν βρέθηκε ούτε μια λύση?
                        if (!aSolution) {
                            strResult = "Solution unobtainable within established parameters";
                        }
                        break;
                    }
                    
                    /*
                     * Προσαύξηση του πρώτου πολλαπλασιαστή +1, αν έφτασε στον μέγιστο
                     *  επιτρεπτό πολλαπλασιαστή τότε προσαύξηση των αμέσως επόμενων του
                     * όταν/αν πρέπει..
                     */
                    if (++Counter[0] > MaxMultiplier) {
                        Counter[0] = 1;

                        // 'Flag' προσαύξησης του επόμενου πολλαπλασιαστή (από αριστερά προς δεξιά..)
                        var Advance = true;

                        // Προσαύξηση κάθε επόμενου πολλαπλασιαστή? (τα δυο Advance μπορεί να γίνουν ένα για σύμπτυξη κώδικα)
                        for (var iCnt = 1; iCnt < Quantity.length && Advance; iCnt++) {
                            if (Counter[iCnt] + 1 > MaxMultiplier) {
                                Counter[iCnt] = 1;
                                Advance = true; // ναι!
                            } else {
                                Counter[iCnt]++;
                                Advance = false;// όχι..
                            }
                        }
                    }
                    
                    /*
                     * Ολοκλήρωση διαδικασίας? ναι όταν όλοι οι πολλαπλασιαστές του μετρητή
                     *  φτάσουν στην τιμή MaxMultiplier..
                     */
                    Final = true;

                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                        if (Counter[iCnt] != MaxMultiplier) {
                            Final = false;
                            break;
                        }
                    }
                    
                }
                return strResult;
            }            
        </SCRIPT>    
    </BODY>
</HTML>

Καλή συνέχεια.

Σ ευχαριστω και παλι

Νομιζω παλι δε βγαζει τις λυσεις με 1 ή 2 στοιχεια πχ 100χ10 ή 333χ3=999 ή 300χ3+100χ1

Για περισσότερα απο 3 δεδομενα πχ 5 μαλλον θελει μετατροπη

 Solver([100, 200, 300, 333, 250], 990, 1000, 10);

Επεξ/σία 1 Μαΐου 2022 από adi32

Directx · 1 Μαΐου 2022

6 ώρες πριν, adi32 είπε
Σ ευχαριστω και παλι

Νομιζω παλι δε βγαζει τις λυσεις με 1 ή 2 στοιχεια πχ 100χ10 ή 333χ3=999 ή 300χ3+100χ1

Για περισσότερα απο 3 δεδομενα πχ 5 μαλλον θελει μετατροπη
 Solver([100, 200, 300, 333, 250], 990, 1000, 10); 

Η είσοδος που όρισες δεν μπορεί να λυθεί στο επιτρεπτό διάστημα τιμών καθώς αν αθροίσεις τα (100+200+300+333+250) εξ’ αρχής λαμβάνεις αποτέλεσμα εκτός του μέγιστου επιτρεπτού ορίου δηλαδή 1183.

Αυτό που θα μπορούσε να γίνει ώστε να διευκολυνθείς σε κάποιες περιπτώσεις , είναι η δυνατότητα μηδενικού πολλαπλασιαστή που έχει ως αποτέλεσμα όμως την (έμμεση) διαγραφή κάποιας ή κάποιων ποσοτήτων (καθώς ποσότητα x 0 = 0).

Εναλλακτικά θα μπορούσε να αλλάζει ο αριθμός ποσοτήτων που ως τώρα θεωρείται σταθερός ή ότι μπορεί μια ποσότητα να διαγραφτεί.

Συνεπώς η συνάρτηση πλέον ξεκινά την αναζήτηση επιθυμητών συνδυασμών από πολλαπλασιαστή μηδέν έως MaxMultiplier εν γνώσει της ότι για ορισμένες λύσεις κάποιες ποσότητες θα μηδενιστούν..

Spoiler

<!--- Επιλυτής σε Javascript by xdir v4 --->
<!DOCTYPE html>
<HTML>
    <BODY>  
        <H2>Solver for Javascript v4</H2>
        
        <P ID="RESULT"/>
    
        <SCRIPT>            
            document.getElementById("RESULT").innerHTML = 
                // v3; μέγιστη τιμή πολλαπλασιαστών 10, ελάχιστη τιμή στόχου 990 , μέγιστη τιμή στόχου 1000
                Solver([100, 200, 300, 333, 250], 990, 1000, 10); 
            
            /* 
             * Quantity       = ποσότητες, 
             * TargetValueMin = ελάχιστη ζητούμενη τιμή ; v3
             * TargetValueMax = μέγιστη ζητούμενη τιμή  ; v3
             * MaxMultiplier  = μέγιστος επιτρεπτός πολλαπλασιαστής
             *
             * Επιστροφή αλφαριθμητικού
             */
            function Solver(Quantity, TargetValueMin, TargetValueMax, MaxMultiplier) { 
                // flag τερματισμού while-loop
                var Final = false;
                            
                // v2; flag εύρεσης κάποιας λύσης?
                var aSolution = false;                
                
                // Προετοιμασία μετρητή πολλαπλασιαστών ; v4 πλέον οι πολλαπλασιαστές ξεκινάν από μηδέν
                var Counter = new Array(Quantity.length).fill(0);

                // Αλφαριθμητικό αποτελέσματος
                var strResult = "";

                while (true) {
                    // Υπολογισμός αθροίσματος..
                    var Sum = 0;
                    
                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++)
                        Sum += (Quantity[iCnt] * Counter[iCnt]);
                        
                    /*
                     * Έλεγχος αθροίσματος, αν πρόκειται για το ζητούμενο άθροισμα,
                     *  εκτύπωση της λύσης στο αλφαριθμητικό 'strResult' και τέλος συνάρτησης
                     *
                     * v3; νέα συνθήκη με όρια επίλυσης μεταξύ TargetValueMin .. TargetValueMax
                     */
                    if (Sum >= TargetValueMin && Sum <= TargetValueMax) {
                        // v2; προσαύξηση (+=) λύσεων
                        strResult += "Solution: ";                        

                        for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                            strResult += "(" + Quantity[iCnt].toString() + " * " + 
                                               Counter[iCnt].toString()
                                             + (iCnt < Quantity.length - 1 ? ") + ": ")")
                        }

                        // v2; (+=) προσαύξηση λύσεων
                        strResult += " = " + Sum.toString() + "<BR>";

                        // v2; βρέθηκε έστω μια λύση
                        aSolution = true;

                        // break; // v2; δεν διακόπτουμε πλέον
                    }
                    
                    // Τέλος λύσεων, δίχως εύρεση του ζητούμενου TargetValue :-(
                    if (Final) { 
                        // v2; δεν βρέθηκε ούτε μια λύση?
                        if (!aSolution) {
                            strResult = "Solution unobtainable within established parameters";
                        }
                        break;
                    }
                    
                    /*
                     * Προσαύξηση του πρώτου πολλαπλασιαστή +1, αν έφτασε στον μέγιστο
                     *  επιτρεπτό πολλαπλασιαστή τότε προσαύξηση των αμέσως επόμενων του
                     * όταν/αν πρέπει..
                     */
                    if (++Counter[0] > MaxMultiplier) {
                        Counter[0] = 0; // v4; πλέον οι πολλαπλασιαστές ξεκινάν από μηδέν

                        // 'Flag' προσαύξησης του επόμενου πολλαπλασιαστή (από αριστερά προς δεξιά..)
                        var Advance = true;

                        // Προσαύξηση κάθε επόμενου πολλαπλασιαστή? (τα δυο Advance μπορεί να γίνουν ένα για σύμπτυξη κώδικα)
                        for (var iCnt = 1; iCnt < Quantity.length && Advance; iCnt++) {
                            if (Counter[iCnt] + 1 > MaxMultiplier) {
                                Counter[iCnt] = 0; // v4; πλέον οι πολλαπλασιαστές ξεκινάν από μηδέν
                                Advance = true; // ναι!
                            } else {
                                Counter[iCnt]++;
                                Advance = false;// όχι..
                            }
                        }
                    }
                    
                    /*
                     * Ολοκλήρωση διαδικασίας? ναι όταν όλοι οι πολλαπλασιαστές του μετρητή
                     *  φτάσουν στην τιμή MaxMultiplier..
                     */
                    Final = true;

                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                        if (Counter[iCnt] != MaxMultiplier) {
                            Final = false;
                            break;
                        }
                    }
                    
                }
                return strResult;
            }            
        </SCRIPT>    
    </BODY>
</HTML>

ΕΙΣΟΔΟΣ / ΕΞΟΔΟΣ:

[100, 200, 300, 333, 250]

Solution: (100 * 10) + (200 * 0) + (300 * 0) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 8) + (200 * 1) + (300 * 0) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 6) + (200 * 2) + (300 * 0) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 4) + (200 * 3) + (300 * 0) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 2) + (200 * 4) + (300 * 0) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 0) + (200 * 5) + (300 * 0) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 7) + (200 * 0) + (300 * 1) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 5) + (200 * 1) + (300 * 1) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 3) + (200 * 2) + (300 * 1) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 1) + (200 * 3) + (300 * 1) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 4) + (200 * 0) + (300 * 2) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 2) + (200 * 1) + (300 * 2) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 0) + (200 * 2) + (300 * 2) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 1) + (200 * 0) + (300 * 3) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 0) + (200 * 0) + (300 * 0) + (333 * 3) + (250 * 0) = 999
Solution: (100 * 5) + (200 * 0) + (300 * 0) + (333 * 0) + (250 * 2) = 1000
Solution: (100 * 3) + (200 * 1) + (300 * 0) + (333 * 0) + (250 * 2) = 1000
Solution: (100 * 1) + (200 * 2) + (300 * 0) + (333 * 0) + (250 * 2) = 1000
Solution: (100 * 2) + (200 * 0) + (300 * 1) + (333 * 0) + (250 * 2) = 1000
Solution: (100 * 0) + (200 * 1) + (300 * 1) + (333 * 0) + (250 * 2) = 1000
Solution: (100 * 0) + (200 * 0) + (300 * 0) + (333 * 0) + (250 * 4) = 1000

[100]

Solution: (100 * 10) = 1000

[333]

Solution: (333 * 3) = 999

[300, 100]

Solution: (300 * 3) + (100 * 1) = 1000
Solution: (300 * 2) + (100 * 4) = 1000
Solution: (300 * 1) + (100 * 7) = 1000
Solution: (300 * 0) + (100 * 10) = 1000

ΥΓ.

Σχετικά τώρα με τις εισόδους [100] ή [333] ή [100, 300] και η προηγούμενη έκδοση (v3) έδινε αναμενόμενα αποτελέσματα , απλά τώρα λαμβάνεις και ένα εξτρά που είναι με πολλαπλασιαστή ..μηδέν (δηλαδή εκτός μια ποσότητα)

Επεξ/σία 1 Μαΐου 2022 από Directx

adi32 · 1 Μαΐου 2022

2 ώρες πριν, Directx είπε

Η είσοδος που όρισες δεν μπορεί να λυθεί στο επιτρεπτό διάστημα τιμών καθώς αν αθροίσεις τα (100+200+300+333+250) εξ’ αρχής λαμβάνεις αποτέλεσμα εκτός του μέγιστου επιτρεπτού ορίου δηλαδή 1183.

Αυτό που θα μπορούσε να γίνει ώστε να διευκολυνθείς σε κάποιες περιπτώσεις , είναι η δυνατότητα μηδενικού πολλαπλασιαστή που έχει ως αποτέλεσμα όμως την (έμμεση) διαγραφή κάποιας ή κάποιων ποσοτήτων (καθώς ποσότητα x 0 = 0).

Εναλλακτικά θα μπορούσε να αλλάζει ο αριθμός ποσοτήτων που ως τώρα θεωρείται σταθερός ή ότι μπορεί μια ποσότητα να διαγραφτεί.

Συνεπώς η συνάρτηση πλέον ξεκινά την αναζήτηση επιθυμητών συνδυασμών από πολλαπλασιαστή μηδέν έως MaxMultiplier εν γνώσει της ότι για ορισμένες λύσεις κάποιες ποσότητες θα μηδενιστούν..

Εμφάνιση κρυμμένου περιεχομένου

<!--- Επιλυτής σε Javascript by xdir v4 --->
<!DOCTYPE html>
<HTML>
    <BODY>  
        <H2>Solver for Javascript v4</H2>
        
        <P ID="RESULT"/>
    
        <SCRIPT>            
            document.getElementById("RESULT").innerHTML = 
                // v3; μέγιστη τιμή πολλαπλασιαστών 10, ελάχιστη τιμή στόχου 990 , μέγιστη τιμή στόχου 1000
                Solver([100, 200, 300, 333, 250], 990, 1000, 10); 
            
            /* 
             * Quantity       = ποσότητες, 
             * TargetValueMin = ελάχιστη ζητούμενη τιμή ; v3
             * TargetValueMax = μέγιστη ζητούμενη τιμή  ; v3
             * MaxMultiplier  = μέγιστος επιτρεπτός πολλαπλασιαστής
             *
             * Επιστροφή αλφαριθμητικού
             */
            function Solver(Quantity, TargetValueMin, TargetValueMax, MaxMultiplier) { 
                // flag τερματισμού while-loop
                var Final = false;
                            
                // v2; flag εύρεσης κάποιας λύσης?
                var aSolution = false;                
                
                // Προετοιμασία μετρητή πολλαπλασιαστών ; v4 πλέον οι πολλαπλασιαστές ξεκινάν από μηδέν
                var Counter = new Array(Quantity.length).fill(0);

                // Αλφαριθμητικό αποτελέσματος
                var strResult = "";

                while (true) {
                    // Υπολογισμός αθροίσματος..
                    var Sum = 0;
                    
                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++)
                        Sum += (Quantity[iCnt] * Counter[iCnt]);
                        
                    /*
                     * Έλεγχος αθροίσματος, αν πρόκειται για το ζητούμενο άθροισμα,
                     *  εκτύπωση της λύσης στο αλφαριθμητικό 'strResult' και τέλος συνάρτησης
                     *
                     * v3; νέα συνθήκη με όρια επίλυσης μεταξύ TargetValueMin .. TargetValueMax
                     */
                    if (Sum >= TargetValueMin && Sum <= TargetValueMax) {
                        // v2; προσαύξηση (+=) λύσεων
                        strResult += "Solution: ";                        

                        for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                            strResult += "(" + Quantity[iCnt].toString() + " * " + 
                                               Counter[iCnt].toString()
                                             + (iCnt < Quantity.length - 1 ? ") + ": ")")
                        }

                        // v2; (+=) προσαύξηση λύσεων
                        strResult += " = " + Sum.toString() + "<BR>";

                        // v2; βρέθηκε έστω μια λύση
                        aSolution = true;

                        // break; // v2; δεν διακόπτουμε πλέον
                    }
                    
                    // Τέλος λύσεων, δίχως εύρεση του ζητούμενου TargetValue :-(
                    if (Final) { 
                        // v2; δεν βρέθηκε ούτε μια λύση?
                        if (!aSolution) {
                            strResult = "Solution unobtainable within established parameters";
                        }
                        break;
                    }
                    
                    /*
                     * Προσαύξηση του πρώτου πολλαπλασιαστή +1, αν έφτασε στον μέγιστο
                     *  επιτρεπτό πολλαπλασιαστή τότε προσαύξηση των αμέσως επόμενων του
                     * όταν/αν πρέπει..
                     */
                    if (++Counter[0] > MaxMultiplier) {
                        Counter[0] = 0; // v4; πλέον οι πολλαπλασιαστές ξεκινάν από μηδέν

                        // 'Flag' προσαύξησης του επόμενου πολλαπλασιαστή (από αριστερά προς δεξιά..)
                        var Advance = true;

                        // Προσαύξηση κάθε επόμενου πολλαπλασιαστή? (τα δυο Advance μπορεί να γίνουν ένα για σύμπτυξη κώδικα)
                        for (var iCnt = 1; iCnt < Quantity.length && Advance; iCnt++) {
                            if (Counter[iCnt] + 1 > MaxMultiplier) {
                                Counter[iCnt] = 0; // v4; πλέον οι πολλαπλασιαστές ξεκινάν από μηδέν
                                Advance = true; // ναι!
                            } else {
                                Counter[iCnt]++;
                                Advance = false;// όχι..
                            }
                        }
                    }
                    
                    /*
                     * Ολοκλήρωση διαδικασίας? ναι όταν όλοι οι πολλαπλασιαστές του μετρητή
                     *  φτάσουν στην τιμή MaxMultiplier..
                     */
                    Final = true;

                    for (var iCnt = 0; iCnt < Quantity.length; iCnt++) {
                        if (Counter[iCnt] != MaxMultiplier) {
                            Final = false;
                            break;
                        }
                    }
                    
                }
                return strResult;
            }            
        </SCRIPT>    
    </BODY>
</HTML>

ΕΙΣΟΔΟΣ / ΕΞΟΔΟΣ:

[100, 200, 300, 333, 250]

Solution: (100 * 10) + (200 * 0) + (300 * 0) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 8) + (200 * 1) + (300 * 0) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 6) + (200 * 2) + (300 * 0) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 4) + (200 * 3) + (300 * 0) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 2) + (200 * 4) + (300 * 0) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 0) + (200 * 5) + (300 * 0) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 7) + (200 * 0) + (300 * 1) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 5) + (200 * 1) + (300 * 1) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 3) + (200 * 2) + (300 * 1) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 1) + (200 * 3) + (300 * 1) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 4) + (200 * 0) + (300 * 2) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 2) + (200 * 1) + (300 * 2) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 0) + (200 * 2) + (300 * 2) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 1) + (200 * 0) + (300 * 3) + (333 * 0) + (250 * 0) = 1000
Solution: (100 * 0) + (200 * 0) + (300 * 0) + (333 * 3) + (250 * 0) = 999
Solution: (100 * 5) + (200 * 0) + (300 * 0) + (333 * 0) + (250 * 2) = 1000
Solution: (100 * 3) + (200 * 1) + (300 * 0) + (333 * 0) + (250 * 2) = 1000
Solution: (100 * 1) + (200 * 2) + (300 * 0) + (333 * 0) + (250 * 2) = 1000
Solution: (100 * 2) + (200 * 0) + (300 * 1) + (333 * 0) + (250 * 2) = 1000
Solution: (100 * 0) + (200 * 1) + (300 * 1) + (333 * 0) + (250 * 2) = 1000
Solution: (100 * 0) + (200 * 0) + (300 * 0) + (333 * 0) + (250 * 4) = 1000

[100]

Solution: (100 * 10) = 1000

[333]

Solution: (333 * 3) = 999

[300, 100]

Solution: (300 * 3) + (100 * 1) = 1000
Solution: (300 * 2) + (100 * 4) = 1000
Solution: (300 * 1) + (100 * 7) = 1000
Solution: (300 * 0) + (100 * 10) = 1000

ΥΓ.

Σχετικά τώρα με τις εισόδους [100] ή [333] ή [100, 300] και η προηγούμενη έκδοση (v3) έδινε αναμενόμενα αποτελέσματα , απλά τώρα λαμβάνεις και ένα εξτρά που είναι με πολλαπλασιαστή ..μηδέν (δηλαδή εκτός μια ποσότητα)

Είσαι πρώτος.

Νομιζω είναι τέλειο τώρα.

k33theod · 24 Μαΐου 2022

και μια λύση ακόμα

>>> def f(x,y,z,s):
	xint = int (s/x) +1
	yint = int(s/y)+1
	zint = int(s/z)+1
	sol = []
	for i in range(xint):
		for j in range(yint):
			for k in range(zint):
				if i*x + j*y +k*z == s:
					sol.append([i,j,k])
	return sol

>>> f(100,200,300,1000)
[[0, 2, 2], [0, 5, 0], [1, 0, 3], [1, 3, 1], [2, 1, 2], [2, 4, 0], [3, 2, 1], [4, 0, 2], [4, 3, 0], [5, 1, 1], [6, 2, 0], [7, 0, 1], [8, 1, 0], [10, 0, 0]]

@elio_1 Είδα τη λύση σου μετά που έγραψα το παραπάνω. Μην νομίζεις ότι έκλεψα την ιδέα 😀

elio_1 · 24 Μαΐου 2022

@k33theod μη σε απασχολεί, δεν ανακάλυψα την Αμερική.

Επεξ/σία 24 Μαΐου 2022 από elio_1

Σύνδεση

Υπολογισμός συνδυασμών αθροισμάτων

Προτεινόμενες αναρτήσεις

basilis5

Επισκέπτης

demessakis

adi32

DrKo

Directx

adi32

Directx

adi32

Directx

adi32

Directx

adi32

k33theod

elio_1

Δημιουργήστε ένα λογαριασμό ή συνδεθείτε για να σχολιάσετε

Δημιουργία λογαριασμού

Σύνδεση

Σύνδεση