Groovy选举

interface ElectionStrategy {

    Election.ElectionResult elect(Election election)

}

class Election {

    final List<Candidate> candidates = new ArrayList<>()
    final List<Vote> votes = new ArrayList<>()
    int availablePositions
    int maxChoices

    private Election(int availablePositions) {
        this.availablePositions = availablePositions
    }

    void addVote(Vote vote) {
        this.votes << vote
        this.maxChoices = Math.max(maxChoices, vote.preferences.length)
    }

    void addCandidate(String name) {
        this.candidates.add(new Candidate(name: name))
    }

    double calculateQuota(double excess) {
        (votes.size() - excess) / (availablePositions + 1)
    }

    static class ElectionResult {
        List<Round> rounds
        List<Candidate> candidateResults

        List<Candidate> getCandidates(CandidateState state) {
            candidateResults.stream()
                .filter({it.state == state})
                .collect(Collectors.toList())
        }
    }

    ElectionResult elect(ElectionStrategy strategy) {
        strategy.elect(this)
    }

    static enum CandidateState {
        HOPEFUL, EXCLUDED, ALMOST, NEWLY_ELECTED, ELECTED
    }

    @ToString(includeNames = true, includePackage = false)
    static class Candidate {
        String name
        double weighting = 1
        double votes
        CandidateState state = CandidateState.HOPEFUL

        Candidate copy() {
            new Candidate(name: name, weighting: weighting, votes: votes, state: state)
        }
    }

    @ToString
    static class Vote {
        int numVotes
        Candidate[] preferences

        static Vote fromLine(String line, Election election) {
            String[] data = line.split()
            Vote vote = new Vote()
            vote.numVotes = data[0] as int
            int candidateVotes = data.length - 2
            vote.preferences = new Candidate[candidateVotes]
            for (int i = 0; i < vote.preferences.length; i++) {
                int candidate = data[i + 1] as int
                if (candidate > 0) {
                    vote.preferences[i] = election.candidates.get(candidate - 1)
                }
            }
            vote
        }

        void distribute(Round round) {
            double remaining = numVotes
            int choiceIndex = 0
            preferences.eachWithIndex { Candidate entry, int i ->
                if (entry) {
                    double myScore = remaining * entry.weighting
                    entry.votes += myScore
                    remaining -= myScore
                    round.usedVotes[choiceIndex++] += myScore
                }
            }
            round.excess += remaining
        }
    }

    static final ElectionResult fromURL(URL url, ElectionStrategy strategy) {
        BufferedReader reader = url.newReader()
        String[] head = reader.readLine().split()
        int candidates = head[0] as int
        Election stv = new Election(head[1] as int)
        for (int i = 0; i < candidates; i++) {
            stv.addCandidate("Candidate $i") // use a temporary name at first. real names are at the end of the file
        }

        String line = reader.readLine();
        while (line != '0') {
            Vote vote = Vote.fromLine(line, stv)
            stv.addVote(vote)
            line = reader.readLine();
        }
        for (int i = 0; i < candidates; i++) {
            String name = reader.readLine()
            stv.candidates.get(i).name = name
        }
        stv.elect(strategy)
    }

}

class SimonElection implements ElectionStrategy {

    @Override
    Election.ElectionResult elect(Election election) {
        List<Round> rounds = new ArrayList<>()

        int electedCount = 0
        int roundsCount = 0
        double previousExcess = 0
        while (electedCount < election.availablePositions) {
            Round round = new Round(roundsCount, election.maxChoices)
            rounds << round
            double roundQuota = election.calculateQuota(previousExcess)
            roundsCount++
            round.quota = roundQuota
            election.candidates*.votes = 0
            election.votes*.distribute(round)
            List<Election.Candidate> elected = election.candidates.stream()
                    .filter({candidate -> candidate.votes > roundQuota})
                    .collect(Collectors.toList())
            elected.each {
                if (it.state != Election.CandidateState.ELECTED) {
                    electedCount++
                }
                it.state = Election.CandidateState.ELECTED
                it.weighting *= roundQuota / it.votes
            }
            if (elected.isEmpty()) {
                Election.Candidate loser = election.candidates.stream()
                        .filter({it.state == Election.CandidateState.HOPEFUL})
                        .min(Comparator.comparingDouble({it.votes})).get()
                loser.state = Election.CandidateState.EXCLUDED
                loser.weighting = 0
            }
            round.candidates = election.candidates.collect {it.copy()}
            previousExcess = round.excess
        }
        new Election.ElectionResult(rounds: rounds, candidateResults: election.candidates)
    }

}

@ToString
class Round {

    int round
    List<Election.Candidate> candidates = new ArrayList<>()
    double quota
    double[] usedVotes
    double excess

    Round(int round, int maxChoices) {
        this.round = round
        this.usedVotes = new double[maxChoices]
    }

}

// Eeewwww
String s1 = 'hello'
double d1 = Math.floor(10.34)
ArrayList<Integer> l1 = new ArrayList<Integer>()
l1.add(1)
l1.add(2)
l1.add(3)

// Much better.
def s2 = 'hello'
def d2 = Math.floor(10.34)
def l2 = [1, 2, 3]

// It's all the same
assert s1 == s2  // == calls me.equals(other)
assert s1.is(s2) // me.is(other) is Java's reference equality
assert d1 == d2
assert l1 == l2

assert s1.class == s2.class
assert d1.class == d2.class
assert l1.class == l2.class

// This is the same...
for (int i = 0; i < candidates; i++) {
    String name = reader.readLine()
    stv.candidates.get(i).name = name
}

// ...as this, which uses Number.times(Closure)...
candidates.times {
    String name = reader.readLine()
    stv.candidates.get(i).name = name
}

// ...and as this, which uses Range.each{Closure).
(0..<candidates).each {
    String name = reader.readLine()
    stv.candidates.get(i).name = name
}

candidateResults.stream()
    .filter({it.state == state})
    .collect(Collectors.toList())

election.candidates.stream()
    .filter({candidate -> candidate.votes > roundQuota})
    .collect(Collectors.toList())

election.candidates.stream()
    .filter({it.state == Election.CandidateState.HOPEFUL})
    .min(Comparator.comparingDouble({it.votes})).get()    

candidateResults.findAll {it.state == state}

election.candidates
    .findAll {candidate -> candidate.votes > roundQuota}

election.candidates
    .findAll {it.state == Election.CandidateState.HOPEFUL}
    .min {it.votes}

/* Iterates through two sections of the file.
 * The first section is handled with the 'while loop',
 * and the second in the 'for loop'
 */
while (line != '0') {
    Vote vote = Vote.fromLine(line, stv)
    stv.addVote(vote)
    line = reader.readLine()
}

for (int i = 0; i < candidates; i++) {
    String name = reader.readLine()
    stv.candidates.get(i).name = name
}

/* Also iterates through two sections of the file,
 * but by using an Iterator.while(Closure condition) method
 * added through meta-programming.
 *
 * The first section is handled with the 'while()/call() loop',
 * and the second in the 'upto() loop'
 */
use(IteratorCategory) {
    reader.iterator().while { line -> line != '0' }.call { line ->
        stv << Vote.fromLine(line, stv)
    }.upto(candidates) { line, i -> 
        stv.candidates.get(i).name = line 
    }
}

package net.zomis.meta

/*
 * Adds useful methods to Iterator.
 */
@groovy.lang.Category(Iterator)
class IteratorCategory {

    /*
     * Returns a Closure which iterates while the condition Closure 
     * evaluates to true. The returned Closure expects another Closure, 
     * an action closure, as its single argument.
     * This 'action' Closure is called during each iteration and is passed 
     * the Iterator.next()value. 
     * When the iteration is complete, the Iterator is returned.
     *
     * Example usage: 
     * use(IteratorCategory) {
     *   def iter = reader.iterator().while { it != 'end' }.call { println it }
     * }
     *
     * @param condition Closure to evaluate on each iteration.
     * @return a Closure
     */
    Closure 'while'(Closure condition) {
        {Iterator iter, Closure closure ->
            while(iter.hasNext()) {
                def it = iter.next()

                if(condition(it)) {
                    closure(it)
                } else {
                    break
                }
            }

            return iter
        }.curry(this)
    }

    /*
     * Similar to Number.upto(Number, Closure), executes the Closure
     * UP TO a specified number of times. However, instead of returning
     * the Closure's return value, it returns the Iterator where
     * it left off.
     *
     * Example usage:
     * use(IteratorCategory) {
     *   def iter = reader.iterator().upto(5) {it, i -> println "$i - $it" }
     * }
     *
     * @param to number of times to iterate
     * @param closure to execute. Called with Iterator.next() and index.
     * @return Iterator
     */
    Iterator upto(int to, Closure closure) {
        int i = 0

        while(this.hasNext() && i < to) {
            closure this.next(), i
            i++
        }

        return this
    }
}