2

我开发了一个程序来解决基本物理学中的运动学方程。要解决这个问题，需要 5 个可能的变量中的 3 个。已知 3 个变量有 10 种不同的组合。我编写了类似于下面两个代码块的 10 个场景

    // If we have acceleration, final velocity, and initial velocity
    if (varEntered[0] == true && varEntered[1] == true && varEntered[2] == true)
    {
        double acceleration = knownVariables[0];        //Setting acceleration
        double finalVelocity = knownVariables[1];       //Setting finalVelocity
        double initVelocity = knownVariables[2];        //Setting initVelocity

        double time = ((finalVelocity - initVelocity)/acceleration);        //Finding time using an equation
        double distance = ((finalVelocity + initVelocity)*((0.5)*time));    //Finding distance using an equation

        System.out.println("The time is " + time + " seconds");             //Printing time
        System.out.println("The distance is " + distance + " meters");      //Printing distance
    }




    //If we have distance, final velocity, initial velocity
    if (varEntered[3] == true && varEntered[1] == true && varEntered[2] == true)
    {
        //Known variables
        double distance = knownVariables[3];        //Acceleration
        double finalVelocity = knownVariables[1];   //Final Velocity
        double initVelocity = knownVariables[2];    //Initial Velocity

        // Unknown variables
        double time = (distance/((0.5)*(finalVelocity + initVelocity)));    //Time
        double acceleration = ((finalVelocity - initVelocity)/time);        //Acceleration

        System.out.println("The time is " + time + " meters/second");                               //Printing time
        System.out.println("The acceleration is " + acceleration + " meters/second^2");     //Printing distance
    }

这些看起来非常相似，但却是不同的场景。作为一个编程初学者，我想知道是否可以修改我使用的算法以缩短代码。如果需要更多信息，我将非常乐意提供。

4

4 回答 4

0

如果你小心你的依赖关系，你可以摆脱 5 个案例，每个案例 1 个计算，而不是 10 个案例，每个案例 2 个计算。为此，您必须确保没有两个变量直接相互依赖。如果发生这种情况，那么当两个变量都未知时，您将不走运。

一种方法是获取变量列表并根据以下三个计算每个变量（当您到达列表末尾时环绕），如下例所示。在此示例中，solveAll 采用一个双精度数组，未知数设置为 Double.MAX_VALUE，并将未知数设置为正确的值。（如果有两个以上的未知数，你会得到一个无限递归。）

// Really should use enum instead of constant ints, and an EnumMap instead of an array.
public final static int ACCELERATION = 0;
public final static int FINALVELOCITY = 1;
public final static int INITVELOCITY = 2;
public final static int DISTANCE = 3;
public final static int TIME = 4;

private double[] vars;

public void solveAll(double[] vars) {
    this.vars = vars;
    for (int i=ACCELERATION; i<=TIME; i++) {
        get(i);
    }
}

private double get(int v) {
    if (vars[v] != Double.MAX_VALUE) {
        return vars[v];
    }

    switch (v) {
    case ACCELERATION:
        return (vars[ACCELERATION] = (get(FINALVELOCITY)*get(FINALVELOCITY) - get(INITVELOCITY)*get(INITVELOCITY)) / (2*get(DISTANCE)));
    case FINALVELOCITY:
        return (vars[FINALVELOCITY] = 2*get(DISTANCE)/get(TIME) - get(INITVELOCITY));
    case INITVELOCITY:
        return (vars[INITVELOCITY] = get(DISTANCE)/get(TIME) - get(ACCELERATION)*get(TIME)/2);
    case DISTANCE:
        return (vars[DISTANCE] = (get(FINALVELOCITY) - get(ACCELERATION)*get(TIME)/2) * get(TIME));
    case TIME:
        return (vars[TIME] = (get(FINALVELOCITY) - get(INITVELOCITY)) / get(ACCELERATION));
    }

    return Double.MAX_VALUE; // Bad variable index
}
于 2012-10-17T20:57:40.300 回答
0

您应该定义一个接受三个数字并执行一般计算的函数。对于初学者，请尝试本教程。然后你可以调用你的函数两次，每次使用不同的变量集。

于 2012-10-17T00:48:48.927 回答
0

我会使用地图并做这样的事情（警告：伪代码）：

import java.util.HashMap;
import java.util.Map;

 Map<String,double> map=new HashMap<String, double>();

使用所有已知值初始化地图，例如：

 map.put("initVelocity", 0.35);

然后您可以定义以下函数：

void  calculateValues(Map<double,String> map){

if( map.containsKey("initVelocity") && map.containsKey("finalVelocity") && map.containsKey("acceleration")){
map.put("time",((map.get("finalVelocity") - map.get("initVelocity")/map.get("acceleration"));    
}

add all the other algorithms here in the same way!!!

}

此函数采用已在 HashMap 中定义的值并尝试计算缺失的参数。通常需要在地图上多次调用它，直到设置所有参数。您可以执行以下操作：

while( the map has not all values set){
calculateValues(map);
}

此外，您可以确保（通过将此条件添加到 if 语句）仅在尚未设置结果值时调用任何算法。但不要太担心这一点。

于 2012-10-17T01:19:11.277 回答
0

从我注意到的情况来看，似乎每个变量都与一个数字相关联。您可以完全消除所有可能的情况，并在五个变量中的每一个上都有 if 条件；通过这个首先识别3个变量并初始化局部变量。它们在分配时是相互独立的，因此没有理由进行那么多组合。这将大大缩短代码。

下一步是减少您拥有的组合数量。我能想到的最好的事情是找出你需要计算的两个值并使用公式，换句话说，另一个 if else 语句块。下面是代码的样子：

//initialize all to 0
double acceleration = 0;
double distance = 0;        
double finalVelocity = 0;
double initVelocity = 0;
double time = 0;

//place the proper values for each 
if (varEntered[0] == true){
    acceleration = knownVariables[0];
}
if (varEntered[1] == true){
    finalVelocity = knownVariables[1];
}
if (varEntered[2] == true){
    initVelocity = knownVariables[2];
}
if (varEntered[3] == true){
    distance = knownVariables[3];
}
if (varEntered[4] == true){
   time = knownVariables[4];
}

// now you have 10 cases 
if(varEntered[0] == false && varEntered[1] == false){
//use the formulas here
} else if (varEntered[0] == false && varEntered[2] == false){
//use other formula here
}// repeat for the next 8, with each time you change the condition and formulas 
//like you have it. Also, I noticed that you missed the else in your conditionals; 
//it is more efficient if you use if-else clauses when only one should execute every time you run the code.

希望这可以帮助。

随意将其复制出来，填写其余部分并尝试一下。

于 2012-10-17T01:44:26.757 回答