Sprawdź, czy liczba jest parzysta czy nieparzysta

Jak określić, czy dana liczba jest parzysta czy nieparzysta? Od dawna chciałem to rozgryźć i do niczego nie doszedłem.

Możesz użyć operatora modułu, ale może to być powolne. Jeśli jest to liczba całkowita, możesz:

if ( (x & 1) == 0 ) { even... } else { odd... }

Dzieje się tak, ponieważ niski bit będzie zawsze ustawiany na nieparzystą liczbę.

if((x%2)==0)
   // even
else
   // odd

Jeśli reszta po podzieleniu przez 2 wynosi 0, jest parzysta. %jest operatorem, który ma otrzymać resztę.

Operator reszty,%, poda resztę po podzieleniu przez liczbę.

Więc n % 2 == 0będzie prawdą, jeśli n jest parzyste, a fałszem, jeśli n jest nieparzyste.

Każda liczba parzysta jest podzielna przez dwa, niezależnie od tego, czy jest to liczba dziesiętna (ale liczba dziesiętna, jeśli występuje, również musi być parzysta). Możesz więc użyć %operatora (modulo), który dzieli liczbę po lewej stronie przez liczbę po prawej i zwraca resztę ...

boolean isEven(double num) { return ((num % 2) == 0); }

Chciałbym polecić

Java Puzzlers: Traps, Pitfalls, and Corner Cases Book autorstwa Joshua Blocha i Neala Gaftera

Istnieje krótkie wyjaśnienie, jak sprawdzić, czy liczba jest nieparzysta. Pierwsza próba to coś podobnego do tego, co próbował @AseemYadav:

public static boolean isOdd(int i) {
     return i % 2 == 1;
}

ale jak wspomniano w książce:

gdy operacja reszty zwraca wynik różny od zera, ma ten sam znak co lewy operand

więc ogólnie, gdy mamy ujemną liczbę nieparzystą, zamiast tego 1otrzymamy -1jako wynik i%2. Możemy więc skorzystać z rozwiązania @Camilo lub po prostu:

public static boolean isOdd(int i) {
     return i % 2 != 0;
}

ale generalnie najszybszym rozwiązaniem jest użycie operatora AND, takiego jak @lucasmo, napisz powyżej:

public static boolean isOdd(int i) {
     return (i & 1) != 0;
}

@Edit Warto również wskazać, Math.floorMod(int x, int y);który radzi sobie dobrze z ujemną dywidendą, ale może również zwrócić, -1jeśli dzielnik jest ujemny

Działa dla liczb dodatnich lub ujemnych

int start = -3;
int end = 6;

for (int val = start; val < end; val++)
{
    // Condition to Check Even, Not condition (!) will give Odd number
    if (val % 2 == 0) 
    {
        System.out.println("Even" + val);
    }
    else
    {
        System.out.println("Odd" + val);
    }
}

Najmniej znaczący bit (prawy) może być użyty do sprawdzenia, czy liczba jest parzysta czy nieparzysta. Dla wszystkich liczb nieparzystych, najbardziej prawy bit ma zawsze 1 w reprezentacji binarnej.

public static boolean checkOdd(long number){
   return ((number & 0x1) == 1);
}

Jeśli moduł podanej liczby jest równy zero, jest to liczba parzysta, w przeciwnym razie liczba nieparzysta. Poniżej znajduje się metoda, która to robi:

public void evenOrOddNumber(int number) {
  if (number % 2 == 0) {
    System.out.println("Number is Even");
   } else {
    System.out.println("Number is odd");
  }
 }

Ten następujący program może obsługiwać duże liczby (liczba cyfr większa niż 20)

package com.isEven.java;
import java.util.Scanner;

public class isEvenValuate{

public static void main(String[] args) {            

        Scanner in = new Scanner(System.in);
        String digit = in.next();

        int y = Character.getNumericValue(digit.charAt(digit.length()-1));

        boolean isEven = (y&1)==0;

        if(isEven)
            System.out.println("Even");
        else
            System.out.println("Odd");

    }
}

Oto wynik:

  122873215981652362153862153872138721637272
  Even

Możesz użyć operatora modułu, ale może to być powolne. Bardziej wydajnym sposobem byłoby sprawdzenie najniższego bitu, ponieważ to określa, czy liczba jest parzysta czy nieparzysta. Kod wyglądałby mniej więcej tak:

public static void main(String[] args) {        
    System.out.println("Enter a number to check if it is even or odd");        
    System.out.println("Your number is " + (((new Scanner(System.in).nextInt() & 1) == 0) ? "even" : "odd"));        
}

Możesz zrobić tak:

boolean is_odd(int n) {
    return n % 2 == 1 || n % 2 == -1;
}

Dzieje się tak, ponieważ Java w swojej operacji modulo ma znak dywidendy, po lewej stronie: n. Tak więc w przypadku dywidend negatywnych i pozytywnych modulo ma ich znak.

Oczywiście operacja bitowa jest szybsza i zoptymalizowana, wystarczy udokumentować wiersz kodu za pomocą dwóch lub trzech krótkich słów, co zwiększa czytelność.

Inny łatwy sposób na zrobienie tego bez użycia warunku if / else (działa zarówno dla liczb dodatnich, jak i ujemnych):

int n = 8;
List<String> messages = Arrays.asList("even", "odd");

System.out.println(messages.get(Math.abs(n%2)));

Dla Nieparzystego nie. Wyrażenie zwróci „1” jako resztę, dając

messages.get (1) = 'nieparzyste' i dlatego wypisuje 'nieparzyste'

w przeciwnym razie wypisywane jest „parzyste”, gdy wyrażenie zwraca wynik „0”

package isevenodd;
import java.util.Scanner;
public class IsEvenOdd {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("Enter number: ");
        int y = scan.nextInt();       
        boolean isEven = (y % 2 == 0) ? true : false;
        String x = (isEven) ? "even" : "odd";  
        System.out.println("Your number is " + x);
    }
}

Oto przykład, aby określić, czy dana liczba jest parzysta czy nieparzysta,

import java.util.Scanner;

public class EvenOdd
{
   public static void main(String[] args)
   {
      int a;
      System.out.println("Please enter a number to check even or odd:");
      Scanner sc = new Scanner(System.in);
      a = sc.nextInt();

      if(a % 2 == 0)
      {
         System.out.println("Entered number is an even number");
      }
      else
      {
         System.out.println("Entered number is an odd number");
      }
   }
}

Cóż, istnieje wiele sposobów, aby ustalić to samo. Zapoznaj się z tym źródłem, aby uzyskać więcej przykładów, aby znaleźć podaną liczbę parzystą lub nieparzystą.

Oto pełny przykład: -

import java.text.ParseException;

public class TestOddEvenExample {
    public static void main(String args[]) throws ParseException {

        int x = 24;
        oddEvenChecker(x);

        int xx = 3;
        oddEvenChecker(xx);
    }

    static void oddEvenChecker(int x) {
        if (x % 2 == 0)
            System.out.println("You entered an even number." + x);
        else
            System.out.println("You entered an odd number." + x);
    }
}

    /**
     * Check if a number is even or not using modulus operator.
     *
     * @param number the number to be checked.
     * @return {@code true} if the given number is even, otherwise {@code false}.
     */
    public static boolean isEven(int number) {
        return number % 2 == 0;
    }

    /**
     * Check if a number is even or not using & operator.
     *
     * @param number the number to be checked.
     * @return {@code true} if the given number is even, otherwise {@code false}.
     */
    public static boolean isEvenFaster(int number) {
        return (number & 1) == 0;
    }

źródło