TODOPIC

Lenguajes de programación para PC => Python => Mensaje iniciado por: Nocturno en 05 de Enero de 2022, 12:34:55

Título: Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Nocturno en 05 de Enero de 2022, 12:34:55
Buenas, participé en un hilo de Twitter en el que un usuario proponía calcular los números del 1 al 100 utilizando sólo los dígitos del año 2022 y operaciones básicas.
Había ya muchos cálculos (del 1 al 30 con algunas excepciones) y pude aportar las soluciones al 17 ((2*2)^2+0!) y el 15 ((2*2)^2-0!).

Pero me quedé con la espina de saber si habíamos terminado o podíamos calcular algunos más.

Así que me propuse hacer un programa en Python que resuelva este problema y aquí lo tengo:
Código: Python
  1. import itertools
  2. import math
  3. import warnings
  4. warnings.filterwarnings("error")
  5.  
  6. # esta función devuelve todas las permutaciones de obj sin repeticiones
  7. def perms(obj):
  8.     perm_set = set()
  9.     for item in list(itertools.permutations(obj)):
  10.         if item not in perm_set:
  11.             perm_set.add(item)
  12.     return (perm_set)
  13.  
  14. # función recursiva para calcular el factorial de un número
  15. def factorial(n):
  16.     return n * factorial(n - 1) if n > 1 else 1
  17.  
  18. # Todas las posibilidades de situar paréntesis en la expresión (con 4 dígitos)
  19. parentesis = (  "        ",
  20.                                 "(  )    ",
  21.                                 "(  )(  )",
  22.                                 "  (  )  ",
  23.                                 "    (  )",
  24.                                 "(    )  ",
  25.                                 "  (    )")
  26.  
  27. print ("Comenzamos")
  28. entradas = "2022"       # dígitos a utilizar en los cálculos
  29.  
  30. # las operaciones que vamos a combinar serán la suma, resta, multiplicación, división
  31. # potencia y concatenación. Para cada una se escribe su fórmula en python y su
  32. # expresión matemática de cara a visualizar los resultados
  33. operaciones = (('+','+'), ('-','-'), ('*','x'), ('/','/'), ('**','^'), ('',''))
  34.  
  35. debug = 0       # poner a 1 si queremos activar todos los print intermedios
  36.  
  37. # preparamos una lista vacía con 100 posiciones para almacenar los resultados
  38. salidas=[]
  39. for i in range(101):
  40.         salidas.append([])
  41.  
  42. indice=1
  43. # recorremos todas las permutaciones de los dígitos de entrada
  44. for digito in perms(entradas):         
  45.         if debug:
  46.                 print ("Usaremos estos dígitos ", digito)
  47.         # recorremos todas las combinaciones posibles de las operaciones disponibles
  48.         for operaciones_seleccionadas in list(itertools.combinations_with_replacement(operaciones,len(entradas)-1)):   
  49.                 if debug:
  50.                         print ("con estas operaciones ",operaciones_seleccionadas)
  51.                 else:
  52.                         print (".", end="")
  53.                 # con cada combinación de operaciones hacemos todas las permutaciones
  54.                 for op in perms(operaciones_seleccionadas):            
  55.                         # cada dígito puede tener asignada la operación factorial o no. Se recorren todas las combinaciones
  56.                         for fact in range (2**len(entradas)):          
  57.                                 # recorremos todas las opciones de agrupación por paréntesis disponibles
  58.                                 for par in parentesis:                                 
  59.                                         # El cálculo a realizar consiste en la concatenación de dígitos y operaciones
  60.                                         # incluyendo el tratamiento especial de algunos dígitos que en ocasiones pueden llevar
  61.                                         # el cálculo de su factorial.
  62.                                         # Además, la expresión del cálculo incorpora el carácter de paréntesis que corresponda
  63.                                         # según los strings definidos más arriba
  64.                                         # Se preparan dos strings: calculo y expresion
  65.                                         # - calculo: es la sentencia que se evalúa realmente y de la que se obtiene resultado
  66.                                         # - expresion: es la misma sentencia, pero escrita en lenguaje matemático
  67.                                         #              (x para multiplicación, ! para factorial y ^ para potencias)
  68.                                         calculo = par[0]+ ("factorial("+digito[0]+")" if (fact & 0b0001)>0 else digito[0]) + par[1]
  69.                                         expresion = par[0]+ (digito[0]+"!" if (fact & 0b0001)>0 else digito[0]) + par[1]
  70.                                         for i in range (len(entradas)-1):
  71.                                                 calculo += op[i][0] + par[(i+1)*2]+ ("factorial("+digito[i+1]+")" if (fact & (1<<(i+1))>0) else digito[i+1]) + par[(i+1)*2+1]  
  72.                                                 expresion += op[i][1] + par[(i+1)*2]+ (digito[i+1]+"!" if (fact & (1<<(i+1))>0) else digito[i+1]) + par[(i+1)*2+1]     
  73.                                        
  74.                                         # Una vez montados los strings, limpiamos los espacios que hayan quedado dentro
  75.                                         calculo = calculo.replace (" ","")
  76.                                         expresion = expresion.replace (" ","")
  77.                                        
  78.                                         if debug:
  79.                                                 print (indice, ": ",end="")
  80.                                                 print (calculo, " - ", end="")
  81.                                        
  82.                                         try:
  83.                                                 # Evaluamos el resultado
  84.                                                 resultado=eval(calculo)
  85.                                                 # El resultado sólo será válido si está entre 1 y 100, y es un número entero
  86.                                                 if (resultado>0) and (resultado<101) and int(resultado)==resultado:
  87.                                                         if debug:
  88.                                                                 print (resultado)
  89.                                                         # cuando el resultado es válido lo guardamos en una lista, en su posición correspondiente
  90.                                                         salidas[int(resultado)].append (expresion)
  91.                                                 else:
  92.                                                         if debug:
  93.                                                                 print ("Fuera de rango")
  94.                                         # A veces las expresiones no se pueden evaluar porque aparecen divisiones por cero, paréntesis
  95.                                         # concatenados con dígitos y otras incorrecciones. Las descartamos.
  96.                                         except (ZeroDivisionError):
  97.                                                 if debug:
  98.                                                         print ("Error división por cero")
  99.                                                 pass
  100.                                         except (TypeError, SyntaxError):
  101.                                                 if debug:
  102.                                                         print ("Operación no permitida - (concatenar paréntesis)")
  103.                                                 pass
  104.                                         indice = indice + 1
  105.  
  106. # Mostramos las soluciones encontradas. Para cada cálculo, se muestra una lista con todas las opciones encontradas
  107. soluciones= 0
  108. for i in range (101):
  109.         if len(salidas[i])>0:
  110.                 print (i, " -> ", salidas[i])
  111.                 soluciones = soluciones + 1
  112. print ("Se han encontrado", soluciones, "soluciones")

El resultado es este (en los casos que aparecen muchas soluciones, sólo muestro las 10 primeras):
Código: [Seleccionar]
Se han encontrado 36 soluciones
1  -> (2+2)-(2+0!), 2+2-(2+0!), (2!+2)-(2+0!), 2!+2-(2+0!), (2+2!)-(2+0!), 2+2!-(2+0!), (2!+2!)-(2+0!), 2!+2!-(2+0!), (2+2)-(2!+0!), 2+2-(2!+0!)
2  -> 2-2+2+0, (2-2)+2+0, (2-2)+(2+0), 2-2+(2+0), (2-2+2)+0, 2!-2+2+0, (2!-2)+2+0, (2!-2)+(2+0), 2!-2+(2+0), (2!-2+2)+0
3  -> 2-2+2+0!, (2-2)+2+0!, (2-2)+(2+0!), 2-2+(2+0!), (2-2+2)+0!, 2!-2+2+0!, (2!-2)+2+0!, (2!-2)+(2+0!), 2!-2+(2+0!), (2!-2+2)+0!
4  -> 2+2+2x0, (2+2)+2x0, (2+2)+(2x0), 2+2+(2x0), 2+(2+2x0), 2!+2+2x0, (2!+2)+2x0, (2!+2)+(2x0), 2!+2+(2x0), 2!+(2+2x0)
5  -> 2+2+2-0!, (2+2)+2-0!, (2+2)+(2-0!), 2+(2+2)-0!, 2+2+(2-0!), (2+2+2)-0!, 2+(2+2-0!), 2!+2+2-0!, (2!+2)+2-0!, (2!+2)+(2-0!)
6  -> 2+2+2+0, (2+2)+2+0, (2+2)+(2+0), 2+(2+2)+0, 2+2+(2+0), (2+2+2)+0, 2+(2+2+0), 2!+2+2+0, (2!+2)+2+0, (2!+2)+(2+0)
7  -> 2+2+2+0!, (2+2)+2+0!, (2+2)+(2+0!), 2+(2+2)+0!, 2+2+(2+0!), (2+2+2)+0!, 2+(2+2+0!), 2!+2+2+0!, (2!+2)+2+0!, (2!+2)+(2+0!)
8  -> 2x(2+2)+0, 2x(2+2+0), 2!x(2+2)+0, 2!x(2+2+0), 2x(2!+2)+0, 2x(2!+2+0), 2!x(2!+2)+0, 2!x(2!+2+0), 2x(2+2!)+0, 2x(2+2!+0)
9  -> 2x(2+2)+0!, 2!x(2+2)+0!, 2x(2!+2)+0!, 2!x(2!+2)+0!, 2x(2+2!)+0!, 2!x(2+2!)+0!, 2x(2!+2!)+0!, 2!x(2!+2!)+0!, (2+2)x2+0!, (2!+2)x2+0!
10  -> 2x(2+2+0!), 2!x(2+2+0!), 2x(2!+2+0!), 2!x(2!+2+0!), 2x(2+2!+0!), 2!x(2+2!+0!), 2x(2!+2!+0!), 2!x(2!+2!+0!), 2+2^(2+0!), 2!+2^(2+0!)
11  -> 22/2+0, (22)/2+0, (22)/(2+0), 22/(2+0), (22/2)+0, 22/2!+0, (22)/2!+0, (22)/(2!+0), 22/(2!+0), (22/2!)+0
12  -> (2+2)x(2+0!), (2!+2)x(2+0!), (2+2!)x(2+0!), (2!+2!)x(2+0!), (2+2)x(2!+0!), (2!+2)x(2!+0!), (2+2!)x(2!+0!), (2!+2!)x(2!+0!), (2x2)x(2+0!), 2x2x(2+0!)
15  -> 2^(2+2)-0!, 2!^(2+2)-0!, 2^(2!+2)-0!, 2!^(2!+2)-0!, 2^(2+2!)-0!, 2!^(2+2!)-0!, 2^(2!+2!)-0!, 2!^(2!+2!)-0!, (2+2)^2-0!, (2!+2)^2-0!
16  -> 2^(2+2)+0, 2^(2+2+0), 2!^(2+2)+0, 2!^(2+2+0), 2^(2!+2)+0, 2^(2!+2+0), 2!^(2!+2)+0, 2!^(2!+2+0), 2^(2+2!)+0, 2^(2+2!+0)
17  -> 2^(2+2)+0!, 2!^(2+2)+0!, 2^(2!+2)+0!, 2!^(2!+2)+0!, 2^(2+2!)+0!, 2!^(2+2!)+0!, 2^(2!+2!)+0!, 2!^(2!+2!)+0!, (2+2)^2+0!, (2!+2)^2+0!
18  -> 2x(0!+2)^2, 2!x(0!+2)^2, 2x(0!+2!)^2, 2!x(0!+2!)^2, 2x(0!+2)^2!, 2!x(0!+2)^2!, 2x(0!+2!)^2!, 2!x(0!+2!)^2!, (2+0!)^2x2, (2!+0!)^2x2
19  -> (22)-(2+0!), 22-(2+0!), (22)-(2!+0!), 22-(2!+0!), 22-2-0!, (22)-2-0!, (22-2)-0!, 22-2!-0!, (22)-2!-0!, (22-2!)-0!
20  -> 22-2+0, (22)-2+0, (22)-(2+0), 22-(2+0), (22-2)+0, 22-2!+0, (22)-2!+0, (22)-(2!+0), 22-(2!+0), (22-2!)+0
21  -> 22-2+0!, (22)-2+0!, (22-2)+0!, 22-2!+0!, (22)-2!+0!, (22-2!)+0!, 2/2+20, (2/2)+20, (2/2)+(20), 2/2+(20)
22  -> 22+2x0, (22)+2x0, (22)+(2x0), 22+(2x0), 22+2!x0, (22)+2!x0, (22)+(2!x0), 22+(2!x0), 22-2x0, (22)-2x0
23  -> 22+2-0!, (22)+2-0!, (22)+(2-0!), 22+(2-0!), (22+2)-0!, 22+2!-0!, (22)+2!-0!, (22)+(2!-0!), 22+(2!-0!), (22+2!)-0!
24  -> 2+2+20, (2+2)+20, (2+2)+(20), 2+2+(20), 2+(2+20), 2!+2+20, (2!+2)+20, (2!+2)+(20), 2!+2+(20), 2!+(2+20)
25  -> 2+22+0!, 2+(22)+0!, (2+22)+0!, 2+(22+0!), 2!+22+0!, 2!+(22)+0!, (2!+22)+0!, 2!+(22+0!), 22+2+0!, (22)+2+0!
32  -> 2^(2+2+0!), 2!^(2+2+0!), 2^(2!+2+0!), 2!^(2!+2+0!), 2^(2+2!+0!), 2!^(2+2!+0!), 2^(2!+2!+0!), 2!^(2!+2!+0!), 2^(2x2+0!), 2!^(2x2+0!)
36  -> (20-2)x2, (20-2!)x2, (20-2)x2!, (20-2!)x2!, 2x(20-2), 2!x(20-2), 2x(20-2!), 2!x(20-2!)
38  -> 20x2-2, (20)x2-2, (20x2)-2, 20x2!-2, (20)x2!-2, (20x2!)-2, 20x2-2!, (20)x2-2!, (20x2)-2!, 20x2!-2!
42  -> 2+2x20, 2+2x(20), 2+(2x20), 2!+2x20, 2!+2x(20), 2!+(2x20), 2+2!x20, 2+2!x(20), 2+(2!x20), 2!+2!x20
43  -> 22x2-0!, (22)x2-0!, (22x2)-0!, 22x2!-0!, (22)x2!-0!, (22x2!)-0!, 2x22-0!, 2x(22)-0!, (2x22)-0!, 2!x22-0!
44  -> 2x22+0, 2x(22)+0, (2x22)+0, 2x(22+0), 2!x22+0, 2!x(22)+0, (2!x22)+0, 2!x(22+0), 22x2+0, (22)x2+0
45  -> 2x22+0!, 2x(22)+0!, (2x22)+0!, 2!x22+0!, 2!x(22)+0!, (2!x22)+0!, 22x2+0!, (22)x2+0!, (22x2)+0!, 22x2!+0!
46  -> 2x(22+0!), 2!x(22+0!), 2x(0!+22), 2!x(0!+22), (0!+22)x2, (0!+22)x2!, (22+0!)x2, (22+0!)x2!
64  -> (2+2)^(2+0!), (2!+2)^(2+0!), (2+2!)^(2+0!), (2!+2!)^(2+0!), (2+2)^(2!+0!), (2!+2)^(2!+0!), (2+2!)^(2!+0!), (2!+2!)^(2!+0!), (2x2)^(2+0!), (2!x2)^(2+0!)
66  -> (22)x(2+0!), 22x(2+0!), (22)x(2!+0!), 22x(2!+0!), (2+0!)x22, (2+0!)x(22), (2!+0!)x22, (2!+0!)x(22), (0!+2)x22, (0!+2)x(22)
80  -> (2+2)x20, (2+2)x(20), (2!+2)x20, (2!+2)x(20), (2+2!)x20, (2+2!)x(20), (2!+2!)x20, (2!+2!)x(20), 2x2x20, (2x2)x20
81  -> (2+0!)^(2+2), (2!+0!)^(2+2), (2+0!)^(2!+2), (2!+0!)^(2!+2), (2+0!)^(2+2!), (2!+0!)^(2+2!), (2+0!)^(2!+2!), (2!+0!)^(2!+2!), (2+0!)^(2x2), (2!+0!)^(2x2)
100  -> (20/2)^2, (20/2!)^2, (20/2)^2!, (20/2!)^2!
Estoy convencido que podéis mejorarlo bastante, porque soy principiante con Python, así que os animo a hacerlo y comentarlo aquí.
Por mi parte me quedaría pendiente poder aplicar el factorial a expresiones encerradas entre paréntesis. Actualmente sólo lo aplico a los dígitos individuales.
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Picuino en 06 de Enero de 2022, 20:42:32
Yo he hecho el programa de nuevo.

Primero una función calcula todas las combinaciones posibles de números y operaciones de forma recursiva.

Las operaciones se realizan en notación RPN (https://es.wikipedia.org/wiki/Notaci%C3%B3n_polaca_inversa) para evitar el uso de paréntesis y luego se va representando en paralelo la operación con notación tradicional para visualizarla después.

Programa:
Código: Python
  1. import copy
  2.  
  3. class Stack():
  4.     def __init__(self, numbers=[2,0,2,2]):
  5.         self.stack_rpn = []
  6.         self.stack_oper = []
  7.         self.numbers = numbers
  8.         self.operations = ['+', '-', '*', '/', '^', 'J', '!']
  9.  
  10.     def __str__(self):
  11.         return f"stack={self.stack_rpn}, operations={self.stack_oper}, numbers={self.numbers}"
  12.        
  13.     def append_operation_to_stack(self, i):
  14.         item = self.operations[i]
  15.         error = False
  16.         if item in ['+', '-', '*', '/', '^', 'J'] and len(self.stack_rpn) < 2:
  17.             error = True
  18.         elif item == '!' and (len(self.stack_rpn) < 1 or self.stack_rpn[-1] not in [0,3,4,5,6]):
  19.             error = True            
  20.         elif item == '^' and self.stack_rpn[-1] < 0:
  21.             error = True            
  22.         elif item == '/' and self.stack_rpn[-1] == 0:
  23.             error = True
  24.         elif item == 'J' and ( type(self.stack_oper[-1]) != int or type(self.stack_oper[-2]) != int ):
  25.             error = True
  26.  
  27.         if not error:
  28.             self.stack_rpn.append(item)
  29.             self.stack_oper.append(item)
  30.             self.evaluate()
  31.             return True
  32.         else:
  33.             return False
  34.        
  35.     def append_number_to_stack(self, i):
  36.         item = self.numbers[i]      
  37.         self.stack_rpn.append(item)
  38.         self.stack_oper.append(item)
  39.         self.numbers = self.numbers[:i] + self.numbers[i+1:]
  40.  
  41.     def evaluate(self):
  42.         if not self.stack_rpn:
  43.             return
  44.  
  45.         operation = self.stack_rpn[-1]
  46.  
  47.         if operation == '!':
  48.             self.stack_oper = self.stack_oper[:-2] + [f"({self.stack_oper[-2]}!)"]
  49.             self.stack_rpn = self.stack_rpn[:-2] + [factorial(self.stack_rpn[-2])]
  50.  
  51.         elif operation == '+':
  52.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} + {self.stack_oper[-2]})"]
  53.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] + self.stack_rpn[-2]]
  54.  
  55.         elif operation == '-':
  56.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} - {self.stack_oper[-2]})"]
  57.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] - self.stack_rpn[-2]]
  58.  
  59.         elif operation == '*':
  60.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} * {self.stack_oper[-2]})"]
  61.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] * self.stack_rpn[-2]]
  62.  
  63.         elif operation == '/':
  64.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} / {self.stack_oper[-2]})"]
  65.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] / self.stack_rpn[-2]]
  66.  
  67.         elif operation == '^':
  68.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} ^ {self.stack_oper[-2]})"]
  69.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] ** self.stack_rpn[-2]]
  70.  
  71.         elif operation == 'J':
  72.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]}{self.stack_oper[-2]})"]
  73.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] * 10 + self.stack_rpn[-2]]
  74.  
  75.  
  76. def main():
  77.     stack = Stack(numbers=[2, 0, 2, 2])
  78.     results = {}
  79.     for result, operations in combine(stack):
  80.         if (type(result) == int or float) and result <= 100 and result >= 0:
  81.             if result in results:
  82.                 continue
  83.             else:
  84.                 results[result] = operations
  85.  
  86.     for i in range(101):
  87.         if i in results:
  88.             print(i, ' -> ', results[i])
  89.  
  90.  
  91. def combine(stack):
  92.     if len(stack.stack_rpn) == 1 and len(stack.numbers) == 0:
  93.         yield stack.stack_rpn[0], stack.stack_oper[0]
  94.  
  95.     for i in range(len(stack.numbers)):
  96.         new_stack = copy.deepcopy(stack)
  97.         new_stack.append_number_to_stack(i)
  98.         yield from combine(new_stack)
  99.  
  100.     for i in range(len(stack.operations)):
  101.         new_stack = copy.deepcopy(stack)
  102.         if new_stack.append_operation_to_stack(i):
  103.            yield from combine(new_stack)
  104.  
  105.  
  106. def factorial(n):
  107.     if n < 2:
  108.         return 1
  109.     return factorial(n-1) * n
  110.  
  111. main()

El problema que tiene es que tarda demasiado en obtener resultados.
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: AKENAFAB en 06 de Enero de 2022, 21:03:29
Hola,

Estos ejercicios , ¿que nivel de programación es necesario para realizarlo?

Yo no entiendo nada , por eso mi pregunta, :D

Saludos!
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Picuino en 06 de Enero de 2022, 21:09:24
Algunos resultados obtenidos (44):

Código: [Seleccionar]
0  ->  (2 * (0 * (2 + 2)))
1  ->  ((2 * (0 * (2 + 2)))!)
2  ->  (2 + (0 * (2 + 2)))
3  ->  (2 + ((0 * (2 + 2))!))
4  ->  (2 + ((0 * 2) + 2))
5  ->  (2 + (((0 * 2)!) + 2))
6  ->  (2 + (0 + (2 + 2)))
7  ->  (2 + ((0!) + (2 + 2)))
8  ->  (2 * (0 + (2 + 2)))
9  ->  ((2 + ((0 * 2)!)) ^ 2)
10  ->  (2 * ((0!) + (2 + 2)))
11  ->  (((20) + 2) / 2)
12  ->  (((2 + (0 + 2))!) / 2)
14  ->  (2 + ((((0!) + 2)!) * 2))
16  ->  (2 ^ (0 + (2 + 2)))
18  ->  (2 * (((0!) + 2) ^ 2))
19  ->  ((20) - ((2 - 2)!))
20  ->  ((20) + (2 - 2))
21  ->  ((20) + ((2 - 2)!))
22  ->  (((2 + (0 + 2))!) - 2)
23  ->  (((2 * 0)!) + (22))
24  ->  (2 + (0 + (22)))
25  ->  (((2 * 0)!) + ((2 + 2)!))
26  ->  (2 + ((0 + (2 + 2))!))
27  ->  (2 + ((0!) + ((2 + 2)!)))
28  ->  (((2 + (0!))!) + (22))
30  ->  (((2 + (0!))!) + ((2 + 2)!))
32  ->  (2 ^ ((0!) + (2 + 2)))
34  ->  ((((2 + (0!))!) ^ 2) - 2)
36  ->  (((2 + ((0 * 2)!))!) ^ 2)
38  ->  (((20) * 2) - 2)
42  ->  ((20) + (22))
44  ->  (2 * (0 + (22)))
46  ->  (2 * ((0!) + (22)))
48  ->  (2 * ((0 + (2 + 2))!))
50  ->  (2 * ((0!) + ((2 + 2)!)))
60  ->  (((2 + ((0!) + 2))!) / 2)
62  ->  ((2 ^ (((0!) + 2)!)) - 2)
64  ->  (2 ^ ((((0 * 2)!) + 2)!))
66  ->  ((2 ^ (((0!) + 2)!)) + 2)
72  ->  (2 * ((((0!) + 2)!) ^ 2))
80  ->  ((20) * (2 + 2))
81  ->  ((2 + (0!)) ^ (2 + 2))
100  ->  (((20) / 2) ^ 2)
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Picuino en 06 de Enero de 2022, 21:12:08
Cita de: AKENAFAB en 06 de Enero de 2022, 21:03:29
Hola,

Estos ejercicios , ¿que nivel de programación es necesario para realizarlo?

Yo no entiendo nada , por eso mi pregunta, :D

Saludos!

No sé qué nivel, pero desde luego no un nivel bajo.
En el mío utilizo recursividad con la orden yield de Python y también clases (programación orientada a objetos).
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Nocturno en 07 de Enero de 2022, 02:44:00
Me ha encantado tu solución Picuino, sobre todo porque me ha permitido aprender eso de la notación RPN, de la que no tenía ni idea, y el interesante uso del yield.
Sin embargo, es cierto que tarda muchísimo más que la mía. No alcanzo a entender por qué ocurre eso; al fin y al cabo exploramos el mismo universo de combinaciones.

La tuya arroja más resultados que la mía, y en todos los casos se trata de lo que yo apuntaba: cálculo del factorial detrás de un paréntesis. A ver si tengo un rato para completar mi programa y lo resuelvo.

Sin embargo, me ha sorprendido que en la mía hay algunas soluciones que la tuya no ha encontrado, como estas:
Código: [Seleccionar]
15  -> 2^(2+2)-0!, 2!^(2+2)-0!, 2^(2!+2)-0!, 2!^(2!+2)-0!, 2^(2+2!)-0!, 2!^(2+2!)-0!, 2^(2!+2!)-0!, 2!^(2!+2!)-0!, (2+2)^2-0!, (2!+2)^2-0!
17  -> 2^(2+2)+0!, 2!^(2+2)+0!, 2^(2!+2)+0!, 2!^(2!+2)+0!, 2^(2+2!)+0!, 2!^(2+2!)+0!, 2^(2!+2!)+0!, 2!^(2!+2!)+0!, (2+2)^2+0!, (2!+2)^2+0!
43  -> 22x2-0!, (22)x2-0!, (22x2)-0!, 22x2!-0!, (22)x2!-0!, (22x2!)-0!, 2x22-0!, 2x(22)-0!, (2x22)-0!, 2!x22-0!
45  -> 2x22+0!, 2x(22)+0!, (2x22)+0!, 2!x22+0!, 2!x(22)+0!, (2!x22)+0!, 22x2+0!, (22)x2+0!, (22x2)+0!, 22x2!+0!
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Picuino en 07 de Enero de 2022, 06:02:51
Es que el programa tiene un error y se queda bloqueado consumiendo memoria. Tengo que depurarlo y lo vuelvo a subir.
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Picuino en 07 de Enero de 2022, 08:40:38
He conseguido 51 resultados, incluídos los que me has comentado que no aparecían. Pero el programa se sigue bloqueando. No sé cómo resolverlo.

Programa:
Código: Python
  1. import copy
  2.  
  3. class Stack():
  4.     def __init__(self, numbers=[2, 0, 2, 2]):
  5.         self.stack_rpn = []
  6.         self.stack_oper = []
  7.         self.numbers = numbers
  8.         self.operations = ['+', '-', '*', '/', '^', 'J', '!']
  9.  
  10.     def __str__(self):
  11.         return f"stack={self.stack_rpn}, operations={self.stack_oper}, numbers={self.numbers}"
  12.        
  13.     def append_operation_to_stack(self, i):
  14.         item = self.operations[i]
  15.         error = False
  16.         if item in ['+', '-', '*', '/', '^', 'J'] and len(self.stack_rpn) < 2:
  17.             error = True
  18.         elif item == '!' and (len(self.stack_rpn) < 1 or self.stack_rpn[-1] not in [0, 3, 4, 5, 6]):
  19.             error = True            
  20.         elif item == '^' and self.stack_rpn[-1] < 0:
  21.             error = True            
  22.         elif item == '/' and self.stack_rpn[-1] == 0:
  23.             error = True
  24.         elif item == 'J' and ( type(self.stack_oper[-1]) != int or type(self.stack_oper[-2]) != int ):
  25.             error = True
  26.  
  27.         if not error:
  28.             self.stack_rpn.append(item)
  29.             self.stack_oper.append(item)
  30.             self.evaluate()
  31.             return True
  32.         else:
  33.             return False
  34.        
  35.     def append_number_to_stack(self, i):
  36.         item = self.numbers[i]      
  37.         self.stack_rpn.append(item)
  38.         self.stack_oper.append(item)
  39.         self.numbers = self.numbers[:i] + self.numbers[i+1:]
  40.  
  41.     def evaluate(self):
  42.         operation = self.stack_rpn[-1]
  43.  
  44.         if operation == '!':
  45.             self.stack_oper = self.stack_oper[:-2] + [f"({self.stack_oper[-2]}!)"]
  46.             self.stack_rpn = self.stack_rpn[:-2] + [factorial(self.stack_rpn[-2])]
  47.  
  48.         elif operation == '+':
  49.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} + {self.stack_oper[-2]})"]
  50.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] + self.stack_rpn[-2]]
  51.  
  52.         elif operation == '-':
  53.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} - {self.stack_oper[-2]})"]
  54.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] - self.stack_rpn[-2]]
  55.  
  56.         elif operation == '*':
  57.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} * {self.stack_oper[-2]})"]
  58.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] * self.stack_rpn[-2]]
  59.  
  60.         elif operation == '/':
  61.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} / {self.stack_oper[-2]})"]
  62.             self.stack_rpn = self.stack_rpn[:-3] + [to_int(self.stack_rpn[-3] / self.stack_rpn[-2])]
  63.  
  64.         elif operation == '^':
  65.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} ^ {self.stack_oper[-2]})"]
  66.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] ** self.stack_rpn[-2]]
  67.  
  68.         elif operation == 'J': # Join 2 figures
  69.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]}{self.stack_oper[-2]})"]
  70.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] * 10 + self.stack_rpn[-2]]
  71.    
  72.  
  73. def to_int(num):
  74.     if num == int(num):
  75.         return int(num)
  76.     return num
  77.  
  78.  
  79. def factorial(n):
  80.     if n < 2:
  81.         return 1
  82.     return factorial(n-1) * n
  83.  
  84.  
  85. def combine(stack):
  86.     if len(stack.stack_rpn) == 1 and len(stack.numbers) == 0:
  87.         yield stack.stack_rpn[0], stack.stack_oper[0]
  88.     else:
  89.         for i in range(len(stack.operations)):
  90.             new_stack = copy.deepcopy(stack)
  91.             if new_stack.append_operation_to_stack(i):
  92.                 yield from combine(new_stack)
  93.  
  94.         for i in range(len(stack.numbers)):
  95.             new_stack = copy.deepcopy(stack)
  96.             new_stack.append_number_to_stack(i)
  97.             yield from combine(new_stack)
  98.  
  99.  
  100.  
  101. def main():
  102.     stack = Stack(numbers=[2, 0, 2, 2])
  103.     results = {}
  104.     for result, operations in combine(stack):
  105.         if type(result) == int and result <= 100 and result >= 0:
  106.             if result in results:
  107.                 continue
  108.             else:
  109.                 results[result] = operations
  110.  
  111.                 print('\n\n')
  112.                 for i in range(101):
  113.                     if i in results:
  114.                         print(i, ' -> ', results[i])
  115.  
  116.  
  117. main()

Resultados:
Código: [Seleccionar]
0  ->  (((2 + 0) - 2) * 2)
1  ->  ((((2 + 0) - 2)!) ^ 2)
2  ->  (((2 + 0) + 2) - 2)
3  ->  ((((2 + 0) - 2)!) + 2)
4  ->  (((((2 * 0)!) + 2)!) - 2)
5  ->  ((((2 * 0)!) + 2) + 2)
6  ->  (((2 + 0) + 2) + 2)
7  ->  (((2 + (0!))!) + ((2 - 2)!))
8  ->  (((2 + 0) + 2) * 2)
9  ->  ((((2 * 0)!) + 2) ^ 2)
10  ->  ((((2 + (0!))!) + 2) + 2)
11  ->  (((20) + 2) / 2)
12  ->  ((((2 + 0) + 2)!) / 2)
13  ->  ((((2 + 2)!) / 2) + (0!))
14  ->  ((((2 + (0!))!) * 2) + 2)
15  ->  (((2 + 2) ^ 2) - (0!))
16  ->  (((2 + 0) + 2) ^ 2)
17  ->  (((2 + 2) ^ 2) + (0!))
18  ->  ((((2 + (0!))!) ^ 2) / 2)
19  ->  ((20) - ((2 - 2)!))
20  ->  (((20) + 2) - 2)
21  ->  ((20) + ((2 - 2)!))
22  ->  ((((2 + 0) + 2)!) - 2)
23  ->  (((2 * 0)!) + (22))
24  ->  ((2 + 0) + (22))
25  ->  (((2 * 0)!) + ((2 + 2)!))
26  ->  ((((2 + 0) + 2)!) + 2)
27  ->  ((2 + (0!)) + ((2 + 2)!))
28  ->  (((2 + (0!))!) + (22))
30  ->  ((((2 + (0!))!)!) / ((2 + 2)!))
32  ->  ((2 ^ (((0!) + 2)!)) / 2)
34  ->  ((((2 + (0!))!) ^ 2) - 2)
36  ->  (((((2 * 0)!) + 2)!) ^ 2)
38  ->  (((20) * 2) - 2)
42  ->  (((20) * 2) + 2)
43  ->  (((22) * 2) - (0!))
44  ->  ((2 + 0) * (22))
45  ->  (((22) * 2) + (0!))
46  ->  (2 * ((0!) + (22)))
47  ->  ((((2 + 2)!) * 2) - (0!))
48  ->  ((((2 + 0) + 2)!) * 2)
49  ->  ((((2 + 2)!) * 2) + (0!))
50  ->  (2 * ((0!) + ((2 + 2)!)))
60  ->  ((((2 + (0!)) + 2)!) / 2)
62  ->  ((2 ^ (((0!) + 2)!)) - 2)
64  ->  ((((2 + (0!))!) + 2) ^ 2)
66  ->  ((2 + (0!)) * (22))
72  ->  ((((2 + (0!))!) ^ 2) * 2)
80  ->  (((20) * 2) * 2)
81  ->  (((2 + (0!)) ^ 2) ^ 2)
100  ->  (((20) / 2) ^ 2)
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Picuino en 07 de Enero de 2022, 11:56:09
Ya está resuelto. El problema estaba en el cálculo de una potencia muy alta.

Programa:
Código: Python
  1. import copy
  2.  
  3. class Stack():
  4.     def __init__(self, numbers=[2, 0, 2, 2]):
  5.         self.stack_rpn = []
  6.         self.stack_oper = []
  7.         self.numbers = numbers
  8.         self.operations = ['+', '-', '*', '/', '^', 'J', '!', '']
  9.  
  10.     def __str__(self):
  11.         return f"stack={self.stack_rpn}, operations={self.stack_oper}, numbers={self.numbers}"
  12.        
  13.     def append_operation_to_stack(self, i):
  14.         item = self.operations[i]
  15.         error = False
  16.         if item in ['+', '-', '*', '/', '^', 'J'] and len(self.stack_rpn) < 2:
  17.             error = True
  18.         elif item == '!' and (len(self.stack_rpn) < 1 or self.stack_rpn[-1] not in [0, 3, 4, 5, 6]):
  19.             error = True            
  20.         elif item == '^' and (self.stack_rpn[-1] < 0 or self.stack_rpn[-1] > 100):
  21.             error = True            
  22.         elif item == '/' and self.stack_rpn[-1] == 0:
  23.             error = True
  24.         elif item == 'J' and ( type(self.stack_oper[-1]) != int or type(self.stack_oper[-2]) != int ):
  25.             error = True
  26.         if item == '':
  27.             error = True
  28.  
  29.         if not error:
  30.             self.stack_rpn.append(item)
  31.             self.stack_oper.append(item)
  32.             self.evaluate()
  33.             return True
  34.         else:
  35.             return False
  36.        
  37.     def append_number_to_stack(self, i):
  38.         item = self.numbers[i]      
  39.         self.stack_rpn.append(item)
  40.         self.stack_oper.append(item)
  41.         self.numbers = self.numbers[:i] + self.numbers[i+1:]
  42.  
  43.     def evaluate(self):
  44.         operation = self.stack_rpn[-1]
  45.  
  46.         if operation == '!':
  47.             self.stack_oper = self.stack_oper[:-2] + [f"({self.stack_oper[-2]}!)"]
  48.             self.stack_rpn = self.stack_rpn[:-2] + [factorial(self.stack_rpn[-2])]
  49.  
  50.         elif operation == '+':
  51.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} + {self.stack_oper[-2]})"]
  52.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] + self.stack_rpn[-2]]
  53.  
  54.         elif operation == '-':
  55.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} - {self.stack_oper[-2]})"]
  56.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] - self.stack_rpn[-2]]
  57.  
  58.         elif operation == '*':
  59.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} * {self.stack_oper[-2]})"]
  60.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] * self.stack_rpn[-2]]
  61.  
  62.         elif operation == '/':
  63.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} / {self.stack_oper[-2]})"]
  64.             self.stack_rpn = self.stack_rpn[:-3] + [to_int(self.stack_rpn[-3] / self.stack_rpn[-2])]
  65.  
  66.         elif operation == '^':
  67.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]} ^ {self.stack_oper[-2]})"]
  68.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] ** self.stack_rpn[-2]]
  69.  
  70.         elif operation == 'J': # Join 2 figures
  71.             self.stack_oper = self.stack_oper[:-3] + [f"({self.stack_oper[-3]}{self.stack_oper[-2]})"]
  72.             self.stack_rpn = self.stack_rpn[:-3] + [self.stack_rpn[-3] * 10 + self.stack_rpn[-2]]
  73.    
  74.  
  75. def to_int(num):
  76.     if num == int(num):
  77.         return int(num)
  78.     return num
  79.  
  80.  
  81. def factorial(n):
  82.     if n < 2:
  83.         return 1
  84.     return factorial(n-1) * n
  85.  
  86.  
  87. def combine(stack):
  88.     if len(stack.stack_rpn) == 1 and len(stack.numbers) == 0:
  89.         yield stack.stack_rpn[0], stack.stack_oper[0]
  90.     else:
  91.         for i in range(len(stack.operations)):
  92.             new_stack = copy.deepcopy(stack)
  93.             if new_stack.append_operation_to_stack(i):
  94.                 yield from combine(new_stack)
  95.  
  96.         for i in range(len(stack.numbers)):
  97.             new_stack = copy.deepcopy(stack)
  98.             new_stack.append_number_to_stack(i)
  99.             yield from combine(new_stack)
  100.  
  101.  
  102. def main():
  103.     stack = Stack(numbers=[2, 0, 2, 2])
  104.     results = {}
  105.     for result, operations in combine(stack):
  106.         if type(result) == int and result <= 100 and result >= 0:
  107.             if result in results:
  108.                 continue
  109.             else:
  110.                 results[result] = operations
  111.  
  112.     print('\n\n')
  113.     for i in range(101):
  114.         if i in results:
  115.             print(i, ' -> ', results[i])
  116.  
  117.  
  118. main()


Resultado con 51 líneas (lo calcula en pocos segundos):
Código: [Seleccionar]
0  ->  (((2 + 0) - 2) * 2)
1  ->  ((((2 + 0) - 2)!) ^ 2)
2  ->  (((2 + 0) + 2) - 2)
3  ->  ((((2 + 0) - 2)!) + 2)
4  ->  (((((2 * 0)!) + 2)!) - 2)
5  ->  ((((2 * 0)!) + 2) + 2)
6  ->  (((2 + 0) + 2) + 2)
7  ->  (((2 + (0!))!) + ((2 - 2)!))
8  ->  (((2 + 0) + 2) * 2)
9  ->  ((((2 * 0)!) + 2) ^ 2)
10  ->  ((((2 + (0!))!) + 2) + 2)
11  ->  (((20) + 2) / 2)
12  ->  ((((2 + 0) + 2)!) / 2)
13  ->  ((((2 + 2)!) / 2) + (0!))
14  ->  ((((2 + (0!))!) * 2) + 2)
15  ->  (((2 + 2) ^ 2) - (0!))
16  ->  (((2 + 0) + 2) ^ 2)
17  ->  (((2 + 2) ^ 2) + (0!))
18  ->  ((((2 + (0!))!) ^ 2) / 2)
19  ->  ((20) - ((2 - 2)!))
20  ->  (((20) + 2) - 2)
21  ->  ((20) + ((2 - 2)!))
22  ->  ((((2 + 0) + 2)!) - 2)
23  ->  (((2 * 0)!) + (22))
24  ->  ((2 + 0) + (22))
25  ->  (((2 * 0)!) + ((2 + 2)!))
26  ->  ((((2 + 0) + 2)!) + 2)
27  ->  ((2 + (0!)) + ((2 + 2)!))
28  ->  (((2 + (0!))!) + (22))
30  ->  ((((2 + (0!))!)!) / ((2 + 2)!))
32  ->  ((2 ^ (((0!) + 2)!)) / 2)
34  ->  ((((2 + (0!))!) ^ 2) - 2)
36  ->  (((((2 * 0)!) + 2)!) ^ 2)
38  ->  (((20) * 2) - 2)
42  ->  (((20) * 2) + 2)
43  ->  (((22) * 2) - (0!))
44  ->  ((2 + 0) * (22))
45  ->  (((22) * 2) + (0!))
46  ->  (2 * ((0!) + (22)))
47  ->  ((((2 + 2)!) * 2) - (0!))
48  ->  ((((2 + 0) + 2)!) * 2)
49  ->  ((((2 + 2)!) * 2) + (0!))
50  ->  (2 * ((0!) + ((2 + 2)!)))
60  ->  ((((2 + (0!)) + 2)!) / 2)
62  ->  ((2 ^ (((0!) + 2)!)) - 2)
64  ->  ((((2 + (0!))!) + 2) ^ 2)
66  ->  ((2 + (0!)) * (22))
72  ->  ((((2 + (0!))!) ^ 2) * 2)
80  ->  (((20) * 2) * 2)
81  ->  (((2 + (0!)) ^ 2) ^ 2)
100  ->  (((20) / 2) ^ 2)
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Picuino en 07 de Enero de 2022, 11:57:35
Con el próximo año (2023) salen más combinaciones (80 en total):

Código: [Seleccionar]
0  ->  (((2 + 0) - 2) * 3)
1  ->  (((2 + 0) + 2) - 3)
2  ->  ((2 + 0) * (3 - 2))
3  ->  ((((2 + 0) - 2)!) * 3)
4  ->  ((((2 + 0) + 2)!) / (3!))
5  ->  ((2 + 0) + ((3!) / 2))
6  ->  ((((2 + 0) - 2)!) * (3!))
7  ->  (((2 + 0) + 2) + 3)
8  ->  ((((2 + 0) + 2)!) / 3)
9  ->  (((((2 * 0)!) + 2)!) + 3)
10  ->  (((2 + 0) + 2) + (3!))
11  ->  ((2 + 0) + (3 ^ 2))
12  ->  (((2 + 0) + 2) * 3)
13  ->  (((2 * 0)!) + (2 * (3!)))
14  ->  ((2 + 0) + (2 * (3!)))
15  ->  (((20) - 2) - 3)
16  ->  ((2 + 0) * (2 ^ 3))
17  ->  ((20) - ((3!) / 2))
18  ->  ((((2 + 0) + 2)!) - (3!))
19  ->  (((20) + 2) - 3)
20  ->  ((20) * (3 - 2))
21  ->  ((((2 + 0) + 2)!) - 3)
22  ->  (((((2 * 0)!) + 3)!) - 2)
23  ->  (((2 * 0)!) * (23))
24  ->  (((2 + 0) + 2) * (3!))
25  ->  ((2 + 0) + (23))
26  ->  ((2 + 0) + (((3!) - 2)!))
27  ->  ((((2 + 0) + 2)!) + 3)
28  ->  (((20) + 2) + (3!))
29  ->  ((20) + (3 ^ 2))
30  ->  ((((2 + 0) + 2)!) + (3!))
31  ->  ((((2 + 2)!) + (0!)) + (3!))
32  ->  ((2 + 0) ^ (2 + 3))
33  ->  (((2 * 0)!) + (32))
34  ->  ((2 + 0) + (32))
35  ->  ((2 + (0!)) + (32))
36  ->  (((2 + 0) * 3) ^ 2)
37  ->  (((2 * 0)!) + ((3!) ^ 2))
38  ->  ((2 + 0) + ((3!) ^ 2))
39  ->  ((((2 + (0!))!) ^ 2) + 3)
40  ->  ((((2 + (0!)) + 2)!) / 3)
42  ->  ((((2 + (0!))!) ^ 2) + (3!))
43  ->  (((20) * 2) + 3)
44  ->  ((20) + (((3!) - 2)!))
45  ->  ((2 * (23)) - (0!))
46  ->  ((2 + 0) * (23))
47  ->  ((2 * (23)) + (0!))
48  ->  ((2 + 0) * (((3!) - 2)!))
49  ->  ((((2 * 0)!) + (3!)) ^ 2)
50  ->  ((2 * (((0!) + 3)!)) + 2)
51  ->  (2 + (((0!) + (3!)) ^ 2))
52  ->  (((20) + (3!)) * 2)
54  ->  (((20) - 2) * 3)
56  ->  ((20) + ((3!) ^ 2))
58  ->  (((20) * 3) - 2)
59  ->  ((((2 + 3)!) / 2) - (0!))
60  ->  ((((2 + 0) + 3)!) / 2)
61  ->  ((2 ^ (((0!) + 2)!)) - 3)
62  ->  (((2 + 0) ^ (3!)) - 2)
63  ->  (((2 + 2) ^ 3) - (0!))
64  ->  (((2 + 0) + 2) ^ 3)
65  ->  (((2 * 0)!) + (2 ^ (3!)))
66  ->  ((2 + 0) + (2 ^ (3!)))
67  ->  ((2 + (0!)) + (2 ^ (3!)))
69  ->  ((2 + (0!)) * (23))
70  ->  (((2 + (0!))!) + (2 ^ (3!)))
71  ->  ((((2 + 2)!) * 3) - (0!))
72  ->  ((((2 + 0) + 2)!) * 3)
73  ->  ((((2 + 2)!) * 3) + (0!))
74  ->  (2 * ((0!) + ((3!) ^ 2)))
75  ->  ((((2 + 2)!) + (0!)) * 3)
80  ->  ((20) * ((3!) - 2))
81  ->  ((((2 + (0!))!) + 3) ^ 2)
82  ->  ((0!) + ((3 ^ 2) ^ 2))
84  ->  ((20) + (2 ^ (3!)))
88  ->  ((22) * ((0!) + 3))
90  ->  ((((2 + (0!))!)!) / (2 ^ 3))
96  ->  ((2 + (0!)) * (32))
98  ->  (2 * (((0!) + (3!)) ^ 2))
100  ->  ((20) * (2 + 3))
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Nocturno en 07 de Enero de 2022, 13:16:24
¡Espectacular!, ahora sí que funciona realmente rápido  ((:-)) ((:-)) ((:-))
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Sispic en 08 de Enero de 2022, 03:51:54
Cita de: AKENAFAB en 06 de Enero de 2022, 21:03:29
Hola,

Estos ejercicios , ¿que nivel de programación es necesario para realizarlo?

Yo no entiendo nada , por eso mi pregunta, :D

Saludos!

A mi me pasa lo mismo . :?
Todo lo que salga de cero-uno-suma-resta-multiplicación- división ya me viene grande.
Aqui hay maestros con mucho nivel . ((:-))
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Nocturno en 09 de Enero de 2022, 16:11:48
Bien, ya me he sacado la espinita y he conseguido encontrar también 51 soluciones con mi programa.
Obviamente es mucho mejor el de Picuino, por sencillo, intuitivo y rápido, pero tenía interés en terminar lo que empecé.

Código: Python
  1. import itertools
  2. import math
  3. import warnings
  4. import time
  5.  
  6.  
  7. warnings.filterwarnings("error")
  8.  
  9. # esta función devuelve todas las permutaciones de obj sin repeticiones
  10. def perms(obj):
  11.     perm_set = set()
  12.     for item in list(itertools.permutations(obj)):
  13.         if item not in perm_set:
  14.             perm_set.add(item)
  15.     return (perm_set)
  16.  
  17. # función recursiva para calcular el factorial de un número
  18. def factorial(n):
  19.     if (n<10):
  20.         return n * factorial(n - 1) if n > 1 else 1
  21.     else:
  22.         return 0
  23.  
  24. # Todas las posibilidades de situar paréntesis en la expresión (con 4 dígitos)
  25.  
  26. formulas = (    ("  AQJ x BRK y CSL z DTM ",5),
  27.                 ("E(AQJ x BRK)Ny CSL z DTM ",6),
  28.                 ("  AQJ xE(BRK y CSL)Nz DTM ",6),
  29.                 (" E(AQJ x BRK y CSL)Nz DTM ",6),
  30.                 (" E(AQJ x BRK)NyF(CSL z DTM)O",7),
  31.                 ("E(F(AQJ x BRK)Oy CSL)Nz DTM ",7)
  32. )
  33.  
  34. print ("Comenzamos")
  35. inicio = time.time()
  36.  
  37. entradas = "2022"       # dígitos a utilizar en los cálculos
  38.  
  39. # las operaciones que vamos a combinar serán la suma, resta, multiplicación, división
  40. # potencia y concatenación. Para cada una se escribe su fórmula en python y su
  41. # expresión matemática de cara a visualizar los resultados
  42. operaciones = (('+','+'), ('-','-'), ('*','x'), ('/','/'), ('**','^'), ('',''))
  43.  
  44. # preparamos una lista vacía con 100 posiciones para almacenar los resultados
  45. salidas=[]
  46. for i in range(101):
  47.     salidas.append([])
  48.  
  49. indice=0
  50. # recorremos todas las permutaciones de los dígitos de entrada
  51. for digito in perms(entradas):         
  52.  
  53.     # recorremos todas las combinaciones posibles de las operaciones disponibles
  54.     for operaciones_seleccionadas in list(itertools.combinations_with_replacement(operaciones,len(entradas)-1)):       
  55.         # con cada combinación de operaciones hacemos todas las permutaciones
  56.         for op in perms(operaciones_seleccionadas):            
  57.             # cada dígito puede tener asignada la operación factorial o no. Se recorren todas las combinaciones
  58.             for formula in formulas:
  59.                 for fact in range (2**formula[1]):
  60.                    
  61.                         # El cálculo a realizar consiste en la concatenación de dígitos y operaciones
  62.                         # incluyendo el tratamiento especial de algunos dígitos que en ocasiones pueden llevar
  63.                         # el cálculo de su factorial.
  64.                         # Además, la expresión del cálculo incorpora el carácter de paréntesis que corresponda
  65.                         # según los strings definidos más arriba
  66.                         # Se preparan dos strings: calculo y expresion
  67.                         # - calculo: es la sentencia que se evalúa realmente y de la que se obtiene resultado
  68.                         # - expresion: es la misma sentencia, pero escrita en lenguaje matemático
  69.                         #              (x para multiplicación, ! para factorial y ^ para potencias)
  70.  
  71.                         calculo = formula[0]
  72.  
  73.                         # Primero sustituimos los dígitos numéricos, caracteres QRST
  74.                         for orden in range(4):
  75.                             calculo = calculo.replace(chr(ord('Q')+orden),digito[orden])
  76.                            
  77.                         expresion = calculo
  78.  
  79.                         # Luego metemos las tres operaciones matemáticas seleccionadas, caracteres xyz
  80.                         for orden in range(3):
  81.                             calculo = calculo.replace(chr(ord('x')+orden),op[orden][0])
  82.                             expresion = expresion.replace(chr(ord('x')+orden),op[orden][1])
  83.                        
  84.                         # Por último ponemos los factoriales donde toque
  85.                         # caracteres ABCDEF para "factorial("
  86.                         # y caracteres JKLMNO para cerrar el paréntesis
  87.                         for orden in range(formula[1]):
  88.                             calculo = calculo.replace (chr(ord('A')+orden),"factorial(" if (fact & (1<<(orden+1))>0) else "")
  89.                             calculo = calculo.replace (chr(ord('J')+orden),")" if (fact & (1<<(orden+1))>0) else "")
  90.                             expresion = expresion.replace (chr(ord('A')+orden),"")
  91.                             expresion = expresion.replace (chr(ord('J')+orden),"!" if (fact & (1<<(orden+1))>0) else "")
  92.                      
  93.                         # Una vez montados los strings, limpiamos los espacios que hayan quedado dentro9
  94.                         calculo = calculo.replace (" ","")
  95.                         expresion = expresion.replace (" ","")
  96.  
  97.                         try:
  98.                             # Evaluamos el resultado
  99.                             resultado=eval(calculo)
  100.                             # El resultado sólo será válido si está entre 1 y 1000, y es un número entero
  101.                             if (resultado>=0) and (resultado<101) and int(resultado)==resultado:
  102.                                 # cuando el resultado es válido lo guardamos en una lista, en su posición correspondiente
  103.                                 salidas[int(resultado)].append (expresion)
  104.                         # A veces las expresiones no se pueden evaluar porque aparecen divisiones por cero, paréntesis
  105.                         # concatenados con dígitos y otras incorrecciones. Las descartamos.
  106.                         except (ZeroDivisionError):
  107.                             pass
  108.                         except (TypeError, SyntaxError):
  109.                             pass
  110.                         indice = indice + 1
  111. fin = time.time()
  112. soluciones= 0
  113. for i in range (101):
  114.     if len(salidas[i])>0:
  115.         print (i, " -> ", end="")
  116.         for j in range (min(10, len(salidas[i]))):
  117.             print (salidas[i][j], end="")
  118.             if (j<min(10, len(salidas[i]))-1):
  119.                 print (", ",end="")
  120.         print ("")
  121.         soluciones = soluciones + 1
  122. print ("Se han encontrado", soluciones, "soluciones en {:,.2f}".format(fin-inicio), "segundos")

Código: [Seleccionar]
Comenzamos
0  -> 2+0x2-2, 2+0x2-2, 2!+0x2-2, 2!+0x2-2, 2+0x2!-2, 2+0x2!-2, 2!+0x2!-2, 2!+0x2!-2, 2+0x2-2!, 2+0x2-2!
1  -> 2-(0!+2)+2, 2-(0!+2)+2, 2!-(0!+2)+2, 2!-(0!+2)+2, 2-(0!+2!)+2, 2-(0!+2!)+2, 2!-(0!+2!)+2, 2!-(0!+2!)+2, 2-(0!+2)+2!, 2-(0!+2)+2!
2  -> 2+0+2-2, 2+0+2-2, 2!+0+2-2, 2!+0+2-2, 2+0+2!-2, 2+0+2!-2, 2!+0+2!-2, 2!+0+2!-2, 2+0+2-2!, 2+0+2-2!
3  -> 2+0!+2-2, 2+0!+2-2, 2!+0!+2-2, 2!+0!+2-2, 2+0!+2!-2, 2+0!+2!-2, 2!+0!+2!-2, 2!+0!+2!-2, 2+0!+2-2!, 2+0!+2-2!
4  -> (2+0!)+(2-2)!, (2+0!)+(2-2)!, (2!+0!)+(2-2)!, (2!+0!)+(2-2)!, (2+0!)+(2!-2)!, (2+0!)+(2!-2)!, (2!+0!)+(2!-2)!, (2!+0!)+(2!-2)!, (2+0!)+(2-2!)!, (2+0!)+(2-2!)!
5  -> 2+(0-2)!+2, 2+(0-2)!+2, 2!+(0-2)!+2, 2!+(0-2)!+2, 2+(0!-2)!+2, 2+(0!-2)!+2, 2!+(0!-2)!+2, 2!+(0!-2)!+2, 2+(0-2!)!+2, 2+(0-2!)!+2
6  -> 2+0+2+2, 2+0+2+2, 2!+0+2+2, 2!+0+2+2, 2+0+2!+2, 2+0+2!+2, 2!+0+2!+2, 2!+0+2!+2, 2+0+2+2!, 2+0+2+2!
7  -> 2+0!+2+2, 2+0!+2+2, 2!+0!+2+2, 2!+0!+2+2, 2+0!+2!+2, 2+0!+2!+2, 2!+0!+2!+2, 2!+0!+2!+2, 2+0!+2+2!, 2+0!+2+2!
8  -> (2-0!+2)!+2, (2-0!+2)!+2, (2!-0!+2)!+2, (2!-0!+2)!+2, (2-0!+2!)!+2, (2-0!+2!)!+2, (2!-0!+2!)!+2, (2!-0!+2!)!+2, (2-0!+2)!+2!, (2-0!+2)!+2!
9  -> (2-0!+2)^2, (2-0!+2)^2, (2!-0!+2)^2, (2!-0!+2)^2, (2-0!+2!)^2, (2-0!+2!)^2, (2!-0!+2!)^2, (2!-0!+2!)^2, (2-0!+2)^2!, (2-0!+2)^2!
10  -> (2+0!)!+2+2, (2+0!)!+2+2, (2!+0!)!+2+2, (2!+0!)!+2+2, (2+0!)!+2!+2, (2+0!)!+2!+2, (2!+0!)!+2!+2, (2!+0!)!+2!+2, (2+0!)!+2+2!, (2+0!)!+2+2!
11  -> 2+(0!+2)^2, 2+(0!+2)^2, 2!+(0!+2)^2, 2!+(0!+2)^2, 2+(0!+2!)^2, 2+(0!+2!)^2, 2!+(0!+2!)^2, 2!+(0!+2!)^2, 2+(0!+2)^2!, 2+(0!+2)^2!
12  -> (2+0!)x(2+2), (2+0!)x(2+2), (2!+0!)x(2+2), (2!+0!)x(2+2), (2+0!)x(2!+2), (2+0!)x(2!+2), (2!+0!)x(2!+2), (2!+0!)x(2!+2), (2+0!)x(2+2!), (2+0!)x(2+2!)
13  -> (2+2)!/2+0!, (2+2)!/2+0!, (2!+2)!/2+0!, (2!+2)!/2+0!, (2+2!)!/2+0!, (2+2!)!/2+0!, (2!+2!)!/2+0!, (2!+2!)!/2+0!, (2+2)!/2!+0!, (2+2)!/2!+0!
14  -> (2+0!)!x2+2, (2+0!)!x2+2, (2!+0!)!x2+2, (2!+0!)!x2+2, (2+0!)!x2!+2, (2+0!)!x2!+2, (2!+0!)!x2!+2, (2!+0!)!x2!+2, (2+0!)!x2+2!, (2+0!)!x2+2!
15  -> 2^(2+2)-0!, 2^(2+2)-0!, 2!^(2+2)-0!, 2!^(2+2)-0!, 2^(2!+2)-0!, 2^(2!+2)-0!, 2!^(2!+2)-0!, 2!^(2!+2)-0!, 2^(2+2!)-0!, 2^(2+2!)-0!
16  -> ((2+0!)!+2)x2, ((2+0!)!+2)x2, ((2!+0!)!+2)x2, ((2!+0!)!+2)x2, ((2+0!)!+2!)x2, ((2+0!)!+2!)x2, ((2!+0!)!+2!)x2, ((2!+0!)!+2!)x2, ((2+0!)!+2)x2!, ((2+0!)!+2)x2!
17  -> 2^(2+2)+0!, 2^(2+2)+0!, 2!^(2+2)+0!, 2!^(2+2)+0!, 2^(2!+2)+0!, 2^(2!+2)+0!, 2!^(2!+2)+0!, 2!^(2!+2)+0!, 2^(2+2!)+0!, 2^(2+2!)+0!
18  -> 2x(0!+2)^2, 2x(0!+2)^2, 2!x(0!+2)^2, 2!x(0!+2)^2, 2x(0!+2!)^2, 2x(0!+2!)^2, 2!x(0!+2!)^2, 2!x(0!+2!)^2, 2x(0!+2)^2!, 2x(0!+2)^2!
19  -> (20)-(2-2)!, (20)-(2-2)!, (20)-(2!-2)!, (20)-(2!-2)!, (20)-(2-2!)!, (20)-(2-2!)!, (20)-(2!-2!)!, (20)-(2!-2!)!, 20-2/2, 20-2/2
20  -> 20-2+2, 20-2+2, 20-2!+2, 20-2!+2, 20-2+2!, 20-2+2!, 20-2!+2!, 20-2!+2!, (20)-2+2, (20)-2+2
21  -> (20)+(2-2)!, (20)+(2-2)!, (20)+(2!-2)!, (20)+(2!-2)!, (20)+(2-2!)!, (20)+(2-2!)!, (20)+(2!-2!)!, (20)+(2!-2!)!, 20+2/2, 20+2/2
22  -> (2+0+2)!-2, (2+0+2)!-2, (2!+0+2)!-2, (2!+0+2)!-2, (2+0+2!)!-2, (2+0+2!)!-2, (2!+0+2!)!-2, (2!+0+2!)!-2, (2+0+2)!-2!, (2+0+2)!-2!
23  -> 2-0!+22, 2-0!+22, 2!-0!+22, 2!-0!+22, (2-0!)+22, (2-0!)+22, (2!-0!)+22, (2!-0!)+22, (2-0!)!+22, (2-0!)!+22
24  -> (2+0!)!x(2+2), (2+0!)!x(2+2), (2!+0!)!x(2+2), (2!+0!)!x(2+2), (2+0!)!x(2!+2), (2+0!)!x(2!+2), (2!+0!)!x(2!+2), (2!+0!)!x(2!+2), (2+0!)!x(2+2!), (2+0!)!x(2+2!)
25  -> (2-0!)+(2+2)!, (2-0!)+(2+2)!, (2!-0!)+(2+2)!, (2!-0!)+(2+2)!, (2-0!)+(2!+2)!, (2-0!)+(2!+2)!, (2!-0!)+(2!+2)!, (2!-0!)+(2!+2)!, (2-0!)+(2+2!)!, (2-0!)+(2+2!)!
26  -> (2+0+2)!+2, (2+0+2)!+2, (2!+0+2)!+2, (2!+0+2)!+2, (2+0+2!)!+2, (2+0+2!)!+2, (2!+0+2!)!+2, (2!+0+2!)!+2, (2+0+2)!+2!, (2+0+2)!+2!
27  -> (2+0!)+(2+2)!, (2+0!)+(2+2)!, (2!+0!)+(2+2)!, (2!+0!)+(2+2)!, (2+0!)+(2!+2)!, (2+0!)+(2!+2)!, (2!+0!)+(2!+2)!, (2!+0!)+(2!+2)!, (2+0!)+(2+2!)!, (2+0!)+(2+2!)!
28  -> (2+0!)!+22, (2+0!)!+22, (2!+0!)!+22, (2!+0!)!+22, (2+0!)!+(22), (2+0!)!+(22), (2!+0!)!+(22), (2!+0!)!+(22), (22)+(2+0!)!, (22)+(2+0!)!
30  -> (2+0!)!+(2+2)!, (2+0!)!+(2+2)!, (2!+0!)!+(2+2)!, (2!+0!)!+(2+2)!, (2+0!)!+(2!+2)!, (2+0!)!+(2!+2)!, (2!+0!)!+(2!+2)!, (2!+0!)!+(2!+2)!, (2+0!)!+(2+2!)!, (2+0!)!+(2+2!)!
32  -> 2^(0!+2)!/2, 2^(0!+2)!/2, 2!^(0!+2)!/2, 2!^(0!+2)!/2, 2^(0!+2!)!/2, 2^(0!+2!)!/2, 2!^(0!+2!)!/2, 2!^(0!+2!)!/2, 2^(0!+2)!/2!, 2^(0!+2)!/2!
34  -> (2+0!)!^2-2, (2+0!)!^2-2, (2!+0!)!^2-2, (2!+0!)!^2-2, (2+0!)!^2!-2, (2+0!)!^2!-2, (2!+0!)!^2!-2, (2!+0!)!^2!-2, (2+0!)!^2-2!, (2+0!)!^2-2!
36  -> (2-0!+2)!^2, (2-0!+2)!^2, (2!-0!+2)!^2, (2!-0!+2)!^2, (2-0!+2!)!^2, (2-0!+2!)!^2, (2!-0!+2!)!^2, (2!-0!+2!)!^2, (2-0!+2)!^2!, (2-0!+2)!^2!
38  -> 2+(0!+2)!^2, 2+(0!+2)!^2, 2!+(0!+2)!^2, 2!+(0!+2)!^2, 2+(0!+2!)!^2, 2+(0!+2!)!^2, 2!+(0!+2!)!^2, 2!+(0!+2!)!^2, 2+(0!+2)!^2!, 2+(0!+2)!^2!
42  -> 20x2+2, 20x2+2, 20x2!+2, 20x2!+2, 20x2+2!, 20x2+2!, 20x2!+2!, 20x2!+2!, (20)x2+2, (20)x2+2
43  -> 2x22-0!, 2x22-0!, 2!x22-0!, 2!x22-0!, 2x(22)-0!, 2x(22)-0!, 2!x(22)-0!, 2!x(22)-0!, (2x22)-0!, (2x22)-0!
44  -> (20)+(2+2)!, (20)+(2+2)!, (20)+(2!+2)!, (20)+(2!+2)!, (20)+(2+2!)!, (20)+(2+2!)!, (20)+(2!+2!)!, (20)+(2!+2!)!, (2+0)x22, (2+0)x22
45  -> 2x22+0!, 2x22+0!, 2!x22+0!, 2!x22+0!, 2x(22)+0!, 2x(22)+0!, 2!x(22)+0!, 2!x(22)+0!, (2x22)+0!, (2x22)+0!
46  -> ((2+2)!-0!)x2, ((2+2)!-0!)x2, ((2!+2)!-0!)x2, ((2!+2)!-0!)x2, ((2+2!)!-0!)x2, ((2+2!)!-0!)x2, ((2!+2!)!-0!)x2, ((2!+2!)!-0!)x2, ((2+2)!-0!)x2!, ((2+2)!-0!)x2!
47  -> (2+2)!x2-0!, (2+2)!x2-0!, (2!+2)!x2-0!, (2!+2)!x2-0!, (2+2!)!x2-0!, (2+2!)!x2-0!, (2!+2!)!x2-0!, (2!+2!)!x2-0!, (2+2)!x2!-0!, (2+2)!x2!-0!
48  -> (2+0)x(2+2)!, (2+0)x(2+2)!, (2!+0)x(2+2)!, (2!+0)x(2+2)!, (2+0)x(2!+2)!, (2+0)x(2!+2)!, (2!+0)x(2!+2)!, (2!+0)x(2!+2)!, (2+0)x(2+2!)!, (2+0)x(2+2!)!
49  -> (2+2)!x2+0!, (2+2)!x2+0!, (2!+2)!x2+0!, (2!+2)!x2+0!, (2+2!)!x2+0!, (2+2!)!x2+0!, (2!+2!)!x2+0!, (2!+2!)!x2+0!, (2+2)!x2!+0!, (2+2)!x2!+0!
50  -> ((2+2)!+0!)x2, ((2+2)!+0!)x2, ((2!+2)!+0!)x2, ((2!+2)!+0!)x2, ((2+2!)!+0!)x2, ((2+2!)!+0!)x2, ((2!+2!)!+0!)x2, ((2!+2!)!+0!)x2, ((2+2)!+0!)x2!, ((2+2)!+0!)x2!
60  -> (2+0!+2)!/2, (2+0!+2)!/2, (2!+0!+2)!/2, (2!+0!+2)!/2, (2+0!+2!)!/2, (2+0!+2!)!/2, (2!+0!+2!)!/2, (2!+0!+2!)!/2, (2+0!+2)!/2!, (2+0!+2)!/2!
62  -> 2^(0!+2)!-2, 2^(0!+2)!-2, 2!^(0!+2)!-2, 2!^(0!+2)!-2, 2^(0!+2!)!-2, 2^(0!+2!)!-2, 2!^(0!+2!)!-2, 2!^(0!+2!)!-2, 2^(0!+2)!-2!, 2^(0!+2)!-2!
64  -> ((2+0!)!+2)^2, ((2+0!)!+2)^2, ((2!+0!)!+2)^2, ((2!+0!)!+2)^2, ((2+0!)!+2!)^2, ((2+0!)!+2!)^2, ((2!+0!)!+2!)^2, ((2!+0!)!+2!)^2, ((2+0!)!+2)^2!, ((2+0!)!+2)^2!
66  -> 2^(0!+2)!+2, 2^(0!+2)!+2, 2!^(0!+2)!+2, 2!^(0!+2)!+2, 2^(0!+2!)!+2, 2^(0!+2!)!+2, 2!^(0!+2!)!+2, 2!^(0!+2!)!+2, 2^(0!+2)!+2!, 2^(0!+2)!+2!
72  -> (2+0!)x(2+2)!, (2+0!)x(2+2)!, (2!+0!)x(2+2)!, (2!+0!)x(2+2)!, (2+0!)x(2!+2)!, (2+0!)x(2!+2)!, (2!+0!)x(2!+2)!, (2!+0!)x(2!+2)!, (2+0!)x(2+2!)!, (2+0!)x(2+2!)!
80  -> (20)x(2+2), (20)x(2+2), (20)x(2!+2), (20)x(2!+2), (20)x(2+2!), (20)x(2+2!), (20)x(2!+2!), (20)x(2!+2!), 20x2x2, 20x2x2
81  -> (2+0!)^(2+2), (2+0!)^(2+2), (2!+0!)^(2+2), (2!+0!)^(2+2), (2+0!)^(2!+2), (2+0!)^(2!+2), (2!+0!)^(2!+2), (2!+0!)^(2!+2), (2+0!)^(2+2!), (2+0!)^(2+2!)
100  -> (20/2)^2, (20/2)^2, (20/2!)^2, (20/2!)^2, (20/2)^2!, (20/2)^2!, (20/2!)^2!, (20/2!)^2!, ((20)/2)^2, ((20)/2)^2
Se han encontrado 51 soluciones en 26.95 segundos
Título: Re:Cálculo de los números del 1 al 100 usando los dígitos del año "2022"
Publicado por: Picuino en 10 de Enero de 2022, 07:36:51
Bravo.  ((:-)) ((:-)) ((:-)) ((:-))