resolucao LAB 11

Sorteador/LAB11.txt

@@ -113,7 +113,7 @@ Exercícios:
    (pode inclusive ser um DadoComum).
    No método sortear(),
    joga um dado 3 vezes, com resultados X, Y, Z.
-   retornando 1 se A==B==C
+   retornando 1 se X==Y==Z
    e 0 caso contrário.
 
 4) Repetir a simulação do exercício 2 do LAB 10,

Sorteador/src/DadoGenerico.java

@@ -1,16 +1,43 @@
 import java.util.Map;
+import java.util.Random;
 
 public class DadoGenerico<T> implements Sorteador<T> {
 
-    Map<T, Integer> frequenciaByResultado;
+    private Map<T, Integer> frequenciaByResultado;
+
+    private int somaDasFrequenciasRelativas;
+
+    private Random random;
 
     public DadoGenerico(Map<T, Integer> frequenciaByResultado) {
         this.frequenciaByResultado = frequenciaByResultado;
+
+        this.somaDasFrequenciasRelativas = 0;
+        for (int freq : frequenciaByResultado.values()) {
+            somaDasFrequenciasRelativas += freq;
+        }
+
+        this.random = new Random();
     }
 
     @Override
     public T sortear() {
-        // ToDo IMPLEMENT ME!!!!
+
+        double numeroSorteado = this.random.nextDouble() * this.somaDasFrequenciasRelativas;
+
+        int freqAcumulada = 0;
+
+        for (Map.Entry<T, Integer> resultadoEFrequencia : this.frequenciaByResultado.entrySet()) {
+            T resultado = resultadoEFrequencia.getKey();
+            int frequenciaRelativa = resultadoEFrequencia.getValue();
+
+            freqAcumulada += frequenciaRelativa;
+
+            if (numeroSorteado < freqAcumulada) {
+                return resultado;
+            }
+        }
+
         return null;
     }
 }

Sorteador/src/DadoGenericoTest.java

@@ -0,0 +1,54 @@
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+public class DadoGenericoTest {
+
+    @Test
+    public void testarFuncionamento() {
+
+        Map<String, Integer> mapinha = new HashMap<>();
+        mapinha.put("pedra", 2);
+        mapinha.put("papel", 3);
+        mapinha.put("tesoura", 10);
+
+        DadoGenerico<String> dadoGenerico = new DadoGenerico<>(mapinha);
+
+        int contPedra = 0;
+        int contPapel = 0;
+        int contTesoura = 0;
+
+
+        final int TOTAL_SORTEIOS = 10_000;
+
+        for (int i = 0; i < TOTAL_SORTEIOS; i++) {
+            final String resultado = dadoGenerico.sortear();
+
+            System.out.println(resultado);
+
+            switch (resultado) {
+                case "pedra":
+                    contPedra++;
+                    break;
+                case "papel":
+                    contPapel++;
+                    break;
+                case "tesoura":
+                    contTesoura++;
+                    break;
+            }
+        }
+
+        final double frequenciaPedra = contPedra / (double) TOTAL_SORTEIOS;
+        final double frequenciaPapel = contPapel / (double) TOTAL_SORTEIOS;
+        final double frequenciaTesoura = contTesoura / (double) TOTAL_SORTEIOS;
+
+
+        assertTrue(Math.abs(frequenciaPedra - 2/15.0) < 0.01);
+        assertTrue(Math.abs(frequenciaPapel - 3/15.0) < 0.01);
+        assertTrue(Math.abs(frequenciaTesoura - 10/15.0) < 0.01);
+    }
+}

Sorteador/src/Principal.java

@@ -3,50 +3,84 @@
 
 public class Principal {
 
-    private static final int CONT_REPETICOES_POR_SIMULACAO = 2_000_000;
+    private static final int CONT_REPETICOES_POR_SIMULACAO = 100_000;
 
     private static DadosDeGamao dadosDeGamao = new DadosDeGamao();
     private static DadosTriplos dadosTriplos = new DadosTriplos();
 
+    private static DadoGenerico<Integer> dadoGenerico = construirDadoGenerico();
+
+    private static SorteadorViaDoisParesConsecutivos sorteadorPares =
+            new SorteadorViaDoisParesConsecutivos(dadoGenerico);
+
+    private static SorteadorViaTrio sorteadorTrio =
+            new SorteadorViaTrio(dadoGenerico);
+
+//    PRIMEIRA SIMULAÇÃO: usando dado comum, honesto
+//
+//    private static DadoGenerico<Integer> construirDadoGenerico() {
+//        return new DadoComum();
+//    }
+
+
+//    SEGUNDA SIMULAÇÃO: usando um dado viciado
+//
+//    private static DadoGenerico<Integer> construirDadoGenerico() {
+//
+//        Map<Integer, Integer> mapinha = new HashMap<>();
+//        mapinha.put(1, 2);
+//        mapinha.put(2, 2);
+//        mapinha.put(3, 2);
+//        mapinha.put(4, 2);
+//        mapinha.put(5, 2);
+//        mapinha.put(6, 90);  // dado viciado, quase sempre cai "6"
+//
+//        return new DadoGenerico<>(mapinha);
+//    }
+
+
+//    TERCEIRA SIMULAÇÃO: usando uma moeda
+//
+    private static DadoGenerico<Integer> construirDadoGenerico() {
+
+        Map<Integer, Integer> mapinha = new HashMap<>();
+        mapinha.put(1, 15);
+        mapinha.put(2, 85);   // moeda desonesta
+
+        return new DadoGenerico<>(mapinha);
+    }
 
     private static void obterPercentuaisEmpiricos(int numeroDeRodadasPorPartida) {
 
-        JogoMalucoComSorteadores<DadosDeGamao, DadosTriplos> jogoMaluco;
+        JogoMalucoComSorteadores<
+                SorteadorViaDoisParesConsecutivos,
+                SorteadorViaTrio> jogoMaluco;
 
         jogoMaluco = new JogoMalucoComSorteadores<>(
-                "JogadorDosDadosDeGamao", "JogadorDosDadosTriplos",
-                numeroDeRodadasPorPartida, dadosDeGamao, dadosTriplos);
+                "JogadorDosParesConsecutivos", "JogadorDosTrios",
+                numeroDeRodadasPorPartida,
+                sorteadorPares,
+                sorteadorTrio);
 
         for (int i = 0; i < CONT_REPETICOES_POR_SIMULACAO; i++) {
             jogoMaluco.jogar();
         }
 
         System.out.println(String.format("\n\n" +
                 "      Para partidas com %d rodada(s):\n" +
-                "      Vitórias do Jogador 1: %f%%\n" +
-                "      Vitórias do Jogador 2: %f%%\n" +
+                "      Vitórias do %s: %f%%\n" +
+                "      Vitórias do %s: %f%%\n" +
                 "      Empates: %f%%",
                 numeroDeRodadasPorPartida,
+                jogoMaluco.getNomeJogador1(),
                 jogoMaluco.getPercentualVitoriasJogador1(),
+                jogoMaluco.getNomeJogador2(),
                 jogoMaluco.getPercentualVitoriasJogador2(),
                 jogoMaluco.getPercentualEmpates()));
     }
 
     public static void main(String[] args) {
 
-//        Map<String, Integer> frequenciaByDiaDaSemana = new HashMap<>();
-//        frequenciaByDiaDaSemana.put("segunda", 1);
-//        frequenciaByDiaDaSemana.put("terça", 4);
-//        frequenciaByDiaDaSemana.put("quarta", 6);
-//        frequenciaByDiaDaSemana.put("quinta", 1);
-//        frequenciaByDiaDaSemana.put("sexta", 1);
-//        frequenciaByDiaDaSemana.put("sábado", 10);
-//        frequenciaByDiaDaSemana.put("domingo", 10);
-//
-//        DadoGenerico<String> sorteadorDeDiasDaSemana = new DadoGenerico<>(frequenciaByDiaDaSemana);
-//
-//        String diaSorteado = sorteadorDeDiasDaSemana.sortear();
-//
         for (int numeroDeRodadas = 1; numeroDeRodadas <= 1000000; numeroDeRodadas++) {
             obterPercentuaisEmpiricos(numeroDeRodadas);
         }

Sorteador/src/SorteadorViaDoisParesConsecutivos.java

@@ -0,0 +1,18 @@
+public class SorteadorViaDoisParesConsecutivos implements Sorteador<Integer> {
+
+    private DadoGenerico<Integer> dado;
+
+    public SorteadorViaDoisParesConsecutivos(DadoGenerico<Integer> dado) {
+        this.dado = dado;
+    }
+
+    @Override
+    public Integer sortear() {
+        int resultadoA = this.dado.sortear();
+        int resultadoB = this.dado.sortear();
+        int resultadoC = this.dado.sortear();
+        int resultadoD = this.dado.sortear();
+
+        return resultadoA == resultadoB && resultadoC == resultadoD ? 1 : 0;
+    }
+}

Sorteador/src/SorteadorViaTrio.java

@@ -0,0 +1,17 @@
+public class SorteadorViaTrio implements Sorteador<Integer> {
+
+    private DadoGenerico<Integer> dado;
+
+    public SorteadorViaTrio(DadoGenerico<Integer> dado) {
+        this.dado = dado;
+    }
+
+    @Override
+    public Integer sortear() {
+        int resultadoA = this.dado.sortear();
+        int resultadoB = this.dado.sortear();
+        int resultadoC = this.dado.sortear();
+
+        return resultadoA == resultadoB && resultadoA == resultadoC ? 1 : 0;
+    }
+}