Verschachtelte Schleife und funktionale Programmierung

Question

Bitte beachten Sie, ein C-Programm, das, x gegeben, kehren y und z so dass y + z * 2 = x, für die kleinstmögliche y. Grob gesagt, ich könnte eine verschachtelte Schleife erstellen:

for(y = 0; y < x; ++ y){ 
    for(z = 0; z < x; ++z){ 
     if(y + 2 * z == x){ 
      printf("%d + 2 * %d = %d", y, z, x); 
     } 
    } 
} 

Wie konnte ich diese Art von verschachtelter Schleife in übersetze die funktionelle Art und Weise? Ist es machbar? Ist es vernünftig oder verurteile ich nur den Ansatz? Mein bester Versuch so weit:

let foo x = 
    let rec aux (y, z, q) = 
     match (y + z * 2) with 
     r when r = q -> (y, z) 
     |_  -> aux(y + 1, z + 1, q) //How to check different values of z 
    aux(0, 0, x)       //for each value of y? 

Es wird nicht funktionieren, da es sowohl nur y und z erhöht wird. Wie kann ich verschiedene Werte von z für jeden Wert von y überprüfen?

Answer 1

Sie müssen diese Überprüfungen in das Spiel einfügen.

Sehen Sie hier, was Ihr Code fehlt:

let foo x = 
    let rec aux (y, z, q) = 
     match (y + z * 2) with 
     | r when r = q -> (y, z) 
     | _ when y = q -> failwith "not found !" 
     | _ when z = q -> aux (y + 1, 0, q) 
     | _   -> aux (y, z + 1, q) 
    aux (0, 0, x) 

Und hier ist ein anderer Ansatz, ebenso funktional, aber ohne Rekursion:

let foo2 x = 
    let s = 
     {0 .. x} |> Seq.collect (fun y -> 
      {0 .. x} |> Seq.collect (fun z -> 
       seq [y, z])) 
    Seq.find (fun (y, z) -> y + z * 2 = x) s 

, die in F # geschrieben werden können seq Ausdrücke:

let foo3 x = 
    let s = seq { 
     for y in {0 .. x} do 
      for z in {0 .. x} do 
       yield (y, z)} 
    Seq.find (fun (y, z) -> y + z * 2 = x) s 

und es ähnelt Ihrem ursprünglichen C-Programm.