Übersetzen von Ruby-Code zu Java

Question

Ich habe noch nie verwendet, Rubin, aber Notwendigkeit, diesen Code zu Java zu übersetzen.

Kann mir jemand helfen.

Dies ist der Code in 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

Ich erhielt es von hier aus so vielleicht können einige Hinweise dort zu finden. es geht um die Berechnung mittelt

Wie Rang Produkte auf Basis von Benutzereingaben

Das war die Lösung. Für den Fall, muss jemand es

    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

Der Code führt die folgenden Dinge:

Es Satz eine Konstante namens DEFAULT_PRIOR auf ein Array (Java-Äquivalent eine statische endgültige Variable sein würde) die Zahl 2 fünfmal enthält. In Java:

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

Es definiert eine zweiargumentigen Methode mit dem Namen Score, wo die zweite Argument standardmäßig DEFAULT_PRIOR. In Java kann dies mit Überlastung erreicht werden:

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

Innerhalb der Partitur Methode, geschieht Folgendes:

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

Dies erzeugt einen Array posterior, wobei jedes Element die Summe des entsprechenden Elements in Stimmen und das entsprechende Element in vor (d.h. posterior[i] = votes[i] + prior[i]).

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

Hier wird die Summe aller Elemente in posterior summieren.

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

Dieses Bit multipliziert jedes Element in posterior mit seinem Index plus eins und summiert dann die. Das Ergebnis wird in einem Schwimmer umgewandelt und dann durch sum geteilt.

In Java würden Sie über posterior mit for-Schleife durchlaufen (nicht foreach) und in jeder Iteration Add (i + 1) * posterior[i] (wo i ist der Index der for-Schleife) auf eine Variable tmp, die Sie auf 0, bevor die Schleife gesetzt. Dann würden Sie tmp zu float geworfen und es durch sum teilen.