Блог

Приведенный ниже код правильный, но я хочу сократить этот код.

Напишите программу на Java для ввода 10 чисел в одномерный массив и упорядочьте их таким образом, чтобы за всеми четными числами следовали все нечетные числа.

 int a[] = new int[6];
int b[] = new int[6];
int i, j;
int k = 0;
System.out.println("enter array");
for (i = 0; i < 6; i  ) {  
    a[i] = sc.nextInt();
}
for (j = 0; j < 6; j  ) {
    if (a[j] % 2 == 0) {
        b[k] = a[j];
        k  ;
    }
}
for (j = 0; j < 6; j  ) {
    if (a[j] % 2 != 0) {
        b[k] = a[j];
        k  ;
    }
}
System.out.println("out-put");
for (i = 0; i < 6; i  ) {  
    System.out.println(b[i]);
}
  

Могу ли я упорядочить четные и нечетные числа в одном цикле for вместо двух циклов for? Я использую два цикла for для переноса четных и нечетных чисел в b[] массив. Пожалуйста, сократите код. Один для обхода цикла для проверки четного числа и второй для нечетных чисел.

Вот простая программа для вас.

 import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

/**
 *
 * @author Momir Sarac
 */
public class GroupByEvenAndOddNumbers {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // create a collection
        List<Integer> listOfNumbers = new ArrayList<>();
        // do code within a loop for 10 times
        for(int i=0;i<10;i  )
        {
            //print to screen this text
            System.out.println("Input your number:");
            //get next input integer
            int number = scanner.nextInt();
            // add it to collection
            listOfNumbers.add(number);
        }
        // sort this collection, list of numbers
        // convert all numbers(positive and negative ) within to 0 or 1 depending whether or not they are even or odd and sort them accordignaly.
        Collections.sort(listOfNumbers, Comparator.comparingInt(n -> Math.floorMod(n, 2)));
        //print sorted collection
        System.out.println("Ordered list ..."   listOfNumbers);
    }
}
  

В этой версии четное копируется в начало, а нечетное — в конец.

 static int[] sortEvenOdd(int... nums) {
    int even = 0, odd = nums.length, ret[] = new int[nums.length];
    for (int num : nums)
        if (num % 2 == 0)
            ret[even  ] = num;
        else
            ret[--odd] = num;
    return ret;
}

public static void main(String[] args) {
    int[] arr = {1, 3, 2, 4, 7, 6, 9, 10};
    int[] sorted = sortEvenOdd(arr);
    System.out.println(Arrays.toString(sorted));
}
  

С принтами

 [2, 4, 6, 10, 9, 7, 3, 1]
  

Этот код поможет вам разделить четные и нечетные числа.

 // java code to segregate even odd 
// numbers in an array 
public class GFG { 

// Function to segregate even 
// odd numbers 
static void arrayEvenAndOdd( 
            int arr[], int n) 
{ 

    int i = -1, j = 0; 
    while (j != n) { 
        if (arr[j] % 2 == 0) 
        { 
            i  ; 

            // Swapping even and 
            // odd numbers 
            int temp = arr[i]; 
            arr[i] = arr[j]; 
            arr[j] = temp; 
        } 
        j  ; 
    } 

    // Printing segregated array 
    for (int k = 0; k < n; k  ) 
        System.out.print(arr[k]   " "); 
} 

// Driver code 
public static void main(String args[]) 
{ 
    int arr[] = { 1, 3, 2, 4, 7, 
                        6, 9, 10 }; 
    int n = arr.length; 
    arrayEvenAndOdd(arr, n); 
 } 
} 
  

Поскольку у вас нет никаких требований к порядку четных и нечетных чисел в их соответствующей половине массива, вы можете просто назначить их соответствующей части массива при их вводе. Поэтому вам просто нужно использовать две переменные «counter», одну для левой, которая начинается с нуля и увеличивается, и одну для правой, которая начинается с длины вашего массива минус один и уменьшается. Затем вы можете добавить свои числа, проверяя, является ли одно четным, добавьте, назначьте его с увеличенным значением вашего левого счетчика, и если одно нечетное, назначьте его с уменьшенным значением вашего правого счетчика. Делайте это в цикле, пока ваш левый счетчик не станет больше правого. Я создал простой пример, в котором я не проверял NumberFormatException при разборе строки на int:

 import java.util.Arrays;
import java.util.Scanner;

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

        System.out.print("Enter length of array: ");
        final int arrayLength = Integer.parseInt(scanner.nextLine());

        int intArray[] = new int[arrayLength];
        for (int l = 0, r = arrayLength - 1; l <= r; ) {
            System.out.print("Enter new array value: ");
            int v = Integer.parseInt(scanner.nextLine());
            intArray[v % 2 == 0 ? l   : r--] = v;
        }

        System.out.println("Output: "   Arrays.toString(intArray));
    }
}
  

Пример ввода / вывода:

 Enter length of array: 6
Enter new array value: 1
Enter new array value: 2
Enter new array value: 3
Enter new array value: 4
Enter new array value: 5
Enter new array value: 6
Output: [2, 4, 6, 5, 3, 1]
  

Я рекомендую ознакомиться с streams, они значительно упростят для вас обработку коллекции

 List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        numbers.add(6);
        numbers.add(7);
        numbers.add(8);
        numbers.add(9);
        numbers.add(0);

        //this way you simply traverse the numbers twice and output the needed ones
        System.out.println(numbers.stream()
                .filter(x->x%2==0)
                .collect(Collectors.toList()));
        System.out.println(numbers.stream()
                .filter(x->x%2==1)
                .collect(Collectors.toList()));

        //this way you can have the numbers in two collections
        numbers.forEach(x-> x%2==0? addItToEvenCollection : addItToOddCollection);

        //this way you will have a map at the end. The boolean will tell you if the numbers are odd or even, 
        // and the list contains the numbers, in order of apparition in the initial list
        numbers.stream().collect(Collectors.groupingBy(x->x%2==0));
  

Эффективный способ проверить, является ли число четным, заключается в использовании if ( (x amp; 1) == 0)