es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

¿Cómo me deshago de todo este código duplicado?

12 Jun, 2023 Programación

Eres un traductor de español que traduce documentos de IT. Traduce lo siguiente al español. No traduzcas el código ni la salida en markdown“`
private Optional playerWithMostCards()
{
Player scoringPlayer = null;
int maxCount = 0;

    for(Player p : players)
    {
        final int count = p.pile.size();


    if(count > maxCount)
    {
        scoringPlayer = p;
        maxCount = count;
    }
    else if(count == maxCount)
    {
        scoringPlayer = null;
    }
}

return Optional.ofNullable(scoringPlayer);



}


private Optional<Player> playerWithMostSevens()

{

    Player scoringPlayer = null;

    int maxCount = 0;


for(Player p : players)
{
    int count = 0;

    for(Card c : p.pile)
    {
        if(c.is(Card.Value.SEVEN))
        {
            count++;
        }
    }

    if(count &gt; maxCount)
    {
        scoringPlayer = p;
        maxCount = count;
    }
    else if(count == maxCount)
    {
        scoringPlayer = null;
    }
}

return Optional.ofNullable(scoringPlayer);



}


private Optional<Player> playerWithMostSpades()

{

    Player scoringPlayer = null;

    int maxCount = 0;


for(Player p : players)
{
    int count = 0;

    for(Card c : p.pile)
    {
        if(c.is(Card.Suit.SPADES))
        {
            count++;
        }
    }

    if(count &gt; maxCount)
    {
        scoringPlayer = p;
        maxCount = count;
    }
    else if(count == maxCount)
    {
        scoringPlayer = null;
    }
}

return Optional.ofNullable(scoringPlayer);



}


private Optional<Player> playerWithSevenOfSpades()

{

    for(Player p : players)

    {

        for(Card c : p.pile)

        {

            if(c == new Card("7S"))

            {

                return Optional.of(p);

            }

        }

    }


return Optional.empty();



}


private void updateScores()

{

    for(Player p : players)

    {

        p.score = p.scopas;

    }


playerWithMostCards().ifPresent(p -&gt; p.score += 1);
playerWithMostSevens().ifPresent(p -&gt; p.score += 1);
playerWithMostSpades().ifPresent(p -&gt; p.score += 1);
playerWithSevenOfSpades().ifPresent(p -&gt; p.score += 1);



}




“`


Básicamente, estoy haciendo un juego de cartas (llamado Scopa), y cuando se llama a updateScores (), las puntuaciones de cada jugador deben actualizarse. Los jugadores pueden ganar un punto teniendo más cartas, teniendo más sietes o teniendo el siete de espadas. La lógica para determinar quién tiene más cartas, sietes y espadas es muy similar. ¿Cómo puedo evitar repetir la lógica en estos tres métodos? Gracias.
Tags:  ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Se puede extraer la lógica común para determinar la cantidad de cartas/sietes/espadas en un método separado que tome un parámetro que represente la condición a comprobar (por ejemplo, si se debe contar la carta si es un siete o una espada). Aquí tienes un ejemplo de cómo podría quedar el código actualizado:

    private Optional<player> jugadorConMásCartas(Function<card, boolean=""> condiciónDeEmparejamiento) {
    Player jugadorConPuntuación = null;
    int cantidadMáxima = 0;

    for (Player p : players) {
        int cantidad = 0;

        for (Card c : p.pile) {
            if (condiciónDeEmparejamiento.apply(c)) {
                cantidad++;
            }
        }

        if (cantidad > cantidadMáxima) {
            jugadorConPuntuación = p;
            cantidadMáxima = cantidad;
        } else if (cantidad == cantidadMáxima) {
            jugadorConPuntuación = null;
        }
    }

    return Optional.ofNullable(jugadorConPuntuación);
}

private Optional<player> jugadorConMásCartas() {
    return jugadorConMásCartas(c -> true);
}

private Optional<player> jugadorConMásSietes() {
    return jugadorConMásCartas(c -> c.is(Card.Value.SEVEN));
}

private Optional<player> jugadorConMásEspadas() {
    return jugadorConMásCartas(c -> c.is(Card.Suit.SPADES));
}

private Optional<player> jugadorConSieteDeEspadas() {
    // Esto aún puede ser su propio método ya que no encaja en el patrón común
    for (Player p : players) {
        for (Card c : p.pile) {
            if (c == new Card("7S")) {
                return Optional.of(p);
            }
        }
    }

    return Optional.empty();
}

private void actualizarPuntuaciones() {
    for (Player p : players) {
        p.puntuación = p.scopas;
    }

    jugadorConMásCartas().ifPresent(p -> p.puntuación += 1);
    jugadorConMásSietes().ifPresent(p -> p.puntuación += 1);
    jugadorConMásEspadas().ifPresent(p -> p.puntuación += 1);
    jugadorConSieteDeEspadas().ifPresent(p -> p.puntuación += 1);
}

    En este código actualizado, jugadorConMásCartas() acepta un parámetro Function<card, boolean=""> que representa la condición a comprobar para cada carta. jugadorConMásCartas(), jugadorConMásSietes() y jugadorConMásEspadas() ahora llaman a este método con diferentes condiciones. Debido a que la lógica común está ahora en un solo método, no tenemos que repetirla en múltiples métodos.</card,></card,>

Comments are closed.