Cualesquiera 4 números del 1 al 13, suma, resta, multiplica y divide para calcular 24 puntos.
Principio de implementación:
1) Organizar y combinar 4 números
2) Calcular la posibilidad de cada permutación y combinación.
cal24.java
importar java.util.HashSet; importar java.util.Set; clase pública Cal24 {precisión doble final estática privada = 0.00001; destino int final estática privada = 24; cadena pública [] ejecutar (entradas de cadena []) {int [] dígitos; = nuevo int[4]; for (int i = 0; i < entradas.longitud; i++) { dígitos[i] = Integer.valueOf(inputs[i]); } return new String[]{calc(digits)}; } private String calc(final int data[]){ final Set<String> out = new HashSet<String>(); Dígito de combinación = nueva combinación() { @Override protected void handle(int[] resultado) { final int[] r = resultado Combinación oper = nueva combinación(){ @Override protected void; handle(int[] c) { double x = r[0]; for (int i = 0; i < r.length - 1; i++) { x = doCalculate(x, r[i + 1], c[i ]); } if(Math.abs(Math.abs(x) - objetivo) < precisión || Math.abs(Math.abs(1/x) - objetivo) < precisión){ StringBuilder sb = nuevo StringBuilder(); for (int j = 0; j < r.length; j++) { sb.append(r[j]); if(j != r.length - 1){ sb.append(getOperation(c[ j])); } } out.add(sb.toString()); } } }; 3}, data.length - 1, verdadero); } }; digit.combine(data); StringBuilder sb = new StringBuilder(); /n"); } return sb.toString(); } private double doCalculate(doble x, doble y, operación int){ switch (operación) { case 0: devolver x + y; caso 1: devolver x - y; caso 2: devolver x * y; caso 3: devolver x / y; valor predeterminado: devolver 0 } } cadena estática privada getOperation(operación int){ switch (operación) ) { caso 0: devolver "+"; caso 1: devolver "-"; caso 2: devolver "*"; caso 3: devolver "/"; main(String[] args) { System.out.println(new Cal24().calc(new int[]{1, 5, 5, 5}));Combinación.java
Combinación de clase abstracta pública {repetición booleana privada; total int privado = 0; combinación nula pública (datos int []) {combinación (datos, longitud de datos, falso); combinación nula pública (datos int [], recuento int) { combinar(datos, recuento, falso); } combinación nula pública(int datos[], int recuento, repetición booleana){ this.repeat = repetir int veces = datos.longitud = (int)Math.pow(veces, contar); for (int i = 0; i < tamaño; i++) { int[] resultado = toArray(datos, i, contar); resultado total ++; } } } private int[] toArray(int data[], int i, int count){ int [] indices = new int[count]; data.length; para (int j = 0; j < recuento; j++) { int temp = 0; if(i > 0){ temp = i%times; i = (i - temp)/times; ] = temp; } if(!repeat){ //eliminar repetición for (int x = 0; x < count; x++) { for(int y = 0; y < count; y++){ if(x!= y){ if(indices[x] == indices[y]) return null; } } } } int [] resultado = new int[count] for (int x = 0; x < count; x++) { int seleccionado = datos[índices[x]]; resultado[x] = seleccionado; } devolver resultado; } public int getTotal() { devolver total } identificador de vacío abstracto protegido (int[] resultado);}Lo anterior es el contenido completo de este artículo, espero que les guste a todos.