Question

我有这堂课：

public class Vehicle {
    private float speed;

     public void decelerationSpeed()
     {
         --speed;
     }  
}

每次调用decelerationSpeed方法时，速度变量减1。

我需要以这种方式更改decelerationSpeed方法，如果速度变量达到零且已调用decelerationSpeed方法，则不必更改速度值。

在本教程中，我不能使用if else或任何其他条件运算符（我认为我必须使用模运算和除法运算）。

Answer 1

除非我们的速度为零，否则我们总是希望减去1，因此模数运算是合适的，因为0 mod y是0，而对于我们希望x mod y导致的任何其他数字1 {1}}。符合这些标准的模运算是x % (x - 1)然后两个极点情况是1和2，其中1表示模数为0而2 mod 1没有效果。因此，我们通过初步添加和后续减法将它们从可能的值集中排除：

   public void decelerationSpeed()
     {
        speed = speed + 2;
        speed = speed - ((speed) % (speed-1));
        speed = speed - 2;
     }

Answer 2

使用javas浮点到整数转换的一个很好的解决方案如下所示：

speed -= (int) ((speed / (speed + 1.0) + 0.6));

基本思想是java通过丢弃小数位将浮点数转换为整数。因此，我们只需要一种方法来生成值v，其方式为0 <= v < 1，如果输入为0且1 <= v < 2为其他方式。如果speed / (speed + 1.0)为0，则speed提供0的属性，否则它至少为0.5且最多（数学上至少）接近1.只需将所有这一切移动0.6（以确保我们确定高于1）我们已经得到了需求序列。剩下的就是切掉小数位，我们就在那里。

真正丑陋（但更简单）的方式如下：

void decrement()
{
    try{
        int throwaway = 1 / speed;
        speed--;
    }catch(ArithmeticException e){
        //just ignore the exception
    }
}

Answer 3

我不知道是否允许位转换，但这是一个解决方案：

speed -= 1;

int bits = Float.floatToRawIntBits(speed);
bits &= (bits >>> 31) - 1;
speed = Float.intBitsToFloat(bits);

所以，首先我们得到符号位（bits >>> 31）并从中减去一个得到掩码：正数为0xffffffff，负数为0x00000000。使用此功能会将每个负数更改为+0。

这不是一个漂亮的解决方案，但它确实有效。

Answer 4

如果您可以使用Math.sqrt功能，则可以使用以下公式。

(val+|val|)/2

基本上任何负数都会从自身减去0。

显示一些显示它的代码

public static float decelerationSpeed(float speed) {
    speed -= 1; // subtract
    // use (val+|val|)/2 to zero out any negative numbers. Divide by 2 to return to origional number
    return (float) (speed+Math.sqrt(speed*speed))/2f;
}

public static void main(String [] args) throws Exception {
    System.out.println(assertF(decelerationSpeed(-10), 0));
    System.out.println(assertF(decelerationSpeed(10), 9));

    System.out.println(assertF(decelerationSpeed(-2), 0));
    System.out.println(assertF(decelerationSpeed(2), 1));

    System.out.println(assertF(decelerationSpeed(-1), 0));
    System.out.println(assertF(decelerationSpeed(1), 0));

    System.out.println(assertF(decelerationSpeed(-0), 0));
    System.out.println(assertF(decelerationSpeed(0), 0));
}

public static float assertF(float actual, float expected) {
    if(actual != expected) throw new IllegalStateException("Expected "+expected+" but got "+actual);
    return actual;
}

Answer 5

这就是我回答这个问题的方法。传入int，short，float或double等的作品：

public class HelloWorld
{
  private static float speed = 1113; // initial speed
  private static short smallIncrement = 13;

  public static void main(String[] args)
  {
      decelerateAndReturnSpeed(2.33); // prints 1110.67
      decelerateAndReturnSpeed(7.33f); // prints 1103.3401
      decelerateAndReturnSpeed(113); // prints 990.3401
      decelerateAndReturnSpeed(smallIncrement); // prints 977.3401
  }

  public static float decelerateAndReturnSpeed(double vAmt)
  {
    speed -= vAmt;
    if (speed < 0) speed = 0;
    System.out.println(speed);
    return speed;
  }
}

现在，这是因为编译器计算如下，使用隐式强制转换：

speed = (float)(speed -vAmt);  // same as speed =- vAmt

减少变量，直到在java中达到一个数字

5 个答案: