Encontrar un seis dígitos enteros

Question

Encontrar un entero con seis dígitos que los seis dígitos de número entero es divisible por cada uno de sus dígitos.

Por ejemplo, encontrar ABCDEF tales que a, B, C, D, E y F se puede dividir el número ABCDEF.

Indica tu respuesta junto con el razonamiento matemático.

Answer 1

El número de $861432$ va a trabajar. Supongo que $123864$ ve más bonito.

Answer 2

Resultado de la búsqueda exhaustiva con el software:

123648, 123864, 123984, 124368, 126384, 129384, 132648, 132864, 
132984, 134928, 136248, 136824, 138264, 138624, 139248, 139824, 
142368, 143928, 146328, 146832, 148392, 148632, 149328, 149832, 
162384, 163248, 163824, 164328, 164832, 167328, 167832, 168432, 
172368, 183264, 183624, 184392, 184632, 186432, 189432, 192384, 
193248, 193824, 194328, 194832, 198432, 213648, 213864, 213984, 
214368, 216384, 218736, 219384, 231648, 231864, 231984, 234168, 
234816, 236184, 238416, 239184, 241368, 243168, 243768, 243816, 
247968, 248136, 248976, 261384, 263184, 273168, 281736, 283416, 
284136, 291384, 293184, 297864, 312648, 312864, 312984, 314928, 
316248, 316824, 318264, 318624, 319248, 319824, 321648, 321864, 
321984, 324168, 324816, 326184, 328416, 329184, 341928, 342168, 
342816, 346128, 348192, 348216, 348912, 349128, 361248, 361824, 
361872, 362184, 364128, 364728, 367248, 376824, 381264, 381624, 
382416, 384192, 384216, 384912, 391248, 391824, 392184, 394128, 
412368, 413928, 416328, 416832, 418392, 418632, 419328, 419832, 
421368, 423168, 423816, 427896, 428136, 428736, 431928, 432168, 
432768, 432816, 436128, 438192, 438216, 438912, 439128, 461328, 
461832, 463128, 468312, 469728, 478296, 478632, 481392, 481632, 
482136, 483192, 483216, 483672, 483912, 486312, 489312, 491328, 
491832, 493128, 498312, 612384, 613248, 613824, 613872, 614328, 
614832, 618432, 621384, 623184, 623784, 627984, 631248, 631824, 
632184, 634128, 634872, 641328, 641832, 643128, 648312, 671328, 
671832, 681432, 684312, 689472, 732648, 732816, 742896, 746928, 
762384, 768432, 783216, 789264, 796824, 813264, 813624, 814392, 
814632, 816432, 819432, 823416, 824136, 824376, 831264, 831624, 
832416, 834192, 834216, 834912, 836472, 841392, 841632, 842136, 
843192, 843216, 843912, 846312, 849312, 861432, 864312, 873264, 
891432, 894312, 897624, 912384, 913248, 913824, 914328, 914832, 
918432, 921384, 923184, 927864, 931248, 931824, 932184, 934128, 
941328, 941832, 943128, 948312, 976248, 978264, 981432, 984312

Hay más soluciones, $248$, de lo que yo esperaba inicialmente.

Código de Mathematica:

check[a_, b_, c_, d_, e_, f_] := Module[{
    n
  },
  n = f + 10 (e + 10 (d + 10 (c + 10 (b + 10 a))));
  {
    And[
      (* all inputs digits? *)
      0 < a < 10, 0 < b < 10, 0 < c < 10, 0 < d < 10, 0 < e < 10, 0 < f < 10,
      a \[Element] Integers, b \[Element] Integers, 
      c \[Element] Integers, d \[Element] Integers, 
      e \[Element] Integers, f \[Element] Integers, 
      (* all inputs distinct?  *)
      a != b, a != c, a != d, a != e, a != f,
      b != c, b != d, b != e, b != f,
      c != d, c != e, c != f,
      d != e, d != f,
      e != f,
      (* the long number is divisible by each digit? *)
      n/a \[Element] Integers,
      n/b \[Element] Integers,
      n/c \[Element] Integers,
      n/d \[Element] Integers,
      n/e \[Element] Integers,
      n/f \[Element] Integers
    ], 
    n
  }
]

Select[Flatten[
  Outer[check, Range[1, 9], Range[1, 9], Range[1, 9], Range[1, 9],  Range[1, 9], Range[1, 9]
  ],
  5], #[[1]] &
][[All, 2]]

El último comando hace todo lo posible 6-tupla de enteros en $[1,9]$ y pasa las tuplas como las listas de argumentos a check[] (la mitad de la check[] es superflua, ya que sólo estamos de paso en las listas de un solo dígito). El resultado es anidada varias capas de profundidad y haciendo caso omiso de las 5 capas más externas de las hojas {True/False, number} pares. Mantener sólo aquellos que check[] devuelto True, informe de toda su número de miembros.

Hay, por supuesto, una serie de abreviaturas y los accesos directos que se pueden utilizar en este código, pero se tomó el tiempo para cortar-pegar-editar como lo hizo ejecutar, así que probablemente inútil optimizar aún más.

Answer 3

$4\\ 24\\ 624\\ 3624\\ 183624$

2,4,8 son buenas para trabajar, porque una vez que encuentre tres dígitos al final, puedes poner lo que quieras en la parte delantera.

3,6,9 son buenas para trabajar demasiado, porque si usted encuentra algo que divide por 3 o 9, usted puede mezclar los dígitos y todavía se divide por 3 (o 9).

y 1 es simplemente una obviedad

Answer 4

Aquí es una solución de software escrito en el lenguaje c utilizando (oscuro?) bit a bit de la lógica de la comprobación de si un número se cumple el criterio o no.

int check_number(int a){
  int l = a, mask = 0;
  for(;l;l/=10) {
    mask |= (1<<(l%10));
    mask |= (!(mask%2)) && (a%(l%10) != 0);}
  return (__builtin_popcount(mask)==6) && (!(mask%2));
}

El bucle se ejecuta sobre cada dígito decimal, haciendo una secuencia de división (/) por 10 y calculando el resto (%). Como se puede ver en el libro de mantenimiento de la revisamos el campo de bits de la representación y el recuento de la población de la operación en esta pregunta, pero en esta solución para cada valor lógico significa que un dígito Y se divide nuestro número. Podríamos salvar una línea si tuviéramos que encontrar una manera más inteligente para evitar la división por 0.

El resultado cumple con @Eric Torre s solución para al menos el más pequeño y el más grande de los números (123648 y 984312). No he molestado en comprobar todas ellas.

Answer 5

La mayor coincidencia es 984312

Escribí un rápido Python3 secuencia de comandos para encontrar todos los partidos:

for number in range(100000, 1000000):
    string = str(number)
    digits = []
    unique = True

    for ch in string:
        if ch in digits:
            unique = False
            break
        else:
            digits.append(ch)

    if not unique: # If the digits are not unique, move to the next iteration
        continue

    if all([False if digit == '0' else number % int(digit) == 0 for digit in str(number)]):
        # Number divides perfectly with every digit
        print(number)

Este código imprimirá cada número, cada uno a una nueva línea.