Algoritmo per trovare combinazioni di numeri interi e qualsiasi operando per ottenere un risultato fisso

Question

Sto scrivendo un programma che richiede 4 numeri come input e quindi tenta di vedere se una combinazione di divisione di sottrazione e moltiplicazione dei quattro numeri può renderli uguali a 24. La mia strada era la creazione di un metodo per ogni singola combinazione possibile dei quattro numeri e dei quattro operandi, che è un po 'prolisso. Ecco un esempio di 2 metodi.

public static boolean add(int a, int b, int c, int d){ 
    boolean adBool; 
    adBool = a + b + c + d == 24; 
    return adBool; 
} 
public static boolean sub1(int a, int b, int c, int d){ 
    boolean subBool1; 
    subBool1 = a - b - c - d == 24; 
    return subBool1; 
} 

Poi nel mio principale faccio a creare un ciclo while per ogni metodo che se il metodo restituisce true, stamperà che il metodo si è fermato in poi, è stata la soluzione. Ecco un esempio.

while (add(num1, num2, num3, num4)){ 
      System.out.println("Your solution is " + num1 + " + " + num2 + " + " + num3 + " + " + num4 + " = 24\nCongratulations!"); 
      break; 

     } 
     while (sub1(num1, num2, num3, num4)){ 
      System.out.println("Your solution is " + num1 + " - " + num2 + " - " + num3 + " - " + num4 + " = 24\nCongratulations!"); 
      break; 
     } 

C'è un modo per memorizzare operandi come + e - in modo che io possa mettere in un array e basta usare un po 'di cicli for innestati a scrivere questo?

Answer 1

Assumendo gli operandi sono fissi, è possibile creare un generatore che scarica gli eventuali operatori, e passarle a un valutatore per determinare se sono vere.

while (generator.hasNext()){ 
    Operators ops = generator.getNext(); 
    if evaluatesTo(operand1, operand2, operand3, operand4, 24, ops){ 
     // print it 
    } 
} 

Un generatore semplice potrebbe essere fatto in questo modo:

List<String> list = new ArrayList<String>(); 
list.add("+++"); 
list.add("++-"); 
... 
Iterator generator = list.iterator(); 

dove generatore implementa l'interfaccia java.util.Iterator che inizializza con tutti gli operatori (+ - * /) e ne mostra tutte le permutazioni di dimensione 3.

procedimento evalutesTo semplicemente calcola esso:

public boolean (int operand1, int operand2, int operand3, int operand4, int total, Operators ops){ 
    // calculate operand1 "ops.get(0)" operand2 "ops.get(1)" operand3 "ops.get(2)" operand4 == total 
} 

Quindi, se OPS è [+ - /] sarebbe controllare

if (operand1 + operand2 - operand3/operand4 == 24) return true; 

Dovrei aggiungere ci sono tutti i tipi di efficienza è possibile aggiungere in seguito, ma sei domanda è: come si può fare questo con una strategia migliore. Ci sono alcuni commenti sui dettagli di altri utenti, ma non me ne preoccuperei ora. Per prima cosa devi impostare questo tipo di struttura, quindi puoi preoccuparti dei dettagli. La maggior parte della chiave per questo, è che non è necessario fare 100 di metodi di ricerca simili.

Answer 2

Ho fatto un po 'di ricerca per voi.
Ho trovato this stackexchange question esaminando come creare tutte le combinazioni possibili per un determinato set di caratteri. È possibile utilizzare questo per generare tutte le possibili combinazioni di +, -, /, * utilizzando il metodo descritto nella domanda

public static void combinations(int maxLength, char[] alphabet, String curr) { 
     // If the current string has reached it's maximum length 
     if (curr.length() == maxLength) { 
      System.out.println(curr); 

      // Else add each letter from the alphabet to new strings and process these new strings again 
     } else { 
      for (int i = 0; i < alphabet.length; i++) { 
       String oldCurr = curr; 
       curr += alphabet[i]; 
       combinations(maxLength, alphabet, curr); 
       curr = oldCurr; 
      } 
     } 
    } 

e chiamandolo con qualcosa come

char[] operators = new char[]{'+', '-', '/', '*'}; 
combinations(3, operators , ""); //You want to call it with 3 since you only need 3 operators. 

Dopo (o al posto di) stampando la nuova combinazione (System.out.println(curr);) è possibile chiamare un metodo per interpretare l'output.
È possibile uscire da qualcosa di simile a questo stackoverflow simple calculator example.
Per esempio, si può avere qualcosa di simile:

if(curr.charAt(0) == '+'){ 
//add the first and second number 
} 

Penso che questo dovrebbe essere sufficiente a farti andare.

EDIT
avuto il tempo sulle mie mani e voleva finire questo dato che ho trovato interessante. Ecco, vai. Funziona esattamente per quello che ti serve.

Per renderlo interessante ho usato numeri casuali. Non sei sicuro di come stai ricevendo il tuo numero. Una cosa da tenere a mente è che i decimali sono scesi in divisione quando si ha a che fare con l'intero. Quindi qualcosa come 12/64 = 0 o 11/5 = 2.
Ecco un esempio di output:

run: 
+++ 
0+0+10+10= 20 
++- 
59+3+38-80= 20 
++/ 
19+0+66/53= 20 
++* 
15+5+0*54= 20 
+-+ 
23+26-97+68= 20 
+-- 
87+66-73-60= 20 
+-/ 
15+5-0/33= 20 
+-* 
63+57-50*2= 20 
+/+ 
8+61/37+11= 20 
+/- 
72+38/55-52= 20 
+// 
20+61/71/8= 20 
+/* 
18+5/28*14= 20 
+*+ 
2+0*14+18= 20 
+*- 
35+1*75-90= 20 
+*/ 
20+8*5/54= 20 
+** 
20+91*0*2= 20 
-++ 
37-100+17+66= 20 
-+- 
65-89+46-2= 20 
-+/ 
52-32+33/84= 20 
-+* 
52-32+44*0= 20 
--+ 
39-74-22+77= 20 
--- 
92-0-54-18= 20 
--/ 
62-41-45/73= 20 
--* 
54-34-0*82= 20 
-/+ 
22-98/9+9= 20 
-/- 
66-27/71-45= 20 
-// 
20-0/17/41= 20 
-/* 
42-20/71*76= 20 
-*+ 
9-2*0+11= 20 
-*- 
90-6*10-10= 20 
-*/ 
40-75*24/90= 20 
-** 
20-0*26*90= 20 
/++ 
65/47+6+13= 20 
/+- 
91/5+56-54= 20 
/+/ 
64/4+69/16= 20 
/+* 
54/81+2*10= 20 
/-+ 
80/89-68+88= 20 
/-- 
65/2-11-1= 20 
/-/ 
86/4-96/98= 20 
/-* 
80/4-0*100= 20 
//+ 
12/64/57+20= 20 
//- 
64/1/1-44= 20 
/// 
82/1/4/1= 20 
//* 
45/7/18*57= 20 
/*+ 
45/12*4+5= 20 
/*- 
44/21*45-74= 20 
/*/ 
87/6*55/38= 20 
/** 
29/76*5*11= 20 
*++ 
0*36+3+17= 20 
*+- 
4*13+55-87= 20 
*+/ 
2*10+14/72= 20 
*+* 
0*100+2*10= 20 
*-+ 
49*1-29+0= 20 
*-- 
48*2-54-22= 20 
*-/ 
1*21-11/73= 20 
*-* 
44*52-27*84= 20 
*/+ 
7*8/56+19= 20 
*/- 
38*77/55-33= 20 
*// 
95*99/6/77= 20 
*/* 
2*9/72*83= 20 
**+ 
0*11*40+20= 20 
**- 
8*6*1-28= 20 
**/ 
29*59*1/82= 20 
*** 
4*1*5*1= 20 
BUILD SUCCESSFUL (total time: 34 minutes 35 seconds) 

Ha preso 34 minuti per completare la corsa a causa quelli veramente difficili come /// e *** dovuta al tappo intero casuale 100. Inoltre, non mi sono preoccupato di rendere questo più pulito ed efficiente possibile e non ho guardato per perdite di oggetti/creazione di oggetti non necessari. Spetterà a voi :)
Cheers!