4 votos

El uso de + - * / operadores y 4 4 4 4 dígitos encontrar todas las fórmulas que se resuelve a 1 2 3 4 5 6 7 8 9 10

Tuve una conversación con un colega mío y él trajo un problema interesante. Utilizando el + - * / operadores y cuatro 4 4 4 4 dígitos, crear un algoritmo que va a la salida de todas las fórmulas que se podría equiparar a 1 o 2 o 3 o 4 o 5 o 6 o 7 o 9 o 10

Ejemplo de los resultados

1 = (4/4/4)*4  
2 = (4*4)/(4+4)  
3 = (4+4+4)/4  
4 = 4+(4*(4-4))  
5 = ((4*4)+4)/4  
6 = 4+((4+4)/4)  
7 = (4+4)-(4/4)  
8 = (4/4)*(4+4)  
9 = (4+4)+(4/4)  
10 = (44-4)/4  

Pero se debe de salida de todas las combinaciones posibles de los ejemplos de arriba.

La cuestión no es lo que la resultante de las fórmulas son, pero ¿cómo me acerco a crear el algoritmo que produce el resultado deseado en condiciones específicas como las de arriba.

2voto

Vedran Šego Puntos 8041

Crear una recursividad que utiliza la notación polaca inversa. Aquí es un pseudo-código:

function rec(digitsLeft, numbers, operators, expression):
    if digitsLeft == 0 and numbers - operators == 1:
        value = evaluate(expression)
        if value in {1..10}: output expression
        return
    if digitsLeft > 0:
        rec(digitsLeft - 1, numbers + 1, operators, [expression, 4])
    if digitsLeft > 1:
        rec(digitsLeft - 2, numbers + 1, operators, [expression, 44])
    if numbers - operators > 1:
        for op in ['+', '-', '*', '/']:
            rec(digitsLeft, numbers, operators + 1, [expression, op])

La notación polaca inversa se encargará de los operadores de prioridad, de modo que usted no tiene que manejar los soportes.

La llamada inicial es:

rec(4, 0, 0, [])

y los parámetros son:

  • digitsLeft -- ¿cuántos dígitos qué necesidad tenemos ya de uso,
  • numbers -- ¿cuántos números de nuestra expresión ya tiene,
  • operators -- ¿cuántos operadores nuestra expresión ya tiene,
  • expression -- la matriz de la celebración de los elementos de la expresión.

Por supuesto, usted necesita escribir evaluate (la función que evalúa expression) y output (que es la función que lo más probable es convertir la notación polaca inversa expression para el estándar de notación de infijo (usando algunos de los algoritmos conocidos, por ejemplo este) y la impresión a la pantalla o a un archivo).

Una versión más general sería sustituir esto:

    if digitsLeft > 0:
        rec(digitsLeft - 1, numbers + 1, operators, [expression, 4])
    if digitsLeft > 1:
        rec(digitsLeft - 2, numbers + 1, operators, [expression, 44])

con un bucle que vaya a través de $4$, $44$, etc., pero para este ejemplo, era más fácil hacer un copiar/pegar de dos if-s.

Si necesita cualquier aclaración adicional, por favor pregunte.

1voto

Matthew Scouten Puntos 2518

Yo sugiero que el uso de la recursividad. Si $S(k)$ son todas las fórmulas en uso $k$ 4, una fórmula con $k+1$ 4 es

$A + B$, $A * B$, $A - B$, $A / B$ donde $A$ $B$ uso de $j$ $k+1-j$ 4 respectivamente, $j = 1 \ldots k$, o es la concatenación de $k+1$ 4.

Construir cada la fórmula, evaluar con cuidado (ten cuidado con la división por $0$), y seleccionar los donde el resultado es uno de los que desee.

1voto

Will Green Puntos 758

Como una extensión, en lugar de una respuesta ... Si los radicales y/o factoriales se añaden al conjunto de los operadores, entonces el número de maneras en que uno puede combinar los dígitos de un número entero cambia de ser un finito combinatorical problema a uno infinito. Esto es debido a que uno puede repetidamente el nido √ y ! los operadores a cualquier profundidad arbitraria (por ejemplo, 4!!!!!!!).

Hace un par de años, escribí el código de Mathematica para ello, a nivel arbitrario de anidación. Para el problema en cuestión (4444), y permitiendo a los radicales, aquí una muestra de la salida (sólo los primeros 9 variaciones para cada número se muestra aquí):

Para ver una versión ampliada: http://www.tri.org.au/se/4444.png

Un tema relacionado es:

"Bastante Salvaje Narcisista Números - los Números que la red", http://www.numq.com/pwn/

y en un artículo que escribí sobre el radical caso:

De la rosa, C (2005), "Radical Narcisista Números", Revista de Matemáticas Recreativas, 33(4), 2004-2005, 250-254

que también contiene referencias a la bibliografía relacionada con el tema.

0voto

Marko Riedel Puntos 19255

Estoy presentando un auto-contenida ASTUCIA Esquema de programa que logra lo que quiere. Para ver las soluciones individuales, por ejemplo, las representaciones de la gama de $26$ $32$por cuatro patas, escriba el siguiente comando:

guile> (load "ff.scm")
guile> (mesa-pantalla 4 26 27 28 29 30 31 32)
28 (44) - ((4) * (4)); (((4) + (4)) * (4)) - (4);
32 ((4) * (4)) + ((4) * (4));

Otro ejemplo es

guile> (mesa-pantalla 4 11 12 13 14)
12 ((44) + (4)) / (4); ((4) - ((4) / (4))) * (4);

Como no puede haber un par de soluciones para algunos de los valores objetivo no es otro comando para mostrar sólo la cuenta de las soluciones a partir de un cierto rango más un representante de la fórmula. Responder a el cartel de la pregunta que nos puede mostrar la cuenta para el rango de uno a diez/veinte:

guile> (tabla de consulta de puntos 4 1 20)
1 25: (4) / (((4) - (4)) + (4))
2 5: (4) / (((4) + (4)) / (4))
3 2: (((4) + (4)) + (4)) / (4)
4 4: (4) - (((4) - (4)) * (4))
5 1: (((4) * (4)) + (4)) / (4)
6 1: (((4) + (4)) / (4)) + (4)
7 4: (4) - (((4) / (4)) - (4))
8 20: (4) / ((4) / ((4) + (4)))
9 3: ((4) + (4)) + ((4) / (4))
10 1: ((44) - (4)) / (4)
12 2: ((44) + (4)) / (4)
15 2: ((4) * (4)) - ((4) / (4))
16 20: (4) - ((4) - ((4) * (4)))
17 2: ((4) * (4)) + ((4) / (4))
20 1: (((4) / (4)) + (4)) * (4)

Sería interesante ver estos recuentos se confirmó con un lenguaje de programación diferente. Este es el código fuente del programa:

(definir el cuadro-memo
 (let ((vals (hash table)))
 (lambda (recuento)
 (let ((val (hash-ref vals count)))
 (si (no (hash-tabla? val))
(comenzar
 (set! val (tabla calcular count))
 (hash! vals contar val))) val))))

(definir la tabla de la pantalla
 (lambda (recuento . lo)
(hash-para-cada
 (lambda (v l)
 (si (o (null? lo) (miembro de v lo))
(comenzar
 (formato #t "~" v)
(por cada
 (lambda (ent)
 (formato #t " ~;" ent)) l)
 (newline)))) (tabla memo count))))

(definir la tabla de consulta de puntos
 (lambda (recuento de minval maxval)
 (let ((t (tabla memo count)))
(letrec
 ((iter 
 (lambda (val)
 (if (<= val maxval)
 (let ((búsqueda (hash-ref t val)))
 (si (lista? la búsqueda)
 (formato #t "~~: ~a~%"
 val (tiempo de búsqueda) (coche de búsqueda)))
 (iter (1+ val)))))))
 (iter minval)))))



(definir la tabla de calcular
 (lambda (recuento)
 (let ((res (hash table)))
(letrec
((concat4
 (lambda (k)
 (if (= k 1) 4 
 (+ (* 10 (concat4 (- k 1))) 4))))
(registro de
 (lambda (val str)
 (let ((búsqueda (hash-ref res val)))
 (si (lista? la búsqueda)
 (hash! res val (cons str búsqueda))
 (hash! res val (lista de str))))))
(combina-ents
 (lambda (val1 list1 c1 val2 lista2 c2)
(por cada
 (lambda (ent1)
(por cada
 (lambda (ent2)
 (if (<= c1, c2)
(registro de
 (+ val1 val2) 
 (formato #f "(~) + (~)" ent1 ent2)))
 (if (<= c1, c2)
(registro de
 (* val1 val2) 
 (formato #f "(~a) * (~a)" ent1 ent2)))
(registro de
 (- val1 val2) 
 (formato #f "(~) (~)" ent1 ent2))
 (si (no (cero? val2))
(registro de
 (/ val1 val2) 
 (formato #f "(~) / (~a)" ent1 ent2))))
 lista2)) list1)))
(iter
 (lambda (q)
 (if (< q contar)
(comenzar
 (let ((a la izquierda (tabla memo q)) 
 (a la derecha (tabla-memo (recuento q))))
(hash-para-cada
 (lambda (v1 l1)
(hash-para-cada
 (lambda (v2 l2)
 (combina-ents v1 l1 p v2 l2 (- contar q)))
 a la izquierda) de) derecho) de)
 (iter (1+ q)))))))
 (let* ((c4 (concat4 count)))
 (hash! 
 res c4 (lista (número->string c4)))
 el proyecto iter (1))) res))) 

He publicado un programa similar hace algún tiempo y me va a enviar el enlace si la puedo encontrar.

EDITAR
El post anterior que he mencionado se puede encontrar aquí en el MSE. Con lo anterior me hizo un esfuerzo extra para mantenerla compacta y simple como sea posible.

Leyendo el código cuidadosamente, se verá que genera productos y sumas sólo una vez, aunque pueden ser representados por dos árboles de expresión.

El código incluye expresiones donde el cero aparece como un valor intermedio. No es difícil comprobar esto y evitar que se ocurring si lo deseas.

i-Ciencias.com

I-Ciencias es una comunidad de estudiantes y amantes de la ciencia en la que puedes resolver tus problemas y dudas.
Puedes consultar las preguntas de otros usuarios, hacer tus propias preguntas o resolver las de los demás.

Powered by:

X