Tengo un programa que encuentra, para todos los números enteros menores o iguales a la entrada, números que se pueden representar como la suma de dos cubos, dos veces, también conocido como el problema numérico de Ramanujan.
He escrito esto en Java y Rust, sin embargo, funciona más del doble de lento en Rust en comparación con Java.
¿Hay algo que pueda hacer para que funcione mejor o mejorarlo?
Código de óxido:
use num_integer::Roots; fn main() { let v = 984067; // let v = 87539319; for i in 1..=v { ramanujan(i) } } fn ramanujan(m: i32) { let maxcube = m.cbrt(); let mut res1 = 0; let mut res2 = 0; let mut _res3 = 0; let mut _res4 = 0; for i in 1..=maxcube { for j in 1..=maxcube { if i * i * i + j * j * j == m { res1 = i; res2 = j; break; } } } for k in 1..=maxcube { for l in 1..=maxcube { if k == res1 || k == res2 || l == res1 || l == res2 { continue; } if k * k * k + l * l * l == m { _res3 = k; _res4 = l; break; } } } // if ((res1 * res1 * res1) + (res2 * res2 * res2) == m) && ((res3 * res3 * res3) + (res4 * res4 * res4) == m) { // println!("{} is representable as the sums of two different sets of two cubes!\nThese values are {}, {}, and {}, {}.", m, res1, res2, res3, res4); // } }Código Java:
public class Ramun { public static void main(String[] args) { int v = 984067; // int v = 87539319; for (int i = 1; i <= v; i++) { ramanujan(i); } } public static void ramanujan(int m) { int maxcube = (int) Math.round(Math.cbrt(m)); int res1 = 0, res2 = 0, res3 = 0, res4 = 0; for (int i = 1; i <= maxcube; i++) { for (int j = 1; j <= maxcube; j++) { if (((i * i * i) + (j * j * j)) == m) { res1 = i; res2 = j; break; } } } for (int k = 1; k <= maxcube; k++) { for (int l = 1; l <= maxcube; l++) { if (k == res1 || k == res2 || l == res1 || l == res2) continue; if (((k * k * k) + (l * l * l)) == m) { res3 = k; res4 = l; break; } } } // if (((res1 * res1 * res1) + (res2 * res2 * res2) == m) && ((res3 * res3 * res3) + (res4 * res4 * res4) == m)) { // System.out.printf("%d is representable as the sums of two different sets of two cubes!%nThese values are %d, %d, and %d, %d.%n", m, res1, res2, res3, res4); // } } }El problema radica en RangeInclusive , que puede ser costoso.
Aquí hay una versión que lo evita:
fn ramanujan(m: i32) { let maxcube = m.cbrt() + 1; // we know it can't overflow let mut res1 = 0; let mut res2 = 0; let mut res3 = 0; let mut res4 = 0; for i in 1..maxcube { for j in 1..maxcube { if i * i * i + j * j * j == m { res1 = i; res2 = j; break; } } } for k in 1..maxcube { for l in 1..maxcube { if k == res1 || k == res2 || l == res1 || l == res2 { continue; } if k * k * k + l * l * l == m { res3 = k; res4 = l; break; } } } }Resultado:
From: 0.01s user 0.00s system 0% cpu 17.993 total To: 0.00s user 0.01s system 0% cpu 3.494 totalAgregué un comentario a #45222 para llamar la atención sobre este problema.
Parece que for_each() también permite un mejor rendimiento (ya que los bucles for son más naturales y deberían tener el mismo rendimiento, debería considerarse como un error):
fn ramanujan(m: i32) { let maxcube = m.cbrt(); let mut res1 = 0; let mut res2 = 0; let mut res3 = 0; let mut res4 = 0; (1..=maxcube).for_each(|i| { (1..=maxcube).try_for_each(|j| { if i * i * i + j * j * j == m { res1 = i; res2 = j; ControlFlow::Break(()) } else { ControlFlow::Continue(()) } }); }); (1..=maxcube).for_each(|k| { (1..=maxcube).try_for_each(|l| { if k != res1 && k != res2 && l != res1 && l != res2 && k * k * k + l * l * l == m { res3 = k; res4 = l; ControlFlow::Break(()) } else { ControlFlow::Continue(()) } }); }); } 0.00s user 0.01s system 0% cpu 4.029 total