¿Cuál de los números en las primeras 24 filas del triángulo de Pascal se puede numerar con el menor número de puntos P? La Ciencia y la Tecnología mejoran el futuro

Respuesta para combinaciones de 3 dígitos
495 se transpone a 495 que luego se convierte a 415
190 se transpone a 190, que luego se convierte en 191
495 se transpone a 495 que luego se convierte a 595
462 se transpone a 462 que luego se convierte a 562
462 se transpone a 462 que luego se convierte a 472
Respuesta para combinaciones de 4 dígitos
1001 se transpone a 1001 que luego se convierte a 1011
Respuesta para combinaciones de 5 dígitos
19448 se transpone a 19448 que luego se convierte a 49448
Respuesta para combinaciones de 6 dígitos
245157 se transpone a 245157 que luego se convierte a 246178
Respuesta para combinaciones de 7 dígitos
1144066 se transpone a 1144066 que luego se convierte a 2246178

El código utilizado para generar el resultado dado se puede encontrar a continuación (para las personas que sugieren ediciones para incluir esto en las etiquetas de código, eso no funciona por alguna razón).

import java.util. *;
clase pública PascalNumeryclize {
privado estático largo [] [] elegir;
private static int [] [] mejor;
privado estático int ret;
conjunto estático privado Combo ;
conjunto estático privado set;

public static void main (String [] args) {
elegir = nuevo largo [25] [25];
best = new int [10] [10];
for (int i = 0; i <best.length; i ++)
Arrays.fill (mejor [i], 1000);
for (int i = 0; i <choose.length; i ++)
Arrays.fill (elija [i], -1);
para (int i = 0; i <10; i ++) {
para (int j = 0; j <10; j ++) {
best [i] [digitSum (i, j)] = Math.min (best [i] [digitSum (i, j)], j);
}
}
para (int d = 3; d <= 7; d ++) {
System.out.println (“Respuesta para” + d + “combinaciones de dígitos”);
set = new HashSet ();
para (int a = 0; a <10; a ++) {
para (int b = 0; b <10; b ++) {
int curr = 10 * a + b;
int x = a;
int y = b;
para (int i = 2; i <d; i ++) {
curr * = 10;
int z = digitSum (x, y);
curr + = z;
x = y;
y = z;
}
set.add (curr);
}
}
ret = Integer.MAX_VALUE;
combo = nuevo HashSet ();
para (int n = 1; n <= 24; n ++) {
para (int k = 0; k <= n; k ++) {
if (numDigits (elegir (n, k)) == d) {
dfs ((int) elegir (n, k));
}
}
}
para (indicar: combo)
System.out.println (fuera);
}
}

private static int digitSum (int a, int b) {
int ret = a + b;
si (ret <10)
volver ret;
return digitSum (ret / 10, ret% 10);
}

dfs vacío privado estático (int n) {
int [] lista = nuevo int [numDigits (n)];
for (int i = list.length-1; i> = 0; i–) {
lista [i] = n% 10;
n / = 10;
}
dfs (list, new int [list.length], new boolean [list.length], 0, 0);
}

dfs vacío estático privado (int [] list, int [] next, boolean [] used, int index, int score) {
if (puntuación> ret)
regreso;
if (index == list.length) {
empujar (lista, siguiente, puntaje);
}
más {
for (int i = 0; i <used.length; i ++) {
if (! used [i]) {
siguiente [i] = lista [índice];
utilizado [i] = verdadero;
int inc = list [i] == next [i]? 0: mejor [lista [i]] [siguiente [i]];
dfs (list, next, used, index + 1, score + inc);
utilizado [i] = falso;
}
}
}
}

push vacío privado estático (int [] start, int [] list, int ya) {
int orig = 0;
for (int out: start) {
orig * = 10;
orig + = fuera;
}
int curr = 0;
para (int out: list) {
curr * = 10;
curr + = fuera;
}
para (int out: set) {
int inc = 0;
int temp1 = curr;
int temp2 = fuera;
for (int a = 0; a <list.length; a ++) {
inc + = mejor [temp1% 10] [temp2% 10];
temp1 / = 10;
temp2 / = 10;
}
if (inc + ya <ret) {
ret = inc + ya;
combo.clear ();
}
if (inc + ya == ret) {
combo.add (nuevo estado (orig, curr, out));
}
}
}

Estado de clase estática privada {
public int a, b, c;
Estado público (int x, int y, int z) {
a = x;
b = y;
c = z;
}
public String toString () {
return a + “se transpone a” + b + “que luego se convierte en” + c;
}
public int hashCode () {
devuelve 3137 * 3137 * a + 3137 * b + c;
}
public boolean igals (Object o) {
if (! (o instanceof State))
falso retorno;
Estado s = (Estado) o;
devuelve a == sa && b == sb && c == sc;
}
}

private static int numDigits (long n) {
int ret = 1;
n / = 10;
mientras que (n> 0) {
ret ++;
n / = 10;
}
volver ret;
}

elección estática privada larga (int n, int k) {
si (elija [n] [k] <0)
si (k == 0 || k == n)
elija [n] [k] = 1;
más
elegir [n] [k] = elegir (n-1, k) + elegir (n-1, k-1);
volver elegir [n] [k];
}

}

Matemáticas