Блог

Я использую List структуру java ():

 var nums = List.of( 3, 9, 7, 12, 20, 4, 11, 9, 21, 6, 8, 10 );
 

Благодаря этому использованию я выполняю следующую программу без необходимости использования повторяющихся циклов:

     package averagesumwithoutcycles;
    import java.util.*;
    import java.util.List;
    
    public class SumaSinCiclos {
        
        private static int suma = 0;
    
    public static void main(String[] args) {
        int[] nums = {3, 9, 7, 12, 20, 4, 11, 9, 21, 6, 8, 10};
        System.out.println(average(nums, 0));
    }
    
    public static float average(int n[], int pos){
        float resultado = (float)suma /(float)n.length;
        if(pos < n.length) {
            suma = suma   n[pos];
            average(n, pos   1);
            System.out.println(resultado);
        }
        return resultado;
    }
        
    }
 

До сих пор я добился следующего:

• Сумма элементов массива
• Количество элементов в массиве
• Результат деления (среднее значение)

Мой вопрос заключается в следующем, основываясь на моем коде, как я могу суммировать элементы ( array ), вычислять среднее значение и фильтровать те элементы, которые меньше среднего.

Примечание: важно получить эти данные без использования повторяющихся циклов

Вот наилучший возможный ответ, на мой взгляд. Он использует внутренние циклы, но любое возможное решение для получения суммы массива требует цикла (итеративного или рекурсивного).

 import java.util.Arrays;
import java.util.stream.IntStream;

class Main {  
    private static int suma = 0;

    public static void main(String[] args) {
        int[] nums = {3, 9, 7, 12, 20, 4, 11, 9, 21, 6, 8, 10};
        for (int num : nums) {
            System.out.println(num);
        }
        nums = filter(nums, average(nums));
        System.out.println("____________n");
        for (int num : nums) {
            System.out.println(num);
        }
    }
    
    public static float average(int[] n){
        float suma = IntStream.of(n).sum();
        return suma / n.length;
    }
    
    public static int[] filter(int[] nums, float average) {
        return Arrays.stream(nums).filter(x -> x >= average).toArray();
    }
}
 

Вы всегда можете сделать что-то подобное (но это громоздко).

 int[] vals = {10,2,8}; 
int sum = 0;
sum  = vals[0];
sum  = vals[1];
sum  = vals[2];
double avg = (double)sum/vals.length;

List<Integer> lessThan = new ArrayList<>();
if (vals[0] < avg) {
  lessThan.add(vals[0]);
}
if (vals[1] < avg) {
  lessThan.add(vals[1]);
}
if (vals[2] < avg) {
  lessThan.add(vals[2]);
}
System.out.println(lessThan); // prints 2

 

 var nums = List.of( 3, 9, 7, 12, 20, 4, 11, 9, 21, 6, 8, 10 );

int sum = 0;
for (int v : nums) {
   sum =v;
}
double avg = (double)sum/v.size();
 

как только у вас будет среднее значение, вы можете найти те, которые меньше, следующим образом.

 vars lessThan = new ArrayList<>();
for (int v : nums) {
    // store the numbers that are less than avg in the list.
}
Then print them here.
 

Может быть, я что-то упускаю, но, похоже, вы решили проблему. В вашем коде у вас есть сумма элементов и среднее значение, и вы не используете явный цикл.

Единственная проблема заключается в том, что те элементы, которые меньше среднего. Возможным решением может быть использование выделенной рекурсивной функции с того момента, как вы завершили свою первую рекурсию (передайте все элементы и сверьте их со средним значением [у вас уже есть] один за другим при рекурсии).

Может быть, что-то вроде:

 public static void main(String[] args) {
    int[] nums = {3, 9, 7, 12, 20, 4, 11, 9, 21, 6, 8, 10};
    System.out.println(average(nums, 0, nums)); // Added "nums" again
}

public static float average(int n[], int pos, int originalElements[]){
    float resultado = (float)suma /(float)n.length;
    if(pos < n.length) {
        suma = suma   n[pos];
        average(n, pos   1, originalElements);
        System.out.println(resultado);
    } else {
        // you will get hete only ONCE, in case pos = n.length
        // note that in this state, "resultado" contains the original array's average
        checkSmallThanAverage(resultado, 0, originalElements);
    }
    return resultado;
}

public static void checkSmallThanAverage(float resultado, int pos, int originalElements[]) {
     if(pos < originalElements.length) {
         if (originalElements[pos] < resultado) {
             System.out.println("element "   originalElements[pos]   " is smaller than average");
         }
         checkSmallThanAverage(resultado, pos 1, originalElements);
     }
}