Wenn ein Rechteck gezeichnet wird, warum ist eine Koordinate mit der Formula x = y + y * 3 + y anders als x = y * 4?

Question

Für eine Aufgabe wurde ich beauftragt, eine rekursive Methode zu erstellen, um einen Sierpinski-Teppich zu erstellen. Für meinen Code wurde einer meiner Berechnungen nicht die korrekte Ausgabe gegeben, also musste ich meine Formel für eine andere ändern, die das gleiche Ergebnis geben sollte, aber nicht tat. Hier ist der Code, der tatsächlich funktioniert.

import javafx.application.Application; 
import javafx.geometry.Pos; 
import javafx.scene.Scene; 
import javafx.scene.control.Button; 
import javafx.scene.control.Label; 
import javafx.scene.control.TextField; 
import javafx.scene.layout.BorderPane; 
import javafx.scene.layout.HBox; 
import javafx.scene.layout.Pane; 
import javafx.scene.layout.VBox; 
import javafx.scene.shape.Line; 
import javafx.scene.shape.Rectangle; 
import javafx.stage.Stage; 

public class HW2 extends Application { 

    @Override 
    public void start(Stage primaryStage) throws Exception { 
     BorderPane pane = new BorderPane(); 
     Button enter = new Button("Display"); 
     Label number = new Label("Enter in Order:"); 
     TextField input = new TextField(); 
     HBox v = new HBox(); 
     HBox h = new HBox(); 
     Pane p = new Pane(); 
     h.getChildren().addAll(number, input, enter); 
     h.setSpacing(10); 
     pane.setBottom(h); 
     // pane.setCenter(v); 
     pane.setCenter(p); 
     h.setAlignment(Pos.CENTER); 
     v.setAlignment(Pos.CENTER); 
     Scene scene = new Scene(pane, 900, 900); 
     primaryStage.setTitle("Square Fractal"); 
     primaryStage.setScene(scene); 
     primaryStage.show(); 
     enter.setOnAction(e -> { 
      points(Integer.parseInt(input.getText()), p); 
     }); 

    } 

    public static void main(String[] args) { 
     launch(args); 
    } 

    public static void points(int x, Pane p) { 
     p.getChildren().clear(); 
      draw(200, 350, 350, p, x); 
    } 

    public static void draw(double size, double a, double b, Pane p) { 
     Rectangle r = new Rectangle(a,b,size,size); 
     p.getChildren().add(r); 
    } 

    public static void draw(double size, double a, double b, Pane p, double amt) { 
     if (amt == 0) { 
      draw(size, a, b, p); 
     } else { 
      draw(size, a, b, p); 
      double size2 = size/3; 
      double a1, a2, a3, b1, b2, b3; 
      a1 = a - 3 * size2 + size2; 
      a2 = a + 3 * size2 + size2; 
      a3 = a + size2; 
      b1 = b + 3 * size2 + size2; 
      b2 = b - 3 * size2 + size2; 
      b3 = b + size2; 


      draw(size2, a1, b1, p, amt - 1); 
      draw(size2, a1, b2, p, amt - 1); 
      draw(size2, a2, b1, p, amt - 1); 
      draw(size2, a2, b2, p, amt - 1); 
      draw(size2, a1, b3, p, amt - 1); 
      draw(size2, a2, b3, p, amt - 1); 
      draw(size2, a3, b1, p, amt - 1); 
      draw(size2, a3, b2, p, amt - 1); 
     } 
    } 

} 

für das Stück Code `

double size2 = size/3; 
    double a1, a2, a3, b1, b2, b3; 
    a1 = a - 3 * size2 + size2; 
    a2 = a + 3 * size2 + size2; 
    a3 = a + size2; 
    b1 = b + 3 * size2 + size2; 
    b2 = b - 3 * size2 + size2; 
    b3 = b + size2; 

wenn ich ersetzen Sie es mit

double size2 = size/3; 
double a1, a2, a3, b1, b2, b3; 
a1 = a - 4 * size2; 
a2 = a + 4 * size2; 
a3 = a + size2; 
b1 = b + 4 * size2; 
b2 = b - 4 * size2; 
b3 = b + size2; 

die Rechteck-Positionen alle Platz aus sind.

Was ist der Unterschied zwischen 4 * size2 vs 3 * size2 + size2, und warum funktioniert das ehemalige nicht?

Answer 1

Blick Lassen Sie uns bei diesen zwei Reihen:

a1 = a - 3 * size2 + size2; // original 
a1 = a - 4 * size2; // replaced 

Also, was passiert in der ersten? Sie nehmen a subtrahieren 3 * size2 von ihm, dann fügen Sie size2 hinzu.

Die zweite nimmt a und subtrahiert 4 * size2 daraus.

Die erste Zeile subtrahiert ziemlich viel nur 2 mal size2 von a, während die zweite subtrahiert 4 mal size2.

Answer 2

Mathematisch, (x = y + 3y + y)! = (X = 4y). Die erste Gleichung in Ihrer Frage ist einfach (x = 5y) und das ist nur gleich (x = 4y), wenn y = 0 ist.

Wirklich ist das Problem hier Reihenfolge der Operationen. Der Arbeitscode wird interpretiert als ((a - (3 * size2)) + size2). Ihre Revision wird interpretiert als (a - (4 * size2)) und diese beiden werden niemals gleich sein.