Traduzindo código de rubi para java

Question

Eu nunca usei Ruby, mas preciso traduzir esse código para Java.

Alguém pode me ajudar.

Este é o código em Ruby.

DEFAULT_PRIOR = [2, 2, 2, 2, 2]
## input is a five-element array of integers
## output is a score between 1.0 and 5.0
def score votes, prior=DEFAULT_PRIOR
posterior = votes.zip(prior).map { |a, b| a + b }
sum = posterior.inject { |a, b| a + b }
posterior.
map.with_index { |v, i| (i + 1) * v }.
inject { |a, b| a + b }.
to_f / sum
end

Eu o obtive daqui, talvez algumas pistas possam ser encontradas lá. é sobre calcular médias

Como classificar os produtos com base na entrada do usuário

Esta foi a solução. Caso alguém precise

    static final int[] DEFAULT_PRIOR = {2, 2, 2, 2, 2};

static float  score(int[] votes) {
    return score(votes, DEFAULT_PRIOR);
}

private static float score(int[] votes, int[] prior) {

    int[] posterior = new int[votes.length];
    for (int i = 0; i < votes.length; i++) {
        posterior[i] = votes[i] + prior[i];
    }
    int sum = 0;
    for (int i = 0; i < posterior.length; i++) {
        sum = sum + posterior[i];
    }

    float sumPlusOne = 0;
    for (int i = 0; i < posterior.length; i++) {
        sumPlusOne = sumPlusOne + (posterior[i] * (i + 1));
    }
    return sumPlusOne / sum;
}

Answer 1

O código faz as seguintes coisas:

Ele estabeleceu uma constante nomeada DEFAULT_PRIOR (Java equivalente seria uma variável final estática) para uma matriz contendo o número 2 cinco vezes. Em java:

static final int[] DEFAULT_PRIOR = {2,2,2,2,2};

Ele define um método de dois argumentos nomeado, onde o segundo argumento padrão DEFAULT_PRIOR. Em Java, isso pode ser alcançado com sobrecarga:

float score(int[] votes) {
    return score(votes, DEFAULT_PRIOR);
}

Dentro do método de pontuação, ele faz o seguinte:

posterior = votes.zip(prior).map { |a, b| a + b }

Isso cria uma matriz posterior, onde cada elemento é a soma do elemento correspondente nos votos e o elemento correspondente no anterior (ou seja, posterior[i] = votes[i] + prior[i]).

sum = posterior.inject { |a, b| a + b }

Isso define a soma para ser a soma de todos os elementos em posterior.

posterior.
map.with_index { |v, i| (i + 1) * v }.
inject { |a, b| a + b }.
to_f / sum

Esse bit multiplica cada elemento posterior com seu índice mais um e depois resume isso. O resultado é convertido em um flutuador e depois dividido por sum.

Em Java, você iterava o mais posterior com for-loop (não para e nem cada) e em cada iteração adicionar (i + 1) * posterior[i] (Onde i é o índice do for-loop) para uma variável tmp, que você define como 0 antes do loop. Então você lançaria tmp para float e dividi -lo por sum.