Two integers x & y

Question

Given two int values, print whichever value is larger. However if the two values have the same remainder when divided by 5, then the print the smaller value. However, in all cases, if the two values are the same, print 0.

This is what I have so far:

public static void main(String[] args)
{
    Scanner scan = new Scanner(System.in);

    int x = scan.nextInt();
    int y = scan.nextInt();

    if(x > y || (x%5 == y%5 && y > x))
    {
        System.out.println(x);
    }
    else if (y > x || (x%5 == y%5 && x > y ))
    {
        System.out.println(y);
    }
    else if(x == y)
    {
        System.out.println("0");
    }
}

My score was 79/100 when I sent it to an online judge

What seems to be the problem?

Answer 1

• What condition is the most important?

  It seems like if (a == b) is the most important, which is what you then should handle first and use else for the rest.

• Duplicated logic

  You have written (x%5 == y%5 && y > x) twice in your code.

• Using Math.min or Math.max

  Instead of using if (x > y) and if (x < y) you can let Java find out what is smaller or larger.

  public static void main(String[] args) {
      Scanner scan = new Scanner(System.in);
  
      int x = scan.nextInt();
      int y = scan.nextInt();
  
      if (x == y) {
          System.out.println(0);
      } else if (x % 5 == y % 5) {
          System.out.println(Math.min(x, y));
      } else {
          System.out.println(Math.max(x, y));
      }
  }
  

Note: I can't guarantee that this will give you 100 points. I can't even guarantee that this will give you more points than Caridorc's solution with ternaries. But in my opinion, this is the better solution.

Answer 2

One of the problem, I think, is that you should check if both number are equals before doing anything else. Why bother doing arithmetic computing (in your ifs) for nothing?

Also, you should have a method that solves your problem, and do the IO in the main method, not all-in-one.

But the main problem is that you repeat your conditions. Here x > y is written twice :

if(x > y || (x%5 == y%5 && y > x))

And you repeat x%5 == y%5 twice.

You should first check if their modulos are equal, then check for which is bigger. Which gives something like this :

//Naming is hard in such a case.
private static int computeStuff(int x, int y) {
    if(x == y) {
        return 0;
    }
    if (x % 5 == y % 5) {
        return Math.min(x,y);
    }
    return Math.max(x,y);
}

public static void main(String[] args)
{
    Scanner scan = new Scanner(System.in);

    int x = scan.nextInt();
    int y = scan.nextInt();

    System.out.println(computeStuff(x,y));
}

(Note also the spacing is slightly clearer now)

This way, your computeStuff method has its own responsability and using return makes it clearer (in my opinion). The main method takes care of IO!

Answer 3

Probably it's because of duplicated expressions:

x%5 == y%5

These modulos are more expensive and are evaluated twice if x and y are equal, which means that modulo operation is unneccesary.

Answer 4

This is surely going to be controversial, but I suggest a nested ternary.

• This uses less code, such a trivial problem does not need so much code in my opinion.

• Ternaries are expressions, that are much easier to reason about than statements.

• This is easier to change, as just what is needed is written, avoiding for example the repetition of System.out.println

• This is faster, as the compiler is very good at optimizing ternaries.

• This uses the built-ins Math.min and Math.max to simplify the code and make it nicely fit inside a ternary.

System.out.println( x == y ? 0 :
                      x % 5 == y % 5 ? Math.min(x, y) :
                        Math.max(x, y) );

Answer 5

Two numbers have the same remainder when divided by 5 iff their difference is divisible by 5. So you can save yourself one % operation (which is expensive!) by simply doing:

public static int result(int x, int y) {
    if (x == y) {
        return 0;
    }
    else if ((x-y) % 5 == 0) {
        return Math.min(x, y);
    }
    else {
        return Math.max(x, y);
    }
}